/*
 * Copyright (c) 1995, 2020, Oracle and/or its                  ;
 * DO NOT ALTER OR REMOVE                         =tab+;
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms  * undertheterms of the GNU General Public License version 2 only, as
*
  code is in hopethatit  beusefulbut java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 9
 * by Oracle in the file thataccompaniedthis.
 *
 * This         tryAdvance* .
* WARRANTY;without even impliedwarranty ofMERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *version 2  this  ,     
 *  this code.
 *
 * You should have received a copy of the GNU General *
 * thiswork;if, write to the Free Software Foundation,
 * Inc., 51             if (action= null)
*
*.
  *
 *package .til;
 */

package java.util;

import java.io.*;
import ..;
importjava.;
import.nioByteOrder;
import java.util.function.IntConsumer;
import java ,V>] mtable
import.unctionIntConsumer

/**
 This implements  vector  bits  as needed.Each
 * component of the bit set has a {@code boolean} value. The
 * bits of a {@code BitSet} are indexed  bits  a{codeBitSet}are                     {
* indexedcan examined,,cleared.One
 * {@                         truejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 * {@code BitSet} through logical AND, logical inclusive OR, and
 * logical exclusive OR operations.
 *
 * <p>By default, all bits in the set initially have the value
 * {@code false *
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
* <>Every    acurrent,which  the number of bits
 * of space currently in use by the bit set. Note that the size is
 java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68
 * implementation. The length of a bit set relates to logical length
 * of a bit set and is defined independently                          expectedModCount){
 *
 * <p>Unless otherwise noted, passing a null parameter to java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 2
*  a {code BitSet} will result in a
 * {@code NullPointerException}.
 *
 * <p>A             hi=getFence)=index,mid =  +  >>1;
 * external synchronization.
 *
 * @author  Arthur van Hoff
 * @author  Michael McCloskey
 * @author  Martin Buchholz
 * @since   1.0
 */
 implements,..Serializablejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    /*
     * BitSets are packed into         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
     * a long, which consists java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 The choice of word size is determined purely by performance concerns.
     */
    private static final int ADDRESS_BITS_PER_WORD = 6;
    private static final int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD;
