You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by us...@apache.org on 2012/08/25 12:06:16 UTC
svn commit: r1377246 [4/7] - in /lucene/dev/branches/lucene3312: ./
dev-tools/ dev-tools/idea/lucene/analysis/morfologik/
dev-tools/idea/lucene/analysis/phonetic/ dev-tools/maven/
dev-tools/scripts/ lucene/ lucene/analysis/ lucene/analysis/common/ luce...
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperation.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperation.java?rev=1377246&r1=1377245&r2=1377246&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperation.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperation.java Sat Aug 25 10:06:07 2012
@@ -19,22 +19,155 @@ package org.apache.lucene.util.packed;
* limitations under the License.
*/
-import java.util.EnumMap;
+import java.nio.ByteBuffer;
/**
* Efficient sequential read/write of packed integers.
*/
-abstract class BulkOperation {
+abstract class BulkOperation implements PackedInts.Decoder, PackedInts.Encoder {
+ private static final BulkOperation[] packedBulkOps = new BulkOperation[] {
+ new BulkOperationPacked1(),
+ new BulkOperationPacked2(),
+ new BulkOperationPacked3(),
+ new BulkOperationPacked4(),
+ new BulkOperationPacked5(),
+ new BulkOperationPacked6(),
+ new BulkOperationPacked7(),
+ new BulkOperationPacked8(),
+ new BulkOperationPacked9(),
+ new BulkOperationPacked10(),
+ new BulkOperationPacked11(),
+ new BulkOperationPacked12(),
+ new BulkOperationPacked13(),
+ new BulkOperationPacked14(),
+ new BulkOperationPacked15(),
+ new BulkOperationPacked16(),
+ new BulkOperationPacked17(),
+ new BulkOperationPacked18(),
+ new BulkOperationPacked19(),
+ new BulkOperationPacked20(),
+ new BulkOperationPacked21(),
+ new BulkOperationPacked22(),
+ new BulkOperationPacked23(),
+ new BulkOperationPacked24(),
+ new BulkOperationPacked25(),
+ new BulkOperationPacked26(),
+ new BulkOperationPacked27(),
+ new BulkOperationPacked28(),
+ new BulkOperationPacked29(),
+ new BulkOperationPacked30(),
+ new BulkOperationPacked31(),
+ new BulkOperationPacked32(),
+ new BulkOperationPacked33(),
+ new BulkOperationPacked34(),
+ new BulkOperationPacked35(),
+ new BulkOperationPacked36(),
+ new BulkOperationPacked37(),
+ new BulkOperationPacked38(),
+ new BulkOperationPacked39(),
+ new BulkOperationPacked40(),
+ new BulkOperationPacked41(),
+ new BulkOperationPacked42(),
+ new BulkOperationPacked43(),
+ new BulkOperationPacked44(),
+ new BulkOperationPacked45(),
+ new BulkOperationPacked46(),
+ new BulkOperationPacked47(),
+ new BulkOperationPacked48(),
+ new BulkOperationPacked49(),
+ new BulkOperationPacked50(),
+ new BulkOperationPacked51(),
+ new BulkOperationPacked52(),
+ new BulkOperationPacked53(),
+ new BulkOperationPacked54(),
+ new BulkOperationPacked55(),
+ new BulkOperationPacked56(),
+ new BulkOperationPacked57(),
+ new BulkOperationPacked58(),
+ new BulkOperationPacked59(),
+ new BulkOperationPacked60(),
+ new BulkOperationPacked61(),
+ new BulkOperationPacked62(),
+ new BulkOperationPacked63(),
+ new BulkOperationPacked64(),
+ };
+
+ // NOTE: this is sparse (some entries are null):
+ private static final BulkOperation[] packedSingleBlockBulkOps = new BulkOperation[] {
+ new BulkOperationPackedSingleBlock1(),
+ new BulkOperationPackedSingleBlock2(),
+ new BulkOperationPackedSingleBlock3(),
+ new BulkOperationPackedSingleBlock4(),
+ new BulkOperationPackedSingleBlock5(),
+ new BulkOperationPackedSingleBlock6(),
+ new BulkOperationPackedSingleBlock7(),
+ new BulkOperationPackedSingleBlock8(),
+ new BulkOperationPackedSingleBlock9(),
+ new BulkOperationPackedSingleBlock10(),
+ null,
+ new BulkOperationPackedSingleBlock12(),
+ null,
+ null,
+ null,
+ new BulkOperationPackedSingleBlock16(),
+ null,
+ null,
+ null,
+ null,
+ new BulkOperationPackedSingleBlock21(),
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ new BulkOperationPackedSingleBlock32(),
+ };
- static final EnumMap<PackedInts.Format, BulkOperation[]> BULK_OPERATIONS = new EnumMap<PackedInts.Format, BulkOperation[]>(PackedInts.Format.class);
public static BulkOperation of(PackedInts.Format format, int bitsPerValue) {
- assert bitsPerValue > 0 && bitsPerValue <= 64;
- BulkOperation[] ops = BULK_OPERATIONS.get(format);
- if (ops == null || ops[bitsPerValue] == null) {
- throw new IllegalArgumentException("format: " + format + ", bitsPerValue: " + bitsPerValue);
+ switch (format) {
+ case PACKED:
+ assert packedBulkOps[bitsPerValue - 1] != null;
+ return packedBulkOps[bitsPerValue - 1];
+ case PACKED_SINGLE_BLOCK:
+ assert packedSingleBlockBulkOps[bitsPerValue - 1] != null;
+ return packedSingleBlockBulkOps[bitsPerValue - 1];
+ default:
+ throw new AssertionError();
}
- return ops[bitsPerValue];
+ }
+
+
+ private static long[] toLongArray(int[] ints, int offset, int length) {
+ long[] arr = new long[length];
+ for (int i = 0; i < length; ++i) {
+ arr[i] = ints[offset + i];
+ }
+ return arr;
+ }
+
+ @Override
+ public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ encode(toLongArray(values, valuesOffset, iterations * valueCount()), 0, blocks, blocksOffset, iterations);
+ }
+
+ @Override
+ public void encode(long[] values, int valuesOffset, byte[] blocks, int blocksOffset, int iterations) {
+ final long[] longBLocks = new long[blockCount() * iterations];
+ encode(values, valuesOffset, longBLocks, 0, iterations);
+ ByteBuffer.wrap(blocks, blocksOffset, 8 * iterations * blockCount()).asLongBuffer().put(longBLocks);
+ }
+
+ @Override
+ public void encode(int[] values, int valuesOffset, byte[] blocks, int blocksOffset, int iterations) {
+ final long[] longBLocks = new long[blockCount() * iterations];
+ encode(values, valuesOffset, longBLocks, 0, iterations);
+ ByteBuffer.wrap(blocks, blocksOffset, 8 * iterations * blockCount()).asLongBuffer().put(longBLocks);
}
/**
@@ -44,7 +177,7 @@ abstract class BulkOperation {
* - 16 bits per value -> b=1, v=4
* - 24 bits per value -> b=3, v=8
* - 50 bits per value -> b=25, v=32
- * - 63 bits per value -> b=63, v = 64
+ * - 63 bits per value -> b=63, v=64
* - ...
*
* A bulk read consists in copying <code>iterations*v</code> values that are
@@ -56,7747 +189,15 @@ abstract class BulkOperation {
* <code>ramBudget / (8 * (b + v))</code> (since a long is 8 bytes).
*/
public final int computeIterations(int valueCount, int ramBudget) {
- final int iterations = (ramBudget >>> 3) / (blocks() + values());
+ final int iterations = (ramBudget >>> 3) / (blockCount() + valueCount());
if (iterations == 0) {
// at least 1
return 1;
- } else if ((iterations - 1) * blocks() >= valueCount) {
+ } else if ((iterations - 1) * blockCount() >= valueCount) {
// don't allocate for more than the size of the reader
- return (int) Math.ceil((double) valueCount / values());
+ return (int) Math.ceil((double) valueCount / valueCount());
} else {
return iterations;
}
}
-
- /**
- * The minimum number of blocks required to perform a bulk get/set.
- */
- public abstract int blocks();
-
- /**
- * The number of values that can be stored in <code>blocks()</code> blocks.
- */
- public abstract int values();
-
- /**
- * Get <code>n * values()</code> values from <code>n * blocks()</code> blocks.
- */
- public abstract void get(long[] blocks, int blockIndex, long[] values, int valuesIndex, int iterations);
-
- /**
- * Set <code>n * values()</code> values into <code>n * blocks()</code> blocks.
- */
- public abstract void set(long[] blocks, int blockIndex, long[] values, int valuesIndex, int iterations);
-
- static {
- BULK_OPERATIONS.put(PackedInts.Format.PACKED, new BulkOperation[65]); BULK_OPERATIONS.get(PackedInts.Format.PACKED)[1] = new Packed64BulkOperation1();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[2] = new Packed64BulkOperation2();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[3] = new Packed64BulkOperation3();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[4] = new Packed64BulkOperation4();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[5] = new Packed64BulkOperation5();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[6] = new Packed64BulkOperation6();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[7] = new Packed64BulkOperation7();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[8] = new Packed64BulkOperation8();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[9] = new Packed64BulkOperation9();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[10] = new Packed64BulkOperation10();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[11] = new Packed64BulkOperation11();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[12] = new Packed64BulkOperation12();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[13] = new Packed64BulkOperation13();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[14] = new Packed64BulkOperation14();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[15] = new Packed64BulkOperation15();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[16] = new Packed64BulkOperation16();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[17] = new Packed64BulkOperation17();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[18] = new Packed64BulkOperation18();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[19] = new Packed64BulkOperation19();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[20] = new Packed64BulkOperation20();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[21] = new Packed64BulkOperation21();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[22] = new Packed64BulkOperation22();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[23] = new Packed64BulkOperation23();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[24] = new Packed64BulkOperation24();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[25] = new Packed64BulkOperation25();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[26] = new Packed64BulkOperation26();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[27] = new Packed64BulkOperation27();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[28] = new Packed64BulkOperation28();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[29] = new Packed64BulkOperation29();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[30] = new Packed64BulkOperation30();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[31] = new Packed64BulkOperation31();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[32] = new Packed64BulkOperation32();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[33] = new Packed64BulkOperation33();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[34] = new Packed64BulkOperation34();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[35] = new Packed64BulkOperation35();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[36] = new Packed64BulkOperation36();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[37] = new Packed64BulkOperation37();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[38] = new Packed64BulkOperation38();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[39] = new Packed64BulkOperation39();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[40] = new Packed64BulkOperation40();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[41] = new Packed64BulkOperation41();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[42] = new Packed64BulkOperation42();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[43] = new Packed64BulkOperation43();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[44] = new Packed64BulkOperation44();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[45] = new Packed64BulkOperation45();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[46] = new Packed64BulkOperation46();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[47] = new Packed64BulkOperation47();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[48] = new Packed64BulkOperation48();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[49] = new Packed64BulkOperation49();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[50] = new Packed64BulkOperation50();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[51] = new Packed64BulkOperation51();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[52] = new Packed64BulkOperation52();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[53] = new Packed64BulkOperation53();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[54] = new Packed64BulkOperation54();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[55] = new Packed64BulkOperation55();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[56] = new Packed64BulkOperation56();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[57] = new Packed64BulkOperation57();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[58] = new Packed64BulkOperation58();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[59] = new Packed64BulkOperation59();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[60] = new Packed64BulkOperation60();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[61] = new Packed64BulkOperation61();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[62] = new Packed64BulkOperation62();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[63] = new Packed64BulkOperation63();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED)[64] = new Packed64BulkOperation64();
- BULK_OPERATIONS.put(PackedInts.Format.PACKED_SINGLE_BLOCK, new BulkOperation[65]);
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[1] = new Packed64SingleBlockBulkOperation1();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[2] = new Packed64SingleBlockBulkOperation2();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[3] = new Packed64SingleBlockBulkOperation3();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[4] = new Packed64SingleBlockBulkOperation4();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[5] = new Packed64SingleBlockBulkOperation5();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[6] = new Packed64SingleBlockBulkOperation6();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[7] = new Packed64SingleBlockBulkOperation7();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[8] = new Packed64SingleBlockBulkOperation8();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[9] = new Packed64SingleBlockBulkOperation9();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[10] = new Packed64SingleBlockBulkOperation10();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[12] = new Packed64SingleBlockBulkOperation12();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[16] = new Packed64SingleBlockBulkOperation16();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[21] = new Packed64SingleBlockBulkOperation21();
- BULK_OPERATIONS.get(PackedInts.Format.PACKED_SINGLE_BLOCK)[32] = new Packed64SingleBlockBulkOperation32();
- }
- static final class Packed64BulkOperation1 extends BulkOperation {
-
- public int blocks() {
- return 1;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 63;
- values[vi++] = (block0 >>> 62) & 1L;
- values[vi++] = (block0 >>> 61) & 1L;
- values[vi++] = (block0 >>> 60) & 1L;
- values[vi++] = (block0 >>> 59) & 1L;
- values[vi++] = (block0 >>> 58) & 1L;
- values[vi++] = (block0 >>> 57) & 1L;
- values[vi++] = (block0 >>> 56) & 1L;
- values[vi++] = (block0 >>> 55) & 1L;
- values[vi++] = (block0 >>> 54) & 1L;
- values[vi++] = (block0 >>> 53) & 1L;
- values[vi++] = (block0 >>> 52) & 1L;
- values[vi++] = (block0 >>> 51) & 1L;
- values[vi++] = (block0 >>> 50) & 1L;
- values[vi++] = (block0 >>> 49) & 1L;
- values[vi++] = (block0 >>> 48) & 1L;
- values[vi++] = (block0 >>> 47) & 1L;
- values[vi++] = (block0 >>> 46) & 1L;
- values[vi++] = (block0 >>> 45) & 1L;
- values[vi++] = (block0 >>> 44) & 1L;
- values[vi++] = (block0 >>> 43) & 1L;
- values[vi++] = (block0 >>> 42) & 1L;
- values[vi++] = (block0 >>> 41) & 1L;
- values[vi++] = (block0 >>> 40) & 1L;
- values[vi++] = (block0 >>> 39) & 1L;
- values[vi++] = (block0 >>> 38) & 1L;
- values[vi++] = (block0 >>> 37) & 1L;
- values[vi++] = (block0 >>> 36) & 1L;
- values[vi++] = (block0 >>> 35) & 1L;
- values[vi++] = (block0 >>> 34) & 1L;
- values[vi++] = (block0 >>> 33) & 1L;
- values[vi++] = (block0 >>> 32) & 1L;
- values[vi++] = (block0 >>> 31) & 1L;
- values[vi++] = (block0 >>> 30) & 1L;
- values[vi++] = (block0 >>> 29) & 1L;
- values[vi++] = (block0 >>> 28) & 1L;
- values[vi++] = (block0 >>> 27) & 1L;
- values[vi++] = (block0 >>> 26) & 1L;
- values[vi++] = (block0 >>> 25) & 1L;
- values[vi++] = (block0 >>> 24) & 1L;
- values[vi++] = (block0 >>> 23) & 1L;
- values[vi++] = (block0 >>> 22) & 1L;
- values[vi++] = (block0 >>> 21) & 1L;
- values[vi++] = (block0 >>> 20) & 1L;
- values[vi++] = (block0 >>> 19) & 1L;
- values[vi++] = (block0 >>> 18) & 1L;
- values[vi++] = (block0 >>> 17) & 1L;
- values[vi++] = (block0 >>> 16) & 1L;
- values[vi++] = (block0 >>> 15) & 1L;
- values[vi++] = (block0 >>> 14) & 1L;
- values[vi++] = (block0 >>> 13) & 1L;
- values[vi++] = (block0 >>> 12) & 1L;
- values[vi++] = (block0 >>> 11) & 1L;
- values[vi++] = (block0 >>> 10) & 1L;
- values[vi++] = (block0 >>> 9) & 1L;
- values[vi++] = (block0 >>> 8) & 1L;
- values[vi++] = (block0 >>> 7) & 1L;
- values[vi++] = (block0 >>> 6) & 1L;
- values[vi++] = (block0 >>> 5) & 1L;
- values[vi++] = (block0 >>> 4) & 1L;
- values[vi++] = (block0 >>> 3) & 1L;
- values[vi++] = (block0 >>> 2) & 1L;
- values[vi++] = (block0 >>> 1) & 1L;
- values[vi++] = block0 & 1L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 62) | (values[vi++] << 61) | (values[vi++] << 60) | (values[vi++] << 59) | (values[vi++] << 58) | (values[vi++] << 57) | (values[vi++] << 56) | (values[vi++] << 55) | (values[vi++] << 54) | (values[vi++] << 53) | (values[vi++] << 52) | (values[vi++] << 51) | (values[vi++] << 50) | (values[vi++] << 49) | (values[vi++] << 48) | (values[vi++] << 47) | (values[vi++] << 46) | (values[vi++] << 45) | (values[vi++] << 44) | (values[vi++] << 43) | (values[vi++] << 42) | (values[vi++] << 41) | (values[vi++] << 40) | (values[vi++] << 39) | (values[vi++] << 38) | (values[vi++] << 37) | (values[vi++] << 36) | (values[vi++] << 35) | (values[vi++] << 34) | (values[vi++] << 33) | (values[vi++] << 32) | (values[vi++] << 31) | (values[vi++] << 30) | (values[vi++] << 29) | (values[vi++] << 28) | (values[vi++] << 27) | (values[vi++] << 26) | (values[vi++] << 25) | (values[vi++] << 24) | (values[vi++] << 23) | (values[vi++] << 22) |
(values[vi++] << 21) | (values[vi++] << 20) | (values[vi++] << 19) | (values[vi++] << 18) | (values[vi++] << 17) | (values[vi++] << 16) | (values[vi++] << 15) | (values[vi++] << 14) | (values[vi++] << 13) | (values[vi++] << 12) | (values[vi++] << 11) | (values[vi++] << 10) | (values[vi++] << 9) | (values[vi++] << 8) | (values[vi++] << 7) | (values[vi++] << 6) | (values[vi++] << 5) | (values[vi++] << 4) | (values[vi++] << 3) | (values[vi++] << 2) | (values[vi++] << 1) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation2 extends BulkOperation {
-
- public int blocks() {
- return 1;
- }
-
- public int values() {
- return 32;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 62;
- values[vi++] = (block0 >>> 60) & 3L;
- values[vi++] = (block0 >>> 58) & 3L;
- values[vi++] = (block0 >>> 56) & 3L;
- values[vi++] = (block0 >>> 54) & 3L;
- values[vi++] = (block0 >>> 52) & 3L;
- values[vi++] = (block0 >>> 50) & 3L;
- values[vi++] = (block0 >>> 48) & 3L;
- values[vi++] = (block0 >>> 46) & 3L;
- values[vi++] = (block0 >>> 44) & 3L;
- values[vi++] = (block0 >>> 42) & 3L;
- values[vi++] = (block0 >>> 40) & 3L;
- values[vi++] = (block0 >>> 38) & 3L;
- values[vi++] = (block0 >>> 36) & 3L;
- values[vi++] = (block0 >>> 34) & 3L;
- values[vi++] = (block0 >>> 32) & 3L;
- values[vi++] = (block0 >>> 30) & 3L;
- values[vi++] = (block0 >>> 28) & 3L;
- values[vi++] = (block0 >>> 26) & 3L;
- values[vi++] = (block0 >>> 24) & 3L;
- values[vi++] = (block0 >>> 22) & 3L;
- values[vi++] = (block0 >>> 20) & 3L;
- values[vi++] = (block0 >>> 18) & 3L;
- values[vi++] = (block0 >>> 16) & 3L;
- values[vi++] = (block0 >>> 14) & 3L;
- values[vi++] = (block0 >>> 12) & 3L;
- values[vi++] = (block0 >>> 10) & 3L;
- values[vi++] = (block0 >>> 8) & 3L;
- values[vi++] = (block0 >>> 6) & 3L;
- values[vi++] = (block0 >>> 4) & 3L;
- values[vi++] = (block0 >>> 2) & 3L;
- values[vi++] = block0 & 3L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 60) | (values[vi++] << 58) | (values[vi++] << 56) | (values[vi++] << 54) | (values[vi++] << 52) | (values[vi++] << 50) | (values[vi++] << 48) | (values[vi++] << 46) | (values[vi++] << 44) | (values[vi++] << 42) | (values[vi++] << 40) | (values[vi++] << 38) | (values[vi++] << 36) | (values[vi++] << 34) | (values[vi++] << 32) | (values[vi++] << 30) | (values[vi++] << 28) | (values[vi++] << 26) | (values[vi++] << 24) | (values[vi++] << 22) | (values[vi++] << 20) | (values[vi++] << 18) | (values[vi++] << 16) | (values[vi++] << 14) | (values[vi++] << 12) | (values[vi++] << 10) | (values[vi++] << 8) | (values[vi++] << 6) | (values[vi++] << 4) | (values[vi++] << 2) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation3 extends BulkOperation {
-
- public int blocks() {
- return 3;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 61;
- values[vi++] = (block0 >>> 58) & 7L;
- values[vi++] = (block0 >>> 55) & 7L;
- values[vi++] = (block0 >>> 52) & 7L;
- values[vi++] = (block0 >>> 49) & 7L;
- values[vi++] = (block0 >>> 46) & 7L;
- values[vi++] = (block0 >>> 43) & 7L;
- values[vi++] = (block0 >>> 40) & 7L;
- values[vi++] = (block0 >>> 37) & 7L;
- values[vi++] = (block0 >>> 34) & 7L;
- values[vi++] = (block0 >>> 31) & 7L;
- values[vi++] = (block0 >>> 28) & 7L;
- values[vi++] = (block0 >>> 25) & 7L;
- values[vi++] = (block0 >>> 22) & 7L;
- values[vi++] = (block0 >>> 19) & 7L;
- values[vi++] = (block0 >>> 16) & 7L;
- values[vi++] = (block0 >>> 13) & 7L;
- values[vi++] = (block0 >>> 10) & 7L;
- values[vi++] = (block0 >>> 7) & 7L;
- values[vi++] = (block0 >>> 4) & 7L;
- values[vi++] = (block0 >>> 1) & 7L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 1L) << 2) | (block1 >>> 62);
- values[vi++] = (block1 >>> 59) & 7L;
- values[vi++] = (block1 >>> 56) & 7L;
- values[vi++] = (block1 >>> 53) & 7L;
- values[vi++] = (block1 >>> 50) & 7L;
- values[vi++] = (block1 >>> 47) & 7L;
- values[vi++] = (block1 >>> 44) & 7L;
- values[vi++] = (block1 >>> 41) & 7L;
- values[vi++] = (block1 >>> 38) & 7L;
- values[vi++] = (block1 >>> 35) & 7L;
- values[vi++] = (block1 >>> 32) & 7L;
- values[vi++] = (block1 >>> 29) & 7L;
- values[vi++] = (block1 >>> 26) & 7L;
- values[vi++] = (block1 >>> 23) & 7L;
- values[vi++] = (block1 >>> 20) & 7L;
- values[vi++] = (block1 >>> 17) & 7L;
- values[vi++] = (block1 >>> 14) & 7L;
- values[vi++] = (block1 >>> 11) & 7L;
- values[vi++] = (block1 >>> 8) & 7L;
- values[vi++] = (block1 >>> 5) & 7L;
- values[vi++] = (block1 >>> 2) & 7L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 3L) << 1) | (block2 >>> 63);
- values[vi++] = (block2 >>> 60) & 7L;
- values[vi++] = (block2 >>> 57) & 7L;
- values[vi++] = (block2 >>> 54) & 7L;
- values[vi++] = (block2 >>> 51) & 7L;
- values[vi++] = (block2 >>> 48) & 7L;
- values[vi++] = (block2 >>> 45) & 7L;
- values[vi++] = (block2 >>> 42) & 7L;
- values[vi++] = (block2 >>> 39) & 7L;
- values[vi++] = (block2 >>> 36) & 7L;
- values[vi++] = (block2 >>> 33) & 7L;
- values[vi++] = (block2 >>> 30) & 7L;
- values[vi++] = (block2 >>> 27) & 7L;
- values[vi++] = (block2 >>> 24) & 7L;
- values[vi++] = (block2 >>> 21) & 7L;
- values[vi++] = (block2 >>> 18) & 7L;
- values[vi++] = (block2 >>> 15) & 7L;
- values[vi++] = (block2 >>> 12) & 7L;
- values[vi++] = (block2 >>> 9) & 7L;
- values[vi++] = (block2 >>> 6) & 7L;
- values[vi++] = (block2 >>> 3) & 7L;
- values[vi++] = block2 & 7L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 61) | (values[vi++] << 58) | (values[vi++] << 55) | (values[vi++] << 52) | (values[vi++] << 49) | (values[vi++] << 46) | (values[vi++] << 43) | (values[vi++] << 40) | (values[vi++] << 37) | (values[vi++] << 34) | (values[vi++] << 31) | (values[vi++] << 28) | (values[vi++] << 25) | (values[vi++] << 22) | (values[vi++] << 19) | (values[vi++] << 16) | (values[vi++] << 13) | (values[vi++] << 10) | (values[vi++] << 7) | (values[vi++] << 4) | (values[vi++] << 1) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 59) | (values[vi++] << 56) | (values[vi++] << 53) | (values[vi++] << 50) | (values[vi++] << 47) | (values[vi++] << 44) | (values[vi++] << 41) | (values[vi++] << 38) | (values[vi++] << 35) | (values[vi++] << 32) | (values[vi++] << 29) | (values[vi++] << 26) | (values[vi++] << 23) | (values[vi++] << 20) | (values[vi++] << 17) | (values[vi++] << 14) | (values[vi++] << 11) | (values[vi++] << 8) | (values[vi++] << 5) | (values[vi++] << 2) | (values[vi] >>> 1);
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 60) | (values[vi++] << 57) | (values[vi++] << 54) | (values[vi++] << 51) | (values[vi++] << 48) | (values[vi++] << 45) | (values[vi++] << 42) | (values[vi++] << 39) | (values[vi++] << 36) | (values[vi++] << 33) | (values[vi++] << 30) | (values[vi++] << 27) | (values[vi++] << 24) | (values[vi++] << 21) | (values[vi++] << 18) | (values[vi++] << 15) | (values[vi++] << 12) | (values[vi++] << 9) | (values[vi++] << 6) | (values[vi++] << 3) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation4 extends BulkOperation {
-
- public int blocks() {
- return 1;
- }
-
- public int values() {
- return 16;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 60;
- values[vi++] = (block0 >>> 56) & 15L;
- values[vi++] = (block0 >>> 52) & 15L;
- values[vi++] = (block0 >>> 48) & 15L;
- values[vi++] = (block0 >>> 44) & 15L;
- values[vi++] = (block0 >>> 40) & 15L;
- values[vi++] = (block0 >>> 36) & 15L;
- values[vi++] = (block0 >>> 32) & 15L;
- values[vi++] = (block0 >>> 28) & 15L;
- values[vi++] = (block0 >>> 24) & 15L;
- values[vi++] = (block0 >>> 20) & 15L;
- values[vi++] = (block0 >>> 16) & 15L;
- values[vi++] = (block0 >>> 12) & 15L;
- values[vi++] = (block0 >>> 8) & 15L;
- values[vi++] = (block0 >>> 4) & 15L;
- values[vi++] = block0 & 15L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 56) | (values[vi++] << 52) | (values[vi++] << 48) | (values[vi++] << 44) | (values[vi++] << 40) | (values[vi++] << 36) | (values[vi++] << 32) | (values[vi++] << 28) | (values[vi++] << 24) | (values[vi++] << 20) | (values[vi++] << 16) | (values[vi++] << 12) | (values[vi++] << 8) | (values[vi++] << 4) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation5 extends BulkOperation {
-
- public int blocks() {
- return 5;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 59;
- values[vi++] = (block0 >>> 54) & 31L;
- values[vi++] = (block0 >>> 49) & 31L;
- values[vi++] = (block0 >>> 44) & 31L;
- values[vi++] = (block0 >>> 39) & 31L;
- values[vi++] = (block0 >>> 34) & 31L;
- values[vi++] = (block0 >>> 29) & 31L;
- values[vi++] = (block0 >>> 24) & 31L;
- values[vi++] = (block0 >>> 19) & 31L;
- values[vi++] = (block0 >>> 14) & 31L;
- values[vi++] = (block0 >>> 9) & 31L;
- values[vi++] = (block0 >>> 4) & 31L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 15L) << 1) | (block1 >>> 63);
- values[vi++] = (block1 >>> 58) & 31L;
- values[vi++] = (block1 >>> 53) & 31L;
- values[vi++] = (block1 >>> 48) & 31L;
- values[vi++] = (block1 >>> 43) & 31L;
- values[vi++] = (block1 >>> 38) & 31L;
- values[vi++] = (block1 >>> 33) & 31L;
- values[vi++] = (block1 >>> 28) & 31L;
- values[vi++] = (block1 >>> 23) & 31L;
- values[vi++] = (block1 >>> 18) & 31L;
- values[vi++] = (block1 >>> 13) & 31L;
- values[vi++] = (block1 >>> 8) & 31L;
- values[vi++] = (block1 >>> 3) & 31L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 7L) << 2) | (block2 >>> 62);
- values[vi++] = (block2 >>> 57) & 31L;
- values[vi++] = (block2 >>> 52) & 31L;
- values[vi++] = (block2 >>> 47) & 31L;
- values[vi++] = (block2 >>> 42) & 31L;
- values[vi++] = (block2 >>> 37) & 31L;
- values[vi++] = (block2 >>> 32) & 31L;
- values[vi++] = (block2 >>> 27) & 31L;
- values[vi++] = (block2 >>> 22) & 31L;
- values[vi++] = (block2 >>> 17) & 31L;
- values[vi++] = (block2 >>> 12) & 31L;
- values[vi++] = (block2 >>> 7) & 31L;
- values[vi++] = (block2 >>> 2) & 31L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 3L) << 3) | (block3 >>> 61);
- values[vi++] = (block3 >>> 56) & 31L;
- values[vi++] = (block3 >>> 51) & 31L;
- values[vi++] = (block3 >>> 46) & 31L;
- values[vi++] = (block3 >>> 41) & 31L;
- values[vi++] = (block3 >>> 36) & 31L;
- values[vi++] = (block3 >>> 31) & 31L;
- values[vi++] = (block3 >>> 26) & 31L;
- values[vi++] = (block3 >>> 21) & 31L;
- values[vi++] = (block3 >>> 16) & 31L;
- values[vi++] = (block3 >>> 11) & 31L;
- values[vi++] = (block3 >>> 6) & 31L;
- values[vi++] = (block3 >>> 1) & 31L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 1L) << 4) | (block4 >>> 60);
- values[vi++] = (block4 >>> 55) & 31L;
- values[vi++] = (block4 >>> 50) & 31L;
- values[vi++] = (block4 >>> 45) & 31L;
- values[vi++] = (block4 >>> 40) & 31L;
- values[vi++] = (block4 >>> 35) & 31L;
- values[vi++] = (block4 >>> 30) & 31L;
- values[vi++] = (block4 >>> 25) & 31L;
- values[vi++] = (block4 >>> 20) & 31L;
- values[vi++] = (block4 >>> 15) & 31L;
- values[vi++] = (block4 >>> 10) & 31L;
- values[vi++] = (block4 >>> 5) & 31L;
- values[vi++] = block4 & 31L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 59) | (values[vi++] << 54) | (values[vi++] << 49) | (values[vi++] << 44) | (values[vi++] << 39) | (values[vi++] << 34) | (values[vi++] << 29) | (values[vi++] << 24) | (values[vi++] << 19) | (values[vi++] << 14) | (values[vi++] << 9) | (values[vi++] << 4) | (values[vi] >>> 1);
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 58) | (values[vi++] << 53) | (values[vi++] << 48) | (values[vi++] << 43) | (values[vi++] << 38) | (values[vi++] << 33) | (values[vi++] << 28) | (values[vi++] << 23) | (values[vi++] << 18) | (values[vi++] << 13) | (values[vi++] << 8) | (values[vi++] << 3) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 57) | (values[vi++] << 52) | (values[vi++] << 47) | (values[vi++] << 42) | (values[vi++] << 37) | (values[vi++] << 32) | (values[vi++] << 27) | (values[vi++] << 22) | (values[vi++] << 17) | (values[vi++] << 12) | (values[vi++] << 7) | (values[vi++] << 2) | (values[vi] >>> 3);
- blocks[bi++] = (values[vi++] << 61) | (values[vi++] << 56) | (values[vi++] << 51) | (values[vi++] << 46) | (values[vi++] << 41) | (values[vi++] << 36) | (values[vi++] << 31) | (values[vi++] << 26) | (values[vi++] << 21) | (values[vi++] << 16) | (values[vi++] << 11) | (values[vi++] << 6) | (values[vi++] << 1) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 55) | (values[vi++] << 50) | (values[vi++] << 45) | (values[vi++] << 40) | (values[vi++] << 35) | (values[vi++] << 30) | (values[vi++] << 25) | (values[vi++] << 20) | (values[vi++] << 15) | (values[vi++] << 10) | (values[vi++] << 5) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation6 extends BulkOperation {
-
- public int blocks() {
- return 3;
- }
-
- public int values() {
- return 32;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 58;
- values[vi++] = (block0 >>> 52) & 63L;
- values[vi++] = (block0 >>> 46) & 63L;
- values[vi++] = (block0 >>> 40) & 63L;
- values[vi++] = (block0 >>> 34) & 63L;
- values[vi++] = (block0 >>> 28) & 63L;
- values[vi++] = (block0 >>> 22) & 63L;
- values[vi++] = (block0 >>> 16) & 63L;
- values[vi++] = (block0 >>> 10) & 63L;
- values[vi++] = (block0 >>> 4) & 63L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 15L) << 2) | (block1 >>> 62);
- values[vi++] = (block1 >>> 56) & 63L;
- values[vi++] = (block1 >>> 50) & 63L;
- values[vi++] = (block1 >>> 44) & 63L;
- values[vi++] = (block1 >>> 38) & 63L;
- values[vi++] = (block1 >>> 32) & 63L;
- values[vi++] = (block1 >>> 26) & 63L;
- values[vi++] = (block1 >>> 20) & 63L;
- values[vi++] = (block1 >>> 14) & 63L;
- values[vi++] = (block1 >>> 8) & 63L;
- values[vi++] = (block1 >>> 2) & 63L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 3L) << 4) | (block2 >>> 60);
- values[vi++] = (block2 >>> 54) & 63L;
- values[vi++] = (block2 >>> 48) & 63L;
- values[vi++] = (block2 >>> 42) & 63L;
- values[vi++] = (block2 >>> 36) & 63L;
- values[vi++] = (block2 >>> 30) & 63L;
- values[vi++] = (block2 >>> 24) & 63L;
- values[vi++] = (block2 >>> 18) & 63L;
- values[vi++] = (block2 >>> 12) & 63L;
- values[vi++] = (block2 >>> 6) & 63L;
- values[vi++] = block2 & 63L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 52) | (values[vi++] << 46) | (values[vi++] << 40) | (values[vi++] << 34) | (values[vi++] << 28) | (values[vi++] << 22) | (values[vi++] << 16) | (values[vi++] << 10) | (values[vi++] << 4) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 56) | (values[vi++] << 50) | (values[vi++] << 44) | (values[vi++] << 38) | (values[vi++] << 32) | (values[vi++] << 26) | (values[vi++] << 20) | (values[vi++] << 14) | (values[vi++] << 8) | (values[vi++] << 2) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 54) | (values[vi++] << 48) | (values[vi++] << 42) | (values[vi++] << 36) | (values[vi++] << 30) | (values[vi++] << 24) | (values[vi++] << 18) | (values[vi++] << 12) | (values[vi++] << 6) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation7 extends BulkOperation {
-
- public int blocks() {
- return 7;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 57;
- values[vi++] = (block0 >>> 50) & 127L;
- values[vi++] = (block0 >>> 43) & 127L;
- values[vi++] = (block0 >>> 36) & 127L;
- values[vi++] = (block0 >>> 29) & 127L;
- values[vi++] = (block0 >>> 22) & 127L;
- values[vi++] = (block0 >>> 15) & 127L;
- values[vi++] = (block0 >>> 8) & 127L;
- values[vi++] = (block0 >>> 1) & 127L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 1L) << 6) | (block1 >>> 58);
- values[vi++] = (block1 >>> 51) & 127L;
- values[vi++] = (block1 >>> 44) & 127L;
- values[vi++] = (block1 >>> 37) & 127L;
- values[vi++] = (block1 >>> 30) & 127L;
- values[vi++] = (block1 >>> 23) & 127L;
- values[vi++] = (block1 >>> 16) & 127L;
- values[vi++] = (block1 >>> 9) & 127L;
- values[vi++] = (block1 >>> 2) & 127L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 3L) << 5) | (block2 >>> 59);
- values[vi++] = (block2 >>> 52) & 127L;
- values[vi++] = (block2 >>> 45) & 127L;
- values[vi++] = (block2 >>> 38) & 127L;
- values[vi++] = (block2 >>> 31) & 127L;
- values[vi++] = (block2 >>> 24) & 127L;
- values[vi++] = (block2 >>> 17) & 127L;
- values[vi++] = (block2 >>> 10) & 127L;
- values[vi++] = (block2 >>> 3) & 127L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 7L) << 4) | (block3 >>> 60);
- values[vi++] = (block3 >>> 53) & 127L;
- values[vi++] = (block3 >>> 46) & 127L;
- values[vi++] = (block3 >>> 39) & 127L;
- values[vi++] = (block3 >>> 32) & 127L;
- values[vi++] = (block3 >>> 25) & 127L;
- values[vi++] = (block3 >>> 18) & 127L;
- values[vi++] = (block3 >>> 11) & 127L;
- values[vi++] = (block3 >>> 4) & 127L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 15L) << 3) | (block4 >>> 61);
- values[vi++] = (block4 >>> 54) & 127L;
- values[vi++] = (block4 >>> 47) & 127L;
- values[vi++] = (block4 >>> 40) & 127L;
- values[vi++] = (block4 >>> 33) & 127L;
- values[vi++] = (block4 >>> 26) & 127L;
- values[vi++] = (block4 >>> 19) & 127L;
- values[vi++] = (block4 >>> 12) & 127L;
- values[vi++] = (block4 >>> 5) & 127L;
- final long block5 = blocks[bi++];
- values[vi++] = ((block4 & 31L) << 2) | (block5 >>> 62);
- values[vi++] = (block5 >>> 55) & 127L;
- values[vi++] = (block5 >>> 48) & 127L;
- values[vi++] = (block5 >>> 41) & 127L;
- values[vi++] = (block5 >>> 34) & 127L;
- values[vi++] = (block5 >>> 27) & 127L;
- values[vi++] = (block5 >>> 20) & 127L;
- values[vi++] = (block5 >>> 13) & 127L;
- values[vi++] = (block5 >>> 6) & 127L;
- final long block6 = blocks[bi++];
- values[vi++] = ((block5 & 63L) << 1) | (block6 >>> 63);
- values[vi++] = (block6 >>> 56) & 127L;
- values[vi++] = (block6 >>> 49) & 127L;
- values[vi++] = (block6 >>> 42) & 127L;
- values[vi++] = (block6 >>> 35) & 127L;
- values[vi++] = (block6 >>> 28) & 127L;
- values[vi++] = (block6 >>> 21) & 127L;
- values[vi++] = (block6 >>> 14) & 127L;
- values[vi++] = (block6 >>> 7) & 127L;
- values[vi++] = block6 & 127L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 57) | (values[vi++] << 50) | (values[vi++] << 43) | (values[vi++] << 36) | (values[vi++] << 29) | (values[vi++] << 22) | (values[vi++] << 15) | (values[vi++] << 8) | (values[vi++] << 1) | (values[vi] >>> 6);
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 51) | (values[vi++] << 44) | (values[vi++] << 37) | (values[vi++] << 30) | (values[vi++] << 23) | (values[vi++] << 16) | (values[vi++] << 9) | (values[vi++] << 2) | (values[vi] >>> 5);
- blocks[bi++] = (values[vi++] << 59) | (values[vi++] << 52) | (values[vi++] << 45) | (values[vi++] << 38) | (values[vi++] << 31) | (values[vi++] << 24) | (values[vi++] << 17) | (values[vi++] << 10) | (values[vi++] << 3) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 53) | (values[vi++] << 46) | (values[vi++] << 39) | (values[vi++] << 32) | (values[vi++] << 25) | (values[vi++] << 18) | (values[vi++] << 11) | (values[vi++] << 4) | (values[vi] >>> 3);
- blocks[bi++] = (values[vi++] << 61) | (values[vi++] << 54) | (values[vi++] << 47) | (values[vi++] << 40) | (values[vi++] << 33) | (values[vi++] << 26) | (values[vi++] << 19) | (values[vi++] << 12) | (values[vi++] << 5) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 55) | (values[vi++] << 48) | (values[vi++] << 41) | (values[vi++] << 34) | (values[vi++] << 27) | (values[vi++] << 20) | (values[vi++] << 13) | (values[vi++] << 6) | (values[vi] >>> 1);
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 56) | (values[vi++] << 49) | (values[vi++] << 42) | (values[vi++] << 35) | (values[vi++] << 28) | (values[vi++] << 21) | (values[vi++] << 14) | (values[vi++] << 7) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation8 extends BulkOperation {
-
- public int blocks() {
- return 1;
- }
-
- public int values() {
- return 8;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 56;
- values[vi++] = (block0 >>> 48) & 255L;
- values[vi++] = (block0 >>> 40) & 255L;
- values[vi++] = (block0 >>> 32) & 255L;
- values[vi++] = (block0 >>> 24) & 255L;
- values[vi++] = (block0 >>> 16) & 255L;
- values[vi++] = (block0 >>> 8) & 255L;
- values[vi++] = block0 & 255L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 48) | (values[vi++] << 40) | (values[vi++] << 32) | (values[vi++] << 24) | (values[vi++] << 16) | (values[vi++] << 8) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation9 extends BulkOperation {
-
- public int blocks() {
- return 9;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 55;
- values[vi++] = (block0 >>> 46) & 511L;
- values[vi++] = (block0 >>> 37) & 511L;
- values[vi++] = (block0 >>> 28) & 511L;
- values[vi++] = (block0 >>> 19) & 511L;
- values[vi++] = (block0 >>> 10) & 511L;
- values[vi++] = (block0 >>> 1) & 511L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 1L) << 8) | (block1 >>> 56);
- values[vi++] = (block1 >>> 47) & 511L;
- values[vi++] = (block1 >>> 38) & 511L;
- values[vi++] = (block1 >>> 29) & 511L;
- values[vi++] = (block1 >>> 20) & 511L;
- values[vi++] = (block1 >>> 11) & 511L;
- values[vi++] = (block1 >>> 2) & 511L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 3L) << 7) | (block2 >>> 57);
- values[vi++] = (block2 >>> 48) & 511L;
- values[vi++] = (block2 >>> 39) & 511L;
- values[vi++] = (block2 >>> 30) & 511L;
- values[vi++] = (block2 >>> 21) & 511L;
- values[vi++] = (block2 >>> 12) & 511L;
- values[vi++] = (block2 >>> 3) & 511L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 7L) << 6) | (block3 >>> 58);
- values[vi++] = (block3 >>> 49) & 511L;
- values[vi++] = (block3 >>> 40) & 511L;
- values[vi++] = (block3 >>> 31) & 511L;
- values[vi++] = (block3 >>> 22) & 511L;
- values[vi++] = (block3 >>> 13) & 511L;
- values[vi++] = (block3 >>> 4) & 511L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 15L) << 5) | (block4 >>> 59);
- values[vi++] = (block4 >>> 50) & 511L;
- values[vi++] = (block4 >>> 41) & 511L;
- values[vi++] = (block4 >>> 32) & 511L;
- values[vi++] = (block4 >>> 23) & 511L;
- values[vi++] = (block4 >>> 14) & 511L;
- values[vi++] = (block4 >>> 5) & 511L;
- final long block5 = blocks[bi++];
- values[vi++] = ((block4 & 31L) << 4) | (block5 >>> 60);
- values[vi++] = (block5 >>> 51) & 511L;
- values[vi++] = (block5 >>> 42) & 511L;
- values[vi++] = (block5 >>> 33) & 511L;
- values[vi++] = (block5 >>> 24) & 511L;
- values[vi++] = (block5 >>> 15) & 511L;
- values[vi++] = (block5 >>> 6) & 511L;
- final long block6 = blocks[bi++];
- values[vi++] = ((block5 & 63L) << 3) | (block6 >>> 61);
- values[vi++] = (block6 >>> 52) & 511L;
- values[vi++] = (block6 >>> 43) & 511L;
- values[vi++] = (block6 >>> 34) & 511L;
- values[vi++] = (block6 >>> 25) & 511L;
- values[vi++] = (block6 >>> 16) & 511L;
- values[vi++] = (block6 >>> 7) & 511L;
- final long block7 = blocks[bi++];
- values[vi++] = ((block6 & 127L) << 2) | (block7 >>> 62);
- values[vi++] = (block7 >>> 53) & 511L;
- values[vi++] = (block7 >>> 44) & 511L;
- values[vi++] = (block7 >>> 35) & 511L;
- values[vi++] = (block7 >>> 26) & 511L;
- values[vi++] = (block7 >>> 17) & 511L;
- values[vi++] = (block7 >>> 8) & 511L;
- final long block8 = blocks[bi++];
- values[vi++] = ((block7 & 255L) << 1) | (block8 >>> 63);
- values[vi++] = (block8 >>> 54) & 511L;
- values[vi++] = (block8 >>> 45) & 511L;
- values[vi++] = (block8 >>> 36) & 511L;
- values[vi++] = (block8 >>> 27) & 511L;
- values[vi++] = (block8 >>> 18) & 511L;
- values[vi++] = (block8 >>> 9) & 511L;
- values[vi++] = block8 & 511L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 55) | (values[vi++] << 46) | (values[vi++] << 37) | (values[vi++] << 28) | (values[vi++] << 19) | (values[vi++] << 10) | (values[vi++] << 1) | (values[vi] >>> 8);
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 47) | (values[vi++] << 38) | (values[vi++] << 29) | (values[vi++] << 20) | (values[vi++] << 11) | (values[vi++] << 2) | (values[vi] >>> 7);
- blocks[bi++] = (values[vi++] << 57) | (values[vi++] << 48) | (values[vi++] << 39) | (values[vi++] << 30) | (values[vi++] << 21) | (values[vi++] << 12) | (values[vi++] << 3) | (values[vi] >>> 6);
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 49) | (values[vi++] << 40) | (values[vi++] << 31) | (values[vi++] << 22) | (values[vi++] << 13) | (values[vi++] << 4) | (values[vi] >>> 5);
- blocks[bi++] = (values[vi++] << 59) | (values[vi++] << 50) | (values[vi++] << 41) | (values[vi++] << 32) | (values[vi++] << 23) | (values[vi++] << 14) | (values[vi++] << 5) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 51) | (values[vi++] << 42) | (values[vi++] << 33) | (values[vi++] << 24) | (values[vi++] << 15) | (values[vi++] << 6) | (values[vi] >>> 3);
- blocks[bi++] = (values[vi++] << 61) | (values[vi++] << 52) | (values[vi++] << 43) | (values[vi++] << 34) | (values[vi++] << 25) | (values[vi++] << 16) | (values[vi++] << 7) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 53) | (values[vi++] << 44) | (values[vi++] << 35) | (values[vi++] << 26) | (values[vi++] << 17) | (values[vi++] << 8) | (values[vi] >>> 1);
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 54) | (values[vi++] << 45) | (values[vi++] << 36) | (values[vi++] << 27) | (values[vi++] << 18) | (values[vi++] << 9) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation10 extends BulkOperation {
-
- public int blocks() {
- return 5;
- }
-
- public int values() {
- return 32;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 54;
- values[vi++] = (block0 >>> 44) & 1023L;
- values[vi++] = (block0 >>> 34) & 1023L;
- values[vi++] = (block0 >>> 24) & 1023L;
- values[vi++] = (block0 >>> 14) & 1023L;
- values[vi++] = (block0 >>> 4) & 1023L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 15L) << 6) | (block1 >>> 58);
- values[vi++] = (block1 >>> 48) & 1023L;
- values[vi++] = (block1 >>> 38) & 1023L;
- values[vi++] = (block1 >>> 28) & 1023L;
- values[vi++] = (block1 >>> 18) & 1023L;
- values[vi++] = (block1 >>> 8) & 1023L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 255L) << 2) | (block2 >>> 62);
- values[vi++] = (block2 >>> 52) & 1023L;
- values[vi++] = (block2 >>> 42) & 1023L;
- values[vi++] = (block2 >>> 32) & 1023L;
- values[vi++] = (block2 >>> 22) & 1023L;
- values[vi++] = (block2 >>> 12) & 1023L;
- values[vi++] = (block2 >>> 2) & 1023L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 3L) << 8) | (block3 >>> 56);
- values[vi++] = (block3 >>> 46) & 1023L;
- values[vi++] = (block3 >>> 36) & 1023L;
- values[vi++] = (block3 >>> 26) & 1023L;
- values[vi++] = (block3 >>> 16) & 1023L;
- values[vi++] = (block3 >>> 6) & 1023L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 63L) << 4) | (block4 >>> 60);
- values[vi++] = (block4 >>> 50) & 1023L;
- values[vi++] = (block4 >>> 40) & 1023L;
- values[vi++] = (block4 >>> 30) & 1023L;
- values[vi++] = (block4 >>> 20) & 1023L;
- values[vi++] = (block4 >>> 10) & 1023L;
- values[vi++] = block4 & 1023L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 54) | (values[vi++] << 44) | (values[vi++] << 34) | (values[vi++] << 24) | (values[vi++] << 14) | (values[vi++] << 4) | (values[vi] >>> 6);
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 48) | (values[vi++] << 38) | (values[vi++] << 28) | (values[vi++] << 18) | (values[vi++] << 8) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 52) | (values[vi++] << 42) | (values[vi++] << 32) | (values[vi++] << 22) | (values[vi++] << 12) | (values[vi++] << 2) | (values[vi] >>> 8);
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 46) | (values[vi++] << 36) | (values[vi++] << 26) | (values[vi++] << 16) | (values[vi++] << 6) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 50) | (values[vi++] << 40) | (values[vi++] << 30) | (values[vi++] << 20) | (values[vi++] << 10) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation11 extends BulkOperation {
-
- public int blocks() {
- return 11;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 53;
- values[vi++] = (block0 >>> 42) & 2047L;
- values[vi++] = (block0 >>> 31) & 2047L;
- values[vi++] = (block0 >>> 20) & 2047L;
- values[vi++] = (block0 >>> 9) & 2047L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 511L) << 2) | (block1 >>> 62);
- values[vi++] = (block1 >>> 51) & 2047L;
- values[vi++] = (block1 >>> 40) & 2047L;
- values[vi++] = (block1 >>> 29) & 2047L;
- values[vi++] = (block1 >>> 18) & 2047L;
- values[vi++] = (block1 >>> 7) & 2047L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 127L) << 4) | (block2 >>> 60);
- values[vi++] = (block2 >>> 49) & 2047L;
- values[vi++] = (block2 >>> 38) & 2047L;
- values[vi++] = (block2 >>> 27) & 2047L;
- values[vi++] = (block2 >>> 16) & 2047L;
- values[vi++] = (block2 >>> 5) & 2047L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 31L) << 6) | (block3 >>> 58);
- values[vi++] = (block3 >>> 47) & 2047L;
- values[vi++] = (block3 >>> 36) & 2047L;
- values[vi++] = (block3 >>> 25) & 2047L;
- values[vi++] = (block3 >>> 14) & 2047L;
- values[vi++] = (block3 >>> 3) & 2047L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 7L) << 8) | (block4 >>> 56);
- values[vi++] = (block4 >>> 45) & 2047L;
- values[vi++] = (block4 >>> 34) & 2047L;
- values[vi++] = (block4 >>> 23) & 2047L;
- values[vi++] = (block4 >>> 12) & 2047L;
- values[vi++] = (block4 >>> 1) & 2047L;
- final long block5 = blocks[bi++];
- values[vi++] = ((block4 & 1L) << 10) | (block5 >>> 54);
- values[vi++] = (block5 >>> 43) & 2047L;
- values[vi++] = (block5 >>> 32) & 2047L;
- values[vi++] = (block5 >>> 21) & 2047L;
- values[vi++] = (block5 >>> 10) & 2047L;
- final long block6 = blocks[bi++];
- values[vi++] = ((block5 & 1023L) << 1) | (block6 >>> 63);
- values[vi++] = (block6 >>> 52) & 2047L;
- values[vi++] = (block6 >>> 41) & 2047L;
- values[vi++] = (block6 >>> 30) & 2047L;
- values[vi++] = (block6 >>> 19) & 2047L;
- values[vi++] = (block6 >>> 8) & 2047L;
- final long block7 = blocks[bi++];
- values[vi++] = ((block6 & 255L) << 3) | (block7 >>> 61);
- values[vi++] = (block7 >>> 50) & 2047L;
- values[vi++] = (block7 >>> 39) & 2047L;
- values[vi++] = (block7 >>> 28) & 2047L;
- values[vi++] = (block7 >>> 17) & 2047L;
- values[vi++] = (block7 >>> 6) & 2047L;
- final long block8 = blocks[bi++];
- values[vi++] = ((block7 & 63L) << 5) | (block8 >>> 59);
- values[vi++] = (block8 >>> 48) & 2047L;
- values[vi++] = (block8 >>> 37) & 2047L;
- values[vi++] = (block8 >>> 26) & 2047L;
- values[vi++] = (block8 >>> 15) & 2047L;
- values[vi++] = (block8 >>> 4) & 2047L;
- final long block9 = blocks[bi++];
- values[vi++] = ((block8 & 15L) << 7) | (block9 >>> 57);
- values[vi++] = (block9 >>> 46) & 2047L;
- values[vi++] = (block9 >>> 35) & 2047L;
- values[vi++] = (block9 >>> 24) & 2047L;
- values[vi++] = (block9 >>> 13) & 2047L;
- values[vi++] = (block9 >>> 2) & 2047L;
- final long block10 = blocks[bi++];
- values[vi++] = ((block9 & 3L) << 9) | (block10 >>> 55);
- values[vi++] = (block10 >>> 44) & 2047L;
- values[vi++] = (block10 >>> 33) & 2047L;
- values[vi++] = (block10 >>> 22) & 2047L;
- values[vi++] = (block10 >>> 11) & 2047L;
- values[vi++] = block10 & 2047L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 53) | (values[vi++] << 42) | (values[vi++] << 31) | (values[vi++] << 20) | (values[vi++] << 9) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 51) | (values[vi++] << 40) | (values[vi++] << 29) | (values[vi++] << 18) | (values[vi++] << 7) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 49) | (values[vi++] << 38) | (values[vi++] << 27) | (values[vi++] << 16) | (values[vi++] << 5) | (values[vi] >>> 6);
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 47) | (values[vi++] << 36) | (values[vi++] << 25) | (values[vi++] << 14) | (values[vi++] << 3) | (values[vi] >>> 8);
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 45) | (values[vi++] << 34) | (values[vi++] << 23) | (values[vi++] << 12) | (values[vi++] << 1) | (values[vi] >>> 10);
- blocks[bi++] = (values[vi++] << 54) | (values[vi++] << 43) | (values[vi++] << 32) | (values[vi++] << 21) | (values[vi++] << 10) | (values[vi] >>> 1);
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 52) | (values[vi++] << 41) | (values[vi++] << 30) | (values[vi++] << 19) | (values[vi++] << 8) | (values[vi] >>> 3);
- blocks[bi++] = (values[vi++] << 61) | (values[vi++] << 50) | (values[vi++] << 39) | (values[vi++] << 28) | (values[vi++] << 17) | (values[vi++] << 6) | (values[vi] >>> 5);
- blocks[bi++] = (values[vi++] << 59) | (values[vi++] << 48) | (values[vi++] << 37) | (values[vi++] << 26) | (values[vi++] << 15) | (values[vi++] << 4) | (values[vi] >>> 7);
- blocks[bi++] = (values[vi++] << 57) | (values[vi++] << 46) | (values[vi++] << 35) | (values[vi++] << 24) | (values[vi++] << 13) | (values[vi++] << 2) | (values[vi] >>> 9);
- blocks[bi++] = (values[vi++] << 55) | (values[vi++] << 44) | (values[vi++] << 33) | (values[vi++] << 22) | (values[vi++] << 11) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation12 extends BulkOperation {
-
- public int blocks() {
- return 3;
- }
-
- public int values() {
- return 16;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 52;
- values[vi++] = (block0 >>> 40) & 4095L;
- values[vi++] = (block0 >>> 28) & 4095L;
- values[vi++] = (block0 >>> 16) & 4095L;
- values[vi++] = (block0 >>> 4) & 4095L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 15L) << 8) | (block1 >>> 56);
- values[vi++] = (block1 >>> 44) & 4095L;
- values[vi++] = (block1 >>> 32) & 4095L;
- values[vi++] = (block1 >>> 20) & 4095L;
- values[vi++] = (block1 >>> 8) & 4095L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 255L) << 4) | (block2 >>> 60);
- values[vi++] = (block2 >>> 48) & 4095L;
- values[vi++] = (block2 >>> 36) & 4095L;
- values[vi++] = (block2 >>> 24) & 4095L;
- values[vi++] = (block2 >>> 12) & 4095L;
- values[vi++] = block2 & 4095L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 52) | (values[vi++] << 40) | (values[vi++] << 28) | (values[vi++] << 16) | (values[vi++] << 4) | (values[vi] >>> 8);
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 44) | (values[vi++] << 32) | (values[vi++] << 20) | (values[vi++] << 8) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 48) | (values[vi++] << 36) | (values[vi++] << 24) | (values[vi++] << 12) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation13 extends BulkOperation {
-
- public int blocks() {
- return 13;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 51;
- values[vi++] = (block0 >>> 38) & 8191L;
- values[vi++] = (block0 >>> 25) & 8191L;
- values[vi++] = (block0 >>> 12) & 8191L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 4095L) << 1) | (block1 >>> 63);
- values[vi++] = (block1 >>> 50) & 8191L;
- values[vi++] = (block1 >>> 37) & 8191L;
- values[vi++] = (block1 >>> 24) & 8191L;
- values[vi++] = (block1 >>> 11) & 8191L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 2047L) << 2) | (block2 >>> 62);
- values[vi++] = (block2 >>> 49) & 8191L;
- values[vi++] = (block2 >>> 36) & 8191L;
- values[vi++] = (block2 >>> 23) & 8191L;
- values[vi++] = (block2 >>> 10) & 8191L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 1023L) << 3) | (block3 >>> 61);
- values[vi++] = (block3 >>> 48) & 8191L;
- values[vi++] = (block3 >>> 35) & 8191L;
- values[vi++] = (block3 >>> 22) & 8191L;
- values[vi++] = (block3 >>> 9) & 8191L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 511L) << 4) | (block4 >>> 60);
- values[vi++] = (block4 >>> 47) & 8191L;
- values[vi++] = (block4 >>> 34) & 8191L;
- values[vi++] = (block4 >>> 21) & 8191L;
- values[vi++] = (block4 >>> 8) & 8191L;
- final long block5 = blocks[bi++];
- values[vi++] = ((block4 & 255L) << 5) | (block5 >>> 59);
- values[vi++] = (block5 >>> 46) & 8191L;
- values[vi++] = (block5 >>> 33) & 8191L;
- values[vi++] = (block5 >>> 20) & 8191L;
- values[vi++] = (block5 >>> 7) & 8191L;
- final long block6 = blocks[bi++];
- values[vi++] = ((block5 & 127L) << 6) | (block6 >>> 58);
- values[vi++] = (block6 >>> 45) & 8191L;
- values[vi++] = (block6 >>> 32) & 8191L;
- values[vi++] = (block6 >>> 19) & 8191L;
- values[vi++] = (block6 >>> 6) & 8191L;
- final long block7 = blocks[bi++];
- values[vi++] = ((block6 & 63L) << 7) | (block7 >>> 57);
- values[vi++] = (block7 >>> 44) & 8191L;
- values[vi++] = (block7 >>> 31) & 8191L;
- values[vi++] = (block7 >>> 18) & 8191L;
- values[vi++] = (block7 >>> 5) & 8191L;
- final long block8 = blocks[bi++];
- values[vi++] = ((block7 & 31L) << 8) | (block8 >>> 56);
- values[vi++] = (block8 >>> 43) & 8191L;
- values[vi++] = (block8 >>> 30) & 8191L;
- values[vi++] = (block8 >>> 17) & 8191L;
- values[vi++] = (block8 >>> 4) & 8191L;
- final long block9 = blocks[bi++];
- values[vi++] = ((block8 & 15L) << 9) | (block9 >>> 55);
- values[vi++] = (block9 >>> 42) & 8191L;
- values[vi++] = (block9 >>> 29) & 8191L;
- values[vi++] = (block9 >>> 16) & 8191L;
- values[vi++] = (block9 >>> 3) & 8191L;
- final long block10 = blocks[bi++];
- values[vi++] = ((block9 & 7L) << 10) | (block10 >>> 54);
- values[vi++] = (block10 >>> 41) & 8191L;
- values[vi++] = (block10 >>> 28) & 8191L;
- values[vi++] = (block10 >>> 15) & 8191L;
- values[vi++] = (block10 >>> 2) & 8191L;
- final long block11 = blocks[bi++];
- values[vi++] = ((block10 & 3L) << 11) | (block11 >>> 53);
- values[vi++] = (block11 >>> 40) & 8191L;
- values[vi++] = (block11 >>> 27) & 8191L;
- values[vi++] = (block11 >>> 14) & 8191L;
- values[vi++] = (block11 >>> 1) & 8191L;
- final long block12 = blocks[bi++];
- values[vi++] = ((block11 & 1L) << 12) | (block12 >>> 52);
- values[vi++] = (block12 >>> 39) & 8191L;
- values[vi++] = (block12 >>> 26) & 8191L;
- values[vi++] = (block12 >>> 13) & 8191L;
- values[vi++] = block12 & 8191L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 51) | (values[vi++] << 38) | (values[vi++] << 25) | (values[vi++] << 12) | (values[vi] >>> 1);
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 50) | (values[vi++] << 37) | (values[vi++] << 24) | (values[vi++] << 11) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 49) | (values[vi++] << 36) | (values[vi++] << 23) | (values[vi++] << 10) | (values[vi] >>> 3);
- blocks[bi++] = (values[vi++] << 61) | (values[vi++] << 48) | (values[vi++] << 35) | (values[vi++] << 22) | (values[vi++] << 9) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 47) | (values[vi++] << 34) | (values[vi++] << 21) | (values[vi++] << 8) | (values[vi] >>> 5);
- blocks[bi++] = (values[vi++] << 59) | (values[vi++] << 46) | (values[vi++] << 33) | (values[vi++] << 20) | (values[vi++] << 7) | (values[vi] >>> 6);
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 45) | (values[vi++] << 32) | (values[vi++] << 19) | (values[vi++] << 6) | (values[vi] >>> 7);
- blocks[bi++] = (values[vi++] << 57) | (values[vi++] << 44) | (values[vi++] << 31) | (values[vi++] << 18) | (values[vi++] << 5) | (values[vi] >>> 8);
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 43) | (values[vi++] << 30) | (values[vi++] << 17) | (values[vi++] << 4) | (values[vi] >>> 9);
- blocks[bi++] = (values[vi++] << 55) | (values[vi++] << 42) | (values[vi++] << 29) | (values[vi++] << 16) | (values[vi++] << 3) | (values[vi] >>> 10);
- blocks[bi++] = (values[vi++] << 54) | (values[vi++] << 41) | (values[vi++] << 28) | (values[vi++] << 15) | (values[vi++] << 2) | (values[vi] >>> 11);
- blocks[bi++] = (values[vi++] << 53) | (values[vi++] << 40) | (values[vi++] << 27) | (values[vi++] << 14) | (values[vi++] << 1) | (values[vi] >>> 12);
- blocks[bi++] = (values[vi++] << 52) | (values[vi++] << 39) | (values[vi++] << 26) | (values[vi++] << 13) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation14 extends BulkOperation {
-
- public int blocks() {
- return 7;
- }
-
- public int values() {
- return 32;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 50;
- values[vi++] = (block0 >>> 36) & 16383L;
- values[vi++] = (block0 >>> 22) & 16383L;
- values[vi++] = (block0 >>> 8) & 16383L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 255L) << 6) | (block1 >>> 58);
- values[vi++] = (block1 >>> 44) & 16383L;
- values[vi++] = (block1 >>> 30) & 16383L;
- values[vi++] = (block1 >>> 16) & 16383L;
- values[vi++] = (block1 >>> 2) & 16383L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 3L) << 12) | (block2 >>> 52);
- values[vi++] = (block2 >>> 38) & 16383L;
- values[vi++] = (block2 >>> 24) & 16383L;
- values[vi++] = (block2 >>> 10) & 16383L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 1023L) << 4) | (block3 >>> 60);
- values[vi++] = (block3 >>> 46) & 16383L;
- values[vi++] = (block3 >>> 32) & 16383L;
- values[vi++] = (block3 >>> 18) & 16383L;
- values[vi++] = (block3 >>> 4) & 16383L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 15L) << 10) | (block4 >>> 54);
- values[vi++] = (block4 >>> 40) & 16383L;
- values[vi++] = (block4 >>> 26) & 16383L;
- values[vi++] = (block4 >>> 12) & 16383L;
- final long block5 = blocks[bi++];
- values[vi++] = ((block4 & 4095L) << 2) | (block5 >>> 62);
- values[vi++] = (block5 >>> 48) & 16383L;
- values[vi++] = (block5 >>> 34) & 16383L;
- values[vi++] = (block5 >>> 20) & 16383L;
- values[vi++] = (block5 >>> 6) & 16383L;
- final long block6 = blocks[bi++];
- values[vi++] = ((block5 & 63L) << 8) | (block6 >>> 56);
- values[vi++] = (block6 >>> 42) & 16383L;
- values[vi++] = (block6 >>> 28) & 16383L;
- values[vi++] = (block6 >>> 14) & 16383L;
- values[vi++] = block6 & 16383L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 50) | (values[vi++] << 36) | (values[vi++] << 22) | (values[vi++] << 8) | (values[vi] >>> 6);
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 44) | (values[vi++] << 30) | (values[vi++] << 16) | (values[vi++] << 2) | (values[vi] >>> 12);
- blocks[bi++] = (values[vi++] << 52) | (values[vi++] << 38) | (values[vi++] << 24) | (values[vi++] << 10) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 46) | (values[vi++] << 32) | (values[vi++] << 18) | (values[vi++] << 4) | (values[vi] >>> 10);
- blocks[bi++] = (values[vi++] << 54) | (values[vi++] << 40) | (values[vi++] << 26) | (values[vi++] << 12) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 48) | (values[vi++] << 34) | (values[vi++] << 20) | (values[vi++] << 6) | (values[vi] >>> 8);
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 42) | (values[vi++] << 28) | (values[vi++] << 14) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation15 extends BulkOperation {
-
- public int blocks() {
- return 15;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 49;
- values[vi++] = (block0 >>> 34) & 32767L;
- values[vi++] = (block0 >>> 19) & 32767L;
- values[vi++] = (block0 >>> 4) & 32767L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 15L) << 11) | (block1 >>> 53);
- values[vi++] = (block1 >>> 38) & 32767L;
- values[vi++] = (block1 >>> 23) & 32767L;
- values[vi++] = (block1 >>> 8) & 32767L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 255L) << 7) | (block2 >>> 57);
- values[vi++] = (block2 >>> 42) & 32767L;
- values[vi++] = (block2 >>> 27) & 32767L;
- values[vi++] = (block2 >>> 12) & 32767L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 4095L) << 3) | (block3 >>> 61);
- values[vi++] = (block3 >>> 46) & 32767L;
- values[vi++] = (block3 >>> 31) & 32767L;
- values[vi++] = (block3 >>> 16) & 32767L;
- values[vi++] = (block3 >>> 1) & 32767L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 1L) << 14) | (block4 >>> 50);
- values[vi++] = (block4 >>> 35) & 32767L;
- values[vi++] = (block4 >>> 20) & 32767L;
- values[vi++] = (block4 >>> 5) & 32767L;
- final long block5 = blocks[bi++];
- values[vi++] = ((block4 & 31L) << 10) | (block5 >>> 54);
- values[vi++] = (block5 >>> 39) & 32767L;
- values[vi++] = (block5 >>> 24) & 32767L;
- values[vi++] = (block5 >>> 9) & 32767L;
- final long block6 = blocks[bi++];
- values[vi++] = ((block5 & 511L) << 6) | (block6 >>> 58);
- values[vi++] = (block6 >>> 43) & 32767L;
- values[vi++] = (block6 >>> 28) & 32767L;
- values[vi++] = (block6 >>> 13) & 32767L;
- final long block7 = blocks[bi++];
- values[vi++] = ((block6 & 8191L) << 2) | (block7 >>> 62);
- values[vi++] = (block7 >>> 47) & 32767L;
- values[vi++] = (block7 >>> 32) & 32767L;
- values[vi++] = (block7 >>> 17) & 32767L;
- values[vi++] = (block7 >>> 2) & 32767L;
- final long block8 = blocks[bi++];
- values[vi++] = ((block7 & 3L) << 13) | (block8 >>> 51);
- values[vi++] = (block8 >>> 36) & 32767L;
- values[vi++] = (block8 >>> 21) & 32767L;
- values[vi++] = (block8 >>> 6) & 32767L;
- final long block9 = blocks[bi++];
- values[vi++] = ((block8 & 63L) << 9) | (block9 >>> 55);
- values[vi++] = (block9 >>> 40) & 32767L;
- values[vi++] = (block9 >>> 25) & 32767L;
- values[vi++] = (block9 >>> 10) & 32767L;
- final long block10 = blocks[bi++];
- values[vi++] = ((block9 & 1023L) << 5) | (block10 >>> 59);
- values[vi++] = (block10 >>> 44) & 32767L;
- values[vi++] = (block10 >>> 29) & 32767L;
- values[vi++] = (block10 >>> 14) & 32767L;
- final long block11 = blocks[bi++];
- values[vi++] = ((block10 & 16383L) << 1) | (block11 >>> 63);
- values[vi++] = (block11 >>> 48) & 32767L;
- values[vi++] = (block11 >>> 33) & 32767L;
- values[vi++] = (block11 >>> 18) & 32767L;
- values[vi++] = (block11 >>> 3) & 32767L;
- final long block12 = blocks[bi++];
- values[vi++] = ((block11 & 7L) << 12) | (block12 >>> 52);
- values[vi++] = (block12 >>> 37) & 32767L;
- values[vi++] = (block12 >>> 22) & 32767L;
- values[vi++] = (block12 >>> 7) & 32767L;
- final long block13 = blocks[bi++];
- values[vi++] = ((block12 & 127L) << 8) | (block13 >>> 56);
- values[vi++] = (block13 >>> 41) & 32767L;
- values[vi++] = (block13 >>> 26) & 32767L;
- values[vi++] = (block13 >>> 11) & 32767L;
- final long block14 = blocks[bi++];
- values[vi++] = ((block13 & 2047L) << 4) | (block14 >>> 60);
- values[vi++] = (block14 >>> 45) & 32767L;
- values[vi++] = (block14 >>> 30) & 32767L;
- values[vi++] = (block14 >>> 15) & 32767L;
- values[vi++] = block14 & 32767L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 49) | (values[vi++] << 34) | (values[vi++] << 19) | (values[vi++] << 4) | (values[vi] >>> 11);
- blocks[bi++] = (values[vi++] << 53) | (values[vi++] << 38) | (values[vi++] << 23) | (values[vi++] << 8) | (values[vi] >>> 7);
- blocks[bi++] = (values[vi++] << 57) | (values[vi++] << 42) | (values[vi++] << 27) | (values[vi++] << 12) | (values[vi] >>> 3);
- blocks[bi++] = (values[vi++] << 61) | (values[vi++] << 46) | (values[vi++] << 31) | (values[vi++] << 16) | (values[vi++] << 1) | (values[vi] >>> 14);
- blocks[bi++] = (values[vi++] << 50) | (values[vi++] << 35) | (values[vi++] << 20) | (values[vi++] << 5) | (values[vi] >>> 10);
- blocks[bi++] = (values[vi++] << 54) | (values[vi++] << 39) | (values[vi++] << 24) | (values[vi++] << 9) | (values[vi] >>> 6);
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 43) | (values[vi++] << 28) | (values[vi++] << 13) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 47) | (values[vi++] << 32) | (values[vi++] << 17) | (values[vi++] << 2) | (values[vi] >>> 13);
- blocks[bi++] = (values[vi++] << 51) | (values[vi++] << 36) | (values[vi++] << 21) | (values[vi++] << 6) | (values[vi] >>> 9);
- blocks[bi++] = (values[vi++] << 55) | (values[vi++] << 40) | (values[vi++] << 25) | (values[vi++] << 10) | (values[vi] >>> 5);
- blocks[bi++] = (values[vi++] << 59) | (values[vi++] << 44) | (values[vi++] << 29) | (values[vi++] << 14) | (values[vi] >>> 1);
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 48) | (values[vi++] << 33) | (values[vi++] << 18) | (values[vi++] << 3) | (values[vi] >>> 12);
- blocks[bi++] = (values[vi++] << 52) | (values[vi++] << 37) | (values[vi++] << 22) | (values[vi++] << 7) | (values[vi] >>> 8);
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 41) | (values[vi++] << 26) | (values[vi++] << 11) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 45) | (values[vi++] << 30) | (values[vi++] << 15) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation16 extends BulkOperation {
-
- public int blocks() {
- return 1;
- }
-
- public int values() {
- return 4;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 48;
- values[vi++] = (block0 >>> 32) & 65535L;
- values[vi++] = (block0 >>> 16) & 65535L;
- values[vi++] = block0 & 65535L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 48) | (values[vi++] << 32) | (values[vi++] << 16) | values[vi++];
- }
- }
- }
-
- static final class Packed64BulkOperation17 extends BulkOperation {
-
- public int blocks() {
- return 17;
- }
-
- public int values() {
- return 64;
- }
-
- public void get(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- final long block0 = blocks[bi++];
- values[vi++] = block0 >>> 47;
- values[vi++] = (block0 >>> 30) & 131071L;
- values[vi++] = (block0 >>> 13) & 131071L;
- final long block1 = blocks[bi++];
- values[vi++] = ((block0 & 8191L) << 4) | (block1 >>> 60);
- values[vi++] = (block1 >>> 43) & 131071L;
- values[vi++] = (block1 >>> 26) & 131071L;
- values[vi++] = (block1 >>> 9) & 131071L;
- final long block2 = blocks[bi++];
- values[vi++] = ((block1 & 511L) << 8) | (block2 >>> 56);
- values[vi++] = (block2 >>> 39) & 131071L;
- values[vi++] = (block2 >>> 22) & 131071L;
- values[vi++] = (block2 >>> 5) & 131071L;
- final long block3 = blocks[bi++];
- values[vi++] = ((block2 & 31L) << 12) | (block3 >>> 52);
- values[vi++] = (block3 >>> 35) & 131071L;
- values[vi++] = (block3 >>> 18) & 131071L;
- values[vi++] = (block3 >>> 1) & 131071L;
- final long block4 = blocks[bi++];
- values[vi++] = ((block3 & 1L) << 16) | (block4 >>> 48);
- values[vi++] = (block4 >>> 31) & 131071L;
- values[vi++] = (block4 >>> 14) & 131071L;
- final long block5 = blocks[bi++];
- values[vi++] = ((block4 & 16383L) << 3) | (block5 >>> 61);
- values[vi++] = (block5 >>> 44) & 131071L;
- values[vi++] = (block5 >>> 27) & 131071L;
- values[vi++] = (block5 >>> 10) & 131071L;
- final long block6 = blocks[bi++];
- values[vi++] = ((block5 & 1023L) << 7) | (block6 >>> 57);
- values[vi++] = (block6 >>> 40) & 131071L;
- values[vi++] = (block6 >>> 23) & 131071L;
- values[vi++] = (block6 >>> 6) & 131071L;
- final long block7 = blocks[bi++];
- values[vi++] = ((block6 & 63L) << 11) | (block7 >>> 53);
- values[vi++] = (block7 >>> 36) & 131071L;
- values[vi++] = (block7 >>> 19) & 131071L;
- values[vi++] = (block7 >>> 2) & 131071L;
- final long block8 = blocks[bi++];
- values[vi++] = ((block7 & 3L) << 15) | (block8 >>> 49);
- values[vi++] = (block8 >>> 32) & 131071L;
- values[vi++] = (block8 >>> 15) & 131071L;
- final long block9 = blocks[bi++];
- values[vi++] = ((block8 & 32767L) << 2) | (block9 >>> 62);
- values[vi++] = (block9 >>> 45) & 131071L;
- values[vi++] = (block9 >>> 28) & 131071L;
- values[vi++] = (block9 >>> 11) & 131071L;
- final long block10 = blocks[bi++];
- values[vi++] = ((block9 & 2047L) << 6) | (block10 >>> 58);
- values[vi++] = (block10 >>> 41) & 131071L;
- values[vi++] = (block10 >>> 24) & 131071L;
- values[vi++] = (block10 >>> 7) & 131071L;
- final long block11 = blocks[bi++];
- values[vi++] = ((block10 & 127L) << 10) | (block11 >>> 54);
- values[vi++] = (block11 >>> 37) & 131071L;
- values[vi++] = (block11 >>> 20) & 131071L;
- values[vi++] = (block11 >>> 3) & 131071L;
- final long block12 = blocks[bi++];
- values[vi++] = ((block11 & 7L) << 14) | (block12 >>> 50);
- values[vi++] = (block12 >>> 33) & 131071L;
- values[vi++] = (block12 >>> 16) & 131071L;
- final long block13 = blocks[bi++];
- values[vi++] = ((block12 & 65535L) << 1) | (block13 >>> 63);
- values[vi++] = (block13 >>> 46) & 131071L;
- values[vi++] = (block13 >>> 29) & 131071L;
- values[vi++] = (block13 >>> 12) & 131071L;
- final long block14 = blocks[bi++];
- values[vi++] = ((block13 & 4095L) << 5) | (block14 >>> 59);
- values[vi++] = (block14 >>> 42) & 131071L;
- values[vi++] = (block14 >>> 25) & 131071L;
- values[vi++] = (block14 >>> 8) & 131071L;
- final long block15 = blocks[bi++];
- values[vi++] = ((block14 & 255L) << 9) | (block15 >>> 55);
- values[vi++] = (block15 >>> 38) & 131071L;
- values[vi++] = (block15 >>> 21) & 131071L;
- values[vi++] = (block15 >>> 4) & 131071L;
- final long block16 = blocks[bi++];
- values[vi++] = ((block15 & 15L) << 13) | (block16 >>> 51);
- values[vi++] = (block16 >>> 34) & 131071L;
- values[vi++] = (block16 >>> 17) & 131071L;
- values[vi++] = block16 & 131071L;
- }
- }
-
- public void set(long[] blocks, int bi, long[] values, int vi, int iterations) {
- assert bi + iterations * blocks() <= blocks.length;
- assert vi + iterations * values() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[bi++] = (values[vi++] << 47) | (values[vi++] << 30) | (values[vi++] << 13) | (values[vi] >>> 4);
- blocks[bi++] = (values[vi++] << 60) | (values[vi++] << 43) | (values[vi++] << 26) | (values[vi++] << 9) | (values[vi] >>> 8);
- blocks[bi++] = (values[vi++] << 56) | (values[vi++] << 39) | (values[vi++] << 22) | (values[vi++] << 5) | (values[vi] >>> 12);
- blocks[bi++] = (values[vi++] << 52) | (values[vi++] << 35) | (values[vi++] << 18) | (values[vi++] << 1) | (values[vi] >>> 16);
- blocks[bi++] = (values[vi++] << 48) | (values[vi++] << 31) | (values[vi++] << 14) | (values[vi] >>> 3);
- blocks[bi++] = (values[vi++] << 61) | (values[vi++] << 44) | (values[vi++] << 27) | (values[vi++] << 10) | (values[vi] >>> 7);
- blocks[bi++] = (values[vi++] << 57) | (values[vi++] << 40) | (values[vi++] << 23) | (values[vi++] << 6) | (values[vi] >>> 11);
- blocks[bi++] = (values[vi++] << 53) | (values[vi++] << 36) | (values[vi++] << 19) | (values[vi++] << 2) | (values[vi] >>> 15);
- blocks[bi++] = (values[vi++] << 49) | (values[vi++] << 32) | (values[vi++] << 15) | (values[vi] >>> 2);
- blocks[bi++] = (values[vi++] << 62) | (values[vi++] << 45) | (values[vi++] << 28) | (values[vi++] << 11) | (values[vi] >>> 6);
- blocks[bi++] = (values[vi++] << 58) | (values[vi++] << 41) | (values[vi++] << 24) | (values[vi++] << 7) | (values[vi] >>> 10);
- blocks[bi++] = (values[vi++] << 54) | (values[vi++] << 37) | (values[vi++] << 20) | (values[vi++] << 3) | (values[vi] >>> 14);
- blocks[bi++] = (values[vi++] << 50) | (values[vi++] << 33) | (values[vi++] << 16) | (values[vi] >>> 1);
- blocks[bi++] = (values[vi++] << 63) | (values[vi++] << 46) | (values[vi++] << 29) | (values[vi++] << 12) | (values[vi] >>> 5);
[... 6261 lines stripped ...]