146                 int bv = U.getIntUnaligned(b, bOffset + bi);
 147                 if (av != bv) {
 148                     int x = av ^ bv;
 149                     int o = BIG_ENDIAN
 150                             ? Integer.numberOfLeadingZeros(x) >> (LOG2_BYTE_BIT_SIZE + log2ArrayIndexScale)
 151                             : Integer.numberOfTrailingZeros(x) >> (LOG2_BYTE_BIT_SIZE + log2ArrayIndexScale);
 152                     return (wi << log2ValuesPerWidth) + o;
 153                 }
 154                 tail -= wordTail;
 155             }
 156             return ~tail;
 157         }
 158         else {
 159             return ~tail;
 160         }
 161     }
 162 
 163     /**
 164      * Mismatch over long lengths.
 165      */
 166     public static long vectorizedMismatchLarge(Object a, long aOffset,
 167                                                Object b, long bOffset,
 168                                                long length,
 169                                                int log2ArrayIndexScale) {
 170         long off = 0;
 171         long remaining = length;
 172         int i ;
 173         while (remaining > 7) {
 174             int size = (int) Math.min(Integer.MAX_VALUE, remaining);






 175             i = vectorizedMismatch(
 176                     a, aOffset + off,
 177                     b, bOffset + off,
 178                     size, log2ArrayIndexScale);
 179             if (i >= 0)
 180                 return off + i;
 181 
 182             i = size - ~i;
 183             off += i;
 184             remaining -= i;
 185         }
 186         return ~off;
 187     }
 188 
 189     // Booleans
 190     // Each boolean element takes up one byte
 191 
 192     public static int mismatch(boolean[] a,
 193                                boolean[] b,
 194                                int length) {
 195         int i = 0;
 196         if (length > 7) {
 197             if (a[0] != b[0])
 198                 return 0;
 199             i = vectorizedMismatch(
 200                     a, Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
 201                     b, Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
 202                     length, LOG2_ARRAY_BOOLEAN_INDEX_SCALE);
 203             if (i >= 0)
 204                 return i;
 205             i = length - ~i;
 206         }

 146                 int bv = U.getIntUnaligned(b, bOffset + bi);
 147                 if (av != bv) {
 148                     int x = av ^ bv;
 149                     int o = BIG_ENDIAN
 150                             ? Integer.numberOfLeadingZeros(x) >> (LOG2_BYTE_BIT_SIZE + log2ArrayIndexScale)
 151                             : Integer.numberOfTrailingZeros(x) >> (LOG2_BYTE_BIT_SIZE + log2ArrayIndexScale);
 152                     return (wi << log2ValuesPerWidth) + o;
 153                 }
 154                 tail -= wordTail;
 155             }
 156             return ~tail;
 157         }
 158         else {
 159             return ~tail;
 160         }
 161     }
 162 
 163     /**
 164      * Mismatch over long lengths.
 165      */
 166         public static long vectorizedMismatchLargeForBytes(Object a, long aOffset,
 167                                                            Object b, long bOffset,
 168                                                            long length) {

 169             long off = 0;
 170             long remaining = length;
 171             int i, size;
 172             boolean lastSubRange = false;
 173             while (remaining > 7 && !lastSubRange) {
 174                 if (remaining > Integer.MAX_VALUE) {
 175                     size = Integer.MAX_VALUE;
 176                 } else {
 177                     size = (int) remaining;
 178                     lastSubRange = true;
 179                 }
 180                 i = vectorizedMismatch(
 181                         a, aOffset + off,
 182                         b, bOffset + off,
 183                         size, LOG2_ARRAY_BYTE_INDEX_SCALE);
 184                 if (i >= 0)
 185                     return off + i;
 186 
 187                 i = size - ~i;
 188                 off += i;
 189                 remaining -= i;
 190             }
 191             return ~remaining;
 192         }
 193 
 194     // Booleans
 195     // Each boolean element takes up one byte
 196 
 197     public static int mismatch(boolean[] a,
 198                                boolean[] b,
 199                                int length) {
 200         int i = 0;
 201         if (length > 7) {
 202             if (a[0] != b[0])
 203                 return 0;
 204             i = vectorizedMismatch(
 205                     a, Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
 206                     b, Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
 207                     length, LOG2_ARRAY_BOOLEAN_INDEX_SCALE);
 208             if (i >= 0)
 209                 return i;
 210             i = length - ~i;
 211         }