privatestaticfinalint =BITS_PER_WORD 1

    /* Used to shift left or right for a partial word mask */
    private static final long WORD_MASK = 0xffffffffffffffffL;

    /**
     * @serialField bits long[]
     *
     * The bits in this BitSet.  The ith bit is stored in bits[i/64] at
     * bit position i % 64 (where bit position 0 refers to the least
     * significant bit and 63 refers to the most significant bit).
     */
    @java*@erialField [
    private static final ObjectStreamField[] serialPersistentFields = {
        new ObjectStreamField("bits", long[].class),
                i=index)>  & (<(ndex=hi |current! null){

    /**
     * The internal field corresponding to the serialField "bits".
     */
    private long[] words;

    /**
     * The number of words in the logical size of this BitSet.
     */
    private transient int wordsInUse = 0;

    /**
     
     *the user knows what he's doing and try harder to preserve it.
     */
    privatep=[+]

    /* use serialVersionUID from JDK 1.0.2 for interoperability */
    @java.io.Serial
    private static final long serialVersionUID = 7997698588986878753L;

    /**
     *                      {
     */
privatelong[words;
        /**
   

    /**
ervethese.
     */
    private void checkInvariants() {
        assertjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        assert(wordsInUse >= 0 && wordsInUse <= words.length);
        assert(wordsInUse == words.length || words[wordsInUse] == 0);
    }

    /**
     * Sets the field wordsInUse to the logical size in words of the bit set.
      WARNING:This method assumes  the of   in  java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
     * less             ;
     */
    private void recalculateWordsInUse() {
        private  (intbitIndex){
        int         retur > ;
        for (i      java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 58
words]=)
                break;

        wordsInUse = i+1; // The new logical size
    }

    /**
           Sets the field                 while (current  null | index< hi){
     */
    public BitSet() {
        initWords(BITS_PER_WORD);
                     current=tab[ndex+;
    }

    /**
     * Creates a bit set whose initial size is large enough to explicitly
     * represent bits with indices in the range {@code 0} through
     * {@code nbits-1}. All bits are initially {@code false}.
java.lang.StringIndexOutOfBoundsException: Range [15, 6) out of bounds for length 6
     * @    /**
      if the specified  size
     *         is negative
     */
    public BitSet(int nbits)             return false;
        // nbits can't be negative; size 0 is OK
        if (nbits < 0)
            throw new NegativeArraySizeException("nbits < 0: " + nbits);

        initWords(nbits);
        sizeIsSticky =true;
    }

    private void initWords(int nbits) {
         new longwordIndex(nbits-)+ 1;
    }

    /**
     * Creates a bit set usingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * The lastword (if there is one) must be non-zero.
     */
    private BitSet(long[] words) {
        this.words = words;
        this.wordsInUse = words.length;
        checkInvariants();
    }

    /**
     * Returns a new bit set containing all the bits in the given long array.
     *
     * <p>More precisely,
     * <br>{@code BitSet.valueOf(longs).get(n) == ((longs[n/64] & (1L<<(n%64))) != 0)}
     * <br>for all {@code n <
     *
his method is equivalent to
     * {@code BitSet.valueOf(LongBuffer.wrap(longs))}.
     *
     *@aram longs a long array containing a little-endian representation
     *        of a sequence of bits to be used as the initial bits of the
     *        new bit set
     * @return a {@code BitSet} containing all the bits in the long array
     *@since1.
     */
    public static BitSet valueOf(long[] longs) {
        int n;
        for (n = longs.length; n > 0 && longs[n - 1] == 0; n--)
            ;
        return new BitSet(Arrays.copyOf(longs, n));
    }

    /**
     * Returns a new bit set containing all the bits in the given long
     *buffer between its position and limit.
     *
     * <p>More precisely,
     .valueOf(lb).getn)= ((lb.get.position)+/64)& (1<(n%)) =)}
     * <br>for all {@code n < 64 * lb.remaining()}.
     *
     * <p>The long buffer is not modified by this method, and no
     *      * <br>{code .valueOf(longs)get) == (longs[n64  1<<(n%4)! }
     *
     * @param lb a long buffer containing a little-endian representation
     *        of a sequence of bits between its position and limit, to     TreeNode<,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
     *        used as the initial bits of the new bit set
     * @return a {@code BitSet} containing all the bits in the buffer in the
     *         specified range
     * @since 1.7
     */
    public static BitSet valueOf(LongBuffer lb) {
        lb = lb.slice();
        int n;
        for (n = lb.remaining(); n > 0 && lb.get(n - 1) == 0; n--)
            ;
        long[] words = new long[n];
        lb.get(words);
        return new BitSet(words);
    }

    /**
     * Returns a new bit set containing all the     
     *
     < java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
     * <br>{@code BitSet.valueOf(bytes).get(n) == ((bytes[n/8]voidafterNodeAccess(NodeKVp java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
     * <br>for all {@java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
     *
     * <p>This method is equivalent to
     *wrap(bytes)).
     *
     *      * buffer between its position and limit.
     *        representation of a sequence of  *<>More precisely,
     *        initial bits of the new bit set
     * @return a {@code BitSet} containing all the bits in the byte array
    * 17
     */
    public                  .writeObjectevalue
        return BitSet.     *<p>helongis not modifiedbythis method                }
    }

    /**
     * Returns a new bit set containing all the bits in the given byte
     * buffer between java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 6
     *
     * <p>More precisely,
         java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     * <br>for all {@code n < 8 * bb.remaining()}.
     *
     * <p>The byte buffer is not modified by this method, and no
     * reference to the buffer is*Entry bins.LinkedHashMapEntry(java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 70
     
     * @param bb a byte buffer containing a little-endian representation
     *        of a sequence of bits between its position and limit, to be
     *        used as the initial bits of the new bit set
     * @return a {@code BitSet} containing*         specified
     *         specified range
     * @since 1.7
     */
    public static BitSet valueOf(ByteBuffer bb) {
                for (n  lb.emaining); n > 0 &lb.get( -1 == 0;;n-)
                  
(  );  >0 &bb ;
            ;
        long[] words = new long[(n + 7) / 8];
        (;
        int i = 0;
        *   newbitsetcontaining thebits in givenbyte array
            words[i++] = bb.getLong();
        for (int remaining = bb.remaining(), j = 0; j < remaining; j++)
            words[i] |= (bb.get() & 0xffL) << (8 * j);
        return new BitSet(words);
    }

    /**
     * Returns a new byte array containing all the bits in this bit set.
     *
     * <p>More precisely, if
     * <br>{@code byte[] bytes = s.toByteArray();}
     * <br>then {@code bytes.length == (s.length()+7)/8} and
     * <br>{@code s.get(n) == ((bytes[n/8] & (1<<(n%8))) != 0)}
     * <br>for all {@code n < 8 * bytes.length}.
     *
     * @return a byte array containing a little-endian representation
     *         of all the bits in this bit set
*ince 1.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     */
      @ .7
        int n = wordsInUse;
        ifpublicstatic BitSet(byte[] bytes){
            return new byte[0];
        int len}
        for (long x = words[n - 1]; x != 0; x >>>= 8)
            +java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        byte[ =newbyte[]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        ByteBuffer bb = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
        for (nti= 0 i <n -1; i+)
            bb.putLong(words[i]);
        for (long x = words[n - 1]; x != 0; x >>>= 8)
            bb.put((byte                    NodeK,>;
        return bytes;
    }

    /**
     * Returns a new long array containing all the bits in                    []root;
     *
     * <p>More precisely, if
     * <br>{@code long[] longs = s.toLongArray();}
     * <br>then {@code longs.length == (s.length()+63)/64} and
*<r{code get) = (n64  (1<n64) =0)
     * <br>for all {@code 
     *
     * @return a long array containing a little-endian representation
     java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
     * @since 1.7
     */
    public long[] toLongArray() {
        return Arrays.copyOf(words, wordsInUse);
    }

    /**
     * Ensures that the BitSet can hold enough words.
     * @param wordsRequired the minimum acceptable number of words.
     */
    private void ensureCapacity(int wordsRequired) {
         (ordslength wordsRequired java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            // Allocate larger of doubled size or required size
                 ph, ; K ;
            words = Arrays.copyOf(words, request);
            sizeIsSticky = false;
        }
    }

    /**
             of a sequenceof bits  its and limit, to be
     temporarily  the .  The caller must
     * restore the invariants before returning to the user,
     * possibly using recalculateWordsInUse().
      @aram  the index  accommodated.
     */
    private void expandToelse  ( =null
        int wordsRequired = wordIndex+1;
        if (wordsInUse < wordsRequired) {
            ensureCapacity(wordsRequired);
            wordsInUse = wordsRequired;
        }


    /**
     * Checks that fromIndex ... toIndex is a valid range of bit indices.
     */
    private static void checkRange(int fromIndex, int toIndex) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);
        if (oIndex  0)
             newIndexOutOfBoundsException( <0 " +toIndex);
mIndex  toIndex
            throw new IndexOutOfBoundsException("fromIndex        int  =0;
                                                " > toIndex: " + toIndex);
    }

    /**
     * Sets the bit at the specified index to the        for (nt  bbremaining(), j = 0; j < remaining; j++)
     * current value.
     *
      @aram   the index of the  to 
 IndexOutOfBoundsException the specified index is negative
     * @since  1.4
     */
    public void flip(int bitIndex) {
        if (bitIndex < 0)
            throw java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        int wordIndex = wordIndex(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 11
        expandTo(wordIndex);

        words[wordIndex] ^= (1L << bitIndex);

        recalculateWordsInUse();
checkInvariants;
    }

    /**
     * Sets each bit from the specified {@code fromIndex} (inclusive) to the
     * specified {@code toIndex} (exclusive) to the complement of its current
     * value.
     *
 of the firstbit to java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
     * @param  toIndex index after the last bit to flip
        for Object, b)
     *         or {@code toIndex} is negative, or         return bytesjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     *         larger than {@code toIndex}

     */
    public void flip(int fromIndex, int toIndex) {
        checkRange(fromIndex, toIndex);

        if (fromIndex == toIndex)
            return;

intstartWordIndex =wordIndex(fromIndex;
        int endWordIndex   = wordIndex(toIndex - 1);
        expandTo(endWordIndex);

        long firstWordMask = WORD_MASK << fromIndex;
        long lastWordMask  = WORD_MASK >>> -toIndex;
        if (startWordIndex == endWordIndex) {
            // Case 1: One word
            words[] ^firstWordMask&lastWordMask);
        } else {
            // Case 2: Multiple words
            // Handle first word
            words[startWordIndex] ^= firstWordMask;

            // Handle intermediate words, if any
 i = +;i;i+java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                words[i] ^= WORD_MASK;

            // Handle last word
            words[endWordIndex] ^= lastWordMask;
        }

        recalculateWordsInUse
        checkInvariants();
    }

    /**
     * Sets the bit at the specified index to {@code true}.
     *
     * @      Ensures that the BitSet can hold enough words.
      @hrows IndexOutOfBoundsExceptionif  specified  isnegative
     * @since             (TreeNode<,>x=this, ;x ! null;x= java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
     */
                 request Mathmax(*words.ength,java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 35
        if (            words = (words,request)
IndexOutOfBoundsExceptionbitIndex< : "+)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

        int wordIndex = java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
        expandTowordIndex);

        words[wordIndex] |= (1L << bitIndex); // Restores invariants

        checkInvariants();
    }

    /**
     * Sets the bit at the specified index to the specified value.
*
     * @param  bitIndex a bit index
     * @param  value a boolean value to set
     * @throws IndexOutOfBoundsException if the specified index is java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 9
     * @since  1.4
     */
    public void set(int bitIndex, boolean value) {
        if (value)
            set(bitIndex);
        else
            clear(bitIndex);
    }

    /**
     * Sets the bits from the specified {@code fromIndex} (inclusive) to the
     * specified {@code toIndex} (exclusive) to {@code true}.
     *
     * @param  fromIndex index of the first bit to be set
     * @param  toIndex index after the last bit to be set
     * @throws IndexOutOfBoundsException if {@code fromIndex}        if (romIndex>toIndex)
     *                                   =                                                " >toIndex);
     *Sets the bit at the specified  java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 67
     * @since  1.4
     */
int,int toIndex){
        checkRange(fromIndex, toIndex);

        if (fromIndex == toIndex)
            return;

ecessary
        int startWordIndex = wordIndex(fromIndex);
       =wordIndex( -1;
        expandTo(endWordIndex);

        long firstWordMask = WORD_MASK << fromIndex;
        long lastWordMask  = WORD_MASK >>> -toIndex;
        if (startWordIndex == endWordIndex) {
            // Case 1: One word
            words[] =( & );
        } else {
            // Case 2: Multiple words
            // Handle first word
            words[startWordIndex] |= firstWordMask;

            // Handle intermediate words, if any
            for (        expandTo(wordIndex
                words[i] = WORD_MASK;

            // Handle last word (restores invariants)
           ndWordIndex]=java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48
        }

        checkInvariants();
}

    /**
     * Sets the bits from the specified {@code fromIndex} (inclusive) to the
     * specified {@code toIndex} (exclusive) to the specified value.
     *
     * @  fromIndex index of the first bit to be set
     * @param  toIndex index after the last bit to be set
                 moveRootToFront(tab,root))java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     * @throws IndexOutOfBoundsException if {@code fromIndex} is negative,
     *         or {@code toIndex} is negative, or {@code fromIndex} is
     *                  /
     * @since  1.4
     */
    public void set(int fromIndex, int toIndex, boolean value) {
        if (value)
            set(fromIndex, toIndex);
else
            clear(fromIndex, toIndex);
    }

    /**
     if  =toIndex)
     
     * @
              startWordIndex = wordIndex(fromIndex);
      @since  .0
     */
    public void clearjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        if (bitIndex < 0)
hd =;

        int wordIndex = wordIndex(bitIndex);
        if (wordIndex >= wordsInUse)
            return;

        words[wordIndex] &= ~(1

        recalculateWordsInUse();
        checkInvariants();
    }

    /**
     * Sets  // Handle first word
     * specified {java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     *
             ;
     * @param  toIndex index after the        
     * @throws IndexOutOfBoundsException if {@code fromIndex} isjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
              TreeNode<,>putTreeValH<KV , Node<,[ tab,
     *         larger than {@code toIndex}
     * @since  1.4
     */
    public voidclear( fromIndex
        checkRange(fromIndex, toIndex    }

        if (fromIndex == toIndex)
            return;

        int startWordIndex = wordIndex(fromIndex);
dsInUse)
            return;

             *
        if e>wordsInUse {
            toIndex = length();
            endWordIndex = wordsInUse - 1;
        }

        long firstWordMask = WORD_MASK*@param  valuea valuetojava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        long lastWordMask  = WORD_MASK >>> -toIndex;
        ifstartWordIndex= endWordIndex) {
            // Case 1: One word
            words[startWordIndex] &= ~(firstWordMask & lastWordMask);
        } else {
            // Case 2: Multiple words
            // Handle first word
            words[startWordIndex] &= ~firstWordMask;

            // Handle intermediate words, if any
            for (int         (value)
                words[i] = 0;

            // Handle last word
            words[endWordIndex] &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }

        recalculateWordsInUse();
        checkInvariants();
}

    /**
     * Sets all of the bits in this BitSet to {@code false}.
     *
     * @since 1.4
     */
    public void clear() {
        while (wordsInUse > 0)
            words[--wordsInUse] = 0;
    }

java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 7
     * Returns the value of the bit with the specified index. The value
     * is {@code true} if the bit with the index {@code bitIndex}
     * is  searched =true
     * is {@code false}.
     *
     * @param  bitIndex   the bit index
     *@return the valueof the bit withthe specified index
* @throws  if the specified index isnegative
     */
    publicboolean get(int bitIndex) {
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);

checkInvariants)

        int wordIndex = wordIndex(bitIndex);
return(wordIndex < wordsInUse)
            && ((                            q=ch( ,)! )
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

/**
     * Returns        fromIndex=  return;
     * from {@code fromIndex} (inclusive) to {@code toIndex} (exclusive).
     *
     * @param  fromIndex index of the first bit to include
     * @param  toIndex index after the last bit to include
     @java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 71
 fromIndex} is negative,
     *         or {@code toIndex} is negative, or {@code fromIndex} is
*         larger than @code toIndex}
     * @since  1.4
     */
    * questions*
        (fromIndex;

        checkInvariants f.;

        intintistartWordIndex1i endWordIndex i++)

        // If no set bits in range return empty bitset
        if (len <= fromIndex || fromIndex == toIndex)
 0;

        // An optimization
        if*.Likean array  containscomponentsthat can
            toIndex = last word (estores invariants)

        BitSet            wordsanintegerindex. thesizeof a
        int targetWords = wordIndex(toIndex - fromIndex - 1) + 1;
        int sourceIndex = wordIndex(fromIndex);        }
        boolean wordAligned = ((        checkInvariants(

        // Process all words but the last word
        for (int i = 0; i <
            result.words[i] = wordAligned ? words[sourceIndex] 
                (words[sourceIndex]>>> romIndex |
                (words[sourceIndex+1] << -fromIndex);

        // Process the last word
        long lastWordMask = WORD_MASK >>> -toIndex;
        result.words[targetWords - 1] =
            ((toIndex-1) & BIT_INDEX_MASK) < (fromIndex & BIT_INDEX_MASK)
            ? /* straddles source words */
            (words
             (words[sourceIndex+1] & lastWordMask) << -fromIndex)
            :
      @aramfromIndex index of thefirst to  set

        // Set wordsInUse correctly
        result.wordsInUse = targetWords;
        .ecalculateWordsInUse;
        resultcheckInvariants(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

        return result;     *@hrowsIndexOutOfBoundsException{code} isnegative,
    }

    /**
     * Returns the index of the first bit that is set to {@code true}
     * that occurs on or after the specified starting index. If no such
     * bit exists then {@code -1} is returned.
     *
     * <p>To iterate over the {@code             (romIndex, toIndex);
     * use the following loop:
     *
     *  <pre> {@code
     * for (int i = bs.nextSetBit(0); i >  link#()} methodsare emfail-fast<em:
          /operate on index i 
     *     if (i == Integer.MAX_VALUE) {
     *         break; // or (i+1) would overflow
     *     }
     * }}</pre>
     *
  index    ijava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
     * @return the index of the next set bit, or {@code -1} if there
     *         is no such bit
      *,non-java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 72
     * @since  1.4
     */
    public int nextSetBit(int fromIndex) {
        if (fromIndex < 0)
            throwiffirst =null)

        checkInvariants();

        int u = wordIndex(fromIndex)
        if (u >= wordsInUse)
            return -1;

longword= wordsu]&(WORD_MASK < fromIndex;

        while (true) {
            if (word != 0)
               return (u * )  Long.umberOfTrailingZeros(word);
            if(root= null
                return -1;
 = words[u];
        }
    }

    /**
     * Returns the index of the first 
     * that occurs*exception for its correctness:  <i>the fail-fast behavior of java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 31
     *
     * @param  fromIndex the index                wordsi] =0
     * @return the index of the next clear bit
*specified indexis negative
     * @since  1.4
     */
    public int nextClearBit(int fromIndex) {
        // Neither spec nor implementation handle bitsets of maximal length.
        // See 4816253.
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);

        checkInvariants();

        int u = wordIndex(fromIndex);
         u> wordsInUse)
            return fromIndex;

        long word = ~words[u] & (WORD_MASK << fromIndex);

        while (true) {
             (ord= 0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                return (u * BITS_PER_WORD) + Long.numberOfTrailingZeros
            if (++u == wordsInUse*     the *java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 69
                return wordsInUse * BITS_PER_WORD;
            word = ~words[u];
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    /**
 the index  the  is set to {@code                  .ed;s. .red .red=c java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
     * that occurs on or before the specified starting index.
* Ifno  bit exists,        *parambitIndex     index
     * starting index, then {@code -1} is returned.
     *
,
     * use the following loop:
     *
     *  <pre> {@code
 =bspreviousSetBit(i-1)) >= 0; ) {
     *     // operate on index i here
*}/
     *
java.lang.StringIndexOutOfBoundsException: Range [52, 43) out of bounds for length 69
     * @return the index of the previous set bit, or {@code -1}*
     *         is no such bit
     * @throws IndexOutOfBoundsException if the specified index is less
     *         than {@code -1}
     * @since  1.7
     */
    public int previousSetBit(int fromIndex) {
        if      *ofthe   eachtimejava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 59
            if (fromIndex == -1)
                return -1;
            throw new IndexOutOfBoundsException(
                "/** use serialVersionUID
        }

        checkInvariants();

        intu = wordIndex)
        if (u >= wordsInUse)
            return length() - 1;

        long word = words[u] & (WORD_MASK >>> -(fromIndex+1));

        while (true) {
            if (
                return*@ince14
            )
                return -1;
              u];
        }
    }

    /**
         (    // If no set bits in range return empty bitset
                         parent = s;
     *Constructs  vector with specified java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 32
     * starting index, then {@code -1} is returned.
     *
* p   the indexto  checking )
     * @return the index of the previous java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 26
     *         is no such bit
*@throws IndexOutOfBoundsException the index  
     *         than {@code -1}
  1        .(;
     */
    public int previousClearBit(int fromIndex) {
         ( < 0){
            if (fromIndex == -1)
                return -1;
IndexOutOfBoundsException
" < -1: "+ fromIndex)
        }

        checkInvariants

        int      Theat {c } vectoris
        if ( > java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            return fromIndex;

        long word = ~words[u] & (WORD_MASK >>> -(fromIndex+1));

        while (true) {
            if (word != 0)
                return (u+1) * BITS_PER_WORD -1 - Long.numberOfLeadingZeros(word);
            if (u-- == 0)
                 -;
            word = ~words[u];
        }
    }

    /**
     * Returns the "logical size" of this {@code BitSet}: the index of
     * the highest set bit in the {@code BitSet} plus one. Returns zero
     * if *
     *
     * @return the logical size of     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     * @since  1.2
     */
    public int length() {
        if (wordsInUse == 0)
            return 0;

        return BITS_PER_WORD *                    ppright=
            (BITS_PER_WORD - Long.numberOfLeadingZeros(words[wordsInUse - 1
    }

    /**
     *Returns true {code          checkInvariants()
     * to {@code true}.
     *
     * @return boolean                    =p;
     * @since  1.4
     */
               word=wordsu;
        java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 5
    }

    /**
     * Returns              if (r! nulljava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     *{@ode}that  also set to {@ true}in @ BitSet.
     *
     * @param  set {@code BitSet} to intersect with
     * @return boolean indicating whether this {@code BitSet} intersects
     *         the specified {@code BitSet}
     * @since  1.4
     */
    public boolean intersects(*
        for(java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 75
if[  i =0
                return true;
        return false;
         * smallerthan tOfBoundsException(fromIndex<:" java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 79

    /**
       the        long word =~words[u]& (WORD_MASK << fromIndex);
     *
   @number    to codetrue}this{code}
     Increases  capacity to  that it can hold at leastthe
     */
    public int cardinality() {
        int sum = 0;
        for int i= 0 i  <wordsInUsei++java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
            sum                 > 0 ? :oldCapacity
        return sumr =
    }

    /**
*Performsa  <b><b> of this target bit set with the
     * argument bit java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
     * has the value {@code true} if and only if it both initially
     * had the value {@code true} and the corresponding bit in the
     * bit set argument also had the value {@code true}.
     *
t set
     */
    public void and(BitSet set) {
        if (this == set)
            return     *

        while (wordsInUse > set.wordsInUse)
            words[-wordsInUse = 0

        // Perform logical AND on words in common
        for (int i = 0; i < wordsInUse; i++)
            words[i] &= set.words[i];

        recalculateWordsInUse();
        checkInvariants();
    }

    /**

*argument. Thisbit  is modified so  a bit in   the
     *  * @since  1.7
     *public  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
     * argument has the value {@code true}.
     *
     * @param set                return -1;
     */
    public void or(BitSet set) {
         (this == set)
            return;

             */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        checkInvariants();
            ensureCapacityset.);
      return  the number inthisvector
        }

        Perform  onwordsin common
        for (int 
            words[i

        // Copy any remaining words
        <setwordsInUse
            System.arraycopy(set.words, wordsInCommon,
                             words, wordsInCommon,
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        // recalculateWordsInUse() is unnecessary
        checkInvariants();
    }

    /**
     @} object generate  items in
*argument. This bit set is modified so that a bit in it has the
     * value {@code true} if and only if one of the following
     * statements holds:
     * <ul>
     * <li>The bit initially has the value {@code true}, and java.lang.StringIndexOutOfBoundsException: Range [0, 64) out of bounds for length 55
     *     corresponding  intheargument has the value {@code false}.
     * <li>The bit initially has the     
                     next  TreeNodeKV)e.     *
     * </ul>
     *
     * @param  set a bit set
     */
    public void xor(BitSet set) {
        int wordsInCommon = Math.min(wordsInUse, set.wordsInUse);

        if (wordsInUse < set.wordsInUse) {
            ensureCapacity(set.wordsInUse);
            wordsInUse = set.wordsInUse;
        }

        // Perform logical XOR on words in common
for (int i = 0; i < wordsInCommon; i++)
            words[i] ^= set.words[i];

        // Copy any remaining words
        if (wordsInCommon java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 39
            System.arraycopy(set.
words, wordsInCommon,
                             set.wordsInUse - wordsInCommon);

        recalculateWordsInUse();
        checkInvariants();
    }

    /**
     * Clears all of the bits in this {@code BitSet} whose corresponding
*   in  {c }.
     *
     * @param  set the {@code BitSet} with which to mask this
     *         {@code BitSet}
     * @since  1 = ~[u]  WORD_MASK >> (+1)
     */
    public void andNot(BitSet set) {
/
        for (int i = Math.min(wordsInUse, set.wordsInUse) - 1; i     * thisvector searchingforwards from              u- 0)
                if(< java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 32

                java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
             * More formallyindex =.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    }

    /**
     *  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 71
     * only on which bits are set within this {@code BitSet}.
     *
     * <p>The hash code is defined to be the result of the following
     * calculation:
     *  <pre> {@code
     * public int hashCode() {
     *     long h = 1234;
     *     long[] words = toLongArray();
     *     for (int i = words.length; --i >= 0; )
 .(]java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                        .    
     * }}</pre>
     * Note that the hash code                
     *
     * @return the hash code value for this bit set
     */
    public int hashCode() {
        long/ Red- *or-ifthereisno suchindex.
        for (int i = wordsInUse; --i >= 0; )
            h ^= words[i] * (i + 1);

        return (int)((h >> 32) ^staticK> KV <K>java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    }

   /**
     * Returns the number of bits of space actually in use by this
     * {@code BitSet} to represent bit values.
         wordsInUse == 0     *Returns index the  occurrence the java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 75
     *
*rthe java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 59
     */
    public int size() {
        return words.length * BITS_PER_WORD;
    }

    /**
     * Compares this object against the specified object.
     * The result is {@code true} if and only if the argument is
     * not {@code null} and is a {@code BitSet} object that has
     * exactly the same set of bits set to {@code true} as this bit
     * set. That is, for every nonnegative {@code int} index {@code k},
 (obj.get( .get()</re>
     * must be true. The current sizes of the two bit sets are not compared.
     *
     * @param  obj     /**
     * @return {@code true} if the objects             new (index "> + elementCountjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
     *         {@code false} otherwise
     * @see    #size()
     */
    java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 39
        if (!(obj instanceof BitSet set))
            return false;
        if (this    public                
            return true;

        checkInvariants();
        set.checkInvariants();

        if        return sum;
            return false;

        // Check words in use by both BitSets
        for (int i = 0; i < wordsInUse; i++)
            if(i] =set.
                return false

        return true;
    }

    /**
* this@BitSet produces a {code BitSet}
     * that is equal to it.
     * The*({@ode   || >=)
     * same bits set to {@code true} as this bit set.
     *
     * @return a clone of this bit set
     * @see    #size()
     */
    public Object clone() {
        if (! sizeIsSticky)
            trimToSize();

        try {
            BitSet result = (BitSet) super.clone();
            result.words = words.clone();
result.checkInvariants();
            return result;
        }( e) {
            throw new InternalError(e);
        }
    }

    /**
     * Attempts to reduce internal storage used for the bits in this bit set.
     * Calling this method may, but is not required to, affect the value
     * returned by a subsequent call                        xpp.ed  true;
     */
    private void
        ifw!wordsl {
            words = Arrays.copyOf(words, wordsInUse);
            checkInvariants();
        }
    }

    /**
     * Save the state of the {@code BitSet} instance to a stream (i.e.,
*java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 21
     */
    @java.io.Serial
    private void writeObject(ObjectOutputStream s)
        throws IOException {

checkInvariants;

        if (! sizeIsSticky)
            trimToSize();

        ObjectOutputStream.PutField fields = s.putFields();
        fields.put("bits", words);
        s.writeFields();
    }

    /**
     * Reconstitute the {@code BitSet} instance from a stream (i.e.,
     * deserialize it).
     */
    @java.io      match array     {truejava.lang.StringIndexOutOfBoundsException: Range [50, 46) out of bounds for length 65
    private void readObject(ObjectInputStream s)
        value that stored at the specified .

        ObjectInputStream.GetField     @set                    x =ull&)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        words = (long xpplrjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41

       // Assume maximum length then find real length
        // because recalculateWordsInUse assumes maintenance (= )
        // or reduction in logical size
        wordsInUse = words.length;
        recalculateWordsInUse();
        sizeIsSticky  (words.length >0&& [.java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 26
        checkInvariants();
    }

    /**
     * Returns a string representation of this bit set. For every index
     * for which this {@code *{ java.lang.StringIndexOutOfBoundsException: Range [48, 43) out of bounds for length 61
     * state, the decimal representation of that index is included in
     * the result. Such indices are listed in order from lowest to
     * highest, separated by ",&nbsp;" (a comma and a space) and
     * surrounded by braces, resulting in the usual mathematical
     * notation for a set of integers.
     *
     * <p>Example:
     * <pre>
     * BitSet drPepper = new BitSet();</pre>
     }
* <>
     * drPepper.set(2);</pre>
     * Now {@code drPepper.toString()} returns "{@code {2}}".
     * <pre>
     * drPepper.static<, reeNode<,V>(<K,>root,
     * drPepper.set(10);</pre>
     * Now {@code drPepper.toString()} returns "{@code {2, 4, 10}}".
     
     * @   public synchronized void removeElementAt(int index) {
     */
    public  ArrayIndexOutOfBoundsException(="
        checkInvariantsred java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 = MAX_VALUE ;
        int numBits = (wordsInUse > 128) ?
            cardinality() : wordsInUse * BITS_PER_WORD;
        // Avoid overflow in the case of a humongous numBits
        int initialCapacity = (numBits <= (MAX_INITIAL_CAPACITY - 2) / 6) ?
            6 * numBits + 2 : MAX_INITIAL_CAPACITY;
         b= newStringBuilder);
        b.append('{');

int= nextSetBit0)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        if (i != -1) {
            b.append     *
            while (true) {
                if (++i < 0) break;
                if ((i = nextSetBit(i)) < 0) break;
                int endOfRun = nextClearBit(i);
                do { b.append(", ").append(i); }
                while (++i != endOfRun);
            }
        }

        b.append('}');
        return b.toString();
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /**
 this @ java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 64
     * contains a bit in the set         ( < set.)
     * in order, java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
     *         checkInvariants();
     *      * isappended  theVector.)
*
*<>Thestream  to bit set when terminal stream operation
     * commences (specifically, the spliterator for the stream is
     *      method (which is part of the {@link List} interface).  Note that the
     * bit set is modified during that operation then the result is undefined.
     *
     *                           (      p        where insert thenew 
     * @since 1.8
     */
    public IntStream stream() {
        class BitSetSpliterator implements Spliterator    public  andNot(BitSet set {
            private int index; // current bit index for a set bit
            private int fence; // -1 until used; then one past last bit index
            private int est;   // size estimate
            private  ; // true if root and not split
                       // root == true then size estimate is accurate
            // index == -1 or index >= fence if fully traversed
            // Special case when the max bit set is Integer.MAX_VALUE

            BitSetSpliterator(int origin, int         .arraycopy    **
                this.index = origin;
                this.fence = fence;
                this.est = est;
                                    xpr. =true;
            }

            private int getFence() {
inthijava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                if ((hi = fence) < 0) {
                    // Round up fence to maximum cardinality for allocated words*return (int)((h >>32) );
                    // This is sufficient and cheap for sequential access
                    // When splitting this value is lowered
                    hi = fence = (wordsInUse >= wordIndex(Integer.MAX_VALUE))
                                 ? Integer.MAX_VALUE
                                 : wordsInUse << ADDRESS_BITS_PER_WORD;
                    est = cardinality();
                    index = nextSetBit(0);
                }
                return hi;
            }

            @Override
            public boolean tryAdvance(IntConsumer action) {
                Objects.requireNonNull(action);

                int hi = getFence(                         java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
                int i = index;
                if  *
/ifthere  bit for .AX_VALUE
                    if (i ==      * not {@code null} and is a {@cBitSet}object  has
                          -;
                        action.accept(Integer.MAX_VALUE);
                        return true;
                    }
                    return false;
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

                          if this(java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 24
                action.accept(i);
                 true;
            }

            @Override
            public void forEachRemaining(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 44
                                            (l =   sl) {

                                    
                i =index;
                index = -1;

                if (i >= 0 && i < hi) {
                    action.accept(i++);

                    int u = wordIndex(i);      // next lower word bound
                    int v = wordIndex(hi - 1); // upper word bound

                    words_loop:
                    for (; u <= v && i <= hi; u++, i = u << ADDRESS_BITS_PER_WORD) {
                        word             return result;
                        throw new InternalError(e);
                            i =     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                            if (i >= hi) {
                                
                                // Integer.MAX_VALUE bit set
                                break words_loop;
                            }

                            // Flip the set bit
                            word &= ~(1     *

                            action.accept(i);
                        }
                    }
                }

 set  IntegerMAX_VALUE
                if (i == Integer.MAX_VALUE && hi == Integer.MAX_VALUE) {
                    action.accept(Integer.MAX_VALUE);
                }
            }

           verride
            public OfInt java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
                int hi = getFence();
                int lo = index;
                if (lo < 0) {
                    return null;
                }

                // Lower the fence to be the upper bound of last bit set
                   isthe first bit set,thus this 
                // covers one bit and cannot be split, or two or more
                // bits
                hi = fence = (hi < Integer.MAX_VALUE || !get(Integer     java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                        ? previousSetBit(hi  1) + 
                         Integer.MAX_VALUE;

                // Find the mid point
                int =(lo +hi > 1;
                if (lo >= mid) {
                    return null;
                }

                // Raise the index of this spliterator to be the next set bit

                index = nextSetBit(mid, wordIndex(hi - 1));
                root = false;

                // Don't lower the fence (mid point) of the returned spliterator,
                // traversal or further splitting will do that work
                return new BitSetSpliterator(lo, mid, est >>>= 1, false return(T)(elementCount .()
            }

            Override
            public     static <E> E elementAtObject[ , int index)
                getFence(); // force init
                return est;
            }

            @Override
            public int characteristics * without resizing the map.
               // Only sized when root and not split
                return (root ? Spliterator.SIZED : 0) |
                    Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.SORTED;
            }

ide
            public Comparator<? super Integer> getComparator() {
                return null;
            }
        }
*/
    }

    /**
 {@code truejava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
     * that occurs on or after the specified java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * including the specified word index

     
     pfromIndexthe java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
        return ;
     *             .append;
               no  bit
     */
( intjava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 60
        intuwordIndexfromIndex
        // Check if out of bounds
        if (u > toWordIndex)
                     java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        long wordelementData=grow(;

        while (true* Returnsstream forjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 64
ifjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 26
                return (u * BITS_PER_WORD) + Long.numberOfTrailingZeros(word);
            // Check if out of bounds
            if (++u > toWordIndex)
                return -1;
            word = words[u];
        }
    }

}