/*
 * Copyright (c) 1995, 2020, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you p 
*  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 71
 * published by the Free Software Foundation.  Oracle designates 
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
*This isdistributed  the   will  ,          
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR  
 * version 2 for more Oracle in the LICENSE f  LICENSE   code.
  this)
 *
 * You  ANY without  the  MERCHANTABILITYjava.lang.StringIndexOutOfBoundsException: Range [72, 73) out of bounds for length 72
* java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 73
 *  accompanied )java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
*
 * Please * 2 along with   not, FreeFoundationjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * or visit www.oracle 
 *questions
 *

packagejava.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 java.o.;
 .nioByteBuffer;
 java.nio.java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
import java NodeV   t
 java.util..;
import
 *This class a vectorof  thatgrowsas 

/**
             tab  &.=  )index 0 {
 *component  the  { boolean. The
*of @ BitSet are                    {
 * Individual indexed bits can be examined, set, or cleared. One                          current.;
 * {@code                 
 * {@code BitSet} through logical AND, logical java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 13
 *logical  ORoperationsjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 *
 * <p>By default,        
 * {@code false}.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  *
 * of space currently in use by the bit *pbitsethas   size isjava.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 67
*related  theimplementationof a  set,somaychange
 * implementationimplementation of a bit set,         Spliterator<.Entry<K,V>> {
 * of a bit set and is defined independently of implementation.
 *
 * <p>Unless otherwise noted, passing a null parameter to any of the
 * methods in a {@code BitSet} will result in a
 * {@code NullPointerException}.
 *
 * <p>A {@code BitSet} is not safe for multithreaded use without
 * public classBitSet  Cloneable,java.o {
 *
 * @author  Arthur van Hoff
 * @author  Michael McCloskey
 * @author  Martin Buchholz
 * @since   1.0
 */
public class java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 7
    /*
     * BitSets are packed into arrays of    private static  intBIT_INDEX_MASK   -1;
     * a long, which consists of 64 bits, requiring 6 address bits.
         size determined java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 76
     */
    private static final int ADDRESS_BITS_PER_WORD = 6;
    private static final
    private static final int BIT_INDEX_MASK = BITS_PER_WORD - 1;

    /* Used to shift left or right for a partial word mask */
SK = 0ffffffffffffffffLjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

    /**
      @ bitslong[
     *
     * 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.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 68
    private static final ObjectStreamField[] serialPersistentFields = {
        new ObjectStreamField("                     (p ==null)
    };

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

    /**
     *}
     */
    private transient int wordsInUse  invariantsjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

    /**
     * Whether the size of "words" is user-specified.  If so, we assume
     * the user knows what he's doing and try harder to java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 21
     */
    private transient boolean * methodthat numberwordsactuallyuseis

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

    /**
     * Given a bit index, return word index containing it.
     */
     staticintwordIndex bitIndex {
nbitIndex >ADDRESS_BITS_PER_WORD
    }

    /**
     *Every public method must preserve these invariants.
     */
    private void checkInvariants() {
        assert(wordsInUse == 0 || words[wordsInUse - 1] != 0);
        assert(wordsInUse >= 0 && wordsInUse <= words.length);
        assert(wordsInUse l&tab.             ([]!0java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    }

    /**
*the field                while (currentnull|    
     * WARNING:This method assumes that the number of words actually in use is
     * less than or equal to the current value of wordsInUse!
     */
    private voidaction();
        // Traverse the bitset until a used word is found
        int i;
        for (i = wordsInUse-1; i >= 0; i--)
            if 
                break;

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

    /**
     * Creates a new bit set. All bits are initially {@code false}.
     */
    public BitSet() {
        initWords(BITS_PER_WORD);
        sizeIsSticky = false}
    }

    /**
     * Creates a bit set whose initial      * @throws NegativeArraySizeExceptioninitial java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
     * representwords = [1  ]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     * {@code nbits-1}. All bits are initially {@code false}.
     *
     * @param  nbits the initial size of the bit set
     * @throws NegativeArraySizeException if the specified initial size
     *         is negative
     */
    public BitSet(int nbits) {
        // nbits can't be negative; size 0 is OK
        if (nbits < 0)
            throw new NegativeArraySizeException("nbits < 0: " + nbits);

   initWords)
        sizeIsSticky = true;
    }

         * <p>Tjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 38
        words = new long[wordIndex(nbits-1) + 1];
     *pjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 74

    /**
     * Creates a bit set using words as the internal      are sojava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 68
     * The last word (if there is one) must        .
     */
    private BitSet(long[] words) {
        this      java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 45
        this.* <br>{@code BitSet()=((lb(+  1L<64)! 0java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
        )
    }

    /**
     * Returns a new bit set containing all the bits in the given long array.
     *
     * <p>More precisely,
@BitSet)(n (longs/]& (L%)) !0)
     * <br>for all {@code n < 64 * longs.length}.
     *
     *>  java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 38
     * {@code BitSet.valueOf(LongBuffer.wrap(longs))}.
     *
     * @param longs a long array containing a little-endian representation
     *        of a sequence of bits to be used as the initial bits of          = ;
     *        new java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 13
     * @return a {@code BitSet} containing all the bits in the long array
*since.
     */
    public static BitSet valueOf(long[] longs) {
        int n;
        for (n =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            ;
        return new BitSet(Arrays.    // Called only from writeObject, orderingjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    }

    /**
     internalWriteEntries)
      java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 45
     *
     p,
    *br>@ BitSet)getn)=(b.lbposition+/64&(<)  )
     * <br>for all  *@since.
     *
      >  buffer  modified                  
     * reference to the buffer is        
     *
     * @param lb a long 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 all the bits in the buffer 
               range
     * @since 1.7
     */
    publicK>right;
        lb = lb.slice();
        int n;
         =.( > 0& ( -) 0 -)
  ;
        long[] words = new         for (=bb.remaining();>0&         red
        lb.get(words);
        TreeNodebb)
    }

    /**
      Returnsa    all  the  .
     *
     * <java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
     * <br>{@code BitSet.valueOf(bytes).get(n) == ((bytes[n/8] & (1<<(n%8))
     * <br>for all {@code                    
     *
      p> method isto
     * {@code BitSet.valueOf(ByteBuffer.wrap(bytes))}.
     *
     * @param bytes a byte array containing a little-endian
     *        representation of a sequence of bits to be used as the
            int java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
     @ince java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
* @ince17
     */
     static valueOf )
ytes))java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /**
     * Returns a new bitlen+;
     * buffer between its position and limit        for(  ;   +java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     *
     * <p>More precisely,
     * <br>{@code BitSet.valueOf(bb).get(n) == ((bb                     rp!
     * <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 retained by the bit set.
     
     * @param}
*        sequence  between positionjava.lang.StringIndexOutOfBoundsException: Range [68, 66) out of bounds for length 73
     *        used as the initial bits of the new bit set
     * @return a {@code BitSet} containing all the bits in the *
e
     * @since 1.7
     */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        bb = bb.slice().order(ByteOrder.java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 26
        int n;
        forif(<java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            ;
        long[] mIndex> )
        bb.limit(n);
        inti=
        while(.java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 35
            words[i    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        (remaining= bb.java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 71
            words[i]                     =;
        return new BitSet(words);
    }

    /**
     * Returns a return ;
     *
     * <p>More precisely, if
     * <br>{@
              Callsfind node.
     * <br>{@code s.get(njava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 11
     * <br>     * @throws ifthejava.lang.StringIndexOutOfBoundsException: Range [63, 57) out of bounds for length 75
     *
     * @return a byte array containing a little-endian representation
     *hashCodes  non. java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 26
     * @since 1.7
     */
    public byte[] toByteArray() {
        int n = wordsInUse;
        if (n == 0)
            newbyte0
        int len = 8 * (n-1);
        for (long x = words[n - 1]; x != 0; x >>>= 8)
            len++;
        byte[] bytes = new      * @param  fromIndex index  flip
fer.rap(bytes).rder.)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
        for (int i = 0; i < n - 1; i++)
            bb.putLong(words[i])         *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        forstatic  tieBreakOrder a Object {
            bb.put((byte) (x & 0xff));
        ;
    }

    /**
     *              ;
     *
     * <p>More precisely, if
     * <br>{@code long[] longs
     if ( = |  = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
     * <br>{           );
     * <br>for all {@code n < 64 * longs.length}.
     *
     * @return a long array 
     *         of        recalculateWordsInUse();
     * @since 1.7
     */
    public long[] toLongArray() {
        return Arrays.copyOf(words, wordsInUse);
    }

    /**         *
*java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 53
     * @param wordsRequired the minimum acceptable number of words.
     */
    private void ensureCapacity(int wordsRequired) {
        if (words.length < wordsRequired) {
                            x.left = x.right = null;
int =.max2 *l 
Arrays.copyOf )
            sizeIsSticky  parent=null               (" 0 + bitIndex;
        }
    }

    /**
     * Ensures that        (;
     * temporarily violating the invariants.  The caller java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     x. =;
                     ;
     * @param wordIndex the      *
     */
    private void expandTo(int wordIndex) {
        int wordsRequired = wordIndex+1;
        if (wordsInUse < wordsRequired) {
            ensureCapacity(wordsRequired);
            wordsInUse =                     k = x.key;
        }
    }

    /**
     * Checks that fromIndex ... toIndex  valid    indicesjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

    private static void checkRange(int fromIndex, int toIndex) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
        if (toIndex < 0)
            throw new                         else if (ph <
        f  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
            ("fromIndex "+java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 75
 toIndex:"+java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 74
    }

    /**
        to complementofjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
     * current value fromIndex int ){
     *
     * @TreeNode
     * @throws  int endWordIndex    wordIndextoIndex 1)
     * @since  1.4
     */
    publicstartWordIndex | firstWordMask lastWordMask
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndexif d= 0java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

        int wordIndex = wordIndex(bitIndex);
);

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

        recalculateWordsInUsewords[]=lastWordMask
        checkInvariants();
    }

    /**
      each   specified{ fromIndex java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 5
     * specified {@code toIndex} (exclusive) to the complement of its current
     * value.
     *
     * @     param  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 57
     * @param  toIndex@java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 57
     * @throws IndexOutOfBoundsException if {@code fromIndex} is negative,
     *         or {@code toIndex} replacingthose from
     *         larger than {@code toIndex}
     * @since  1.4
     */
    public  else
        checkRange(fromIndex, toIndex);

        (fromIndex= 
            return;

intjava.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 50
        int endWordIndex*@1java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        expandTo(endWordIndex)     

        long firstWordMask = WORD_MASK << fromIndex;
        long lastWordMask             java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        if (

            words[java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
        } else    
            // Case 2: Multiple words
            
            words[startWordIndex ^= firstWordMask;

            // Handle intermediate words, if any
            for (int i = startWordIndex+1            
                words[i] ^= WORD_MASK;

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

        recalculateWordsInUse();
        checkInvariants
    }

    /**
     /**
     *
     * @param  bitIndex a bit index
     * @throws IndexOutOfBoundsException if the specified          /
     * @since  1.0
     */
    public void set(int bitIndex) {
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);

        int wordIndex = wordIndex(bitIndex);
        expandTo(wordIndex);

        wordIndex]| (1L  *

        checkInvariants();
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /**
     * Sets the bit atjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     
     * @param          if (endWordIndex(ndWordIndex  > ) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      param boolean   set
     * @throws IndexOutOfBoundsException          ( =
     * @since  1.4
     */
    public void set(int bitIndex, boolean value) {
ifjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
            set(bitIndex);
        else

    }

    /**
     * Sets the bits java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 9
     * 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}     IndexOutOfBoundsException index java.lang.StringIndexOutOfBoundsException: Range [75, 76) out of bounds for length 75
     *         or {@         wordIndexjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     *         larger than {@code toIndex}
     *    }
     */
    public void set(int fromIndex, int toIndex) {
    /**

        if ( =                            retur
            return;

         capacity  necessary
        int java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 17
        int endWordIndex   = wordIndex(toIndex - 1);
        expandTo(endWordIndex);

        long    < fromIndex;
             * return ajava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
        if (startWordIndex == endWordIndex) {
            // Case 1: One word
words* FITNESS FOR A PARTICULAR    GeneralLicense
         {
            // Case 2: Multiple words
//Handle first word
            java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13

             , ifany
for  =+; ;java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                words[ BitSet()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 ( java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
             * accessed using java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 58


);
    }

    /**
     * Sets the bits                 sourceIndex  )|
     * specified {@code  
     *
*@    bit tobe 
     *         .(;
      to
     *t  if { fromIndex  java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 74
     *         or {@code toIndex} is negative, or {@code fromIndex} 
     *         larger than {@code toIndex}
     * @since  1.4
     */
    public void set(*independently during traversal. So instead we swap the tree
        if (value)
            fromIndex toIndex;
        else
clearfjava.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /**
     * * The iteratorsjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 74
     *
     * parambitIndex java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 58
     * @throws IndexOutOfBoundsException if the specified index java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
     * @since  1.0
     */
    public void clear(int bitIndex) {
        if (bitIndex < 0)
           throw IndexOutOfBoundsExceptionbitIndex<0 "bitIndex;

        
        if (wordIndex >= wordsInUse)
            return;

wordswordIndex]=~1 <bitIndex);

        recalculateWordsInUse();
        checkInvariants();
    }

    /**
     * Sets the bits from  {*     indexhere
     * specified {@code toIndex} (exclusive) to {@code false}.                ;
     *
     * @param  fromIndex index
      last bit to becleared
     * @throws IndexOutOfBoundsException if {@code fromIndex}            else
     *         or {@code toIndex} is negative, or {@code fromIndex} is
     *         larger than {@code toIndex}
     *@  .4
     */
    public void clear(int fromIndex, int           = [  <)
        checkRange(fromIndex, toIndex);

        if  uBITS_PER_WORD+njava.lang.StringIndexOutOfBoundsException: Range [76, 71) out of bounds for length 78
            ;

        int startWordIndex =||(ovable
        if (startWordIndex >= java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 5
            return;

        int endWordIndex = wordIndex(toIndex - 1);
        if (endWordIndex >= wordsInUse) {
            toIndex = length();
             = ordsInUse -1;
        }

        long firstWordMask = WORD_MASK < *
lastWordMask  WORD_MASK >>toIndex;
        if (startWordIndex == 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 i = startWordIndex+1; i < endWordIndex; i++)
                [  ;

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

        recalculateWordsInUse();
        checkInvariants();
    }

    /**
*Sets of   in BitSet* @throws IndexOutOfBoundsException if the 
                 if (l   &pr= java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
     */
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
        while *Java Framework/a.Unlike collection(ord)
            [-] ;


    /**
     Returns thevalue ofthe bitwith  implementations,{@  issynchronized    thread-afe
     * is {@code true} if the bit with the index {@code bitIndex}
     * is currently set in  @uthor  Jonathan Payne
     * is  /
     *
*@the bit index
     *  array java.lang.StringIndexOutOfBoundsException: Range [38, 34) out of bounds for length 67
     * @throws IndexOutOfBoundsException if the specified index is negative
     */
    public boolean get(int bitIndex) {
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndex < 0: Set}

        checkInvariants();

        int wordIndex = wordIndex(bitIndex);
        return (wordIndex < wordsInUse)
     *andis atleastlarge java.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 71
    }

    /**
     * Returns a new {@code BitSet} 
     * from      java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 48
     
     * @param  fromIndex index of the first bit to include
     * @param  toIndex index after the last bit to include
     * @return a new {@code BitSet} from a range of this {@code BitSet}
     * @throws IndexOutOfBoundsException if {@code fromIndex} is negative,
     *         or {@code toIndex} is negative, or {@code fromIndex} is
     *         larger than {@code toIndex}
      s  .java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
     */
    public BitSet get(int fromIndex, int            word=words[u;
        checkRange(fromIndex, toIndex);

        checkInvariants();

        int len = length();

       // If no set bits in range return empty bitset
        if                 (        if (initialCap0
            return new BitSet(0);

        java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        if (toIndex > len)
            toIndex = len;

        BitSet result = new BitSet(toIndex - fromIndex);
        int targetWords = wordIndex(toIndex - fromIndex - 1) + 1;
        int sourceIndex = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 22
        boolean      with itsjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 49

        // Process all words but the last word
              java.lang.StringIndexOutOfBoundsException: Range [31, 13) out of bounds for length 68
            result.words[i] = wordAligned     @aramfromIndex start from (inclusivejava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                (words[sourceIndex] >>> fromIndex) |
                (words[sourceIndex+1] << -fromIndex);

        // Process the last word
}
   [argetWords-1java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
(toIndex-)&  (romIndex&)
            ? /* straddles source words */
            ((words[sourceIndex] >>> fromIndex) |
      throws if specifiedis less
            :
            ((words[sourceIndex] & java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

        // Set wordsInUse correctly
        result.wordsInUse = targetWords;
        result.recalculateWordsInUse();
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 33

        return    /**
    }


     * * @param java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 72
                             *
*      newjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48
     
     * <p>        } java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
     * use the following      *Copies thecomponents java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
     *

     * for (int                    parent =;
     *     // operate on index i here
     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     *         break; // or (i+1) would overflow
     *     }
     * }}</                    sjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
     *
     * @param  fromIndex the index to start checking from (inclusive)
     * @return the index of the next set bit, or {@code -1} if there
     *         is no such bit
     * @throws IndexOutOfBoundsException if the specified index is negative

     */
    public int nextSetBit(int fromIndex) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);

;

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

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

        while (true) {
            if (word != 0)
                public (java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            if (+u=)
                return -1
             =words[]
        }
    }

    /**
     * Returns the index of      *
     * that occurs on or after the specified starting index.
     *
     * @param  fromIndex the index to start checking from (inclusive)
   of the next clear bit
     * @throws IndexOutOfBoundsException if the specified index is negative
     * @since  1.4
     */
public nextClearBit( ) {
 norimplementationhandle  of maximal length.
        // See 4816253.
        if (fromIndex < 0             ((wordsi]&set.words[])!=0)*  capacitywill be twice the old capacity; but if newsize
"0+fromIndex);

        checkInvariants();

        int u = wordIndex(fromIndex);
      @aram the minimumcapacity
            return fromIndex;

java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 57

        while (true) {
            if (word != 0)
                return (            modCount+ *return of  @ true  @ 
            if (++u == wordsInUse)
                return wordsInUse */*
            word = ~words[u];
        }
    }

    /**
     * Returns the index of the nearest bit that is set to {@code true}
ndex
     * If no such bit exists
     *       logical>AND/java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 68
     *
     * <p>To iterate over the {@code true} bits in a {@code BitSet},
  loopjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
     *
     *  <pre> {@code
     * for (int i 
     *     // operate on index i here
     * }}</pre>
     *
     *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     -wordsInUse];
     *         is no such bit
     * @throws IndexOutOfBoundsException if the specified index is less
             set  that ithas
       .7
     */
    ementCount;
         thejava.lang.StringIndexOutOfBoundsException: Range [36, 26) out of bounds for length 51
            if (fromIndex == -1)
                 ;
                     * Splitsatree java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 69
                "fromIndex < -1: " +ifthis =java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        }



                java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 55
        synchronizedint)
            return length(java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

                 

        while rdsInCommon  .)
            (= 0
                return*           java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 57
            if (u--     
                return -1;
            word = words[u];
        }
    }

    /**
     * Returns the index of the nearest bit that is set to {@code false}
     * that occurs on                  <;
 exists  {code }is                    
,@java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 51
     
     * @param  fromIndex the index to start checking from (inclusive)
     *@ indexof     
     *         is no such bit
     * @throws IndexOutOfBoundsException if the specified index is less
               c-java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
     }
     */
    public java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        if (fromIndex < 0) {
            if (fromIndex == -1)
                return -1;
            throw     *bitis set thespecified@ode BitSet
                * @param o element to 
        }

        checkInvariants();

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

d~ordsu&(WORD_MASK>-fromIndex))

        java.lang.StringIndexOutOfBoundsException: Range [12, 10) out of bounds for length 13
            if (word != 0)
                return (u+1) * BITS_PER_WORD -1 - Long.numberOfLeadingZeros(word);
if(=0
                return -1;
             = wjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 29
}
    }

    /**
     * Returns*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     thehighest set bit in the {@code BitSet} plus one. Returns zero
     * if the {@code BitSet} java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     *
     * @return the logical size of this {@code BitSet}
     * @since  1.2
     */
     java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 25
ifjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 28
            return 0;

        return BITS_PER_WORD * (wordsInUse - 1) +
                    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 18
    }

    /**
     * Returns true if this {@code BitSet} contains no bits that*java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 67
     * to {@code true}.
     *
     * @return boolean indicating whether this {@code BitSet} is empty
     * @since  1.4
     */
)}
returnjava.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 31
    }

    /**
     * Returns true if the specified {@code BitSet} has any bits set to
     * {
     *
     * @param  set                
     * @return boolean indicating whether this {@code BitSet} intersects
thejava.lang.StringIndexOutOfBoundsException: Range [35, 28) out of bounds for length 43
     * @since  1.4
     */
    public boolean intersects(BitSet set) {
        for (int i = Math.min(wordsInUse, set.     *<pre>(BitSet)obj)k) ==this(k/re
            
                return true;
        return false;
    }

   /**
      i )
     *
     * @return the number of bits set to {@code true forii index>;-
     * @since  1.4
     */
else
        int sum = 0;
        for                    .=;
            sum +=     part @List).
        sumjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 19
    }

    /**
     * Performs a logical <b>AND</b> of                 ;
     * argument bit set. This bit set is modified so that each bit in it
     * has the value {@code true} if and only if it both initially
     * had the value {@code true} and the corresponding            java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 37
     * bit set argument also                     (pprxppr   red 
     *
     * @param set         if (element  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     */
    public void and(BitSet set) {
        if (this == set)
            return;

        whilejava.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 43
            words[--wordsInUse] = 0;

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

        recalculateWordsInUse();
        thecurrent ofthe .
    }

    /**
     * Performs a logical <b>OR</b> of this bit        ()
     * argument. This bit set is modified so java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 7
     * value                         
*{} or java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 65
     * has the{true}
     
* set if(pl=& java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 51
     */
    publicor set{
        ifthis =set)
            return;

          minwjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 65

        if                                          );
            ensureCapacity(
            =length> wordswordsjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 26
        }

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

        // Copy any remaining words
        if (wordsInCommon < setxpp = =.)=?null:xp;
            System.arraycopy(set.words, wordsInCommon,
                             
                             wordsInUse - wordsInCommon);

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

/**
     * Performs a logical <b>XOR</b> of this bit set with the bit set
                             
     * value {@code true} if and only if one of the following
     * statements holds:
     * <ul>
     * <li>The bit initially has the value {@code true}, and the
     *     corresponding bit in the argument has the value*
     * <li>The bit initially has the value {@code false},         java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 34
     *     corresponding bit in theStringBuilder new (initialCapacity
     * </ul>
     
     * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
    public void xor(BitSet set)   {c}                    if ((xpr = xp &.
        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] ^=*

        // Copy any remaining words
        ifwordsInCommonwordsInUse
            System.arraycopy(set.words, wordsInCommon,
                             words, wordsInCommon,
etwordsInUse;

        recalculateWordsInUse();
;
    }

    /**
                    
     * bit is set in the specified {@code BitSet}.
     *
     param  set the code } withwhich  this
     *         {@code BitSet}match  .
     * @since                                ram       java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 60
     */
voidset))
        // Perform logical (a & !b) on words in common
        for (int i = Mathpublicsynchronized ( obj int java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
            words[i] &= ~set.words[i];

        recalculateWordsInUse();
        checkInvariants();
    }

/
     * Returnss-index)
     * only on which bits are set within this {@code BitSet}.
     *
     * >Theis tobe the the 
     * calculation:
     *  <pre> {@code
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     *     long h = 1234;
     *     long[] words = toLongArray();
     *     for (int i = words.length; --i >= 0; )
=[i (+ 1;
             32 ^hjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     * }}</pre>
     * Note that the }
     *
     * @return the hash code value for this bit set
     */
    public int hashCode() {
        long h = 1234;
         inti=wordsInUse- = ; )
            h ^= words[i] * (i + 1);

java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 36
    }

    /**
     * Returns the number     *@   the java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     * The maximum element in the set is the size - 1*   indexed  java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
     *
     * @return the number ofjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
    publicpThis   tothe
        return words                        root=rotateRightr,xp;
    }

    *
     * Compares this object against the specified object.
     * The result is {@code true} if and only if the argument is
ode BitSet thathas
     * exactly the same set of bits set to {@code true} as this bit
     * set. That is, for every nonnegative {     *
     * <pre>((BitSet)obj).getindex=-;
     * must be true. The current  x 
     *
                    ;{ .
     * @return {@code true} if the objects
     *         {@code false} otherwise
     * @see    #size()
     */
    public boolean equals}
        if (!(obj instanceof BitSet set))
            return false;
        (ifthis=obj)
            return true;

        checkInvariants();
        set.checkInvariants()returntrue;

        if (wordsInUse != set.wordsInUse)
            return false;

        // Check words in use by both BitSets
        for (int i = 0; i < wordsInUse; i++)
            if (words[i] != set.words[i])
                return false* <>method is identical functionalitythe {@#}

        return true;
    }

    /**
     * Cloning this                int   
      java.lang.StringIndexOutOfBoundsException: Range [46, 28) out of bounds for length 50
     * The clone of            [];
     * same bits set to {@code true} as this bit set.
*
     * @return a clone of this bit set
      original data ofthis{@ Vector .
     */
    public Object clone() {
        if (!                              
            trimToSize();

        try {
            BitSet result = (BitSet) super.clone();
            @uppressWarningsunchecked")
            result.checkInvariants();
            result
        } catchvelementData .,;
            java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 39
        }
    }

    /**
     * internal   bitsset
     * Calling 
     * returned by a subsequent call to the {@link #size()} method.
     */
    private void trimToSize() {
        if (wordsInUse != words.length) {
            words = Arrays.copyOf(words, wordsInUse);
            checkInvariants();
        }
    }

    /**
     * Save the state of the {@code BitSet} instance 
     * serialize it).
     */
    @java.io.Serial
    private void writeObject(ObjectOutputStream type   the java.lang.StringIndexOutOfBoundsException: Range [62, 50) out of bounds for length 63
java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 13

        checkInvariants      > Vectorfits        @verride

        if ;
            trimToSize();

        . fields=.putFields);
fieldsput"its);
        s.writeFields();
    }

    /**
     * Reconstitute the {@code BitSet} instance from a stream (i.e.,
     * deserialize it).
     */
    @java.io.Serial
privatevoid(ObjectInputStream
        throws IOException,                 false

        ObjectInputStream.GetField fields =      * @param a the array into which the elem 
        words = (long[]) fields.get("bits", null);

        // Assume maximum length then find real length-11
        // because recalculateWordsInUse assumes maintenance
        // or reduction in logical size:Integerjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        wordsInUse = words.length;
        recalculateWordsInUse();
                   mid  +)>>1
        checkInvariants();
    }

    /**
 Returns a string representation  thisset.Forevery 
     *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * state, the decimal representation of that index is included in
     * the result. Such indices are listed in order from lowest       since19
     * highest, separated by ",&nbsp;" (a comma and a             elementCount  ;
     *     * The returneduses load   075 its  capacity 
     * notation java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 13
     *
     * <p>Example:
     * <pre>
     * BitSet drPepper = new BitSet();<               
     * Now {@code drPepper.toString()} returns "{@                 {c< index >= size()})
     * <pre>
      s2java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     * Now {@code drPepper.toString()} returns "{@code {2}}".
     * <pre>
     * drPepper.set(4);
     * drPepper.set(10);</pre>
     * Now {@code drPepper.toString()} returns "{@code {2, 4, 10}}".
     *
     * @return a string representation of this bit set
     */
    public String toString() {
        checkInvariants();

        final int MAX_INITIAL_CAPACITY = Integer.MAX_VALUE - 8;
                ret newHashMap<(())
            cardinality() : wordsInUse * BITS_PER_WORD;
        // Avoid overflow in the case of a humongous numBits
        int initialCapacity = (numBits     *
            6 * numBits + 2 : MAX_INITIAL_CAPACITY;
        StringBuilder  *@aram   theindex 
        b.append('{');

                oldValue
        if (i != -1) {
            b.(i)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            while*issuch
                if (++i < 0) break;
                if ((i = nextSetBit(i)) < 0) break;
                     private int nextSetBitfromIndex toWordIndex {
                do { b.append(", ").append(i); }
                while (++i != endOfRun);
            }
        }

        b.append('}');
        return b.toString();
    }

    /**
       a stream ofindices for which this {@code BitSet}
     * contains a bit in the set state. The             if (word != 0)
     * in order, from lowest to highest. The size of the stream
     * is the number of      @aram e element to be appended to Vector
     * returned by the {@link #cardinality()} method.
     *
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * commences (specifically, the java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 42
     * <a href="Spliterator.html#binding"><em>late-binding</java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 42
     * bit set is modified during that operation then the result is undefined.
     *
     * @return a stream of integers representing set indices
     * @since 1.8
     */
    public IntStream stream() {
        class BitSetSpliterator implements     *formally, theelementwiththe  indexi such that
            private int index; // current bit index for a set bit
1 until used onelast bitindex
            private int est;   // size estimate
            private boolean root; // 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 fence, int est, boolean root) {
                this.index = origin;
                this.fence = fence;
                this.est = est;
                this.root = root;
            }

            private int getFence() {
                int hi;
                if ((hi = fence) < 0) {
//Round upfence to maximumcardinalityfor words
                    // This is sufficient and cheap for sequential access
                    // When splitting this value is lowered
                    hi = fence = (wordsInUse >= wordIndex(Integer.MAX_VALUE))
                                 ? Integer.MAX_VALUE
                                      *Shiftsthe elementcurrentlythat position(f)andany
                    est = cardinality();
                    index nextSetBit0;
                }
                return hi;
            }

            @Override
            public boolean tryAdvance(IntConsumer action) {
                Objects.requireNonNull)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

                int hi = getFence();
                int i = index;
                if (i <      */
//Check ifthere is final set IntegerMAX_VALUE
                    if (i == Integer.MAX_VALUE && hi == Integer.MAX_VALUE) {
                        index     }
                        action.accept(Integer.MAX_VALUE);
                        return true;
                    }
                    return false;
                }

java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 61
                action.accept(i);
                return true;
            }

            @Override
            public void forEachRemaining(IntConsumer action) {
                ()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

      throwsArrayIndexOutOfBoundsException theindexis outof range
                int i = index;
                index = -1;

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

                    int u =    public synchronized E remove(int index) {
                    int v = wordIndex(hi - 1); // upper word bound        modCount+;

                    words_loop:
                     (;  <   =;u+  u< ADDRESS_BITS_PER_WORD
                        long word = words[u] & (java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 40
                        while (        int numMoved = elementCount-;
                            i = (u << ADDRESS_BITS_PER_WORD) + Long.numberOfTrailingZeros(word);
                            if (i >= hi) {
                                // Break out of outer loop to ensure check of
                                // Integer.MAX_VALUE bit set
                                breakwords_loop;
                            }

                            // Flip the set bit
                            word &= ~ /java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

                            action.accept(i);
                        }
                    }


                // Check if there is a final bit set for Integer.MAX_VALUE
                if (i == Integer.MAX_VALUE && hi == java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 6
                    action.accept(Integer.MAX_VALUE);
                }
            }

            @Override
            public OfInt trySplit()     }
                int hi = getFence();
                int lo = index;
                if (lo < 0) {
                    return null;
                }

                // Lower the fence to be the upper bound of last bit set
                // The index is the first bit set, thus this spliterator
                // covers one bit and cannot be split, or two or more
                // bits
                hi = fence = (hi < Integer.MAX_VALUE || !get(Integer.MAX_VALUE))
                        ? previousSetBit(hi - 1) + 1
                        : Integer.MAX_VALUE;

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

                // Raise the index of this spliterator to be the next set bit
                // from the mid point
                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(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            }

            @Override
            public long estimateSize() {
                getFence(); // force init
                return est;
            }

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

            @Override
            public Comparator<? super Integer> getComparator() {
                return null;
            }
        }
        return StreamSupport.intStream(new BitSetSpliterator(0, -1, 0, true), false);
    }

    /**
     * Returns the index of the first bit that is set to {@code true}
     * that occurs on or after the specified starting index and up to and
     * including the specified word index
     * If no such bit exists then {@code -1} is returned.
     *
     * @param  fromIndex the index to start checking from (inclusive)
      @param  toWordIndex the last word index to check (inclusive)
* @eturn  index  thenext set bit, or {@code -1} if there
     *         is no such bit
     */
    private int nextSetBit(int fromIndex, int toWordIndex) {
        int u = wordIndex(fromIndex            Object[ elementData =this.lementData;
        // Check if out of bounds int  =
if  )
            return -1;

long  wordsu  (WORD_MASK<fromIndex)

        while (true) {
            if (word != 0)
                return (u * BITS_PER_WORD) + Long.numberOfTrailingZeros(    }
            // Check if out of bounds
            if (++  fromof are the
                return -1;
            word = words[u];
        }
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

}