* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing
- * with optimized document ordering, in: WWW �09, 2009, pp. 401�410.
- *
+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410.
+ *
* using Simple16 as the secondary coder.
- *
+ *
+ * It encodes integers in blocks of 128 integers. For arrays containing
+ * an arbitrary number of integers, you should use it in conjunction
+ * with another CODEC:
+ *
+ *
IntegerCODEC ic =
+ * new Composition(new NewPDF(), new VariableByte()).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately. (Yes, this is true even though
+ * the "D" at the end of the name probably stands for delta.)
+ *
+ * For multi-threaded applications, each thread should use its own NewPFD
+ * object.
+ *
* @author Daniel Lemire
*/
-public final class NewPFD implements IntegerCODEC {
- final int PageSize;
- final static int BlockSize = 128;
+public final class NewPFD implements IntegerCODEC,SkippableIntegerCODEC {
+ final static int BLOCK_SIZE = 128;
- int[] exceptbuffer = new int[2 * BlockSize];
-
- /**
- * Constructor for the NewPFD CODEC.
- */
- public NewPFD() {
- PageSize = 65536;
- }
+ int[] exceptbuffer = new int[2 * BLOCK_SIZE];
- @Override
- public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- inlength = inlength / BlockSize * BlockSize;
- if(inlength == 0) return;
- final int finalinpos = inpos.get() + inlength;
- out[outpos.get()] = inlength;
- outpos.increment();
- while (inpos.get() != finalinpos) {
- int thissize = finalinpos > PageSize + inpos.get() ? PageSize
- : (finalinpos - inpos.get());
- encodePage(in, inpos, thissize, out, outpos);
+ /**
+ * Constructor for the NewPFD CODEC.
+ */
+ public NewPFD() {
}
- }
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ encodePage(in, inpos, inlength, out, outpos);
+ }
- protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 16, 20, 32};
- protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16};
+ protected static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 16, 20, 32 };
+ protected static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16 };
- protected static void getBestBFromData(int[] in, int pos, IntWrapper bestb,
- IntWrapper bestexcept) {
- final int mb = Util.maxbits(in, pos, BlockSize);
- int mini = 0;
- if (mini + 28 < bits[invbits[mb]])
- mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions
- int besti = bits.length - 1;
- int exceptcounter = 0;
- for (int i = mini; i < bits.length - 1; ++i) {
- int tmpcounter = 0;
- final int maxv = 1 << bits[i];
- for (int k = pos; k < BlockSize + pos; ++k)
- if (in[k] >= maxv)
- ++tmpcounter;
- if (tmpcounter * 10 <= BlockSize) {
- besti = i;
- exceptcounter = tmpcounter;
- break;
- }
+ protected static void getBestBFromData(int[] in, int pos,
+ IntWrapper bestb, IntWrapper bestexcept) {
+ final int mb = Util.maxbits(in, pos, BLOCK_SIZE);
+ int mini = 0;
+ if (mini + 28 < bits[invbits[mb]])
+ mini = bits[invbits[mb]] - 28; // 28 is the max for
+ // exceptions
+ int besti = bits.length - 1;
+ int exceptcounter = 0;
+ for (int i = mini; i < bits.length - 1; ++i) {
+ int tmpcounter = 0;
+ for (int k = pos; k < BLOCK_SIZE + pos; ++k)
+ if ((in[k] >>> bits[i]) != 0)
+ ++tmpcounter;
+ if (tmpcounter * 10 <= BLOCK_SIZE) {
+ besti = i;
+ exceptcounter = tmpcounter;
+ break;
+ }
+ }
+ bestb.set(besti);
+ bestexcept.set(exceptcounter);
}
- bestb.set(besti);
- bestexcept.set(exceptcounter);
- }
- private void encodePage(int[] in, IntWrapper inpos, int thissize,
- int[] out, IntWrapper outpos) {
- int tmpoutpos = outpos.get();
- int tmpinpos = inpos.get();
- IntWrapper bestb = new IntWrapper();
- IntWrapper bestexcept = new IntWrapper();
- for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) {
- getBestBFromData(in, tmpinpos, bestb, bestexcept);
- int tmpbestb = bestb.get();
- int nbrexcept = bestexcept.get();
- int exceptsize = 0;
- int remember = tmpoutpos;
- tmpoutpos++;
- if (nbrexcept > 0) {
- final int maxv = 1 << bits[tmpbestb];
- for (int i = 0, c = 0; i < BlockSize; ++i) {
- if (in[tmpinpos + i] >= maxv) {
- exceptbuffer[c + nbrexcept] = i;
- exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb];
- ++c;
- }
+ private void encodePage(int[] in, IntWrapper inpos, int thissize,
+ int[] out, IntWrapper outpos) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+ IntWrapper bestb = new IntWrapper();
+ IntWrapper bestexcept = new IntWrapper();
+ for (final int finalinpos = tmpinpos + thissize; tmpinpos
+ + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) {
+ getBestBFromData(in, tmpinpos, bestb, bestexcept);
+ final int tmpbestb = bestb.get();
+ final int nbrexcept = bestexcept.get();
+ int exceptsize = 0;
+ final int remember = tmpoutpos;
+ tmpoutpos++;
+ if (nbrexcept > 0) {
+ for (int i = 0, c = 0; i < BLOCK_SIZE; ++i) {
+ if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) {
+ exceptbuffer[c + nbrexcept] = i;
+ exceptbuffer[c] = in[tmpinpos
+ + i] >>> bits[tmpbestb];
+ ++c;
+ }
+ }
+ exceptsize = S16.compress(exceptbuffer, 0,
+ 2 * nbrexcept, out, tmpoutpos);
+ tmpoutpos += exceptsize;
+ }
+ out[remember] = tmpbestb | (nbrexcept << 8)
+ | (exceptsize << 16);
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastpack(in, tmpinpos + k, out,
+ tmpoutpos, bits[tmpbestb]);
+ tmpoutpos += bits[tmpbestb];
+ }
}
- exceptsize = S16.compress(exceptbuffer, 0, 2 * nbrexcept, out,
- tmpoutpos);
- tmpoutpos += exceptsize;
- }
- out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16);
- for (int k = 0; k < BlockSize; k += 32) {
- BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos,
- bits[tmpbestb]);
- tmpoutpos += bits[tmpbestb];
- }
+ inpos.set(tmpinpos);
+ outpos.set(tmpoutpos);
+ }
+
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos, int mynvalue) {
+ if (inlength == 0)
+ return;
+ mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE);
+ decodePage(in, inpos, out, outpos, mynvalue);
}
- inpos.set(tmpinpos);
- outpos.set(tmpoutpos);
- }
- @Override
- public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- int mynvalue = in[inpos.get()];
- inpos.increment();
- int finalout = outpos.get() + mynvalue;
- while (outpos.get() != finalout) {
- int thissize = finalout > PageSize + outpos.get() ? PageSize
- : (finalout - outpos.get());
- decodePage(in, inpos, out, outpos, thissize);
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ int blockCount = inlength / BLOCK_SIZE;
+ // +1 for the header
+ // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers.
+ int maxBlockSizeInInts = 1 + BLOCK_SIZE;
+ compressedPositions.add(inlength);
+ return maxBlockSizeInInts * blockCount;
}
- }
- private void decodePage(int[] in, IntWrapper inpos, int[] out,
- IntWrapper outpos, int thissize) {
- int tmpoutpos = outpos.get();
- int tmpinpos = inpos.get();
+ private void decodePage(int[] in, IntWrapper inpos, int[] out,
+ IntWrapper outpos, int thissize) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
- for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) {
- final int b = in[tmpinpos] & 0xFF;
- final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
- final int exceptsize = (in[tmpinpos] >>> 16);
- ++tmpinpos;
- S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0,
- 2 * cexcept);
- tmpinpos += exceptsize;
- for (int k = 0; k < BlockSize; k += 32) {
- BitPacking
- .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]);
- tmpinpos += bits[b];
- }
- for (int k = 0; k < cexcept; ++k) {
- out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
- }
+ for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) {
+ final int b = in[tmpinpos] & 0xFF;
+ final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
+ final int exceptsize = (in[tmpinpos] >>> 16);
+ ++tmpinpos;
+ S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer,
+ 0, 2 * cexcept);
+ tmpinpos += exceptsize;
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastunpack(in, tmpinpos, out,
+ tmpoutpos + k, bits[b]);
+ tmpinpos += bits[b];
+ }
+ for (int k = 0; k < cexcept; ++k) {
+ out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
+ }
+ }
+ outpos.set(tmpoutpos);
+ inpos.set(tmpinpos);
+ }
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
}
- outpos.set(tmpoutpos);
- inpos.set(tmpinpos);
- }
- @Override
- public String toString() {
- return this.getClass().getName();
- }
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+ }
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
}
diff --git a/src/main/java/me/lemire/integercompression/NewPFDS16.java b/src/main/java/me/lemire/integercompression/NewPFDS16.java
new file mode 100644
index 0000000..526b8fb
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/NewPFDS16.java
@@ -0,0 +1,195 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+
+package me.lemire.integercompression;
+
+
+/**
+ * NewPFD/NewPFOR based on Simple16 by Yan et al.
+ *
+ * Follows:
+ *
+ * H. Yan, S. Ding, T. Suel, Inverted index compression and query processing
+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410.
+ *
+ * using Simple16 as the secondary coder.
+ *
+ * It encodes integers in blocks of 128 integers. For arrays containing
+ * an arbitrary number of integers, you should use it in conjunction
+ * with another CODEC:
+ *
+ *
IntegerCODEC ic =
+ * new Composition(new PDFS16(), new VariableByte()).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately.
+ *
+ * For multi-threaded applications, each thread should use its own NewPFDS16
+ * object.
+ *
+ * @author Daniel Lemire
+ */
+public final class NewPFDS16 implements IntegerCODEC,SkippableIntegerCODEC {
+ final static int BLOCK_SIZE= 128;
+
+ int[] exceptbuffer = new int[2 * BLOCK_SIZE];
+
+ /**
+ * Constructor for the NewPFDS16 CODEC.
+ */
+ public NewPFDS16() {
+ }
+
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ encodePage(in, inpos, inlength, out, outpos);
+ }
+
+ private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 16, 20, 32 };
+ private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16 };
+
+ private static void getBestBFromData(int[] in, int pos,
+ IntWrapper bestb, IntWrapper bestexcept) {
+ final int mb = Util.maxbits(in, pos, BLOCK_SIZE);
+ int mini = 0;
+ if (mini + 28 < bits[invbits[mb]])
+ mini = bits[invbits[mb]] - 28; // 28 is the max for
+ // exceptions
+ int besti = bits.length - 1;
+ int exceptcounter = 0;
+ for (int i = mini; i < bits.length - 1; ++i) {
+ int tmpcounter = 0;
+ for (int k = pos; k < BLOCK_SIZE + pos; ++k)
+ if ((in[k] >>> bits[i]) != 0)
+ ++tmpcounter;
+ if (tmpcounter * 10 <= BLOCK_SIZE) {
+ besti = i;
+ exceptcounter = tmpcounter;
+ break;
+ }
+ }
+ bestb.set(besti);
+ bestexcept.set(exceptcounter);
+ }
+
+ private void encodePage(int[] in, IntWrapper inpos, int thissize,
+ int[] out, IntWrapper outpos) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+ IntWrapper bestb = new IntWrapper();
+ IntWrapper bestexcept = new IntWrapper();
+ for (final int finalinpos = tmpinpos + thissize; tmpinpos
+ + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) {
+ getBestBFromData(in, tmpinpos, bestb, bestexcept);
+ final int tmpbestb = bestb.get();
+ final int nbrexcept = bestexcept.get();
+ int exceptsize = 0;
+ final int remember = tmpoutpos;
+ tmpoutpos++;
+ if (nbrexcept > 0) {
+ for (int i = 0, c = 0; i < BLOCK_SIZE; ++i) {
+ if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) {
+ exceptbuffer[c + nbrexcept] = i;
+ exceptbuffer[c] = in[tmpinpos
+ + i] >>> bits[tmpbestb];
+ ++c;
+ }
+ }
+ exceptsize = S16.compress(exceptbuffer, 0,
+ 2 * nbrexcept, out, tmpoutpos);
+ tmpoutpos += exceptsize;
+ }
+ out[remember] = tmpbestb | (nbrexcept << 8)
+ | (exceptsize << 16);
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastpack(in, tmpinpos + k, out,
+ tmpoutpos, bits[tmpbestb]);
+ tmpoutpos += bits[tmpbestb];
+ }
+ }
+ inpos.set(tmpinpos);
+ outpos.set(tmpoutpos);
+ }
+
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos, int mynvalue) {
+ if (inlength == 0)
+ return;
+ mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE);
+ decodePage(in, inpos, out, outpos, mynvalue);
+ }
+
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ int blockCount = inlength / BLOCK_SIZE;
+ // +1 for the header
+ // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers.
+ int maxBlockSizeInInts = 1 + BLOCK_SIZE;
+ compressedPositions.add(inlength);
+ return maxBlockSizeInInts * blockCount;
+ }
+
+ private void decodePage(int[] in, IntWrapper inpos, int[] out,
+ IntWrapper outpos, int thissize) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+
+ for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) {
+ final int b = in[tmpinpos] & 0xFF;
+ final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
+ final int exceptsize = (in[tmpinpos] >>> 16);
+ ++tmpinpos;
+ S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer,
+ 0, 2 * cexcept);
+ tmpinpos += exceptsize;
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastunpack(in, tmpinpos, out,
+ tmpoutpos + k, bits[b]);
+ tmpinpos += bits[b];
+ }
+ for (int k = 0; k < cexcept; ++k) {
+ out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
+ }
+ }
+ outpos.set(tmpoutpos);
+ inpos.set(tmpinpos);
+ }
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
+ }
+
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+ }
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/NewPFDS9.java b/src/main/java/me/lemire/integercompression/NewPFDS9.java
index bb53b44..bd802b6 100644
--- a/src/main/java/me/lemire/integercompression/NewPFDS9.java
+++ b/src/main/java/me/lemire/integercompression/NewPFDS9.java
@@ -7,156 +7,188 @@
package me.lemire.integercompression;
+
/**
- * NewPFD/NewPFOR implemented by Daniel Lemire
- *
+ * NewPFD/NewPFOR based on Simple9 by Yan et al.
+ *
* Follows:
- *
+ *
* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing
* with optimized document ordering, in: WWW 09, 2009, pp. 401-410.
- *
+ *
* using Simple9 as the secondary coder.
- *
+ *
+ * It encodes integers in blocks of 128 integers. For arrays containing
+ * an arbitrary number of integers, you should use it in conjunction
+ * with another CODEC:
+ *
+ *
IntegerCODEC ic = new Composition(new PDFS9(), new VariableByte()).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately.
+ *
+ * For multi-threaded applications, each thread should use its own NewPFDS9
+ * object.
+ *
* @author Daniel Lemire
*/
-public final class NewPFDS9 implements IntegerCODEC {
- final int PageSize;
- final static int BlockSize = 128;
-
- int[] exceptbuffer = new int[2 * BlockSize];
+public final class NewPFDS9 implements IntegerCODEC,SkippableIntegerCODEC {
+ final static int BLOCK_SIZE = 128;
- /**
- * Constructor for the NewPFDS9 CODEC.
- */
- public NewPFDS9() {
- PageSize = 65536;
- }
+ int[] exceptbuffer = new int[2 * BLOCK_SIZE];
- @Override
- public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- inlength = inlength / BlockSize * BlockSize;
- if(inlength == 0) return;
- final int finalinpos = inpos.get() + inlength;
- out[outpos.get()] = inlength;
- outpos.increment();
- while (inpos.get() != finalinpos) {
- int thissize = finalinpos > PageSize + inpos.get() ? PageSize
- : (finalinpos - inpos.get());
- encodePage(in, inpos, thissize, out, outpos);
+ /**
+ * Constructor for the NewPFDS9 CODEC.
+ */
+ public NewPFDS9() {
}
- }
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ encodePage(in, inpos, inlength, out, outpos);
+ }
- protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 16, 20, 32};
- protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16};
+ private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 16, 20, 32 };
+ private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16 };
- protected static void getBestBFromData(int[] in, int pos, IntWrapper bestb,
- IntWrapper bestexcept) {
- final int mb = Util.maxbits(in, pos, BlockSize);
- int mini = 0;
- if (mini + 28 < bits[invbits[mb]])
- mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions
- int besti = bits.length - 1;
- int exceptcounter = 0;
- for (int i = mini; i < bits.length - 1; ++i) {
- int tmpcounter = 0;
- final int maxv = 1 << bits[i];
- for (int k = pos; k < BlockSize + pos; ++k)
- if (in[k] >= maxv)
- ++tmpcounter;
- if (tmpcounter * 10 <= BlockSize) {
- besti = i;
- exceptcounter = tmpcounter;
- break;
- }
+ private static void getBestBFromData(int[] in, int pos,
+ IntWrapper bestb, IntWrapper bestexcept) {
+ final int mb = Util.maxbits(in, pos, BLOCK_SIZE);
+ int mini = 0;
+ if (mini + 28 < bits[invbits[mb]])
+ mini = bits[invbits[mb]] - 28; // 28 is the max for
+ // exceptions
+ int besti = bits.length - 1;
+ int exceptcounter = 0;
+ for (int i = mini; i < bits.length - 1; ++i) {
+ int tmpcounter = 0;
+ for (int k = pos; k < BLOCK_SIZE + pos; ++k)
+ if ((in[k] >>> bits[i]) != 0)
+ ++tmpcounter;
+ if (tmpcounter * 10 <= BLOCK_SIZE) {
+ besti = i;
+ exceptcounter = tmpcounter;
+ break;
+ }
+ }
+ bestb.set(besti);
+ bestexcept.set(exceptcounter);
}
- bestb.set(besti);
- bestexcept.set(exceptcounter);
- }
- private void encodePage(int[] in, IntWrapper inpos, int thissize,
- int[] out, IntWrapper outpos) {
- int tmpoutpos = outpos.get();
- int tmpinpos = inpos.get();
- IntWrapper bestb = new IntWrapper();
- IntWrapper bestexcept = new IntWrapper();
- for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) {
- getBestBFromData(in, tmpinpos, bestb, bestexcept);
- int tmpbestb = bestb.get();
- int nbrexcept = bestexcept.get();
- int exceptsize = 0;
- int remember = tmpoutpos;
- tmpoutpos++;
- if (nbrexcept > 0) {
- final int maxv = 1 << bits[tmpbestb];
- for (int i = 0, c = 0; i < BlockSize; ++i) {
- if (in[tmpinpos + i] >= maxv) {
- exceptbuffer[c + nbrexcept] = i;
- exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb];
- ++c;
- }
+ private void encodePage(int[] in, IntWrapper inpos, int thissize,
+ int[] out, IntWrapper outpos) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+ IntWrapper bestb = new IntWrapper();
+ IntWrapper bestexcept = new IntWrapper();
+ for (final int finalinpos = tmpinpos + thissize; tmpinpos
+ + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) {
+ getBestBFromData(in, tmpinpos, bestb, bestexcept);
+ final int tmpbestb = bestb.get();
+ final int nbrexcept = bestexcept.get();
+ int exceptsize = 0;
+ final int remember = tmpoutpos;
+ tmpoutpos++;
+ if (nbrexcept > 0) {
+ for (int i = 0, c = 0; i < BLOCK_SIZE; ++i) {
+ if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) {
+ exceptbuffer[c + nbrexcept] = i;
+ exceptbuffer[c] = in[tmpinpos
+ + i] >>> bits[tmpbestb];
+ ++c;
+ }
+ }
+ exceptsize = S9.compress(exceptbuffer, 0,
+ 2 * nbrexcept, out, tmpoutpos);
+ tmpoutpos += exceptsize;
+ }
+ out[remember] = tmpbestb | (nbrexcept << 8)
+ | (exceptsize << 16);
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastpack(in, tmpinpos + k, out,
+ tmpoutpos, bits[tmpbestb]);
+ tmpoutpos += bits[tmpbestb];
+ }
}
- exceptsize = S9.compress(exceptbuffer, 0, 2 * nbrexcept, out,
- tmpoutpos);
- tmpoutpos += exceptsize;
- }
- out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16);
- for (int k = 0; k < BlockSize; k += 32) {
- BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos,
- bits[tmpbestb]);
- tmpoutpos += bits[tmpbestb];
- }
+ inpos.set(tmpinpos);
+ outpos.set(tmpoutpos);
}
- inpos.set(tmpinpos);
- outpos.set(tmpoutpos);
- }
- @Override
- public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- int mynvalue = in[inpos.get()];
- inpos.increment();
- int finalout = outpos.get() + mynvalue;
- while (outpos.get() != finalout) {
- int thissize = finalout > PageSize + outpos.get() ? PageSize
- : (finalout - outpos.get());
- decodePage(in, inpos, out, outpos, thissize);
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos, int mynvalue) {
+ if (inlength == 0)
+ return;
+ mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE);
+ decodePage(in, inpos, out, outpos, mynvalue);
}
- }
- private void decodePage(int[] in, IntWrapper inpos, int[] out,
- IntWrapper outpos, int thissize) {
- int tmpoutpos = outpos.get();
- int tmpinpos = inpos.get();
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ int blockCount = inlength / BLOCK_SIZE;
+ // +1 for the header
+ // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers.
+ int maxBlockSizeInInts = 1 + BLOCK_SIZE;
+ compressedPositions.add(inlength);
+ return maxBlockSizeInInts * blockCount;
+ }
- for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) {
- final int b = in[tmpinpos] & 0xFF;
- final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
- final int exceptsize = (in[tmpinpos] >>> 16);
- ++tmpinpos;
- S9.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0,
- 2 * cexcept);
- tmpinpos += exceptsize;
- for (int k = 0; k < BlockSize; k += 32) {
- BitPacking
- .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]);
- tmpinpos += bits[b];
- }
- for (int k = 0; k < cexcept; ++k) {
- out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
- }
+ private void decodePage(int[] in, IntWrapper inpos, int[] out,
+ IntWrapper outpos, int thissize) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+
+ for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) {
+ final int b = in[tmpinpos] & 0xFF;
+ final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
+ final int exceptsize = (in[tmpinpos] >>> 16);
+ ++tmpinpos;
+ S9.uncompress(in, tmpinpos, exceptsize, exceptbuffer,
+ 0, 2 * cexcept);
+ tmpinpos += exceptsize;
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastunpack(in, tmpinpos, out,
+ tmpoutpos + k, bits[b]);
+ tmpinpos += bits[b];
+ }
+ for (int k = 0; k < cexcept; ++k) {
+ out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
+ }
+ }
+ outpos.set(tmpoutpos);
+ inpos.set(tmpinpos);
+ }
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
}
- outpos.set(tmpoutpos);
- inpos.set(tmpinpos);
- }
- @Override
- public String toString() {
- return this.getClass().getName();
- }
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+ }
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
}
diff --git a/src/main/java/me/lemire/integercompression/OptPFD.java b/src/main/java/me/lemire/integercompression/OptPFD.java
index dce640f..cfda92e 100644
--- a/src/main/java/me/lemire/integercompression/OptPFD.java
+++ b/src/main/java/me/lemire/integercompression/OptPFD.java
@@ -6,172 +6,206 @@
*/
package me.lemire.integercompression;
+
/**
- * OptPFD implemented by Daniel Lemire
- *
+ * OptPFD: fast patching scheme by Yan et al.
+ *
* Follows:
- *
+ *
* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing
- * with optimized document ordering, in: WWW �09, 2009, pp. 401�410.
- *
+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410.
+ *
* using Simple16 as the secondary coder.
- *
+ *
+ * It encodes integers in blocks of 128 integers. For arrays containing
+ * an arbitrary number of integers, you should use it in conjunction
+ * with another CODEC:
+ *
+ *
IntegerCODEC ic = new Composition(new OptPFD(), new VariableByte()).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately. (Yes, this is true even though
+ * the "D" at the end of the name probably stands for delta.)
+ *
+ * For multi-threaded applications, each thread should use its own OptPFD
+ * object.
+ *
* @author Daniel Lemire
*/
-public final class OptPFD implements IntegerCODEC {
- final int PageSize;
- final static int BlockSize = 128;
-
- int[] exceptbuffer = new int[2 * BlockSize];
- int[] sillybuffer = new int[2 * BlockSize];
+public final class OptPFD implements IntegerCODEC,SkippableIntegerCODEC {
+ final static int BLOCK_SIZE = 128;
- /**
- * Constructor for the OptPFD CODEC.
- */
- public OptPFD() {
- PageSize = 65536;
- }
+ int[] exceptbuffer = new int[2 * BLOCK_SIZE];
+
+ /**
+ * Constructor for the OptPFD CODEC.
+ */
+ public OptPFD() {
+ }
- @Override
- public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- inlength = inlength / BlockSize * BlockSize;
- if(inlength == 0) return;
- final int finalinpos = inpos.get() + inlength;
- out[outpos.get()] = inlength;
- outpos.increment();
- while (inpos.get() != finalinpos) {
- int thissize = finalinpos > PageSize + inpos.get() ? PageSize
- : (finalinpos - inpos.get());
- encodePage(in, inpos, thissize, out, outpos);
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ encodePage(in, inpos, inlength, out, outpos);
}
- }
+ private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 16, 20, 32 };
+ private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16 };
- protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 16, 20, 32};
- protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16};
+ private void getBestBFromData(int[] in, int pos, IntWrapper bestb,
+ IntWrapper bestexcept) {
+ final int mb = Util.maxbits(in, pos, BLOCK_SIZE);
+ int mini = 0;
+ if (mini + 28 < bits[invbits[mb]])
+ mini = bits[invbits[mb]] - 28; // 28 is the max for
+ // exceptions
+ int besti = bits.length - 1;
+ int bestcost = bits[besti] * 4;
+ int exceptcounter = 0;
+ for (int i = mini; i < bits.length - 1; ++i) {
+ int tmpcounter = 0;
+ for (int k = pos; k < BLOCK_SIZE + pos; ++k)
+ if ((in[k] >>> bits[i]) != 0) {
+ ++tmpcounter;
+ }
+ if (tmpcounter == BLOCK_SIZE)
+ continue; // no need
+ for (int k = pos, c = 0; k < pos + BLOCK_SIZE; ++k)
+ if ((in[k] >>> bits[i]) != 0) {
+ exceptbuffer[tmpcounter + c] = k - pos;
+ exceptbuffer[c] = in[k] >>> bits[i];
+ ++c;
+ }
- void getBestBFromData(int[] in, int pos, IntWrapper bestb,
- IntWrapper bestexcept) {
- final int mb = Util.maxbits(in, pos, BlockSize);
- int mini = 0;
- if (mini + 28 < bits[invbits[mb]])
- mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions
- int besti = bits.length - 1;
- int bestcost = bits[besti] * 4;
- int exceptcounter = 0;
- for (int i = mini; i < bits.length - 1; ++i) {
- int tmpcounter = 0;
- final int maxv = 1 << bits[i];
- for (int k = pos; k < BlockSize + pos; ++k)
- if (in[k] >= maxv) {
- ++tmpcounter;
- }
- if (tmpcounter == BlockSize)
- continue; // no need
- for (int k = pos, c = 0; k < pos + BlockSize; ++k)
- if (in[k] >= maxv) {
- exceptbuffer[tmpcounter + c] = k - pos;
- exceptbuffer[c] = in[k] >>> bits[i];
- ++c;
+ final int thiscost = bits[i]
+ * 4
+ + S16.estimatecompress(exceptbuffer, 0,
+ 2 * tmpcounter);
+ if (thiscost <= bestcost) {
+ bestcost = thiscost;
+ besti = i;
+ exceptcounter = tmpcounter;
+ }
}
- final int thiscost = bits[i] * 4
- + S16.estimatecompress(exceptbuffer, 0, 2 * tmpcounter);
- if (thiscost <= bestcost) {
- bestcost = thiscost;
- besti = i;
- exceptcounter = tmpcounter;
- }
+ bestb.set(besti);
+ bestexcept.set(exceptcounter);
}
- bestb.set(besti);
- bestexcept.set(exceptcounter);
- }
-
- private void encodePage(int[] in, IntWrapper inpos, int thissize,
- int[] out, IntWrapper outpos) {
- int tmpoutpos = outpos.get();
- int tmpinpos = inpos.get();
- IntWrapper bestb = new IntWrapper();
- IntWrapper bestexcept = new IntWrapper();
- for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) {
- getBestBFromData(in, tmpinpos, bestb, bestexcept);
- int tmpbestb = bestb.get();
- int nbrexcept = bestexcept.get();
- int exceptsize = 0;
- int remember = tmpoutpos;
- tmpoutpos++;
- if (nbrexcept > 0) {
- final int maxv = 1 << bits[tmpbestb];
- int c = 0;
- for (int i = 0; i < BlockSize; ++i) {
- if (in[tmpinpos + i] >= maxv) {
- exceptbuffer[c + nbrexcept] = i;
- exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb];
- ++c;
- }
+ private void encodePage(int[] in, IntWrapper inpos, int thissize,
+ int[] out, IntWrapper outpos) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+ IntWrapper bestb = new IntWrapper();
+ IntWrapper bestexcept = new IntWrapper();
+ for (final int finalinpos = tmpinpos + thissize; tmpinpos
+ + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) {
+ getBestBFromData(in, tmpinpos, bestb, bestexcept);
+ final int tmpbestb = bestb.get();
+ final int nbrexcept = bestexcept.get();
+ int exceptsize = 0;
+ final int remember = tmpoutpos;
+ tmpoutpos++;
+ if (nbrexcept > 0) {
+ int c = 0;
+ for (int i = 0; i < BLOCK_SIZE; ++i) {
+ if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) {
+ exceptbuffer[c + nbrexcept] = i;
+ exceptbuffer[c] = in[tmpinpos
+ + i] >>> bits[tmpbestb];
+ ++c;
+ }
+ }
+ exceptsize = S16.compress(exceptbuffer, 0,
+ 2 * nbrexcept, out, tmpoutpos);
+ tmpoutpos += exceptsize;
+ }
+ out[remember] = tmpbestb | (nbrexcept << 8)
+ | (exceptsize << 16);
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastpack(in, tmpinpos + k, out,
+ tmpoutpos, bits[tmpbestb]);
+ tmpoutpos += bits[tmpbestb];
+ }
}
- exceptsize = S16.compress(exceptbuffer, 0, 2 * nbrexcept, out,
- tmpoutpos);
- tmpoutpos += exceptsize;
- }
- out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16);
- for (int k = 0; k < BlockSize; k += 32) {
- BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos,
- bits[tmpbestb]);
- tmpoutpos += bits[tmpbestb];
- }
+ inpos.set(tmpinpos);
+ outpos.set(tmpoutpos);
}
- inpos.set(tmpinpos);
- outpos.set(tmpoutpos);
- }
- @Override
- public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- int mynvalue = in[inpos.get()];
- inpos.increment();
- int finalout = outpos.get() + mynvalue;
- while (outpos.get() != finalout) {
- int thissize = finalout > PageSize + outpos.get() ? PageSize
- : (finalout - outpos.get());
- decodePage(in, inpos, out, outpos, thissize);
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos, int mynvalue) {
+ if (inlength == 0)
+ return;
+ mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE);
+ decodePage(in, inpos, out, outpos, mynvalue);
}
- }
- private void decodePage(int[] in, IntWrapper inpos, int[] out,
- IntWrapper outpos, int thissize) {
- int tmpoutpos = outpos.get();
- int tmpinpos = inpos.get();
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ int blockCount = inlength / BLOCK_SIZE;
+ // +1 for the header
+ // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers.
+ int maxBlockSizeInInts = 1 + BLOCK_SIZE;
+ compressedPositions.add(inlength);
+ return maxBlockSizeInInts * blockCount;
+ }
+
+ private void decodePage(int[] in, IntWrapper inpos, int[] out,
+ IntWrapper outpos, int thissize) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
- for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) {
- final int b = in[tmpinpos] & 0xFF;
- final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
- final int exceptsize = (in[tmpinpos] >>> 16);
- ++tmpinpos;
- S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0,
- 2 * cexcept);
- tmpinpos += exceptsize;
- for (int k = 0; k < BlockSize; k += 32) {
- BitPacking
- .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]);
- tmpinpos += bits[b];
- }
- for (int k = 0; k < cexcept; ++k) {
- out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
- }
+ for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) {
+ final int b = in[tmpinpos] & 0xFF;
+ final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
+ final int exceptsize = (in[tmpinpos] >>> 16);
+ ++tmpinpos;
+ S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer,
+ 0, 2 * cexcept);
+ tmpinpos += exceptsize;
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastunpack(in, tmpinpos, out,
+ tmpoutpos + k, bits[b]);
+ tmpinpos += bits[b];
+ }
+ for (int k = 0; k < cexcept; ++k) {
+ out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
+ }
+ }
+ outpos.set(tmpoutpos);
+ inpos.set(tmpinpos);
+ }
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ inlength = inlength / BLOCK_SIZE * BLOCK_SIZE;
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
}
- outpos.set(tmpoutpos);
- inpos.set(tmpinpos);
- }
- @Override
- public String toString() {
- return this.getClass().getName();
- }
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+ }
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
}
diff --git a/src/main/java/me/lemire/integercompression/OptPFDS16.java b/src/main/java/me/lemire/integercompression/OptPFDS16.java
new file mode 100644
index 0000000..95c4f62
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/OptPFDS16.java
@@ -0,0 +1,211 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+
+package me.lemire.integercompression;
+
+
+/**
+ * OptPFD based on Simple16 by Yan et al.
+ *
+ * Follows:
+ *
+ * H. Yan, S. Ding, T. Suel, Inverted index compression and query processing
+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410.
+ *
+ * using Simple16 as the secondary coder.
+ *
+ * It encodes integers in blocks of 128 integers. For arrays containing
+ * an arbitrary number of integers, you should use it in conjunction
+ * with another CODEC:
+ *
+ *
IntegerCODEC ic = new Composition(new OptPFDS16(), new VariableByte()).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately.
+ *
+ * For multi-threaded applications, each thread should use its own OptPFDS16
+ * object.
+ *
+ * @author Daniel Lemire
+ */
+public final class OptPFDS16 implements IntegerCODEC,SkippableIntegerCODEC {
+ final static int BLOCK_SIZE = 128;
+ int[] exceptbuffer = new int[2 * BLOCK_SIZE];
+
+ /**
+ * Constructor for the OptPFDS16 CODEC.
+ */
+ public OptPFDS16() {
+ }
+
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+
+ encodePage(in, inpos, inlength, out, outpos);
+
+ }
+
+ private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 16, 20, 32 };
+ private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16 };
+
+ private void getBestBFromData(int[] in, int pos, IntWrapper bestb,
+ IntWrapper bestexcept) {
+ final int mb = Util.maxbits(in, pos, BLOCK_SIZE);
+ int mini = 0;
+ if (mini + 28 < bits[invbits[mb]])
+ mini = bits[invbits[mb]] - 28; // 28 is the max for
+ // exceptions
+ int besti = bits.length - 1;
+ int bestcost = bits[besti] * 4;
+ int exceptcounter = 0;
+ for (int i = mini; i < bits.length - 1; ++i) {
+ int tmpcounter = 0;
+ for (int k = pos; k < BLOCK_SIZE + pos; ++k)
+ if ((in[k] >>> bits[i]) != 0) {
+ ++tmpcounter;
+ }
+ if (tmpcounter == BLOCK_SIZE)
+ continue; // no need
+ for (int k = pos, c = 0; k < pos + BLOCK_SIZE; ++k)
+ if ((in[k] >>> bits[i]) != 0) {
+ exceptbuffer[tmpcounter + c] = k - pos;
+ exceptbuffer[c] = in[k] >>> bits[i];
+ ++c;
+ }
+
+ final int thiscost = bits[i]
+ * 4
+ + S16.estimatecompress(exceptbuffer, 0,
+ 2 * tmpcounter);
+ if (thiscost <= bestcost) {
+ bestcost = thiscost;
+ besti = i;
+ exceptcounter = tmpcounter;
+ }
+ }
+ bestb.set(besti);
+ bestexcept.set(exceptcounter);
+ }
+
+ private void encodePage(int[] in, IntWrapper inpos, int thissize,
+ int[] out, IntWrapper outpos) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+ IntWrapper bestb = new IntWrapper();
+ IntWrapper bestexcept = new IntWrapper();
+ for (final int finalinpos = tmpinpos + thissize; tmpinpos
+ + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) {
+ getBestBFromData(in, tmpinpos, bestb, bestexcept);
+ final int tmpbestb = bestb.get();
+ final int nbrexcept = bestexcept.get();
+ int exceptsize = 0;
+ final int remember = tmpoutpos;
+ tmpoutpos++;
+ if (nbrexcept > 0) {
+ int c = 0;
+ for (int i = 0; i < BLOCK_SIZE; ++i) {
+ if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) {
+ exceptbuffer[c + nbrexcept] = i;
+ exceptbuffer[c] = in[tmpinpos
+ + i] >>> bits[tmpbestb];
+ ++c;
+ }
+ }
+ exceptsize = S16.compress(exceptbuffer, 0,
+ 2 * nbrexcept, out, tmpoutpos);
+ tmpoutpos += exceptsize;
+ }
+ out[remember] = tmpbestb | (nbrexcept << 8)
+ | (exceptsize << 16);
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastpack(in, tmpinpos + k, out,
+ tmpoutpos, bits[tmpbestb]);
+ tmpoutpos += bits[tmpbestb];
+ }
+ }
+ inpos.set(tmpinpos);
+ outpos.set(tmpoutpos);
+ }
+
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos, int mynvalue) {
+ if (inlength == 0)
+ return;
+ mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE);
+ decodePage(in, inpos, out, outpos, mynvalue);
+ }
+
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ int blockCount = inlength / BLOCK_SIZE;
+ // +1 for the header
+ // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers.
+ int maxBlockSizeInInts = 1 + BLOCK_SIZE;
+ compressedPositions.add(inlength);
+ return maxBlockSizeInInts * blockCount;
+ }
+
+ private void decodePage(int[] in, IntWrapper inpos, int[] out,
+ IntWrapper outpos, int thissize) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+
+ for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) {
+ final int b = in[tmpinpos] & 0xFF;
+ final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
+ final int exceptsize = (in[tmpinpos] >>> 16);
+ ++tmpinpos;
+ S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer,
+ 0, 2 * cexcept);
+ tmpinpos += exceptsize;
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastunpack(in, tmpinpos, out,
+ tmpoutpos + k, bits[b]);
+ tmpinpos += bits[b];
+ }
+ for (int k = 0; k < cexcept; ++k) {
+ out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
+ }
+ }
+ outpos.set(tmpoutpos);
+ inpos.set(tmpinpos);
+ }
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ inlength = inlength / BLOCK_SIZE * BLOCK_SIZE;
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
+ }
+
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+ }
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/OptPFDS9.java b/src/main/java/me/lemire/integercompression/OptPFDS9.java
index 97ba453..0e2563b 100644
--- a/src/main/java/me/lemire/integercompression/OptPFDS9.java
+++ b/src/main/java/me/lemire/integercompression/OptPFDS9.java
@@ -7,170 +7,205 @@
package me.lemire.integercompression;
+
/**
- * OptPFD implemented by Daniel Lemire
- *
+ * OptPFD based on Simple9 by Yan et al.
+ *
* Follows:
- *
+ *
* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing
- * with optimized document ordering, in: WWW 09, 2009, pp. 401--410.
- *
+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410.
+ *
* using Simple9 as the secondary coder.
- *
+ *
+ * It encodes integers in blocks of 128 integers. For arrays containing
+ * an arbitrary number of integers, you should use it in conjunction
+ * with another CODEC:
+ *
+ *
IntegerCODEC ic = new Composition(new OptPFDS9(), new VariableByte()).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately.
+ *
+ * For multi-threaded applications, each thread should use its own OptPFDS9
+ * object.
+ *
* @author Daniel Lemire
*/
-public final class OptPFDS9 implements IntegerCODEC {
- final int PageSize;
- final static int BlockSize = 128;
- int[] exceptbuffer = new int[2 * BlockSize];
-
- /**
- * Constructor for the OptPFDS9 CODEC.
- */
- public OptPFDS9() {
- PageSize = 65536;
- }
-
- @Override
- public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- inlength = inlength / BlockSize * BlockSize;
- if(inlength == 0) return;
-
- final int finalinpos = inpos.get() + inlength;
- out[outpos.get()] = inlength;
- outpos.increment();
- while (inpos.get() != finalinpos) {
- int thissize = finalinpos > PageSize + inpos.get() ? PageSize
- : (finalinpos - inpos.get());
- encodePage(in, inpos, thissize, out, outpos);
+public final class OptPFDS9 implements IntegerCODEC, SkippableIntegerCODEC {
+ final static int BLOCK_SIZE = 128;
+ int[] exceptbuffer = new int[2 * BLOCK_SIZE];
+
+ /**
+ * Constructor for the OptPFDS9 CODEC.
+ */
+ public OptPFDS9() {
}
- }
-
- protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 16, 20, 32};
- protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16};
-
- protected void getBestBFromData(int[] in, int pos, IntWrapper bestb,
- IntWrapper bestexcept) {
- final int mb = Util.maxbits(in, pos, BlockSize);
- int mini = 0;
- if (mini + 28 < bits[invbits[mb]])
- mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions
- int besti = bits.length - 1;
- int bestcost = bits[besti] * 4;
- int exceptcounter = 0;
- for (int i = mini; i < bits.length - 1; ++i) {
- int tmpcounter = 0;
- final int maxv = 1 << bits[i];
- for (int k = pos; k < BlockSize + pos; ++k)
- if (in[k] >= maxv) {
- ++tmpcounter;
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ encodePage(in, inpos, inlength, out, outpos);
+
+ }
+
+ private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 16, 20, 32 };
+ private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16 };
+
+ private void getBestBFromData(int[] in, int pos, IntWrapper bestb,
+ IntWrapper bestexcept) {
+ final int mb = Util.maxbits(in, pos, BLOCK_SIZE);
+ int mini = 0;
+ if (mini + 28 < bits[invbits[mb]])
+ mini = bits[invbits[mb]] - 28; // 28 is the max for
+ // exceptions
+ int besti = bits.length - 1;
+ int bestcost = bits[besti] * 4;
+ int exceptcounter = 0;
+ for (int i = mini; i < bits.length - 1; ++i) {
+ int tmpcounter = 0;
+ for (int k = pos; k < BLOCK_SIZE + pos; ++k)
+ if ((in[k] >>> bits[i]) != 0) {
+ ++tmpcounter;
+ }
+ if (tmpcounter == BLOCK_SIZE)
+ continue; // no need
+ for (int k = pos, c = 0; k < pos + BLOCK_SIZE; ++k)
+ if ((in[k] >>> bits[i]) != 0) {
+ exceptbuffer[tmpcounter + c] = k - pos;
+ exceptbuffer[c] = in[k] >>> bits[i];
+ ++c;
+ }
+
+ final int thiscost = bits[i]
+ * 4
+ + S9.estimatecompress(exceptbuffer, 0,
+ 2 * tmpcounter);
+ if (thiscost <= bestcost) {
+ bestcost = thiscost;
+ besti = i;
+ exceptcounter = tmpcounter;
+ }
}
- if (tmpcounter == BlockSize)
- continue; // no need
- for (int k = pos, c = 0; k < pos + BlockSize; ++k)
- if (in[k] >= maxv) {
- exceptbuffer[tmpcounter + c] = k - pos;
- exceptbuffer[c] = in[k] >>> bits[i];
- ++c;
+ bestb.set(besti);
+ bestexcept.set(exceptcounter);
+ }
+
+ private void encodePage(int[] in, IntWrapper inpos, int thissize,
+ int[] out, IntWrapper outpos) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+ IntWrapper bestb = new IntWrapper();
+ IntWrapper bestexcept = new IntWrapper();
+ for (final int finalinpos = tmpinpos + thissize; tmpinpos
+ + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) {
+ getBestBFromData(in, tmpinpos, bestb, bestexcept);
+ final int tmpbestb = bestb.get();
+ final int nbrexcept = bestexcept.get();
+ int exceptsize = 0;
+ final int remember = tmpoutpos;
+ tmpoutpos++;
+ if (nbrexcept > 0) {
+ int c = 0;
+ for (int i = 0; i < BLOCK_SIZE; ++i) {
+ if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) {
+ exceptbuffer[c + nbrexcept] = i;
+ exceptbuffer[c] = in[tmpinpos
+ + i] >>> bits[tmpbestb];
+ ++c;
+ }
+ }
+ exceptsize = S9.compress(exceptbuffer, 0,
+ 2 * nbrexcept, out, tmpoutpos);
+ tmpoutpos += exceptsize;
+ }
+ out[remember] = tmpbestb | (nbrexcept << 8)
+ | (exceptsize << 16);
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastpack(in, tmpinpos + k, out,
+ tmpoutpos, bits[tmpbestb]);
+ tmpoutpos += bits[tmpbestb];
+ }
}
+ inpos.set(tmpinpos);
+ outpos.set(tmpoutpos);
+ }
- final int thiscost = bits[i] * 4
- + S9.estimatecompress(exceptbuffer, 0, 2 * tmpcounter);
- if (thiscost <= bestcost) {
- bestcost = thiscost;
- besti = i;
- exceptcounter = tmpcounter;
- }
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos, int mynvalue) {
+ if (inlength == 0)
+ return;
+ mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE);
+ decodePage(in, inpos, out, outpos, mynvalue);
}
- bestb.set(besti);
- bestexcept.set(exceptcounter);
- }
-
- private void encodePage(int[] in, IntWrapper inpos, int thissize,
- int[] out, IntWrapper outpos) {
- int tmpoutpos = outpos.get();
- int tmpinpos = inpos.get();
- IntWrapper bestb = new IntWrapper();
- IntWrapper bestexcept = new IntWrapper();
- for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) {
- getBestBFromData(in, tmpinpos, bestb, bestexcept);
- int tmpbestb = bestb.get();
- int nbrexcept = bestexcept.get();
- int exceptsize = 0;
- int remember = tmpoutpos;
- tmpoutpos++;
- if (nbrexcept > 0) {
- final int maxv = 1 << bits[tmpbestb];
- int c = 0;
- for (int i = 0; i < BlockSize; ++i) {
- if (in[tmpinpos + i] >= maxv) {
- exceptbuffer[c + nbrexcept] = i;
- exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb];
- ++c;
- }
- }
- exceptsize = S9.compress(exceptbuffer, 0, 2 * nbrexcept, out,
- tmpoutpos);
- tmpoutpos += exceptsize;
- }
- out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16);
- for (int k = 0; k < BlockSize; k += 32) {
- BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos,
- bits[tmpbestb]);
- tmpoutpos += bits[tmpbestb];
- }
+
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ int blockCount = inlength / BLOCK_SIZE;
+ // +1 for the header
+ // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers.
+ int maxBlockSizeInInts = 1 + BLOCK_SIZE;
+ compressedPositions.add(inlength);
+ return maxBlockSizeInInts * blockCount;
}
- inpos.set(tmpinpos);
- outpos.set(tmpoutpos);
- }
-
- @Override
- public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- int mynvalue = in[inpos.get()];
- inpos.increment();
- int finalout = outpos.get() + mynvalue;
- while (outpos.get() != finalout) {
- int thissize = finalout > PageSize + outpos.get() ? PageSize
- : (finalout - outpos.get());
- decodePage(in, inpos, out, outpos, thissize);
+
+ private void decodePage(int[] in, IntWrapper inpos, int[] out,
+ IntWrapper outpos, int thissize) {
+ int tmpoutpos = outpos.get();
+ int tmpinpos = inpos.get();
+
+ for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) {
+ final int b = in[tmpinpos] & 0xFF;
+ final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
+ final int exceptsize = (in[tmpinpos] >>> 16);
+ ++tmpinpos;
+ S9.uncompress(in, tmpinpos, exceptsize, exceptbuffer,
+ 0, 2 * cexcept);
+ tmpinpos += exceptsize;
+ for (int k = 0; k < BLOCK_SIZE; k += 32) {
+ BitPacking.fastunpack(in, tmpinpos, out,
+ tmpoutpos + k, bits[b]);
+ tmpinpos += bits[b];
+ }
+ for (int k = 0; k < cexcept; ++k) {
+ out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
+ }
+ }
+ outpos.set(tmpoutpos);
+ inpos.set(tmpinpos);
}
- }
-
- private void decodePage(int[] in, IntWrapper inpos, int[] out,
- IntWrapper outpos, int thissize) {
- int tmpoutpos = outpos.get();
- int tmpinpos = inpos.get();
-
- for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) {
- final int b = in[tmpinpos] & 0xFF;
- final int cexcept = (in[tmpinpos] >>> 8) & 0xFF;
- final int exceptsize = (in[tmpinpos] >>> 16);
- ++tmpinpos;
- S9.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0,
- 2 * cexcept);
- tmpinpos += exceptsize;
- for (int k = 0; k < BlockSize; k += 32) {
- BitPacking
- .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]);
- tmpinpos += bits[b];
- }
- for (int k = 0; k < cexcept; ++k) {
- out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
- }
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ inlength = inlength / BLOCK_SIZE * BLOCK_SIZE;
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
}
- outpos.set(tmpoutpos);
- inpos.set(tmpinpos);
- }
- @Override
- public String toString() {
- return this.getClass().getName();
- }
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+ }
+
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/me/lemire/integercompression/S16.java b/src/main/java/me/lemire/integercompression/S16.java
index 8b51cf1..e40522d 100644
--- a/src/main/java/me/lemire/integercompression/S16.java
+++ b/src/main/java/me/lemire/integercompression/S16.java
@@ -9,19 +9,33 @@
/**
* Version of Simple16 for NewPFD and OptPFD.
- *
+ *
* Adapted by D. Lemire from the Apache Lucene project.
+ *
*/
public final class S16 {
-
- protected static int compress(final int[] in, int currentPos, int inlength,
- final int out[], final int tmpoutpos) {
+ /**
+ * Compress an integer array using Simple16
+ *
+ *
+ * @param in
+ * array to compress
+ * @param currentPos
+ * where to start reading
+ * @param inlength
+ * how many integers to read
+ * @param out
+ * output array
+ * @param tmpoutpos
+ * location in the output array
+ * @return the number of 32-bit words written (in compressed form)
+ */
+ public static int compress(final int[] in, int currentPos, int inlength, final int out[], final int tmpoutpos) {
int outpos = tmpoutpos;
final int finalin = currentPos + inlength;
while (currentPos < finalin) {
- int inoffset = compressblock(out, outpos++, in, currentPos,
- inlength);
+ int inoffset = compressblock(out, outpos++, in, currentPos, inlength);
if (inoffset == -1)
throw new RuntimeException("Too big a number");
currentPos += inoffset;
@@ -29,14 +43,18 @@ protected static int compress(final int[] in, int currentPos, int inlength,
}
return outpos - tmpoutpos;
}
+
/**
- * Estimate size of the compressed output.
- *
- * @param in array to compress
- * @param currentPos where to start reading
- * @param inlength how many integers to read
- * @return estimated size of the output (in 32-bit integers)
- */
+ * Estimate size of the compressed output.
+ *
+ * @param in
+ * array to compress
+ * @param currentPos
+ * where to start reading
+ * @param inlength
+ * how many integers to read
+ * @return estimated size of the output (in 32-bit integers)
+ */
public static int estimatecompress(final int[] in, int currentPos, int inlength) {
final int finalin = currentPos + inlength;
int counter = 0;
@@ -53,24 +71,27 @@ public static int estimatecompress(final int[] in, int currentPos, int inlength)
/**
* Compress an integer array using Simple16
- *
- * @param out the compressed output
- * @param outOffset the offset of the output in the number of integers
- * @param in the integer input array
- * @param inOffset the offset of the input in the number of integers
- * @param n the number of elements to be compressed
+ *
+ * @param out
+ * the compressed output
+ * @param outOffset
+ * the offset of the output in the number of integers
+ * @param in
+ * the integer input array
+ * @param inOffset
+ * the offset of the input in the number of integers
+ * @param n
+ * the number of elements to be compressed
* @return the size of the outputs in 32-bit integers
- *
+ *
*/
- public static final int compressblock(int[] out, int outOffset, int[] in,
- int inOffset, int n) {
+ public static final int compressblock(int[] out, int outOffset, int[] in, int inOffset, int n) {
int numIdx, j, num, bits;
for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) {
out[outOffset] = numIdx << S16_BITSSIZE;
num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n;
- for (j = 0, bits = 0; (j < num)
- && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]); ) {
+ for (j = 0, bits = 0; (j < num) && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]);) {
out[outOffset] |= (in[inOffset + j] << bits);
bits += S16_BITS[numIdx][j];
j++;
@@ -89,8 +110,7 @@ private static final int fakecompressblock(int[] in, int inOffset, int n) {
for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) {
num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n;
- for (j = 0; (j < num)
- && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]); ) {
+ for (j = 0; (j < num) && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]);) {
j++;
}
@@ -104,33 +124,51 @@ private static final int fakecompressblock(int[] in, int inOffset, int n) {
/**
* Decompress an integer array using Simple16
- *
- * @param out the decompressed output
- * @param outOffset the offset of the output in the number of integers
- * @param in the compressed input array
- * @param inOffset the offset of the input in the number of integers
- * @param n the number of elements to be compressed
+ *
+ * @param out
+ * the decompressed output
+ * @param outOffset
+ * the offset of the output in the number of integers
+ * @param in
+ * the compressed input array
+ * @param inOffset
+ * the offset of the input in the number of integers
+ * @param n
+ * the number of elements to be compressed
* @return the number of processed integers
*/
- public static final int decompressblock(int[] out, int outOffset, int[] in,
- int inOffset, int n) {
+ public static final int decompressblock(int[] out, int outOffset, int[] in, int inOffset, int n) {
int numIdx, j = 0, bits = 0;
numIdx = in[inOffset] >>> S16_BITSSIZE;
int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n;
for (j = 0, bits = 0; j < num; j++) {
- out[outOffset + j] = (in[inOffset] >>> bits)
- & (0xffffffff >>> (32 - S16_BITS[numIdx][j]));
+ out[outOffset + j] = (in[inOffset] >>> bits) & (0xffffffff >>> (32 - S16_BITS[numIdx][j]));
bits += S16_BITS[numIdx][j];
}
return num;
}
- protected static void uncompress(final int[] in, int tmpinpos, final int inlength,
- final int[] out, int currentPos, int outlength) {
+ /**
+ * Uncompressed data from an input array into an output array
+ *
+ * @param in
+ * input array (in compressed form)
+ * @param tmpinpos
+ * starting location in the compressed input array
+ * @param inlength
+ * how much data we wish the read (in 32-bit words)
+ * @param out
+ * output array (in decompressed form)
+ * @param currentPos
+ * current position in the output array
+ * @param outlength
+ * available data in the output array
+ */
+ public static void uncompress(final int[] in, int tmpinpos, final int inlength, final int[] out, int currentPos,
+ int outlength) {
final int finalpos = tmpinpos + inlength;
while (tmpinpos < finalpos) {
- final int howmany = decompressblock(out, currentPos, in, tmpinpos,
- outlength);
+ final int howmany = decompressblock(out, currentPos, in, tmpinpos, outlength);
outlength -= howmany;
currentPos += howmany;
tmpinpos += 1;
@@ -151,20 +189,17 @@ private static int[][] shiftme(int[][] x) {
private static final int S16_NUMSIZE = 16;
private static final int S16_BITSSIZE = 28;
// the possible number of bits used to represent one integer
- private static final int[] S16_NUM = {28, 21, 21, 21, 14, 9, 8, 7, 6, 6,
- 5, 5, 4, 3, 2, 1};
- // the corresponding number of elements for each value of the number of bits
+ private static final int[] S16_NUM = { 28, 21, 21, 21, 14, 9, 8, 7, 6, 6, 5, 5, 4, 3, 2, 1 };
+ // the corresponding number of elements for each value of the number of
+ // bits
private static final int[][] S16_BITS = {
- {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1},
- {2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
- {1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1},
- {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2},
- {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
- {4, 3, 3, 3, 3, 3, 3, 3, 3}, {3, 4, 4, 4, 4, 3, 3, 3},
- {4, 4, 4, 4, 4, 4, 4}, {5, 5, 5, 5, 4, 4},
- {4, 4, 5, 5, 5, 5}, {6, 6, 6, 5, 5}, {5, 5, 6, 6, 6},
- {7, 7, 7, 7}, {10, 9, 9,}, {14, 14}, {28}};
+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
+ { 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
+ { 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 },
+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2 },
+ { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, { 4, 3, 3, 3, 3, 3, 3, 3, 3 }, { 3, 4, 4, 4, 4, 3, 3, 3 },
+ { 4, 4, 4, 4, 4, 4, 4 }, { 5, 5, 5, 5, 4, 4 }, { 4, 4, 5, 5, 5, 5 }, { 6, 6, 6, 5, 5 }, { 5, 5, 6, 6, 6 },
+ { 7, 7, 7, 7 }, { 10, 9, 9, }, { 14, 14 }, { 28 } };
private static final int[][] SHIFTED_S16_BITS = shiftme(S16_BITS);
}
diff --git a/src/main/java/me/lemire/integercompression/S9.java b/src/main/java/me/lemire/integercompression/S9.java
index 72fc062..7e03e42 100644
--- a/src/main/java/me/lemire/integercompression/S9.java
+++ b/src/main/java/me/lemire/integercompression/S9.java
@@ -8,25 +8,31 @@
/**
* This is a version of Simple9 optimized for NewPFOR, OptPFOR
- *
+ *
+ * Adapted by D. Lemire from the Apache Lucene project.
+ *
+ *
* @author Daniel Lemire
*/
public final class S9 {
- /**
- * Estimate size of the compressed output.
- *
- * @param in array to compress
- * @param currentPos where to start reading
- * @param inlength how many integers to read
- * @return estimated size of the output (in 32-bit integers)
- */
+
+
+ /**
+ * Estimate size of the compressed output.
+ *
+ * @param in
+ * array to compress
+ * @param currentPos
+ * where to start reading
+ * @param inlength
+ * how many integers to read
+ * @return estimated size of the output (in 32-bit integers)
+ */
public static int estimatecompress(int[] in, int currentPos, int inlength) {
int tmpoutpos = 0;
int finalpos = currentPos + inlength;
- outer:
- while (currentPos < finalpos) {
- mainloop:
- for (int selector = 0; selector < 8; selector++) {
+ outer: while (currentPos < finalpos) {
+ mainloop: for (int selector = 0; selector < 8; selector++) {
int compressedNum = codeNum[selector];
if (finalpos <= currentPos + compressedNum - 1)
@@ -35,7 +41,7 @@ public static int estimatecompress(int[] in, int currentPos, int inlength) {
int max = 1 << b;
int i = 0;
for (; i < compressedNum; i++)
- if (max <= in[currentPos + i])
+ if (Util.smallerorequalthan(max , in[currentPos + i]))
continue mainloop;
currentPos += compressedNum;
++tmpoutpos;
@@ -51,14 +57,27 @@ public static int estimatecompress(int[] in, int currentPos, int inlength) {
return tmpoutpos;
}
- protected static int compress(int[] in, int currentPos, int inlength, int out[],
- int tmpoutpos) {
+ /**
+ * Compress an integer array using Simple9
+ *
+ *
+ * @param in
+ * array to compress
+ * @param currentPos
+ * where to start reading
+ * @param inlength
+ * how many integers to read
+ * @param out
+ * output array
+ * @param tmpoutpos
+ * location in the output array
+ * @return the number of 32-bit words written (in compressed form)
+ */
+ public static int compress(int[] in, int currentPos, int inlength, int out[], int tmpoutpos) {
int origtmpoutpos = tmpoutpos;
int finalpos = currentPos + inlength;
- outer:
- while (currentPos < finalpos) {
- mainloop:
- for (int selector = 0; selector < 8; selector++) {
+ outer: while (currentPos < finalpos) {
+ mainloop: for (int selector = 0; selector < 8; selector++) {
int res = 0;
int compressedNum = codeNum[selector];
if (finalpos <= currentPos + compressedNum - 1)
@@ -67,7 +86,7 @@ protected static int compress(int[] in, int currentPos, int inlength, int out[],
int max = 1 << b;
int i = 0;
for (; i < compressedNum; i++) {
- if (max <= in[currentPos + i])
+ if (Util.smallerorequalthan(max, in[currentPos + i]))
continue mainloop;
res = (res << b) + in[currentPos + i];
}
@@ -86,93 +105,99 @@ protected static int compress(int[] in, int currentPos, int inlength, int out[],
return tmpoutpos - origtmpoutpos;
}
- protected static void uncompress(int[] in, int tmpinpos, int inlength,
- int[] out, int currentPos, int outlength) {
+ /**
+ * Uncompressed data from an input array into an output array
+ *
+ * @param in
+ * input array (in compressed form)
+ * @param tmpinpos
+ * starting location in the compressed input array
+ * @param inlength
+ * how much data we wish the read (in 32-bit words)
+ * @param out
+ * output array (in decompressed form)
+ * @param currentPos
+ * current position in the output array
+ * @param outlength
+ * available data in the output array
+ */
+ public static void uncompress(int[] in, int tmpinpos, int inlength, int[] out, int currentPos, int outlength) {
int finallength = currentPos + outlength;
while (currentPos < finallength) {
int val = in[tmpinpos++];
int header = val >>> 28;
switch (header) {
- case 0: { // number : 28, bitwidth : 1
- final int howmany = finallength - currentPos < 28 ? finallength
- - currentPos : 28;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (k + 4)) >>> 31;
- }
- break;
- }
- case 1: { // number : 14, bitwidth : 2
- final int howmany = finallength - currentPos < 14 ? finallength
- - currentPos : 14;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (2 * k + 4)) >>> 30;
- }
- break;
+ case 0: { // number : 28, bitwidth : 1
+ final int howmany = finallength - currentPos < 28 ? finallength - currentPos : 28;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (k + 4)) >>> 31;
}
- case 2: { // number : 9, bitwidth : 3
- final int howmany = finallength - currentPos < 9 ? finallength
- - currentPos : 9;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (3 * k + 5)) >>> 29;
- }
- break;
- }
- case 3: { // number : 7, bitwidth : 4
- final int howmany = finallength - currentPos < 7 ? finallength
- - currentPos : 7;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (4 * k + 4)) >>> 28;
- }
- break;
+ break;
+ }
+ case 1: { // number : 14, bitwidth : 2
+ final int howmany = finallength - currentPos < 14 ? finallength - currentPos : 14;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (2 * k + 4)) >>> 30;
}
- case 4: { // number : 5, bitwidth : 5
- final int howmany = finallength - currentPos < 5 ? finallength
- - currentPos : 5;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (5 * k + 7)) >>> 27;
- }
- break;
+ break;
+ }
+ case 2: { // number : 9, bitwidth : 3
+ final int howmany = finallength - currentPos < 9 ? finallength - currentPos : 9;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (3 * k + 5)) >>> 29;
}
- case 5: { // number : 4, bitwidth : 7
- final int howmany = finallength - currentPos < 4 ? finallength
- - currentPos : 4;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (7 * k + 4)) >>> 25;
- }
- break;
+ break;
+ }
+ case 3: { // number : 7, bitwidth : 4
+ final int howmany = finallength - currentPos < 7 ? finallength - currentPos : 7;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (4 * k + 4)) >>> 28;
}
- case 6: { // number : 3, bitwidth : 9
- final int howmany = finallength - currentPos < 3 ? finallength
- - currentPos : 3;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (9 * k + 5)) >>> 23;
- }
- break;
+ break;
+ }
+ case 4: { // number : 5, bitwidth : 5
+ final int howmany = finallength - currentPos < 5 ? finallength - currentPos : 5;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (5 * k + 7)) >>> 27;
}
- case 7: { // number : 2, bitwidth : 14
- final int howmany = finallength - currentPos < 2 ? finallength
- - currentPos : 2;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (14 * k + 4)) >>> 18;
- }
- break;
+ break;
+ }
+ case 5: { // number : 4, bitwidth : 7
+ final int howmany = finallength - currentPos < 4 ? finallength - currentPos : 4;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (7 * k + 4)) >>> 25;
}
- case 8: { // number : 1, bitwidth : 28
- out[currentPos++] = (val << 4) >>> 4;
- break;
+ break;
+ }
+ case 6: { // number : 3, bitwidth : 9
+ final int howmany = finallength - currentPos < 3 ? finallength - currentPos : 3;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (9 * k + 5)) >>> 23;
}
- default: {
- throw new RuntimeException("shouldn't happen");
+ break;
+ }
+ case 7: { // number : 2, bitwidth : 14
+ final int howmany = finallength - currentPos < 2 ? finallength - currentPos : 2;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (14 * k + 4)) >>> 18;
}
+ break;
+ }
+ case 8: { // number : 1, bitwidth : 28
+ out[currentPos++] = (val << 4) >>> 4;
+ break;
+ }
+ default: {
+ throw new RuntimeException("shouldn't happen");
+ }
}
}
}
- private final static int bitLength[] = {1, 2, 3, 4, 5, 7, 9, 14, 28};
-
- private final static int codeNum[] = {28, 14, 9, 7, 5, 4, 3, 2, 1};
+ private final static int bitLength[] = { 1, 2, 3, 4, 5, 7, 9, 14, 28 };
+ private final static int codeNum[] = { 28, 14, 9, 7, 5, 4, 3, 2, 1 };
}
diff --git a/src/main/java/me/lemire/integercompression/Simple16.java b/src/main/java/me/lemire/integercompression/Simple16.java
new file mode 100644
index 0000000..2b7f27f
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/Simple16.java
@@ -0,0 +1,191 @@
+package me.lemire.integercompression;
+
+/**
+ * This is an implementation of the popular Simple16 scheme. It is limited to
+ * 28-bit integers (between 0 and 2^28-1).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately.
+ *
+ *
+ * Adapted by D. Lemire from the Apache Lucene project.
+ *
+ */
+public final class Simple16 implements IntegerCODEC, SkippableIntegerCODEC {
+
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int out[], IntWrapper outpos) {
+ int i_inpos = inpos.get();
+ int i_outpos = outpos.get();
+ final int finalin = i_inpos + inlength;
+ while (i_inpos < finalin) {
+ int inoffset = compressblock(out, i_outpos++, in, i_inpos, inlength);
+ if (inoffset == -1)
+ throw new RuntimeException("Too big a number");
+ i_inpos += inoffset;
+ inlength -= inoffset;
+ }
+ inpos.set(i_inpos);
+ outpos.set(i_outpos);
+ }
+
+ /**
+ * Compress an integer array using Simple16
+ *
+ * @param out
+ * the compressed output
+ * @param outOffset
+ * the offset of the output in the number of integers
+ * @param in
+ * the integer input array
+ * @param inOffset
+ * the offset of the input in the number of integers
+ * @param n
+ * the number of elements to be compressed
+ * @return the number of compressed integers
+ */
+ public static final int compressblock(int[] out, int outOffset, int[] in, int inOffset, int n) {
+ int numIdx, j, num, bits;
+ for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) {
+ out[outOffset] = numIdx << S16_BITSSIZE;
+ num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n;
+
+ for (j = 0, bits = 0; (j < num) && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]);) {
+ out[outOffset] |= (in[inOffset + j] << bits);
+ bits += S16_BITS[numIdx][j];
+ j++;
+ }
+
+ if (j == num) {
+ return num;
+ }
+ }
+
+ return -1;
+ }
+
+ /**
+ * Decompress an integer array using Simple16
+ *
+ * @param out
+ * the decompressed output
+ * @param outOffset
+ * the offset of the output in the number of integers
+ * @param in
+ * the compressed input array
+ * @param inOffset
+ * the offset of the input in the number of integers
+ * @param n
+ * the number of elements to be compressed
+ * @return the number of processed integers
+ */
+ public static final int decompressblock(int[] out, int outOffset, int[] in, int inOffset, int n) {
+ int numIdx, j = 0, bits = 0;
+ numIdx = in[inOffset] >>> S16_BITSSIZE;
+ int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n;
+ for (j = 0, bits = 0; j < num; j++) {
+ out[outOffset + j] = (in[inOffset] >>> bits) & (0xffffffff >>> (32 - S16_BITS[numIdx][j]));
+ bits += S16_BITS[numIdx][j];
+ }
+ return num;
+ }
+
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos, int num) {
+ int i_inpos = inpos.get();
+ int i_outpos = outpos.get();
+ while (num > 0) {
+ final int howmany = decompressblock(out, i_outpos, in, i_inpos, num);
+ num -= howmany;
+ i_outpos += howmany;
+ i_inpos++;
+ }
+ inpos.set(i_inpos);
+ outpos.set(i_outpos);
+ }
+
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ compressedPositions.add(inlength);
+ return inlength;
+ }
+
+ /**
+ * Uncompress data from an array to another array.
+ *
+ * Both inpos and outpos parameters are modified to indicate new positions
+ * after read/write.
+ *
+ * @param in
+ * array containing data in compressed form
+ * @param tmpinpos
+ * where to start reading in the array
+ * @param inlength
+ * length of the compressed data (ignored by some schemes)
+ * @param out
+ * array where to write the compressed output
+ * @param currentPos
+ * where to write the compressed output in out
+ * @param outlength
+ * number of integers we want to decode
+ */
+ public static void uncompress(int[] in, int tmpinpos, int inlength, int[] out, int currentPos, int outlength) {
+ final int finalpos = tmpinpos + inlength;
+ while (tmpinpos < finalpos) {
+ final int howmany = decompressblock(out, currentPos, in, tmpinpos, outlength);
+ outlength -= howmany;
+ currentPos += howmany;
+ tmpinpos += 1;
+ }
+
+ }
+
+ private static int[][] shiftme(int[][] x) {
+ int[][] answer = new int[x.length][];
+ for (int k = 0; k < x.length; ++k) {
+ answer[k] = new int[x[k].length];
+ for (int z = 0; z < answer[k].length; ++z)
+ answer[k][z] = 1 << x[k][z];
+ }
+ return answer;
+ }
+
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
+ }
+
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+
+ }
+
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
+
+ private static final int S16_NUMSIZE = 16;
+ private static final int S16_BITSSIZE = 28;
+ // the possible number of bits used to represent one integer
+ private static final int[] S16_NUM = { 28, 21, 21, 21, 14, 9, 8, 7, 6, 6, 5, 5, 4, 3, 2, 1 };
+ // the corresponding number of elements for each value of the number of bits
+ private static final int[][] S16_BITS = {
+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
+ { 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
+ { 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 },
+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2 },
+ { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, { 4, 3, 3, 3, 3, 3, 3, 3, 3 }, { 3, 4, 4, 4, 4, 3, 3, 3 },
+ { 4, 4, 4, 4, 4, 4, 4 }, { 5, 5, 5, 5, 4, 4 }, { 4, 4, 5, 5, 5, 5 }, { 6, 6, 6, 5, 5 }, { 5, 5, 6, 6, 6 },
+ { 7, 7, 7, 7 }, { 10, 9, 9, }, { 14, 14 }, { 28 } };
+ private static final int[][] SHIFTED_S16_BITS = shiftme(S16_BITS);
+
+}
diff --git a/src/main/java/me/lemire/integercompression/Simple9.java b/src/main/java/me/lemire/integercompression/Simple9.java
index c97ba38..fd5194d 100644
--- a/src/main/java/me/lemire/integercompression/Simple9.java
+++ b/src/main/java/me/lemire/integercompression/Simple9.java
@@ -7,23 +7,26 @@
package me.lemire.integercompression;
-
/**
+ * This is an implementation of the popular Simple9 scheme. It is limited to
+ * 28-bit integers (between 0 and 2^28-1).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately.
+ *
* @author Daniel Lemire
- *
+ *
*/
-public final class Simple9 implements IntegerCODEC {
+public final class Simple9 implements IntegerCODEC, SkippableIntegerCODEC {
+
+
@Override
- public void compress(int[] in, IntWrapper inpos, int inlength, int out[],
- IntWrapper outpos) {
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int out[], IntWrapper outpos) {
int tmpoutpos = outpos.get();
int currentPos = inpos.get();
- out[tmpoutpos++] = inlength;
final int finalin = currentPos + inlength;
- outer:
- while (currentPos < finalin - 28) {
- mainloop:
- for (int selector = 0; selector < 8; selector++) {
+ outer: while (currentPos < finalin - 28) {
+ mainloop: for (int selector = 0; selector < 8; selector++) {
int res = 0;
int compressedNum = codeNum[selector];
@@ -45,10 +48,8 @@ public void compress(int[] in, IntWrapper inpos, int inlength, int out[],
throw new RuntimeException("Too big a number");
out[tmpoutpos++] = in[currentPos++] | (selector << 28);
}
- outer:
- while (currentPos < finalin) {
- mainloop:
- for (int selector = 0; selector < 8; selector++) {
+ outer: while (currentPos < finalin) {
+ mainloop: for (int selector = 0; selector < 8; selector++) {
int res = 0;
int compressedNum = codeNum[selector];
if (finalin <= currentPos + compressedNum - 1)
@@ -79,194 +80,187 @@ public void compress(int[] in, IntWrapper inpos, int inlength, int out[],
}
@Override
- public void uncompress(int[] in, IntWrapper inpos, int inlength,
- int[] out, IntWrapper outpos) {
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos,
+ int outlength) {
int currentPos = outpos.get();
int tmpinpos = inpos.get();
- final int finalout = currentPos + in[tmpinpos++];
+ final int finalout = currentPos + outlength;
while (currentPos < finalout - 28) {
int val = in[tmpinpos++];
int header = val >>> 28;
switch (header) {
- case 0: { // number : 28, bitwidth : 1
- out[currentPos++] = (val << 4) >>> 31;
- out[currentPos++] = (val << 5) >>> 31;
- out[currentPos++] = (val << 6) >>> 31;
- out[currentPos++] = (val << 7) >>> 31;
- out[currentPos++] = (val << 8) >>> 31;
- out[currentPos++] = (val << 9) >>> 31;
- out[currentPos++] = (val << 10) >>> 31;
- out[currentPos++] = (val << 11) >>> 31;
- out[currentPos++] = (val << 12) >>> 31;
- out[currentPos++] = (val << 13) >>> 31; // 10
- out[currentPos++] = (val << 14) >>> 31;
- out[currentPos++] = (val << 15) >>> 31;
- out[currentPos++] = (val << 16) >>> 31;
- out[currentPos++] = (val << 17) >>> 31;
- out[currentPos++] = (val << 18) >>> 31;
- out[currentPos++] = (val << 19) >>> 31;
- out[currentPos++] = (val << 20) >>> 31;
- out[currentPos++] = (val << 21) >>> 31;
- out[currentPos++] = (val << 22) >>> 31;
- out[currentPos++] = (val << 23) >>> 31; // 20
- out[currentPos++] = (val << 24) >>> 31;
- out[currentPos++] = (val << 25) >>> 31;
- out[currentPos++] = (val << 26) >>> 31;
- out[currentPos++] = (val << 27) >>> 31;
- out[currentPos++] = (val << 28) >>> 31;
- out[currentPos++] = (val << 29) >>> 31;
- out[currentPos++] = (val << 30) >>> 31;
- out[currentPos++] = (val << 31) >>> 31;
- break;
- }
- case 1: { // number : 14, bitwidth : 2
- out[currentPos++] = (val << 4) >>> 30;
- out[currentPos++] = (val << 6) >>> 30;
- out[currentPos++] = (val << 8) >>> 30;
- out[currentPos++] = (val << 10) >>> 30;
- out[currentPos++] = (val << 12) >>> 30;
- out[currentPos++] = (val << 14) >>> 30;
- out[currentPos++] = (val << 16) >>> 30;
- out[currentPos++] = (val << 18) >>> 30;
- out[currentPos++] = (val << 20) >>> 30;
- out[currentPos++] = (val << 22) >>> 30; // 10
- out[currentPos++] = (val << 24) >>> 30;
- out[currentPos++] = (val << 26) >>> 30;
- out[currentPos++] = (val << 28) >>> 30;
- out[currentPos++] = (val << 30) >>> 30;
- break;
- }
- case 2: { // number : 9, bitwidth : 3
- out[currentPos++] = (val << 5) >>> 29;
- out[currentPos++] = (val << 8) >>> 29;
- out[currentPos++] = (val << 11) >>> 29;
- out[currentPos++] = (val << 14) >>> 29;
- out[currentPos++] = (val << 17) >>> 29;
- out[currentPos++] = (val << 20) >>> 29;
- out[currentPos++] = (val << 23) >>> 29;
- out[currentPos++] = (val << 26) >>> 29;
- out[currentPos++] = (val << 29) >>> 29;
- break;
- }
- case 3: { // number : 7, bitwidth : 4
- out[currentPos++] = (val << 4) >>> 28;
- out[currentPos++] = (val << 8) >>> 28;
- out[currentPos++] = (val << 12) >>> 28;
- out[currentPos++] = (val << 16) >>> 28;
- out[currentPos++] = (val << 20) >>> 28;
- out[currentPos++] = (val << 24) >>> 28;
- out[currentPos++] = (val << 28) >>> 28;
- break;
- }
- case 4: { // number : 5, bitwidth : 5
- out[currentPos++] = (val << 7) >>> 27;
- out[currentPos++] = (val << 12) >>> 27;
- out[currentPos++] = (val << 17) >>> 27;
- out[currentPos++] = (val << 22) >>> 27;
- out[currentPos++] = (val << 27) >>> 27;
- break;
- }
- case 5: { // number : 4, bitwidth : 7
- out[currentPos++] = (val << 4) >>> 25;
- out[currentPos++] = (val << 11) >>> 25;
- out[currentPos++] = (val << 18) >>> 25;
- out[currentPos++] = (val << 25) >>> 25;
- break;
- }
- case 6: { // number : 3, bitwidth : 9
- out[currentPos++] = (val << 5) >>> 23;
- out[currentPos++] = (val << 14) >>> 23;
- out[currentPos++] = (val << 23) >>> 23;
- break;
- }
- case 7: { // number : 2, bitwidth : 14
- out[currentPos++] = (val << 4) >>> 18;
- out[currentPos++] = (val << 18) >>> 18;
- break;
- }
- case 8: { // number : 1, bitwidth : 28
- out[currentPos++] = (val << 4) >>> 4;
- break;
- }
- default: {
- throw new RuntimeException("shouldn't happen");
- }
+ case 0: { // number : 28, bitwidth : 1
+ out[currentPos++] = (val << 4) >>> 31;
+ out[currentPos++] = (val << 5) >>> 31;
+ out[currentPos++] = (val << 6) >>> 31;
+ out[currentPos++] = (val << 7) >>> 31;
+ out[currentPos++] = (val << 8) >>> 31;
+ out[currentPos++] = (val << 9) >>> 31;
+ out[currentPos++] = (val << 10) >>> 31;
+ out[currentPos++] = (val << 11) >>> 31;
+ out[currentPos++] = (val << 12) >>> 31;
+ out[currentPos++] = (val << 13) >>> 31; // 10
+ out[currentPos++] = (val << 14) >>> 31;
+ out[currentPos++] = (val << 15) >>> 31;
+ out[currentPos++] = (val << 16) >>> 31;
+ out[currentPos++] = (val << 17) >>> 31;
+ out[currentPos++] = (val << 18) >>> 31;
+ out[currentPos++] = (val << 19) >>> 31;
+ out[currentPos++] = (val << 20) >>> 31;
+ out[currentPos++] = (val << 21) >>> 31;
+ out[currentPos++] = (val << 22) >>> 31;
+ out[currentPos++] = (val << 23) >>> 31; // 20
+ out[currentPos++] = (val << 24) >>> 31;
+ out[currentPos++] = (val << 25) >>> 31;
+ out[currentPos++] = (val << 26) >>> 31;
+ out[currentPos++] = (val << 27) >>> 31;
+ out[currentPos++] = (val << 28) >>> 31;
+ out[currentPos++] = (val << 29) >>> 31;
+ out[currentPos++] = (val << 30) >>> 31;
+ out[currentPos++] = (val << 31) >>> 31;
+ break;
+ }
+ case 1: { // number : 14, bitwidth : 2
+ out[currentPos++] = (val << 4) >>> 30;
+ out[currentPos++] = (val << 6) >>> 30;
+ out[currentPos++] = (val << 8) >>> 30;
+ out[currentPos++] = (val << 10) >>> 30;
+ out[currentPos++] = (val << 12) >>> 30;
+ out[currentPos++] = (val << 14) >>> 30;
+ out[currentPos++] = (val << 16) >>> 30;
+ out[currentPos++] = (val << 18) >>> 30;
+ out[currentPos++] = (val << 20) >>> 30;
+ out[currentPos++] = (val << 22) >>> 30; // 10
+ out[currentPos++] = (val << 24) >>> 30;
+ out[currentPos++] = (val << 26) >>> 30;
+ out[currentPos++] = (val << 28) >>> 30;
+ out[currentPos++] = (val << 30) >>> 30;
+ break;
+ }
+ case 2: { // number : 9, bitwidth : 3
+ out[currentPos++] = (val << 5) >>> 29;
+ out[currentPos++] = (val << 8) >>> 29;
+ out[currentPos++] = (val << 11) >>> 29;
+ out[currentPos++] = (val << 14) >>> 29;
+ out[currentPos++] = (val << 17) >>> 29;
+ out[currentPos++] = (val << 20) >>> 29;
+ out[currentPos++] = (val << 23) >>> 29;
+ out[currentPos++] = (val << 26) >>> 29;
+ out[currentPos++] = (val << 29) >>> 29;
+ break;
+ }
+ case 3: { // number : 7, bitwidth : 4
+ out[currentPos++] = (val << 4) >>> 28;
+ out[currentPos++] = (val << 8) >>> 28;
+ out[currentPos++] = (val << 12) >>> 28;
+ out[currentPos++] = (val << 16) >>> 28;
+ out[currentPos++] = (val << 20) >>> 28;
+ out[currentPos++] = (val << 24) >>> 28;
+ out[currentPos++] = (val << 28) >>> 28;
+ break;
+ }
+ case 4: { // number : 5, bitwidth : 5
+ out[currentPos++] = (val << 7) >>> 27;
+ out[currentPos++] = (val << 12) >>> 27;
+ out[currentPos++] = (val << 17) >>> 27;
+ out[currentPos++] = (val << 22) >>> 27;
+ out[currentPos++] = (val << 27) >>> 27;
+ break;
+ }
+ case 5: { // number : 4, bitwidth : 7
+ out[currentPos++] = (val << 4) >>> 25;
+ out[currentPos++] = (val << 11) >>> 25;
+ out[currentPos++] = (val << 18) >>> 25;
+ out[currentPos++] = (val << 25) >>> 25;
+ break;
+ }
+ case 6: { // number : 3, bitwidth : 9
+ out[currentPos++] = (val << 5) >>> 23;
+ out[currentPos++] = (val << 14) >>> 23;
+ out[currentPos++] = (val << 23) >>> 23;
+ break;
+ }
+ case 7: { // number : 2, bitwidth : 14
+ out[currentPos++] = (val << 4) >>> 18;
+ out[currentPos++] = (val << 18) >>> 18;
+ break;
+ }
+ case 8: { // number : 1, bitwidth : 28
+ out[currentPos++] = (val << 4) >>> 4;
+ break;
+ }
+ default: {
+ throw new RuntimeException("shouldn't happen: limited to 28-bit integers");
+ }
}
}
while (currentPos < finalout) {
int val = in[tmpinpos++];
int header = val >>> 28;
switch (header) {
- case 0: { // number : 28, bitwidth : 1
- final int howmany = finalout - currentPos;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (k + 4)) >>> 31;
- }
- break;
- }
- case 1: { // number : 14, bitwidth : 2
- final int howmany = finalout - currentPos < 14 ? finalout - currentPos
- : 14;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (2 * k + 4)) >>> 30;
- }
- break;
- }
- case 2: { // number : 9, bitwidth : 3
- final int howmany = finalout - currentPos < 9 ? finalout - currentPos
- : 9;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (3 * k + 5)) >>> 29;
- }
- break;
+ case 0: { // number : 28, bitwidth : 1
+ final int howmany = finalout - currentPos;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (k + 4)) >>> 31;
}
- case 3: { // number : 7, bitwidth : 4
- final int howmany = finalout - currentPos < 7 ? finalout - currentPos
- : 7;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (4 * k + 4)) >>> 28;
- }
- break;
+ break;
+ }
+ case 1: { // number : 14, bitwidth : 2
+ final int howmany = finalout - currentPos < 14 ? finalout - currentPos : 14;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (2 * k + 4)) >>> 30;
}
- case 4: { // number : 5, bitwidth : 5
- final int howmany = finalout - currentPos < 5 ? finalout - currentPos
- : 5;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (5 * k + 7)) >>> 27;
- }
- break;
+ break;
+ }
+ case 2: { // number : 9, bitwidth : 3
+ final int howmany = finalout - currentPos < 9 ? finalout - currentPos : 9;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (3 * k + 5)) >>> 29;
}
- case 5: { // number : 4, bitwidth : 7
- final int howmany = finalout - currentPos < 4 ? finalout - currentPos
- : 4;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (7 * k + 4)) >>> 25;
- }
- break;
+ break;
+ }
+ case 3: { // number : 7, bitwidth : 4
+ final int howmany = finalout - currentPos < 7 ? finalout - currentPos : 7;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (4 * k + 4)) >>> 28;
}
- case 6: { // number : 3, bitwidth : 9
- final int howmany = finalout - currentPos < 3 ? finalout - currentPos
- : 3;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (9 * k + 5)) >>> 23;
- }
- break;
+ break;
+ }
+ case 4: { // number : 5, bitwidth : 5
+ final int howmany = finalout - currentPos < 5 ? finalout - currentPos : 5;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (5 * k + 7)) >>> 27;
}
- case 7: { // number : 2, bitwidth : 14
- final int howmany = finalout - currentPos < 2 ? finalout - currentPos
- : 2;
- for (int k = 0; k < howmany; ++k) {
- out[currentPos++] = (val << (14 * k + 4)) >>> 18;
- }
- break;
+ break;
+ }
+ case 5: { // number : 4, bitwidth : 7
+ final int howmany = finalout - currentPos < 4 ? finalout - currentPos : 4;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (7 * k + 4)) >>> 25;
}
- case 8: { // number : 1, bitwidth : 28
- out[currentPos++] = (val << 4) >>> 4;
- break;
+ break;
+ }
+ case 6: { // number : 3, bitwidth : 9
+ final int howmany = finalout - currentPos < 3 ? finalout - currentPos : 3;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (9 * k + 5)) >>> 23;
}
- default: {
- throw new RuntimeException("shouldn't happen");
+ break;
+ }
+ case 7: { // number : 2, bitwidth : 14
+ final int howmany = finalout - currentPos < 2 ? finalout - currentPos : 2;
+ for (int k = 0; k < howmany; ++k) {
+ out[currentPos++] = (val << (14 * k + 4)) >>> 18;
}
+ break;
+ }
+ case 8: { // number : 1, bitwidth : 28
+ out[currentPos++] = (val << 4) >>> 4;
+ break;
+ }
+ default: {
+ throw new RuntimeException("shouldn't happen");
+ }
}
}
outpos.set(currentPos);
@@ -274,14 +268,38 @@ public void uncompress(int[] in, IntWrapper inpos, int inlength,
}
- private final static int bitLength[] = {1, 2, 3, 4, 5, 7, 9, 14, 28};
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ compressedPositions.add(inlength);
+ return inlength;
+ }
+
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
+ }
+
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+
+ }
- private final static int codeNum[] = {28, 14, 9, 7, 5, 4, 3, 2, 1};
+ private final static int bitLength[] = { 1, 2, 3, 4, 5, 7, 9, 14, 28 };
+ private final static int codeNum[] = { 28, 14, 9, 7, 5, 4, 3, 2, 1 };
@Override
public String toString() {
- return this.getClass().getName();
+ return this.getClass().getSimpleName();
}
}
diff --git a/src/main/java/me/lemire/integercompression/SkippableComposition.java b/src/main/java/me/lemire/integercompression/SkippableComposition.java
new file mode 100644
index 0000000..fc3c18e
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/SkippableComposition.java
@@ -0,0 +1,81 @@
+/**
+ * This is code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+package me.lemire.integercompression;
+
+
+/**
+ * Helper class to compose schemes.
+ *
+ * @author Daniel Lemire
+ */
+public class SkippableComposition implements SkippableIntegerCODEC {
+ SkippableIntegerCODEC F1, F2;
+
+ /**
+ * Compose a scheme from a first one (f1) and a second one (f2). The first
+ * one is called first and then the second one tries to compress whatever
+ * remains from the first run.
+ *
+ * By convention, the first scheme should be such that if, during decoding,
+ * a 32-bit zero is first encountered, then there is no output.
+ *
+ * @param f1
+ * first codec
+ * @param f2
+ * second codec
+ */
+ public SkippableComposition(SkippableIntegerCODEC f1,
+ SkippableIntegerCODEC f2) {
+ F1 = f1;
+ F2 = f2;
+ }
+
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ int init = inpos.get();
+ int outposInit = outpos.get();
+ F1.headlessCompress(in, inpos, inlength, out, outpos);
+ if (outpos.get() == outposInit) {
+ out[outposInit] = 0;
+ outpos.increment();
+ }
+ inlength -= inpos.get() - init;
+ F2.headlessCompress(in, inpos, inlength, out, outpos);
+ }
+
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos, int num) {
+ int init = inpos.get();
+ int outposInit = outpos.get();
+
+ F1.headlessUncompress(in, inpos, inlength, out, outpos, num);
+ if (inpos.get() == init) {
+ inpos.increment();
+ }
+ inlength -= inpos.get() - init;
+ num -= outpos.get() - outposInit;
+ F2.headlessUncompress(in, inpos, inlength, out, outpos, num);
+ }
+
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ int init = compressedPositions.get();
+ int maxLength = F1.maxHeadlessCompressedLength(compressedPositions, inlength);
+ maxLength += 1; // Add +1 for the potential F2 header. Question: is this header actually needed in the headless version?
+ inlength -= compressedPositions.get() - init;
+ maxLength += F2.maxHeadlessCompressedLength(compressedPositions, inlength);
+ return maxLength;
+ }
+
+ @Override
+ public String toString() {
+ return F1.toString() + "+" + F2.toString();
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/SkippableIntegerCODEC.java b/src/main/java/me/lemire/integercompression/SkippableIntegerCODEC.java
new file mode 100644
index 0000000..b9bdc04
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/SkippableIntegerCODEC.java
@@ -0,0 +1,89 @@
+/**
+ * This is code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+
+package me.lemire.integercompression;
+
+
+/**
+ * Interface describing a standard CODEC to compress integers. This is a
+ * variation on the IntegerCODEC interface meant to be used for random access
+ * (i.e., given a large array, you can segment it and decode just the subarray you need).
+ *
+ * The main difference is that you must specify the number of integers you wish to
+ * uncompress. This information should be stored elsewhere.
+ *
+ * This interface was designed by the Terrier team for their search engine.
+ *
+ * @author Daniel Lemire
+ *
+ */
+public interface SkippableIntegerCODEC {
+ /**
+ * Compress data from an array to another array.
+ *
+ * Both inpos and outpos are modified to represent how much data was read
+ * and written to. If 12 ints (inlength = 12) are compressed to 3 ints, then
+ * inpos will be incremented by 12 while outpos will be incremented by 3. We
+ * use IntWrapper to pass the values by reference.
+ *
+ * Implementation note: contrary to {@link IntegerCODEC#compress},
+ * this may skip writing information about the number of encoded integers.
+ *
+ * @param in
+ * input array
+ * @param inpos
+ * where to start reading in the array
+ * @param inlength
+ * how many integers to compress
+ * @param out
+ * output array
+ * @param outpos
+ * where to write in the output array
+ */
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos);
+
+ /**
+ * Uncompress data from an array to another array.
+ *
+ * Both inpos and outpos parameters are modified to indicate new positions
+ * after read/write.
+ *
+ * @param in
+ * array containing data in compressed form
+ * @param inpos
+ * where to start reading in the array
+ * @param inlength
+ * length of the compressed data (ignored by some schemes)
+ * @param out
+ * array where to write the uncompressed output
+ * @param outpos
+ * where to start writing the uncompressed output in out
+ * @param num
+ * number of integers we want to decode. May be less than the actual number of compressed integers
+ */
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos, int num);
+
+ /**
+ * Compute the maximum number of integers that might be required to store
+ * the compressed form of a given input array segment, without headers.
+ *
+ * This is useful to pre-allocate the output buffer before calling
+ * {@link #headlessCompress(int[], IntWrapper, int, int[], IntWrapper)}.
+ *
+ *
+ * @param compressedPositions
+ * since not all schemes compress every input integer, this parameter
+ * returns how many input integers will actually be compressed.
+ * This is useful when composing multiple schemes.
+ * @param inlength
+ * number of integers to be compressed
+ * @return the maximum number of integers needed in the output array
+ */
+ int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength);
+}
diff --git a/src/main/java/me/lemire/integercompression/Util.java b/src/main/java/me/lemire/integercompression/Util.java
index 961bb5b..63fc918 100644
--- a/src/main/java/me/lemire/integercompression/Util.java
+++ b/src/main/java/me/lemire/integercompression/Util.java
@@ -10,17 +10,87 @@
* Routine utility functions.
*
* @author Daniel Lemire
- *
+ *
*/
-public class Util {
- protected static int maxbits(int[] i, int pos, int length) {
+public final class Util {
+
+
+
+ // check whether x is small than y as unsigned ints (supported by Java 8 natively);
+ protected static final boolean smallerorequalthan(int x, int y) {
+ return (x + Integer.MIN_VALUE) <= (y + Integer.MIN_VALUE);
+ }
+
+ /**
+ * Compute the maximum of the integer logarithms (ceil(log(x+1)) of a range
+ * of value
+ *
+ * @param i
+ * source array
+ * @param pos
+ * starting position
+ * @param length
+ * number of integers to consider
+ * @return integer logarithm
+ */
+ public static int maxbits(int[] i, int pos, int length) {
int mask = 0;
for (int k = pos; k < pos + length; ++k)
mask |= i[k];
return bits(mask);
}
- protected static int maxdiffbits(int initoffset, int[] i, int pos, int length) {
+ protected static int maxbits32(int[] i, int pos) {
+ int mask = i[pos];
+ mask |= i[pos + 1];
+ mask |= i[pos + 2];
+ mask |= i[pos + 3];
+ mask |= i[pos + 4];
+ mask |= i[pos + 5];
+ mask |= i[pos + 6];
+ mask |= i[pos + 7];
+ mask |= i[pos + 8];
+ mask |= i[pos + 9];
+ mask |= i[pos + 10];
+ mask |= i[pos + 11];
+ mask |= i[pos + 12];
+ mask |= i[pos + 13];
+ mask |= i[pos + 14];
+ mask |= i[pos + 15];
+ mask |= i[pos + 16];
+ mask |= i[pos + 17];
+ mask |= i[pos + 18];
+ mask |= i[pos + 19];
+ mask |= i[pos + 20];
+ mask |= i[pos + 21];
+ mask |= i[pos + 22];
+ mask |= i[pos + 23];
+ mask |= i[pos + 24];
+ mask |= i[pos + 25];
+ mask |= i[pos + 26];
+ mask |= i[pos + 27];
+ mask |= i[pos + 28];
+ mask |= i[pos + 29];
+ mask |= i[pos + 30];
+ mask |= i[pos + 31];
+ return bits(mask);
+ }
+
+ /**
+ * Compute the maximum of the integer logarithms (ceil(log(x+1)) of a the
+ * successive differences (deltas) of a range of value
+ *
+ * @param initoffset
+ * initial vallue for the computation of the deltas
+ * @param i
+ * source array
+ * @param pos
+ * starting position
+ * @param length
+ * number of integers to consider
+ * @return integer logarithm
+ */
+ public static int maxdiffbits(int initoffset, int[] i, int pos, int length) {
int mask = 0;
mask |= (i[pos] - initoffset);
for (int k = pos + 1; k < pos + length; ++k) {
@@ -29,8 +99,112 @@ protected static int maxdiffbits(int initoffset, int[] i, int pos, int length) {
return bits(mask);
}
- protected static int bits(int i) {
+ /**
+ * Compute the integer logarithms (ceil(log(x+1)) of a value
+ *
+ * @param i
+ * source value
+ * @return integer logarithm
+ */
+ public static int bits(int i) {
return 32 - Integer.numberOfLeadingZeros(i);
}
+ protected static int packsize(int num, int b) {
+ if (b > 16)
+ return num;
+ int howmanyfit = 32 / b;
+ return (num + howmanyfit - 1) / howmanyfit;
+ }
+
+ protected static int pack(int[] outputarray, int arraypos, int[] data, int datapos,
+ int num, int b) {
+ if (num == 0)
+ return arraypos;
+ if (b > 16) {
+ System.arraycopy(data, datapos, outputarray, arraypos, num);
+ return num + arraypos;
+ }
+ for (int k = 0; k < packsize(num, b); ++k)
+ outputarray[k + arraypos] = 0;
+ int inwordpointer = 0;
+ for (int k = 0; k < num; ++k) {
+ outputarray[arraypos] |= (data[k + datapos] << inwordpointer);
+ inwordpointer += b;
+ final int increment = ((inwordpointer + b - 1) >> 5);
+ arraypos += increment;
+ inwordpointer &= ~(-increment);
+ }
+ return arraypos + (inwordpointer > 0 ? 1 : 0);
+ }
+
+ protected static int unpack(int[] sourcearray, int arraypos, int[] data, int datapos,
+ int num, int b) {
+ if (b > 16) {
+ System.arraycopy(sourcearray, arraypos, data, 0, num);
+ return num + arraypos;
+ }
+ final int mask = (1 << b) - 1;
+ int inwordpointer = 0;
+ for (int k = 0; k < num; ++k) {
+ data[k + datapos] = ((sourcearray[arraypos] >>> inwordpointer) & mask);
+ inwordpointer += b;
+ final int increment = ((inwordpointer + b - 1) >> 5);
+ arraypos += increment;
+ inwordpointer &= ~(-increment);
+ }
+ return arraypos + (inwordpointer > 0 ? 1 : 0);
+ }
+
+ protected static int packsizew(int num, int b) {
+ int howmanyfit = 32 / b;
+ if (num <= howmanyfit)
+ return 1;
+ return num;
+ }
+
+ protected static int packw(int[] outputarray, int arraypos, int[] data,
+ int num, int b) {
+ int howmanyfit = 32 / b;
+ if (num > howmanyfit) {
+ System.arraycopy(data, 0, outputarray, arraypos, num);
+ return num + arraypos;
+ }
+ outputarray[arraypos] = 0;
+ int inwordpointer = 0;
+ for (int k = 0; k < num; ++k) {
+ outputarray[arraypos] |= (data[k] << inwordpointer);
+ inwordpointer += b;
+ }
+ return arraypos + 1;
+ }
+
+ protected static int unpackw(int[] sourcearray, int arraypos, int[] data,
+ int num, int b) {
+ int howmanyfit = 32 / b;
+ if (num > howmanyfit) {
+ System.arraycopy(sourcearray, arraypos, data, 0, num);
+ return num + arraypos;
+ }
+ final int mask = (1 << b) - 1;
+ int val = sourcearray[arraypos];
+ for (int k = 0; k < num; ++k) {
+ data[k] = (val & mask);
+ val >>>= b;
+ }
+ return arraypos + 1;
+ }
+
+ /**
+ * return floor(value / factor) * factor
+ *
+ * @param value
+ * numerator
+ * @param factor
+ * denominator
+ * @return greatest multiple of factor no larger than value
+ */
+ public static int greatestMultiple(int value, int factor) {
+ return value - value % factor;
+ }
}
diff --git a/src/main/java/me/lemire/integercompression/VariableByte.java b/src/main/java/me/lemire/integercompression/VariableByte.java
index 53d4bb4..c9b04d0 100644
--- a/src/main/java/me/lemire/integercompression/VariableByte.java
+++ b/src/main/java/me/lemire/integercompression/VariableByte.java
@@ -7,31 +7,69 @@
package me.lemire.integercompression;
import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
import java.nio.IntBuffer;
/**
- * Implementation of variable-byte. Possibly inefficient.
- *
+ * Implementation of variable-byte. For best performance, use it using the
+ * ByteIntegerCODEC interface.
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, you must compute the deltas separately.
+ *
* @author Daniel Lemire
*/
-public class VariableByte implements IntegerCODEC {
+public class VariableByte implements IntegerCODEC, ByteIntegerCODEC, SkippableIntegerCODEC {
+
+ private static final int MAX_BYTES_PER_INT = 5;
+
+ private static byte extract7bits(int i, long val) {
+ return (byte) ((val >> (7 * i)) & ((1 << 7) - 1));
+ }
+
+ private static byte extract7bitsmaskless(int i, long val) {
+ return (byte) ((val >> (7 * i)));
+ }
@Override
public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
- IntWrapper outpos) {
- ByteBuffer buf = ByteBuffer.allocateDirect(inlength * 8);
+ IntWrapper outpos) {
+ headlessCompress(in, inpos, inlength, out, outpos);
+ }
+
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ ByteBuffer buf = makeBuffer(inlength * 8);
+ buf.order(ByteOrder.LITTLE_ENDIAN);
for (int k = inpos.get(); k < inpos.get() + inlength; ++k) {
- int val = in[k];
- do {
- int b = (val & 127);
- val >>>= 7;
- if (val != 0) {
- b |= 128;
- }
- buf.put((byte) b);
- } while (val != 0);
+ final long val = in[k] & 0xFFFFFFFFL; // To be consistent with
+ // unsigned integers in C/C++
+ if (val < (1 << 7)) {
+ buf.put((byte) (val | (1 << 7)));
+ } else if (val < (1 << 14)) {
+ buf.put((byte) extract7bits(0, val));
+ buf.put((byte) (extract7bitsmaskless(1, (val)) | (1 << 7)));
+ } else if (val < (1 << 21)) {
+ buf.put((byte) extract7bits(0, val));
+ buf.put((byte) extract7bits(1, val));
+ buf.put((byte) (extract7bitsmaskless(2, (val)) | (1 << 7)));
+ } else if (val < (1 << 28)) {
+ buf.put((byte) extract7bits(0, val));
+ buf.put((byte) extract7bits(1, val));
+ buf.put((byte) extract7bits(2, val));
+ buf.put((byte) (extract7bitsmaskless(3, (val)) | (1 << 7)));
+ } else {
+ buf.put((byte) extract7bits(0, val));
+ buf.put((byte) extract7bits(1, val));
+ buf.put((byte) extract7bits(2, val));
+ buf.put((byte) extract7bits(3, val));
+ buf.put((byte) (extract7bitsmaskless(4, (val)) | (1 << 7)));
+ }
}
while (buf.position() % 4 != 0)
- buf.put((byte) 128);
+ buf.put((byte) 0);
final int length = buf.position();
buf.flip();
IntBuffer ibuf = buf.asIntBuffer();
@@ -41,21 +79,59 @@ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out,
}
@Override
- public void uncompress(int[] in, IntWrapper inpos, int inlength,
- int[] out, IntWrapper outpos) {
+ public void compress(int[] in, IntWrapper inpos, int inlength, byte[] out,
+ IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ int outpostmp = outpos.get();
+ for (int k = inpos.get(); k < inpos.get() + inlength; ++k) {
+ final long val = in[k] & 0xFFFFFFFFL; // To be consistent with
+ // unsigned integers in C/C++
+ if (val < (1 << 7)) {
+ out[outpostmp++] = (byte) (val | (1 << 7));
+ } else if (val < (1 << 14)) {
+ out[outpostmp++] = (byte) extract7bits(0, val);
+ out[outpostmp++] = (byte) (extract7bitsmaskless(1, (val)) | (1 << 7));
+ } else if (val < (1 << 21)) {
+ out[outpostmp++] = (byte) extract7bits(0, val);
+ out[outpostmp++] = (byte) extract7bits(1, val);
+ out[outpostmp++] = (byte) (extract7bitsmaskless(2, (val)) | (1 << 7));
+ } else if (val < (1 << 28)) {
+ out[outpostmp++] = (byte) extract7bits(0, val);
+ out[outpostmp++] = (byte) extract7bits(1, val);
+ out[outpostmp++] = (byte) extract7bits(2, val);
+ out[outpostmp++] = (byte) (extract7bitsmaskless(3, (val)) | (1 << 7));
+ } else {
+ out[outpostmp++] = (byte) extract7bits(0, val);
+ out[outpostmp++] = (byte) extract7bits(1, val);
+ out[outpostmp++] = (byte) extract7bits(2, val);
+ out[outpostmp++] = (byte) extract7bits(3, val);
+ out[outpostmp++] = (byte) (extract7bitsmaskless(4, (val)) | (1 << 7));
+ }
+ }
+ outpos.set(outpostmp);
+ inpos.add(inlength);
+ }
+
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos) {
int s = 0;
+ int val = 0;
int p = inpos.get();
int finalp = inpos.get() + inlength;
int tmpoutpos = outpos.get();
- for (int v = 0, shift = 0; p < finalp; ) {
- int c = (byte) (in[p] >>> (24 - s));
+ for (int v = 0, shift = 0; p < finalp;) {
+ val = in[p];
+ int c = (byte) (val >>> s);
+ // Shift to next byte
s += 8;
- if (s == 32) {
- s = 0;
- p++;
- }
+ // Shift to next integer if s==32
+ p += s>>5;
+ // cycle from 31 to 0
+ s = s & 31;
v += ((c & 127) << shift);
- if ((c & 128) == 0) {
+ if ((c & 128) == 128) {
out[tmpoutpos++] = v;
v = 0;
shift = 0;
@@ -66,9 +142,93 @@ public void uncompress(int[] in, IntWrapper inpos, int inlength,
inpos.add(inlength);
}
+ @Override
+ public void uncompress(byte[] in, IntWrapper inpos, int inlength,
+ int[] out, IntWrapper outpos) {
+ int p = inpos.get();
+ int finalp = inpos.get() + inlength;
+ int tmpoutpos = outpos.get();
+ for (int v = 0; p < finalp; out[tmpoutpos++] = v) {
+ v = in[p] & 0x7F;
+ if (in[p] < 0) {
+ p += 1;
+ continue;
+ }
+ v = ((in[p + 1] & 0x7F) << 7) | v;
+ if (in[p + 1] < 0) {
+ p += 2;
+ continue;
+ }
+ v = ((in[p + 2] & 0x7F) << 14) | v;
+ if (in[p + 2] < 0 ) {
+ p += 3;
+ continue;
+ }
+ v = ((in[p + 3] & 0x7F) << 21) | v;
+ if (in[p + 3] < 0) {
+ p += 4;
+ continue;
+ }
+ v = ((in[p + 4] & 0x7F) << 28) | v;
+ p += 5;
+ }
+ outpos.set(tmpoutpos);
+ inpos.add(p);
+ }
+
@Override
public String toString() {
- return this.getClass().getName();
+ return this.getClass().getSimpleName();
+ }
+
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out,
+ IntWrapper outpos, int num) {
+ int s = 0;
+ int val = 0;
+ int p = inpos.get();
+ int tmpoutpos = outpos.get();
+ int finaloutpos = num + tmpoutpos;
+ for (int v = 0, shift = 0; tmpoutpos < finaloutpos;) {
+ val = in[p];
+ int c = val >>> s;
+ // Shift to next byte
+ s += 8;
+ // Shift to next integer if s==32
+ p += s>>5;
+ // cycle from 31 to 0
+ s = s & 31;
+ v += ((c & 127) << shift);
+ if ((c & 128) == 128) {
+ out[tmpoutpos++] = v;
+ v = 0;
+ shift = 0;
+ } else
+ shift += 7;
+ }
+ outpos.set(tmpoutpos);
+ inpos.set(p + (s!=0 ? 1 : 0));
+ }
+
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ int maxLengthInBytes = inlength * MAX_BYTES_PER_INT;
+ int maxLengthInInts = (maxLengthInBytes + Integer.BYTES - 1) / Integer.BYTES;
+ compressedPositions.add(inlength);
+ return maxLengthInInts;
}
+ /**
+ * Creates a new buffer of the requested size.
+ *
+ * In case you need a different way to allocate buffers, you can override this method
+ * with a custom behavior. The default implementation allocates a new Java direct
+ * {@link ByteBuffer} on each invocation.
+ *
+ * @param sizeInBytes
+ * @return
+ */
+ protected ByteBuffer makeBuffer(int sizeInBytes) {
+ return ByteBuffer.allocateDirect(sizeInBytes);
+ }
}
diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/Benchmark.java b/src/main/java/me/lemire/integercompression/benchmarktools/Benchmark.java
new file mode 100644
index 0000000..ef4a386
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/benchmarktools/Benchmark.java
@@ -0,0 +1,691 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+package me.lemire.integercompression.benchmarktools;
+
+import com.kamikaze.pfordelta.PForDelta;
+
+import me.lemire.integercompression.BinaryPacking;
+import me.lemire.integercompression.ByteIntegerCODEC;
+import me.lemire.integercompression.Composition;
+import me.lemire.integercompression.DeltaZigzagBinaryPacking;
+import me.lemire.integercompression.DeltaZigzagVariableByte;
+import me.lemire.integercompression.FastPFOR;
+import me.lemire.integercompression.FastPFOR128;
+import me.lemire.integercompression.GroupSimple9;
+import me.lemire.integercompression.IntWrapper;
+import me.lemire.integercompression.IntegerCODEC;
+import me.lemire.integercompression.JustCopy;
+import me.lemire.integercompression.NewPFD;
+import me.lemire.integercompression.NewPFDS16;
+import me.lemire.integercompression.NewPFDS9;
+import me.lemire.integercompression.OptPFD;
+import me.lemire.integercompression.OptPFDS16;
+import me.lemire.integercompression.OptPFDS9;
+import me.lemire.integercompression.Simple16;
+import me.lemire.integercompression.Simple9;
+import me.lemire.integercompression.VariableByte;
+import me.lemire.integercompression.differential.Delta;
+import me.lemire.integercompression.differential.IntegratedBinaryPacking;
+import me.lemire.integercompression.differential.IntegratedByteIntegerCODEC;
+import me.lemire.integercompression.differential.IntegratedComposition;
+import me.lemire.integercompression.differential.IntegratedIntegerCODEC;
+import me.lemire.integercompression.differential.IntegratedVariableByte;
+import me.lemire.integercompression.differential.XorBinaryPacking;
+import me.lemire.integercompression.synth.ClusteredDataGenerator;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ *
+ * Simple class meant to compare the speed of different schemes.
+ *
+ * @author Daniel Lemire
+ *
+ */
+public class Benchmark {
+
+ /**
+ * Standard benchmark
+ *
+ * @param csvLog
+ * Writer for CSV log.
+ * @param c
+ * the codec
+ * @param data
+ * arrays of input data
+ * @param repeat
+ * How many times to repeat the test
+ * @param verbose
+ * whether to output result on screen
+ */
+ private static void testCodec(PrintWriter csvLog, int sparsity,
+ IntegerCODEC c, int[][] data, int repeat, boolean verbose) {
+ if (verbose) {
+ System.out.println("# " + c.toString());
+ System.out
+ .println("# bits per int, compress speed (mis), decompression speed (mis) ");
+ }
+
+ int N = data.length;
+
+ int totalSize = 0;
+ int maxLength = 0;
+ for (int k = 0; k < N; ++k) {
+ totalSize += data[k].length;
+ if (data[k].length > maxLength) {
+ maxLength = data[k].length;
+ }
+ }
+
+ // 4x + 1024 to account for the possibility of some negative
+ // compression.
+ int[] compressBuffer = new int[4 * maxLength + 1024];
+ int[] decompressBuffer = new int[maxLength + 1024];
+
+ // These variables hold time in microseconds (10^-6).
+ long compressTime = 0;
+ long decompressTime = 0;
+
+ int size = 0;
+ IntWrapper inpos = new IntWrapper();
+ IntWrapper outpos = new IntWrapper();
+
+ for (int r = 0; r < repeat; ++r) {
+ size = 0;
+ for (int k = 0; k < N; ++k) {
+ int[] backupdata = Arrays.copyOf(data[k],
+ data[k].length);
+
+ // compress data.
+ long beforeCompress = System.nanoTime() / 1000;
+ inpos.set(1);
+ outpos.set(0);
+ if (!(c instanceof IntegratedIntegerCODEC)) {
+ Delta.delta(backupdata);
+ }
+ c.compress(backupdata, inpos, backupdata.length
+ - inpos.get(), compressBuffer, outpos);
+ long afterCompress = System.nanoTime() / 1000;
+
+ // measure time of compression.
+ compressTime += afterCompress - beforeCompress;
+ final int thiscompsize = outpos.get() + 1;
+ size += thiscompsize;
+
+ // extract (uncompress) data
+ long beforeDecompress = System.nanoTime() / 1000;
+ inpos.set(0);
+ outpos.set(1);
+ decompressBuffer[0] = backupdata[0];
+ c.uncompress(compressBuffer, inpos,
+ thiscompsize - 1, decompressBuffer,
+ outpos);
+ if (!(c instanceof IntegratedIntegerCODEC))
+ Delta.fastinverseDelta(decompressBuffer);
+ long afterDecompress = System.nanoTime() / 1000;
+
+ // measure time of extraction (uncompression).
+ decompressTime += afterDecompress
+ - beforeDecompress;
+ if (outpos.get() != data[k].length)
+ throw new RuntimeException(
+ "we have a bug (diff length) "
+ + c + " expected "
+ + data[k].length
+ + " got "
+ + outpos.get());
+
+ // verify: compare original array with
+ // compressed and
+ // uncompressed.
+
+ for (int m = 0; m < outpos.get(); ++m) {
+ if (decompressBuffer[m] != data[k][m]) {
+ throw new RuntimeException(
+ "we have a bug (actual difference), expected "
+ + data[k][m]
+ + " found "
+ + decompressBuffer[m]
+ + " at " + m + " out of " + outpos.get());
+ }
+ }
+ }
+ }
+
+ if (verbose) {
+ double bitsPerInt = size * 32.0 / totalSize;
+ long compressSpeed = totalSize * repeat
+ / (compressTime);
+ long decompressSpeed = totalSize * repeat
+ / (decompressTime);
+ System.out.println(String.format(
+ "\t%1$.2f\t%2$d\t%3$d", bitsPerInt,
+ compressSpeed, decompressSpeed));
+ csvLog.format("\"%1$s\",%2$d,%3$.2f,%4$d,%5$d\n",
+ c.toString(), sparsity, bitsPerInt,
+ compressSpeed, decompressSpeed);
+ csvLog.flush();
+ }
+ }
+
+ /**
+ * Standard benchmark byte byte-aligned schemes
+ *
+ * @param csvLog
+ * Writer for CSV log.
+ * @param c
+ * the codec
+ * @param data
+ * arrays of input data
+ * @param repeat
+ * How many times to repeat the test
+ * @param verbose
+ * whether to output result on screen
+ */
+ private static void testByteCodec(PrintWriter csvLog, int sparsity,
+ ByteIntegerCODEC c, int[][] data, int repeat, boolean verbose) {
+ if (verbose) {
+ System.out.println("# " + c.toString());
+ System.out
+ .println("# bits per int, compress speed (mis), decompression speed (mis) ");
+ }
+
+ int N = data.length;
+
+ int totalSize = 0;
+ int maxLength = 0;
+ for (int k = 0; k < N; ++k) {
+ totalSize += data[k].length;
+ if (data[k].length > maxLength) {
+ maxLength = data[k].length;
+ }
+ }
+
+ byte[] compressBuffer = new byte[8 * maxLength + 1024];
+ int[] decompressBuffer = new int[maxLength + 1024];
+
+ // These variables hold time in microseconds (10^-6).
+ long compressTime = 0;
+ long decompressTime = 0;
+
+ int size = 0;
+ IntWrapper inpos = new IntWrapper();
+ IntWrapper outpos = new IntWrapper();
+
+ for (int r = 0; r < repeat; ++r) {
+ size = 0;
+ for (int k = 0; k < N; ++k) {
+ int[] backupdata = Arrays.copyOf(data[k],
+ data[k].length);
+
+ // compress data.
+ long beforeCompress = System.nanoTime() / 1000;
+ inpos.set(1);
+ outpos.set(0);
+ if (!(c instanceof IntegratedByteIntegerCODEC)) {
+ Delta.delta(backupdata);
+ }
+ c.compress(backupdata, inpos, backupdata.length
+ - inpos.get(), compressBuffer, outpos);
+ long afterCompress = System.nanoTime() / 1000;
+
+ // measure time of compression.
+ compressTime += afterCompress - beforeCompress;
+ final int thiscompsize = outpos.get() + 1;
+ size += thiscompsize;
+
+ // extract (uncompress) data
+ long beforeDecompress = System.nanoTime() / 1000;
+ inpos.set(0);
+ outpos.set(1);
+ decompressBuffer[0] = backupdata[0];
+ c.uncompress(compressBuffer, inpos,
+ thiscompsize - 1, decompressBuffer,
+ outpos);
+ if (!(c instanceof IntegratedByteIntegerCODEC))
+ Delta.fastinverseDelta(decompressBuffer);
+ long afterDecompress = System.nanoTime() / 1000;
+
+ // measure time of extraction (uncompression).
+ decompressTime += afterDecompress
+ - beforeDecompress;
+ if (outpos.get() != data[k].length)
+ throw new RuntimeException(
+ "we have a bug (diff length) "
+ + c + " expected "
+ + data[k].length
+ + " got "
+ + outpos.get());
+
+ // verify: compare original array with
+ // compressed and
+ // uncompressed.
+ for (int m = 0; m < outpos.get(); ++m) {
+ if (decompressBuffer[m] != data[k][m]) {
+ throw new RuntimeException(
+ "we have a bug (actual difference), expected "
+ + data[k][m]
+ + " found "
+ + decompressBuffer[m]
+ + " at " + m);
+ }
+ }
+ }
+ }
+
+ if (verbose) {
+ double bitsPerInt = size * 8.0 / totalSize;
+ long compressSpeed = totalSize * repeat
+ / (compressTime);
+ long decompressSpeed = totalSize * repeat
+ / (decompressTime);
+ System.out.println(String.format(
+ "\t%1$.2f\t%2$d\t%3$d", bitsPerInt,
+ compressSpeed, decompressSpeed));
+ csvLog.format("\"%1$s\",%2$d,%3$.2f,%4$d,%5$d\n",
+ c.toString(), sparsity, bitsPerInt,
+ compressSpeed, decompressSpeed);
+ csvLog.flush();
+ }
+ }
+
+ /**
+ * Main method.
+ *
+ * @param args
+ * command-line arguments
+ * @throws FileNotFoundException when we fail to create a new file
+ */
+ public static void main(String args[]) throws FileNotFoundException {
+ System.out
+ .println("# benchmark based on the ClusterData model from:");
+ System.out.println("# Vo Ngoc Anh and Alistair Moffat. ");
+ System.out.println("# Index compression using 64-bit words.");
+ System.out
+ .println("# Softw. Pract. Exper.40, 2 (February 2010), 131-147. ");
+ System.out.println();
+
+ PrintWriter writer = null;
+ try {
+ File csvFile = new File(
+ String.format(
+ "benchmark-%1$tY%1$tm%1$tdT%1$tH%1$tM%1$tS.csv",
+ System.currentTimeMillis()));
+ writer = new PrintWriter(csvFile);
+ System.out
+ .println("# Results will be written into a CSV file: "
+ + csvFile.getName());
+ System.out.println();
+ test(writer, 20, 18, 10);
+ System.out.println();
+ System.out
+ .println("Results were written into a CSV file: "
+ + csvFile.getName());
+ } finally {
+ if (writer != null) {
+ writer.close();
+ }
+ }
+ }
+
+ /**
+ * Standard test for the Kamikaze library
+ *
+ * @param data
+ * input data
+ * @param repeat
+ * how many times to repeat
+ * @param verbose
+ * whether to output data on screen
+ */
+ public static void testKamikaze(int[][] data, int repeat,
+ boolean verbose) {
+ DecimalFormat df = new DecimalFormat("0.00");
+ DecimalFormat dfspeed = new DecimalFormat("0");
+ if (verbose)
+ System.out.println("# kamikaze PForDelta");
+ if (verbose)
+ System.out
+ .println("# bits per int, compress speed (mis), decompression speed (mis) ");
+ long bef, aft;
+ String line = "";
+ int N = data.length;
+ int totalsize = 0;
+ int maxlength = 0;
+ for (int k = 0; k < N; ++k) {
+ totalsize += data[k].length;
+ if (data[k].length > maxlength)
+ maxlength = data[k].length;
+ }
+ int[] buffer = new int[maxlength + 1024];
+ /*
+ * 4x + 1024 to account for the possibility of some negative
+ * compression
+ */
+ int size = 0;
+ int comptime = 0;
+ long decomptime = 0;
+ for (int r = 0; r < repeat; ++r) {
+ size = 0;
+ for (int k = 0; k < N; ++k) {
+ int outpos = 0;
+ int[] backupdata = Arrays.copyOf(data[k],
+ data[k].length);
+ //
+ bef = System.nanoTime() / 1000;
+ Delta.delta(backupdata);
+ ArrayList dataout = new ArrayList(
+ data[k].length / 128);
+ for (int K = 0; K < data[k].length; K += 128) {
+ final int[] compressedbuf = PForDelta
+ .compressOneBlockOpt(Arrays
+ .copyOfRange(
+ backupdata, K,
+ K + 128), 128);
+ dataout.add(compressedbuf);
+ outpos += compressedbuf.length;
+ }
+ aft = System.nanoTime() / 1000;
+ //
+ comptime += aft - bef;
+ final int thiscompsize = outpos;
+ size += thiscompsize;
+ //
+ bef = System.nanoTime() / 1000;
+ ArrayList datauncomp = new ArrayList(
+ dataout.size());
+ int deltaoffset = 0;
+
+ for (int[] compbuf : dataout) {
+ int[] tmpbuf = new int[128];
+ PForDelta.decompressOneBlock(tmpbuf,
+ compbuf, 128);
+ tmpbuf[0] += deltaoffset;
+ Delta.fastinverseDelta(tmpbuf);
+ deltaoffset = tmpbuf[127];
+ datauncomp.add(tmpbuf);
+ }
+ aft = System.nanoTime() / 1000;
+ //
+ decomptime += aft - bef;
+ if (datauncomp.size() * 128 != data[k].length)
+ throw new RuntimeException(
+ "we have a bug (diff length) "
+ + " expected "
+ + data[k].length
+ + " got "
+ + datauncomp.size()
+ * 128);
+ for (int m = 0; m < data[k].length; ++m)
+ if (datauncomp.get(m / 128)[m % 128] != data[k][m]) {
+ throw new RuntimeException(
+ "we have a bug (actual difference), expected "
+ + data[k][m]
+ + " found "
+ + buffer[m]
+ + " at " + m);
+ }
+
+ }
+ }
+
+ line += "\t" + df.format(size * 32.0 / totalsize);
+ line += "\t" + dfspeed.format(totalsize * repeat / (comptime));
+ line += "\t"
+ + dfspeed.format(totalsize * repeat / (decomptime));
+ if (verbose)
+ System.out.println(line);
+ }
+
+ /**
+ * Generate test data.
+ *
+ * @param N
+ * How many input arrays to generate
+ * @param nbr
+ * How big (in log2) should the arrays be
+ * @param sparsity
+ * How sparse test data generated
+ */
+ private static int[][] generateTestData(ClusteredDataGenerator dataGen,
+ int N, int nbr, int sparsity) {
+ final int[][] data = new int[N][];
+ final int dataSize = (1 << (nbr + sparsity));
+ for (int i = 0; i < N; ++i) {
+ data[i] = dataGen.generateClustered((1 << nbr),
+ dataSize);
+ }
+ return data;
+ }
+
+ /**
+ * Generates data and calls other tests.
+ *
+ * @param csvLog
+ * Writer for CSV log.
+ * @param N
+ * How many input arrays to generate
+ * @param nbr
+ * how big (in log2) should the arrays be
+ * @param repeat
+ * How many times should we repeat tests.
+ */
+ private static void test(PrintWriter csvLog, int N, int nbr, int repeat) {
+ csvLog.format("\"Algorithm\",\"Sparsity\",\"Bits per int\",\"Compress speed (MiS)\",\"Decompress speed (MiS)\"\n");
+ ClusteredDataGenerator cdg = new ClusteredDataGenerator();
+ final int max_sparsity = 31 - nbr;
+ for (int sparsity = 1; sparsity < max_sparsity; ++sparsity) {
+ System.out.println("# sparsity " + sparsity);
+ System.out.println("# generating random data...");
+ int[][] data = generateTestData(cdg, N, nbr, sparsity);
+ System.out.println("# generating random data... ok.");
+
+ testCodec(csvLog, sparsity, new Composition(
+ new FastPFOR128(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new FastPFOR128(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new FastPFOR128(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+ testCodec(csvLog, sparsity, new Composition(
+ new FastPFOR(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new FastPFOR(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new FastPFOR(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+
+
+ // TODO: support CSV log output.
+ testKamikaze(data, repeat, false);
+ testKamikaze(data, repeat, false);
+ testKamikaze(data, repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new IntegratedComposition(
+ new IntegratedBinaryPacking(),
+ new IntegratedVariableByte()), data, repeat,
+ false);
+ testCodec(csvLog, sparsity, new IntegratedComposition(
+ new IntegratedBinaryPacking(),
+ new IntegratedVariableByte()), data, repeat,
+ false);
+ testCodec(csvLog, sparsity, new IntegratedComposition(
+ new IntegratedBinaryPacking(),
+ new IntegratedVariableByte()), data, repeat,
+ true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new JustCopy(), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new JustCopy(), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new JustCopy(), data,
+ repeat, true);
+ System.out.println();
+
+ testByteCodec(csvLog, sparsity, new VariableByte(),
+ data, repeat, false);
+ testByteCodec(csvLog, sparsity, new VariableByte(),
+ data, repeat, false);
+ testByteCodec(csvLog, sparsity, new VariableByte(),
+ data, repeat, true);
+ System.out.println();
+
+ testByteCodec(csvLog, sparsity,
+ new IntegratedVariableByte(), data, repeat,
+ false);
+ testByteCodec(csvLog, sparsity,
+ new IntegratedVariableByte(), data, repeat,
+ false);
+ testByteCodec(csvLog, sparsity,
+ new IntegratedVariableByte(), data, repeat,
+ true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new Composition(
+ new BinaryPacking(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new BinaryPacking(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new BinaryPacking(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFD(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFD(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFD(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFDS9(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFDS9(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFDS9(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFDS16(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFDS16(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new NewPFDS16(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFD(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFD(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFD(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFDS9(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFDS9(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFDS9(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFDS16(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFDS16(), new VariableByte()), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Composition(
+ new OptPFDS16(), new VariableByte()), data,
+ repeat, true);
+ System.out.println();
+
+
+ testCodec(csvLog, sparsity, new Simple16(), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Simple16(), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Simple16(), data,
+ repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new Simple9(), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Simple9(), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new Simple9(), data,
+ repeat, true);
+ System.out.println();
+
+ testCodec(csvLog, sparsity, new GroupSimple9(), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new GroupSimple9(), data,
+ repeat, false);
+ testCodec(csvLog, sparsity, new GroupSimple9(), data,
+ repeat, true);
+ System.out.println();
+
+ {
+ IntegerCODEC c = new Composition(
+ new XorBinaryPacking(),
+ new VariableByte());
+ testCodec(csvLog, sparsity, c, data, repeat,
+ false);
+ testCodec(csvLog, sparsity, c, data, repeat,
+ false);
+ testCodec(csvLog, sparsity, c, data, repeat,
+ true);
+ System.out.println();
+ }
+
+ {
+ IntegerCODEC c = new Composition(
+ new DeltaZigzagBinaryPacking(),
+ new DeltaZigzagVariableByte());
+ testCodec(csvLog, sparsity, c, data, repeat,
+ false);
+ testCodec(csvLog, sparsity, c, data, repeat,
+ false);
+ testCodec(csvLog, sparsity, c, data, repeat,
+ true);
+ System.out.println();
+ }
+
+ }
+ }
+}
diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkBitPacking.java b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkBitPacking.java
new file mode 100644
index 0000000..3380d36
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkBitPacking.java
@@ -0,0 +1,154 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+package me.lemire.integercompression.benchmarktools;
+
+import java.text.DecimalFormat;
+import java.util.Arrays;
+import java.util.Random;
+
+import me.lemire.integercompression.BitPacking;
+import me.lemire.integercompression.differential.Delta;
+import me.lemire.integercompression.differential.IntegratedBitPacking;
+
+/**
+ * Class used to benchmark the speed of bit packing. (For expert use.)
+ *
+ * @author Daniel Lemire
+ *
+ */
+public class BenchmarkBitPacking {
+
+ private static void test(boolean verbose) {
+ DecimalFormat dfspeed = new DecimalFormat("0");
+ final int N = 32;
+ final int times = 100000;
+ Random r = new Random(0);
+ int[] data = new int[N];
+ int[] compressed = new int[N];
+ int[] uncompressed = new int[N];
+ for (int bit = 0; bit < 31; ++bit) {
+ long comp = 0;
+ long compwm = 0;
+ long decomp = 0;
+ for (int t = 0; t < times; ++t) {
+ for (int k = 0; k < N; ++k) {
+ data[k] = r.nextInt(1 << bit);
+ }
+ long time1 = System.nanoTime();
+ BitPacking
+ .fastpack(data, 0, compressed, 0, bit);
+ long time2 = System.nanoTime();
+ BitPacking.fastpackwithoutmask(data, 0,
+ compressed, 0, bit);
+ long time3 = System.nanoTime();
+ BitPacking.fastunpack(compressed, 0,
+ uncompressed, 0, bit);
+ long time4 = System.nanoTime();
+ comp += time2 - time1;
+ compwm += time3 - time2;
+ decomp += time4 - time3;
+ }
+ if (verbose)
+ System.out.println("bit = "
+ + bit
+ + " comp. speed = "
+ + dfspeed.format(N * times * 1000.0
+ / (comp))
+ + " comp. speed wm = "
+ + dfspeed.format(N * times * 1000.0
+ / (compwm))
+ + " decomp. speed = "
+ + dfspeed.format(N * times * 1000.0
+ / (decomp)));
+ }
+ }
+
+ private static void testWithDeltas(boolean verbose) {
+ DecimalFormat dfspeed = new DecimalFormat("0");
+ final int N = 32;
+ final int times = 100000;
+ Random r = new Random(0);
+ int[] data = new int[N];
+ int[] compressed = new int[N];
+ int[] icompressed = new int[N];
+ int[] uncompressed = new int[N];
+ for (int bit = 1; bit < 31; ++bit) {
+ long comp = 0;
+ long decomp = 0;
+ long icomp = 0;
+ long idecomp = 0;
+ for (int t = 0; t < times; ++t) {
+ data[0] = r.nextInt(1 << bit);
+ for (int k = 1; k < N; ++k) {
+ data[k] = r.nextInt(1 << bit)
+ + data[k - 1];
+ }
+ int[] tmpdata = Arrays
+ .copyOf(data, data.length);
+ long time1 = System.nanoTime();
+ Delta.delta(tmpdata);
+ BitPacking.fastpackwithoutmask(tmpdata, 0,
+ compressed, 0, bit);
+ long time2 = System.nanoTime();
+ BitPacking.fastunpack(compressed, 0,
+ uncompressed, 0, bit);
+ Delta.fastinverseDelta(uncompressed);
+ long time3 = System.nanoTime();
+ if (!Arrays.equals(data, uncompressed))
+ throw new RuntimeException("bug");
+ comp += time2 - time1;
+ decomp += time3 - time2;
+ tmpdata = Arrays.copyOf(data, data.length);
+ time1 = System.nanoTime();
+ IntegratedBitPacking.integratedpack(0, tmpdata,
+ 0, icompressed, 0, bit);
+ time2 = System.nanoTime();
+ IntegratedBitPacking.integratedunpack(0,
+ icompressed, 0, uncompressed, 0, bit);
+ time3 = System.nanoTime();
+ if (!Arrays.equals(icompressed, compressed))
+ throw new RuntimeException("ibug "
+ + bit);
+ if (!Arrays.equals(data, uncompressed))
+ throw new RuntimeException("bug " + bit);
+ icomp += time2 - time1;
+ idecomp += time3 - time2;
+ }
+ if (verbose)
+ System.out.println("bit = "
+ + bit
+ + " comp. speed = "
+ + dfspeed.format(N * times * 1000.0
+ / (comp))
+ + " decomp. speed = "
+ + dfspeed.format(N * times * 1000.0
+ / (decomp))
+ + " icomp. speed = "
+ + dfspeed.format(N * times * 1000.0
+ / (icomp))
+ + " idecomp. speed = "
+ + dfspeed.format(N * times * 1000.0
+ / (idecomp)));
+ }
+ }
+
+ /**
+ * Main method
+ *
+ * @param args
+ * command-line arguments
+ */
+ public static void main(String[] args) {
+ System.out.println("Testing packing and delta ");
+ testWithDeltas(false);
+ testWithDeltas(true);
+ System.out.println("Testing packing alone ");
+ test(false);
+ test(true);
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkCSV.java b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkCSV.java
new file mode 100644
index 0000000..3115f0a
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkCSV.java
@@ -0,0 +1,314 @@
+package me.lemire.integercompression.benchmarktools;
+
+import me.lemire.integercompression.*;
+import me.lemire.integercompression.differential.IntegratedBinaryPacking;
+import me.lemire.integercompression.differential.IntegratedByteIntegerCODEC;
+import me.lemire.integercompression.differential.IntegratedComposition;
+import me.lemire.integercompression.differential.IntegratedIntegerCODEC;
+import me.lemire.integercompression.differential.IntegratedVariableByte;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * This will run benchmarks using a set of posting lists stored as CSV files.
+ *
+ * @author lemire
+ *
+ */
+public class BenchmarkCSV {
+ static IntegratedIntegerCODEC codecs[] = {
+ new IntegratedComposition(new IntegratedBinaryPacking(),
+ new IntegratedVariableByte()) };
+ static IntegratedByteIntegerCODEC bcodecs[] = { new IntegratedVariableByte() };
+ static IntegerCODEC regcodecs[] = {
+ new Composition(new FastPFOR128(), new VariableByte()),
+ new Composition(new FastPFOR(), new VariableByte()),
+ new Composition(new BinaryPacking(), new VariableByte()) };
+ static ByteIntegerCODEC regbcodecs[] = { new VariableByte() };
+
+ private static ArrayList loadIntegers(final String filename, final Format f)
+ throws IOException {
+ int misparsed = 0;
+ if (f == Format.ONEARRAYPERLINE) {
+ ArrayList answer = new ArrayList();
+ BufferedReader br = new BufferedReader(new FileReader(
+ filename));
+ String s;
+ while ((s = br.readLine()) != null) {
+ String[] numbers = s.split("[,;;]"); // that's
+ // slow
+ int[] a = new int[numbers.length];
+ for (int k = 0; k < numbers.length; ++k) {
+ try {
+ a[k] = Integer
+ .parseInt(numbers[k]
+ .trim());
+ } catch (java.lang.NumberFormatException nfe) {
+ if (misparsed == 0)
+ System.err.println(nfe);
+ ++misparsed;
+ }
+ }
+ answer.add(a);
+ }
+ if (misparsed > 0)
+ System.out.println("Failed to parse "
+ + misparsed + " entries");
+ br.close();
+ return answer;
+ } else if (f == Format.ONEARRAYPERFILE) {
+ ArrayList answer = new ArrayList();
+ BufferedReader br = new BufferedReader(new FileReader(
+ filename));
+ String s;
+ while ((s = br.readLine()) != null) {
+ String[] numbers = s.split("[,;;]");// that's
+ // slow
+ for (int k = 0; k < numbers.length; ++k) {
+ try {
+ answer.add(Integer
+ .parseInt(numbers[k]
+ .trim()));
+ } catch (java.lang.NumberFormatException nfe) {
+ if (misparsed == 0)
+ System.err.println(nfe);
+ ++misparsed;
+ }
+ }
+ }
+ int[] actualanswer = new int[answer.size()];
+ for (int i = 0; i < answer.size(); ++i)
+ actualanswer[i] = answer.get(i);
+ ArrayList wrap = new ArrayList();
+ wrap.add(actualanswer);
+ if (misparsed > 0)
+ System.out.println("Failed to parse "
+ + misparsed + " entries");
+ br.close();
+ return wrap;
+ } else {
+ ArrayList answer = new ArrayList();
+ BufferedReader br = new BufferedReader(new FileReader(
+ filename));
+ String s;
+ while ((s = br.readLine()) != null) {
+ try {
+ answer.add(Integer.parseInt(s.trim()));
+ } catch (java.lang.NumberFormatException nfe) {
+ if (misparsed == 0)
+ System.err.println(nfe);
+ ++misparsed;
+ }
+ }
+ int[] actualanswer = new int[answer.size()];
+ for (int i = 0; i < answer.size(); ++i)
+ actualanswer[i] = answer.get(i);
+ ArrayList wrap = new ArrayList();
+ wrap.add(actualanswer);
+ if (misparsed > 0)
+ System.out.println("Failed to parse "
+ + misparsed + " entries");
+ br.close();
+ return wrap;
+ }
+ }
+
+ private enum Format {
+ ONEARRAYPERLINE, ONEARRAYPERFILE, ONEINTPERLINE
+ }
+
+ private enum CompressionMode {
+ AS_IS, DELTA
+ }
+
+ /**
+ * @param args command-line arguments
+ * @throws IOException when some IO error occurs
+ */
+ public static void main(final String[] args) throws IOException {
+ Format myformat = Format.ONEARRAYPERLINE;
+ CompressionMode cm = CompressionMode.DELTA;
+ ArrayList files = new ArrayList();
+ for (String s : args) {
+ if (s.startsWith("-")) {// it is a flag
+ if (s.equals("--onearrayperfile"))
+ myformat = Format.ONEARRAYPERFILE;
+ else if (s.equals("--nodelta"))
+ cm = CompressionMode.AS_IS;
+ else if (s.equals("--oneintperline"))
+ myformat = Format.ONEINTPERLINE;
+ else
+ throw new RuntimeException(
+ "I don't understand: " + s);
+ } else {// it is a filename
+ files.add(s);
+ }
+ }
+ if (myformat == Format.ONEARRAYPERFILE)
+ System.out.println("Treating each file as one array.");
+ else if (myformat == Format.ONEARRAYPERLINE)
+ System.out
+ .println("Each line of each file is an array: use --onearrayperfile or --oneintperline to change.");
+ else if (myformat == Format.ONEINTPERLINE)
+ System.out
+ .println("Treating each file as one array, with one integer per line.");
+ if (cm == CompressionMode.AS_IS)
+ System.out
+ .println("Compressing the integers 'as is' (no differential coding)");
+ else
+ System.out
+ .println("Using differential coding (arrays will be sorted): use --nodelta to prevent sorting");
+ ArrayList data = new ArrayList();
+ for (String fn : files)
+ for (int[] x : loadIntegers(fn, myformat))
+ data.add(x);
+ System.out.println("Loaded " + data.size() + " array(s)");
+ if (cm == CompressionMode.DELTA) {
+ System.out
+ .println("Sorting the arrray(s) because you are using differential coding");
+ for (int[] x : data)
+ Arrays.sort(x);
+ }
+ bench(data, cm, false);
+ bench(data, cm, false);
+ bench(data, cm, true);
+ bytebench(data, cm, false);
+ bytebench(data, cm, false);
+ bytebench(data, cm, true);
+ }
+
+ private static void bench(ArrayList postings, CompressionMode cm,
+ boolean verbose) {
+ int maxlength = 0;
+ for (int[] x : postings)
+ if (maxlength < x.length)
+ maxlength = x.length;
+ if (verbose)
+ System.out.println("Max array length: " + maxlength);
+ int[] compbuffer = new int[2 * maxlength + 1024];
+ int[] decompbuffer = new int[maxlength];
+ if (verbose)
+ System.out.println("Scheme -- bits/int -- speed (mis)");
+ for (IntegerCODEC c : (cm == CompressionMode.DELTA ? codecs
+ : regcodecs)) {
+ long bef = 0;
+ long aft = 0;
+ long decomptime = 0;
+ long volumein = 0;
+ long volumeout = 0;
+ int[][] compdata = new int[postings.size()][];
+ for (int k = 0; k < postings.size(); ++k) {
+ int[] in = postings.get(k);
+ IntWrapper inpos = new IntWrapper(0);
+ IntWrapper outpos = new IntWrapper(0);
+ c.compress(in, inpos, in.length, compbuffer,
+ outpos);
+ int clength = outpos.get();
+ inpos = new IntWrapper(0);
+ outpos = new IntWrapper(0);
+ c.uncompress(compbuffer, inpos, clength,
+ decompbuffer, outpos);
+ volumein += in.length;
+ volumeout += clength;
+
+ if (outpos.get() != in.length)
+ throw new RuntimeException("bug");
+ for (int z = 0; z < in.length; ++z)
+ if (in[z] != decompbuffer[z])
+ throw new RuntimeException(
+ "bug");
+ compdata[k] = Arrays
+ .copyOf(compbuffer, clength);
+ }
+ bef = System.nanoTime();
+ for (int[] cin : compdata) {
+ IntWrapper inpos = new IntWrapper(0);
+ IntWrapper outpos = new IntWrapper(0);
+ c.uncompress(cin, inpos, cin.length,
+ decompbuffer, outpos);
+ if (inpos.get() != cin.length)
+ throw new RuntimeException("bug");
+ }
+ aft = System.nanoTime();
+ decomptime += (aft - bef);
+ double bitsPerInt = volumeout * 32.0 / volumein;
+ double decompressSpeed = volumein * 1000.0
+ / (decomptime);
+ if (verbose)
+ System.out.println(c.toString()
+ + "\t"
+ + String.format("\t%1$.2f\t%2$.2f",
+ bitsPerInt, decompressSpeed));
+
+ }
+ }
+
+ private static void bytebench(ArrayList postings,
+ CompressionMode cm, boolean verbose) {
+ int maxlength = 0;
+ for (int[] x : postings)
+ if (maxlength < x.length)
+ maxlength = x.length;
+ if (verbose)
+ System.out.println("Max array length: " + maxlength);
+ byte[] compbuffer = new byte[6 * (maxlength + 1024)];
+ int[] decompbuffer = new int[maxlength];
+ if (verbose)
+ System.out.println("Scheme -- bits/int -- speed (mis)");
+ for (ByteIntegerCODEC c : (cm == CompressionMode.DELTA ? bcodecs
+ : regbcodecs)) {
+ long bef = 0;
+ long aft = 0;
+ long decomptime = 0;
+ long volumein = 0;
+ long volumeout = 0;
+ byte[][] compdata = new byte[postings.size()][];
+ for (int k = 0; k < postings.size(); ++k) {
+ int[] in = postings.get(k);
+ IntWrapper inpos = new IntWrapper(0);
+ IntWrapper outpos = new IntWrapper(0);
+ c.compress(in, inpos, in.length, compbuffer,
+ outpos);
+ int clength = outpos.get();
+ inpos = new IntWrapper(0);
+ outpos = new IntWrapper(0);
+ c.uncompress(compbuffer, inpos, clength,
+ decompbuffer, outpos);
+ volumein += in.length;
+ volumeout += clength;
+
+ if (outpos.get() != in.length)
+ throw new RuntimeException("bug");
+ for (int z = 0; z < in.length; ++z)
+ if (in[z] != decompbuffer[z])
+ throw new RuntimeException(
+ "bug");
+ compdata[k] = Arrays
+ .copyOf(compbuffer, clength);
+ }
+ bef = System.nanoTime();
+ for (byte[] cin : compdata) {
+ IntWrapper inpos = new IntWrapper(0);
+ IntWrapper outpos = new IntWrapper(0);
+ c.uncompress(cin, inpos, cin.length,
+ decompbuffer, outpos);
+ if (inpos.get() != cin.length)
+ throw new RuntimeException("bug");
+ }
+ aft = System.nanoTime();
+ decomptime += (aft - bef);
+ double bitsPerInt = volumeout * 8.0 / volumein;
+ double decompressSpeed = volumein * 1000.0
+ / (decomptime);
+ if (verbose)
+ System.out.println(c.toString()
+ + "\t"
+ + String.format("\t%1$.2f\t%2$.2f",
+ bitsPerInt, decompressSpeed));
+
+ }
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkOffsettedSeries.java b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkOffsettedSeries.java
new file mode 100644
index 0000000..c31411d
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkOffsettedSeries.java
@@ -0,0 +1,295 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ */
+package me.lemire.integercompression.benchmarktools;
+
+import java.io.File;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Random;
+
+import me.lemire.integercompression.BinaryPacking;
+import me.lemire.integercompression.DeltaZigzagBinaryPacking;
+import me.lemire.integercompression.DeltaZigzagVariableByte;
+import me.lemire.integercompression.FastPFOR;
+import me.lemire.integercompression.FastPFOR128;
+import me.lemire.integercompression.IntWrapper;
+import me.lemire.integercompression.IntegerCODEC;
+import me.lemire.integercompression.JustCopy;
+import me.lemire.integercompression.differential.IntegratedBinaryPacking;
+import me.lemire.integercompression.differential.XorBinaryPacking;
+
+/**
+ * Simple synthetic benchmark
+ *
+ */
+public class BenchmarkOffsettedSeries {
+ private static final int DEFAULT_MEAN = 1 << 20;
+ private static final int DEFAULT_RANGE = 1 << 10;
+ private static final int DEFAULT_REPEAT = 5;
+ private static final int DEFAULT_WARMUP = 2;
+
+
+ /**
+ * Run benchmark.
+ *
+ * @param csvWriter
+ * Write for results in CSV.
+ * @param count
+ * Count of data chunks.
+ * @param length
+ * Length of a data chunk.
+ */
+ public static void run(final PrintWriter csvWriter, final int count, final int length) {
+ IntegerCODEC[] codecs = { new JustCopy(), new BinaryPacking(),
+ new DeltaZigzagBinaryPacking(),
+ new DeltaZigzagVariableByte(),
+ new IntegratedBinaryPacking(), new XorBinaryPacking(),
+ new FastPFOR128(), new FastPFOR()};
+
+ csvWriter
+ .format("\"Dataset\",\"CODEC\",\"Bits per int\","
+ + "\"Compress speed (MiS)\",\"Decompress speed (MiS)\"\n");
+
+ benchmark(csvWriter, codecs, count, length, DEFAULT_MEAN,
+ DEFAULT_RANGE);
+ benchmark(csvWriter, codecs, count, length, DEFAULT_MEAN >> 5,
+ DEFAULT_RANGE);
+
+ IntegerCODEC[] codecs2 = { new JustCopy(), new BinaryPacking(),
+ new DeltaZigzagBinaryPacking(),
+ new DeltaZigzagVariableByte(),
+ new IntegratedBinaryPacking(), new XorBinaryPacking(),
+ new FastPFOR128(),new FastPFOR(), };
+
+ int freq = length / 4;
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 0, freq);
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 0, freq);
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 0, freq);
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 2, freq);
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 2, freq);
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 2, freq);
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 4, freq);
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 4, freq);
+ benchmarkSine(csvWriter, codecs2, count, length,
+ DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 4, freq);
+ }
+
+ private static void benchmarkSine(final PrintWriter csvWriter,
+ final IntegerCODEC[] codecs, final int count, final int length, final int mean,
+ final int range, final int freq) {
+ String dataProp = String.format(
+ "(mean=%1$d range=%2$d freq=%3$d)", mean, range, freq);
+ int[][] data = generateSineDataChunks(0, count, length, mean,
+ range, freq);
+ benchmark(csvWriter, "Sine " + dataProp, codecs, data,
+ DEFAULT_REPEAT, DEFAULT_WARMUP);
+ benchmark(csvWriter, "Sine+delta " + dataProp, codecs, data,
+ DEFAULT_REPEAT, DEFAULT_WARMUP);
+ }
+
+ private static void benchmark(final PrintWriter csvWriter, final IntegerCODEC[] codecs,
+ final int count, final int length, final int mean, final int range) {
+ String dataProp = String.format("(mean=%1$d range=%2$d)", mean,
+ range);
+
+ int[][] randData = generateDataChunks(0, count, length, mean,
+ range);
+ int[][] deltaData = deltaDataChunks(randData);
+ int[][] sortedData = sortDataChunks(randData);
+ int[][] sortedDeltaData = deltaDataChunks(sortedData);
+
+ benchmark(csvWriter, "Random " + dataProp, codecs, randData,
+ DEFAULT_REPEAT, DEFAULT_WARMUP);
+ benchmark(csvWriter, "Random+delta " + dataProp, codecs,
+ deltaData, DEFAULT_REPEAT, DEFAULT_WARMUP);
+ benchmark(csvWriter, "Sorted " + dataProp, codecs, sortedData,
+ DEFAULT_REPEAT, DEFAULT_WARMUP);
+ benchmark(csvWriter, "Sorted+delta " + dataProp, codecs,
+ sortedDeltaData, DEFAULT_REPEAT, DEFAULT_WARMUP);
+ }
+
+ private static void benchmark(final PrintWriter csvWriter, final String dataName,
+ final IntegerCODEC[] codecs, final int[][] data, final int repeat, final int warmup) {
+ System.out.println("Processing: " + dataName);
+ for (IntegerCODEC codec : codecs) {
+ String codecName = codec.toString();
+ for (int i = 0; i < warmup; ++i) {
+ benchmark(null, null, null, codec, data, repeat);
+ }
+ benchmark(csvWriter, dataName, codecName, codec, data,
+ repeat);
+ }
+ }
+
+ private static void benchmark(PrintWriter csvWriter, String dataName,
+ String codecName, IntegerCODEC codec, int[][] data, int repeat) {
+ PerformanceLogger logger = new PerformanceLogger();
+
+ int maxLen = getMaxLen(data);
+ int[] compressBuffer = new int[4 * maxLen + 1024];
+ int[] decompressBuffer = new int[maxLen];
+
+ for (int i = 0; i < repeat; ++i) {
+ for (int[] array : data) {
+ int compSize = compress(logger, codec, array,
+ compressBuffer);
+ int decompSize = decompress(logger, codec,
+ compressBuffer, compSize,
+ decompressBuffer);
+ checkArray(array, decompressBuffer, decompSize,
+ codec);
+ }
+ }
+
+ if (csvWriter != null) {
+ csvWriter.format(
+ "\"%1$s\",\"%2$s\",%3$.2f,%4$.0f,%5$.0f\n",
+ dataName, codecName, logger.getBitPerInt(),
+ logger.getCompressSpeed(),
+ logger.getDecompressSpeed());
+ }
+ }
+
+ private static void checkArray(int[] expected, int[] actualArray,
+ int actualLen, IntegerCODEC codec) {
+ if (actualLen != expected.length) {
+ throw new RuntimeException("Length mismatch:"
+ + " expected=" + expected.length + " actual="
+ + actualLen + " codec=" + codec.toString());
+ }
+ for (int i = 0; i < expected.length; ++i) {
+ if (actualArray[i] != expected[i]) {
+ throw new RuntimeException("Value mismatch: "
+ + " where=" + i + " expected="
+ + expected[i] + " actual="
+ + actualArray[i] + " codec="
+ + codec.toString());
+ }
+ }
+ }
+
+ private static int compress(PerformanceLogger logger, IntegerCODEC codec,
+ int[] src, int[] dst) {
+ IntWrapper inpos = new IntWrapper();
+ IntWrapper outpos = new IntWrapper();
+ logger.compressionTimer.start();
+ codec.compress(src, inpos, src.length, dst, outpos);
+ logger.compressionTimer.end();
+ int outSize = outpos.get();
+ logger.addOriginalSize(src.length);
+ logger.addCompressedSize(outSize);
+ return outSize;
+ }
+
+ private static int decompress(PerformanceLogger logger, IntegerCODEC codec,
+ int[] src, int srcLen, int[] dst) {
+ IntWrapper inpos = new IntWrapper();
+ IntWrapper outpos = new IntWrapper();
+ logger.decompressionTimer.start();
+ codec.uncompress(src, inpos, srcLen, dst, outpos);
+ logger.decompressionTimer.end();
+ return outpos.get();
+ }
+
+ private static int getMaxLen(int[][] data) {
+ int maxLen = 0;
+ for (int[] array : data) {
+ if (array.length > maxLen) {
+ maxLen = array.length;
+ }
+ }
+ return maxLen;
+ }
+
+ private static int[][] generateSineDataChunks(long seed, int count,
+ int length, int mean, int range, int freq) {
+ int[][] chunks = new int[count][];
+ Random r = new Random(seed);
+ for (int i = 0; i < count; ++i) {
+ int[] chunk = chunks[i] = new int[length];
+ int phase = r.nextInt(2 * freq);
+ for (int j = 0; j < length; ++j) {
+ double angle = 2.0 * Math.PI * (j + phase)
+ / freq;
+ chunk[j] = (int) (mean + Math.sin(angle)
+ * range);
+ }
+ }
+ return chunks;
+ }
+
+ private static int[][] generateDataChunks(long seed, int count,
+ int length, int mean, int range) {
+ int offset = mean - range / 2;
+ int[][] chunks = new int[count][];
+ Random r = new Random(seed);
+ for (int i = 0; i < count; ++i) {
+ int[] chunk = chunks[i] = new int[length];
+ for (int j = 0; j < length; ++j) {
+ chunk[j] = r.nextInt(range) + offset;
+ }
+ }
+ return chunks;
+ }
+
+ private static int[][] deltaDataChunks(int[][] src) {
+ int[][] dst = new int[src.length][];
+ for (int i = 0; i < src.length; ++i) {
+ int[] s = src[i];
+ int[] d = dst[i] = new int[s.length];
+ int prev = 0;
+ for (int j = 0; j < s.length; ++j) {
+ d[j] = s[j] - prev;
+ prev = s[j];
+ }
+ }
+ return dst;
+ }
+
+ private static int[][] sortDataChunks(int[][] src) {
+ int[][] dst = new int[src.length][];
+ for (int i = 0; i < src.length; ++i) {
+ dst[i] = Arrays.copyOf(src[i], src[i].length);
+ Arrays.sort(dst[i]);
+ }
+ return dst;
+ }
+
+ /**
+ * @param args command-line arguments
+ * @throws Exception when some problem occurs
+ */
+ public static void main(final String[] args) throws Exception {
+ File csvFile = new File(
+ String.format(
+ "benchmark-offsetted-%1$tY%1$tm%1$tdT%1$tH%1$tM%1$tS.csv",
+ System.currentTimeMillis()));
+ PrintWriter writer = null;
+ try {
+ writer = new PrintWriter(csvFile);
+ System.out
+ .println("# Results will be written into a CSV file: "
+ + csvFile.getName());
+ System.out.println();
+ BenchmarkOffsettedSeries.run(writer, 8 * 1024, 1280);
+ System.out.println();
+ System.out
+ .println("# Results were written into a CSV file: "
+ + csvFile.getName());
+ } finally {
+ if (writer != null) {
+ writer.close();
+ }
+ }
+ }
+}
diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkSkippable.java b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkSkippable.java
new file mode 100644
index 0000000..b930568
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkSkippable.java
@@ -0,0 +1,339 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+package me.lemire.integercompression.benchmarktools;
+
+import me.lemire.integercompression.BinaryPacking;
+import me.lemire.integercompression.FastPFOR;
+import me.lemire.integercompression.FastPFOR128;
+import me.lemire.integercompression.IntWrapper;
+import me.lemire.integercompression.JustCopy;
+import me.lemire.integercompression.NewPFD;
+import me.lemire.integercompression.NewPFDS16;
+import me.lemire.integercompression.NewPFDS9;
+import me.lemire.integercompression.OptPFD;
+import me.lemire.integercompression.OptPFDS16;
+import me.lemire.integercompression.OptPFDS9;
+import me.lemire.integercompression.Simple16;
+import me.lemire.integercompression.Simple9;
+import me.lemire.integercompression.SkippableComposition;
+import me.lemire.integercompression.SkippableIntegerCODEC;
+import me.lemire.integercompression.VariableByte;
+import me.lemire.integercompression.differential.Delta;
+import me.lemire.integercompression.differential.IntegratedBinaryPacking;
+import me.lemire.integercompression.differential.IntegratedVariableByte;
+import me.lemire.integercompression.differential.SkippableIntegratedComposition;
+import me.lemire.integercompression.differential.SkippableIntegratedIntegerCODEC;
+import me.lemire.integercompression.synth.ClusteredDataGenerator;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+/**
+ *
+ * Simple class meant to compare the speed of different schemes.
+ *
+ * @author Daniel Lemire
+ *
+ */
+public class BenchmarkSkippable {
+
+ private static int compressWithSkipTable(Object c, int[] data,
+ int[] output, IntWrapper outpos, int[] metadata, int blocksize) {
+ int metapos = 0;
+ metadata[metapos++] = data.length;
+ IntWrapper inpos = new IntWrapper();
+ int initvalue = 0;
+ IntWrapper ival = new IntWrapper(initvalue);
+ while (inpos.get() < data.length) {
+ metadata[metapos++] = outpos.get();
+ metadata[metapos++] = initvalue;
+ if (c instanceof SkippableIntegerCODEC) {
+ int size = blocksize > data.length - inpos.get() ? data.length
+ - inpos.get() : blocksize;
+ initvalue = Delta.delta(data, inpos.get(), size, initvalue);
+
+ ((SkippableIntegerCODEC) c).headlessCompress(data, inpos,
+ blocksize, output, outpos);
+ } else if (c instanceof SkippableIntegratedIntegerCODEC) {
+ ival.set(initvalue);
+ ((SkippableIntegratedIntegerCODEC) c).headlessCompress(data,
+ inpos, blocksize, output, outpos, ival);
+ initvalue = ival.get();
+ } else {
+ throw new RuntimeException("Unrecognized codec " + c);
+ }
+ }
+ return metapos;
+ }
+
+ private static int decompressFromSkipTable(Object c, int[] compressed,
+ IntWrapper compressedpos, int[] metadata, int blocksize, int[] data) {
+ int metapos = 0;
+ int length = metadata[metapos++];
+ IntWrapper uncomppos = new IntWrapper();
+ IntWrapper ival = new IntWrapper();
+ while (uncomppos.get() < length) {
+ int num = blocksize;
+ if (num > length - uncomppos.get())
+ num = length - uncomppos.get();
+ int location = metadata[metapos++];
+ int initvalue = metadata[metapos++];
+ int outputlocation = uncomppos.get();
+ if (location != compressedpos.get())
+ throw new RuntimeException("Bug " + location + " "
+ + compressedpos.get() + " codec " + c);
+ if (c instanceof SkippableIntegerCODEC) {
+ ((SkippableIntegerCODEC) c).headlessUncompress(compressed,
+ compressedpos, compressed.length - uncomppos.get(),
+ data, uncomppos, num);
+ initvalue = Delta.fastinverseDelta(data, outputlocation, num,
+ initvalue);
+ } else if (c instanceof SkippableIntegratedIntegerCODEC) {
+ ival.set(initvalue);
+ ((SkippableIntegratedIntegerCODEC) c).headlessUncompress(
+ compressed, compressedpos, compressed.length
+ - uncomppos.get(), data, uncomppos, num, ival);
+ } else {
+ throw new RuntimeException("Unrecognized codec " + c);
+ }
+ }
+ return length;
+ }
+
+ /**
+ * Standard benchmark
+ *
+ * @param csvLog
+ * Writer for CSV log.
+ * @param c
+ * the codec
+ * @param data
+ * arrays of input data
+ * @param repeat
+ * How many times to repeat the test
+ * @param verbose
+ * whether to output result on screen
+ */
+ private static void testCodec(PrintWriter csvLog, int sparsity, Object c,
+ int[][] data, int repeat, boolean verbose) {
+ if (verbose) {
+ System.out.println("# " + c.toString());
+ System.out
+ .println("# bits per int, compress speed (mis), decompression speed (mis) ");
+ }
+
+ int N = data.length;
+
+ int totalSize = 0;
+ int maxLength = 0;
+ for (int k = 0; k < N; ++k) {
+ totalSize += data[k].length;
+ if (data[k].length > maxLength) {
+ maxLength = data[k].length;
+ }
+ }
+
+ // 4x + 1024 to account for the possibility of some negative
+ // compression.
+ int[] compressBuffer = new int[4 * maxLength + 1024];
+ int[] decompressBuffer = new int[maxLength + 1024];
+ int[] metadataBuffer = new int[maxLength];
+ final int blocksize = 1024;
+
+ // These variables hold time in microseconds (10^-6).
+ double compressTime = 0;
+ double decompressTime = 0;
+ final int times = 5;
+
+ int size = 0;
+
+ for (int r = 0; r < repeat; ++r) {
+ size = 0;
+ for (int k = 0; k < N; ++k) {
+ int[] backupdata = Arrays.copyOf(data[k], data[k].length);
+
+ // compress data.
+ long beforeCompress = System.nanoTime() / 1000;
+ IntWrapper outpos = new IntWrapper();
+ compressWithSkipTable(c, backupdata, compressBuffer, outpos,
+ metadataBuffer, blocksize);
+ long afterCompress = System.nanoTime() / 1000;
+
+ // measure time of compression.
+ compressTime += afterCompress - beforeCompress;
+ final int thiscompsize = outpos.get();
+ size += thiscompsize;
+ // dry run
+ int volume = 0;
+ {
+ IntWrapper compressedpos = new IntWrapper(0);
+ volume = decompressFromSkipTable(c, compressBuffer,
+ compressedpos, metadataBuffer, blocksize,
+ decompressBuffer);
+
+ // let us check the answer
+ if (volume != backupdata.length)
+ throw new RuntimeException(
+ "Bad output size with codec " + c);
+ for (int j = 0; j < volume; ++j) {
+ if (data[k][j] != decompressBuffer[j])
+ throw new RuntimeException("bug in codec " + c);
+ }
+ }
+ // extract (uncompress) data
+ long beforeDecompress = System.nanoTime() / 1000;
+ for (int t = 0; t < times; ++t) {
+ IntWrapper compressedpos = new IntWrapper(0);
+ volume = decompressFromSkipTable(c, compressBuffer,
+ compressedpos, metadataBuffer, blocksize,
+ decompressBuffer);
+ }
+ long afterDecompress = System.nanoTime() / 1000;
+
+ // measure time of extraction (uncompression).
+ decompressTime += (afterDecompress - beforeDecompress) / times;
+ if (volume != data[k].length)
+ throw new RuntimeException("we have a bug (diff length) "
+ + c + " expected " + data[k].length + " got "
+ + volume);
+
+ // verify: compare original array with
+ // compressed and
+ // uncompressed.
+ for (int m = 0; m < outpos.get(); ++m) {
+ if (decompressBuffer[m] != data[k][m]) {
+ throw new RuntimeException(
+ "we have a bug (actual difference), expected "
+ + data[k][m] + " found "
+ + decompressBuffer[m] + " at " + m);
+ }
+ }
+ }
+ }
+
+ if (verbose) {
+ double bitsPerInt = size * 32.0 / totalSize;
+ long compressSpeed = Math
+ .round(totalSize * repeat / (compressTime));
+ long decompressSpeed = Math.round(totalSize * repeat
+ / (decompressTime));
+ System.out.println(String.format("\t%1$.2f\t%2$d\t%3$d",
+ bitsPerInt, compressSpeed, decompressSpeed));
+ csvLog.format("\"%1$s\",%2$d,%3$.2f,%4$d,%5$d\n", c.toString(),
+ sparsity, bitsPerInt, compressSpeed, decompressSpeed);
+ csvLog.flush();
+ }
+ }
+
+ /**
+ * Main method.
+ *
+ * @param args
+ * command-line arguments
+ * @throws FileNotFoundException
+ * when we fail to create a new file
+ */
+ public static void main(String args[]) throws FileNotFoundException {
+ System.out.println("# benchmark based on the ClusterData model from:");
+ System.out.println("# Vo Ngoc Anh and Alistair Moffat. ");
+ System.out.println("# Index compression using 64-bit words.");
+ System.out
+ .println("# Softw. Pract. Exper.40, 2 (February 2010), 131-147. ");
+ System.out.println();
+
+ PrintWriter writer = null;
+ try {
+ File csvFile = new File(String.format(
+ "benchmark-%1$tY%1$tm%1$tdT%1$tH%1$tM%1$tS.csv",
+ System.currentTimeMillis()));
+ writer = new PrintWriter(csvFile);
+ System.out.println("# Results will be written into a CSV file: "
+ + csvFile.getName());
+ System.out.println();
+ test(writer, 20, 18, 10);
+ System.out.println();
+ System.out.println("Results were written into a CSV file: "
+ + csvFile.getName());
+ } finally {
+ if (writer != null) {
+ writer.close();
+ }
+ }
+ }
+
+ /**
+ * Generate test data.
+ *
+ * @param N
+ * How many input arrays to generate
+ * @param nbr
+ * How big (in log2) should the arrays be
+ * @param sparsity
+ * How sparse test data generated
+ */
+ private static int[][] generateTestData(ClusteredDataGenerator dataGen,
+ int N, int nbr, int sparsity) {
+ final int[][] data = new int[N][];
+ final int dataSize = (1 << (nbr + sparsity));
+ for (int i = 0; i < N; ++i) {
+ data[i] = dataGen.generateClustered((1 << nbr), dataSize);
+ }
+ return data;
+ }
+
+ static Object[] codecs = {
+
+ new SkippableIntegratedComposition(new IntegratedBinaryPacking(),
+ new IntegratedVariableByte()), new JustCopy(), new VariableByte(),
+
+ new SkippableComposition(new BinaryPacking(), new VariableByte()),
+ new SkippableComposition(new NewPFD(), new VariableByte()),
+ new SkippableComposition(new NewPFDS9(), new VariableByte()),
+ new SkippableComposition(new NewPFDS16(), new VariableByte()),
+ new SkippableComposition(new OptPFD(), new VariableByte()),
+ new SkippableComposition(new OptPFDS9(), new VariableByte()),
+ new SkippableComposition(new OptPFDS16(), new VariableByte()),
+ new SkippableComposition(new FastPFOR(), new VariableByte()),
+ new SkippableComposition(new FastPFOR128(), new VariableByte()),
+ new Simple9(), new Simple16() };
+
+ /**
+ * Generates data and calls other tests.
+ *
+ * @param csvLog
+ * Writer for CSV log.
+ * @param N
+ * How many input arrays to generate
+ * @param nbr
+ * how big (in log2) should the arrays be
+ * @param repeat
+ * How many times should we repeat tests.
+ */
+ private static void test(PrintWriter csvLog, int N, int nbr, int repeat) {
+ csvLog.format("\"Algorithm\",\"Sparsity\",\"Bits per int\",\"Compress speed (MiS)\",\"Decompress speed (MiS)\"\n");
+ ClusteredDataGenerator cdg = new ClusteredDataGenerator();
+ final int max_sparsity = 31 - nbr;
+
+ for (int sparsity = 1; sparsity < max_sparsity; sparsity+=4) {
+ System.out.println("# sparsity " + sparsity);
+ System.out.println("# generating random data...");
+ int[][] data = generateTestData(cdg, N, nbr, sparsity);
+ System.out.println("# generating random data... ok.");
+ for (Object c : codecs) {
+ testCodec(csvLog, sparsity, c, data, repeat, false);
+ testCodec(csvLog, sparsity, c, data, repeat, false);
+ testCodec(csvLog, sparsity, c, data, repeat, true);
+ testCodec(csvLog, sparsity, c, data, repeat, true);
+ testCodec(csvLog, sparsity, c, data, repeat, true);
+
+ }
+
+ }
+ }
+}
diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/PerformanceLogger.java b/src/main/java/me/lemire/integercompression/benchmarktools/PerformanceLogger.java
new file mode 100644
index 0000000..ca97144
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/benchmarktools/PerformanceLogger.java
@@ -0,0 +1,75 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ */
+package me.lemire.integercompression.benchmarktools;
+
+/**
+ * PerformanceLogger for IntegerCODEC.
+ *
+ * @author MURAOKA Taro http://github.com/koron
+ */
+public final class PerformanceLogger {
+ static class Timer {
+ private long startNano;
+ private long duration = 0;
+
+ public Timer() {
+ }
+
+ public void start() {
+ this.startNano = System.nanoTime();
+ }
+
+ public long end() {
+ return this.duration += System.nanoTime()
+ - this.startNano;
+ }
+
+ public long getDuration() {
+ return this.duration;
+ }
+ }
+
+ final Timer compressionTimer = new Timer();
+
+ final Timer decompressionTimer = new Timer();
+
+ private long originalSize = 0;
+
+ private long compressedSize = 0;
+
+ long addOriginalSize(long value) {
+ return this.originalSize += value;
+ }
+
+ long addCompressedSize(long value) {
+ return this.compressedSize += value;
+ }
+
+ long getOriginalSize() {
+ return this.originalSize;
+ }
+
+ long getCompressedSize() {
+ return this.compressedSize;
+ }
+
+ double getBitPerInt() {
+ return this.compressedSize * 32.0 / this.originalSize;
+ }
+
+ private static double getMiS(long size, long nanoTime) {
+ return (size * 1e-6) / (nanoTime * 1.0e-9);
+ }
+
+ double getCompressSpeed() {
+ return getMiS(this.originalSize,
+ this.compressionTimer.getDuration());
+ }
+
+ double getDecompressSpeed() {
+ return getMiS(this.originalSize,
+ this.decompressionTimer.getDuration());
+ }
+}
diff --git a/src/main/java/me/lemire/integercompression/differential/Delta.java b/src/main/java/me/lemire/integercompression/differential/Delta.java
new file mode 100644
index 0000000..4f7c144
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/differential/Delta.java
@@ -0,0 +1,150 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+
+package me.lemire.integercompression.differential;
+
+/**
+ * Generic class to compute differential coding.
+ *
+ * @author Daniel Lemire
+ *
+ */
+public final class Delta {
+
+ /**
+ * Apply differential coding (in-place).
+ *
+ * @param data
+ * data to be modified
+ */
+ public static void delta(int[] data) {
+ for (int i = data.length - 1; i > 0; --i) {
+ data[i] -= data[i - 1];
+ }
+ }
+
+ /**
+ * Apply differential coding (in-place) given an initial value.
+ *
+ * @param data
+ * data to be modified
+ * @param start
+ * starting index
+ * @param length
+ * number of integers to process
+ * @param init
+ * initial value
+ * @return next initial vale
+ */
+ public static int delta(int[] data, int start, int length, int init) {
+ final int nextinit = data[start + length - 1];
+ for (int i = length - 1; i > 0; --i) {
+ data[start + i] -= data[start + i - 1];
+ }
+ data[start] -= init;
+ return nextinit;
+ }
+
+ /**
+ * Compute differential coding given an initial value. Output is written
+ * to a provided array: must have length "length" or better.
+ *
+ * @param data
+ * data to be modified
+ * @param start
+ * starting index
+ * @param length
+ * number of integers to process
+ * @param init
+ * initial value
+ * @param out
+ * output array
+ * @return next initial vale
+ */
+ public static int delta(int[] data, int start, int length, int init,
+ int[] out) {
+ for (int i = length - 1; i > 0; --i) {
+ out[i] = data[start + i] - data[start + i - 1];
+ }
+ out[0] = data[start] - init;
+ return data[start + length - 1];
+ }
+
+ /**
+ * Undo differential coding (in-place). Effectively computes a prefix
+ * sum.
+ *
+ * @param data
+ * to be modified.
+ */
+ public static void inverseDelta(int[] data) {
+ for (int i = 1; i < data.length; ++i) {
+ data[i] += data[i - 1];
+ }
+ }
+
+ /**
+ * Undo differential coding (in-place). Effectively computes a prefix
+ * sum. Like inverseDelta, only faster.
+ *
+ * @param data
+ * to be modified
+ */
+ public static void fastinverseDelta(int[] data) {
+ int sz0 = data.length / 4 * 4;
+ int i = 1;
+ if (sz0 >= 4) {
+ int a = data[0];
+ for (; i < sz0 - 4; i += 4) {
+ a = data[i] += a;
+ a = data[i + 1] += a;
+ a = data[i + 2] += a;
+ a = data[i + 3] += a;
+ }
+ }
+
+ for (; i != data.length; ++i) {
+ data[i] += data[i - 1];
+ }
+ }
+
+ /**
+ * Undo differential coding (in-place). Effectively computes a prefix
+ * sum. Like inverseDelta, only faster. Uses an initial value.
+ *
+ * @param data
+ * to be modified
+ * @param start
+ * starting index
+ * @param length
+ * number of integers to process
+ * @param init
+ * initial value
+ * @return next initial value
+ */
+ public static int fastinverseDelta(int[] data, int start, int length,
+ int init) {
+ data[start] += init;
+ int sz0 = length / 4 * 4;
+ int i = 1;
+ if (sz0 >= 4) {
+ int a = data[start];
+ for (; i < sz0 - 4; i += 4) {
+ a = data[start + i] += a;
+ a = data[start + i + 1] += a;
+ a = data[start + i + 2] += a;
+ a = data[start + i + 3] += a;
+ }
+ }
+
+ for (; i != length; ++i) {
+ data[start + i] += data[start + i - 1];
+ }
+ return data[start + length - 1];
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/differential/IntegratedBinaryPacking.java b/src/main/java/me/lemire/integercompression/differential/IntegratedBinaryPacking.java
new file mode 100644
index 0000000..f50a367
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/differential/IntegratedBinaryPacking.java
@@ -0,0 +1,183 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+
+package me.lemire.integercompression.differential;
+
+import me.lemire.integercompression.BitPacking;
+import me.lemire.integercompression.IntWrapper;
+import me.lemire.integercompression.Util;
+
+/**
+ * Scheme based on a commonly used idea: can be extremely fast.
+ *
+ * You should only use this scheme on sorted arrays. Use BinaryPacking if you
+ * have unsorted arrays.
+ *
+ * It encodes integers in blocks of 32 integers. For arrays containing an
+ * arbitrary number of integers, you should use it in conjunction with another
+ * CODEC:
+ *
+ *
+ * IntegratedIntegerCODEC is =
+ * new IntegratedComposition(new IntegratedBinaryPacking(),
+ * new IntegratedVariableByte())
+ *
+ * This is useful to pre-allocate the output buffer before calling
+ * {@link #headlessCompress(int[], IntWrapper, int, int[], IntWrapper, IntWrapper)}.
+ *
+ *
+ * @param compressedPositions
+ * since not all schemes compress every input integer, this parameter
+ * returns how many input integers will actually be compressed.
+ * This is useful when composing multiple schemes.
+ * @param inlength
+ * number of integers to be compressed
+ * @return the maximum number of integers needed in the output array
+ */
+ int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength);
+}
diff --git a/src/main/java/me/lemire/integercompression/differential/XorBinaryPacking.java b/src/main/java/me/lemire/integercompression/differential/XorBinaryPacking.java
new file mode 100644
index 0000000..0e2b067
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/differential/XorBinaryPacking.java
@@ -0,0 +1,139 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ */
+package me.lemire.integercompression.differential;
+
+import me.lemire.integercompression.BitPacking;
+import me.lemire.integercompression.IntWrapper;
+
+/**
+ * BinaryPacking over XOR differential.
+ *
+ *
IntegratedIntegerCODEC is =
+ * new Composition(new XorBinaryPacking(), new VariableByte())
+ *
+ * @author MURAOKA Taro http://github.com/koron
+ */
+public final class XorBinaryPacking implements IntegratedIntegerCODEC {
+
+ private static final int BLOCK_LENGTH = 128;
+
+ @Override
+ public void compress(final int[] inBuf, final IntWrapper inPos,
+ int inLen, final int[] outBuf, final IntWrapper outPos) {
+ inLen = inLen - inLen % BLOCK_LENGTH;
+ if (inLen == 0)
+ return;
+
+ outBuf[outPos.get()] = inLen;
+ outPos.increment();
+
+ int context = 0;
+ final int[] work = new int[32];
+
+ int op = outPos.get();
+ int ip = inPos.get();
+ final int inPosLast = ip + inLen;
+ for (; ip < inPosLast; ip += BLOCK_LENGTH) {
+ final int bits1 = xorMaxBits(inBuf, ip + 0, 32, context);
+ final int bits2 = xorMaxBits(inBuf, ip + 32, 32,
+ inBuf[ip + 31]);
+ final int bits3 = xorMaxBits(inBuf, ip + 64, 32,
+ inBuf[ip + 63]);
+ final int bits4 = xorMaxBits(inBuf, ip + 96, 32,
+ inBuf[ip + 95]);
+ outBuf[op++] = (bits1 << 24) | (bits2 << 16)
+ | (bits3 << 8) | (bits4 << 0);
+ op += xorPack(inBuf, ip + 0, outBuf, op, bits1,
+ context, work);
+ op += xorPack(inBuf, ip + 32, outBuf, op, bits2,
+ inBuf[ip + 31], work);
+ op += xorPack(inBuf, ip + 64, outBuf, op, bits3,
+ inBuf[ip + 63], work);
+ op += xorPack(inBuf, ip + 96, outBuf, op, bits4,
+ inBuf[ip + 95], work);
+ context = inBuf[ip + 127];
+ }
+
+ inPos.add(inLen);
+ outPos.set(op);
+ }
+
+ @Override
+ public void uncompress(int[] inBuf, IntWrapper inPos, int inLen,
+ int[] outBuf, IntWrapper outPos) {
+ if (inLen == 0)
+ return;
+
+ final int outLen = inBuf[inPos.get()];
+ inPos.increment();
+
+ int context = 0;
+ final int[] work = new int[32];
+
+ int ip = inPos.get();
+ int op = outPos.get();
+ final int outPosLast = op + outLen;
+ for (; op < outPosLast; op += BLOCK_LENGTH) {
+ final int bits1 = (inBuf[ip] >>> 24);
+ final int bits2 = (inBuf[ip] >>> 16) & 0xFF;
+ final int bits3 = (inBuf[ip] >>> 8) & 0xFF;
+ final int bits4 = (inBuf[ip] >>> 0) & 0xFF;
+ ++ip;
+ ip += xorUnpack(inBuf, ip, outBuf, op + 0, bits1,
+ context, work);
+ ip += xorUnpack(inBuf, ip, outBuf, op + 32, bits2,
+ outBuf[op + 31], work);
+ ip += xorUnpack(inBuf, ip, outBuf, op + 64, bits3,
+ outBuf[op + 63], work);
+ ip += xorUnpack(inBuf, ip, outBuf, op + 96, bits4,
+ outBuf[op + 95], work);
+ context = outBuf[op + 127];
+ }
+
+ outPos.add(outLen);
+ inPos.set(ip);
+ }
+
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
+
+ private static int xorMaxBits(final int[] buf, final int offset,
+ final int length, final int context) {
+ int mask = buf[offset] ^ context;
+ final int M = offset + length;
+ for (int i = offset + 1, prev = offset; i < M; ++i, ++prev) {
+ mask |= buf[i] ^ buf[prev];
+ }
+
+ return 32 - Integer.numberOfLeadingZeros(mask);
+ }
+
+ private static int xorPack(final int[] inBuf, final int inOff,
+ final int[] outBuf, final int outOff, final int validBits,
+ final int context, final int[] work) {
+ work[0] = inBuf[inOff] ^ context;
+ for (int i = 1, p = inOff + 1; i < 32; ++i, ++p) {
+ work[i] = inBuf[p] ^ inBuf[p - 1];
+ }
+ BitPacking.fastpackwithoutmask(work, 0, outBuf, outOff,
+ validBits);
+
+ return validBits;
+ }
+
+ private static int xorUnpack(final int[] inBuf, final int inOff,
+ final int[] outBuf, final int outOff, final int validBits,
+ int context, final int[] work) {
+
+ BitPacking.fastunpack(inBuf, inOff, work, 0, validBits);
+ outBuf[outOff] = context = work[0] ^ context;
+ for (int i = 1, p = outOff + 1; i < 32; ++i, ++p) {
+ outBuf[p] = context = work[i] ^ context;
+ }
+ return validBits;
+ }
+}
diff --git a/src/main/java/me/lemire/integercompression/synth/ClusteredDataGenerator.java b/src/main/java/me/lemire/integercompression/synth/ClusteredDataGenerator.java
index c1293a5..12bf550 100644
--- a/src/main/java/me/lemire/integercompression/synth/ClusteredDataGenerator.java
+++ b/src/main/java/me/lemire/integercompression/synth/ClusteredDataGenerator.java
@@ -7,66 +7,82 @@
package me.lemire.integercompression.synth;
/**
- * This class will generate lists of random integers based on the clustered model:
+ * This class will generate lists of random integers based on the clustered
+ * model:
*
- * Reference:
- * Vo Ngoc Anh and Alistair Moffat. 2010. Index compression using 64-bit words.
- * Softw. Pract. Exper.40, 2 (February 2010), 131-147.
+ * Reference: Vo Ngoc Anh and Alistair Moffat. 2010. Index compression using
+ * 64-bit words. Softw. Pract. Exper.40, 2 (February 2010), 131-147.
*
* @author Daniel Lemire
*/
public class ClusteredDataGenerator {
- UniformDataGenerator unidg = new UniformDataGenerator();
+ UniformDataGenerator unidg = new UniformDataGenerator();
- public ClusteredDataGenerator() {
- }
-
- void fillUniform(int[] array, int offset, int length, int Min, int Max) {
- int[] v = this.unidg.generateUniform(length, Max - Min);
- for (int k = 0; k < v.length; ++k)
- array[k + offset] = Min + v[k];
- }
+ /**
+ * Creating random array generator.
+ */
+ public ClusteredDataGenerator() {
+ }
- void fillClustered(int[] array, int offset, int length, int Min, int Max) {
- final int range = Max - Min;
- if ((range == length) || (length <= 10)) {
- fillUniform(array, offset, length, Min, Max);
- return;
+ void fillUniform(int[] array, int offset, int length, int Min, int Max) {
+ int[] v = this.unidg.generateUniform(length, Max - Min);
+ for (int k = 0; k < v.length; ++k)
+ array[k + offset] = Min + v[k];
}
- final int cut = length
- / 2
- + ((range - length - 1 > 0) ? this.unidg.rand.nextInt(range - length - 1)
- : 0);
- final double p = this.unidg.rand.nextDouble();
- if (p < 0.25) {
- fillUniform(array, offset, length / 2, Min, Min + cut);
- fillClustered(array, offset + length / 2, length - length / 2, Min + cut,
- Max);
- } else if (p < 0.5) {
- fillClustered(array, offset, length / 2, Min, Min + cut);
- fillUniform(array, offset + length / 2, length - length / 2, Min + cut,
- Max);
- } else {
- fillClustered(array, offset, length / 2, Min, Min + cut);
- fillClustered(array, offset + length / 2, length - length / 2, Min + cut,
- Max);
+
+ void fillClustered(int[] array, int offset, int length, int Min, int Max) {
+ final int range = Max - Min;
+ if ((range == length) || (length <= 10)) {
+ fillUniform(array, offset, length, Min, Max);
+ return;
+ }
+ final int cut = length
+ / 2
+ + ((range - length - 1 > 0) ? this.unidg.rand
+ .nextInt(range - length - 1) : 0);
+ final double p = this.unidg.rand.nextDouble();
+ if (p < 0.25) {
+ fillUniform(array, offset, length / 2, Min, Min + cut);
+ fillClustered(array, offset + length / 2, length
+ - length / 2, Min + cut, Max);
+ } else if (p < 0.5) {
+ fillClustered(array, offset, length / 2, Min, Min + cut);
+ fillUniform(array, offset + length / 2, length - length
+ / 2, Min + cut, Max);
+ } else {
+ fillClustered(array, offset, length / 2, Min, Min + cut);
+ fillClustered(array, offset + length / 2, length
+ - length / 2, Min + cut, Max);
+ }
}
- }
- /**
- * generates randomly N distinct integers from 0 to Max.
- */
- public int[] generateClustered(int N, int Max) {
- int[] array = new int[N];
- fillClustered(array, 0, N, 0, Max);
- return array;
- }
+ /**
+ * generates randomly N distinct integers from 0 to Max.
+ *
+ * @param N
+ * number of integers to generate
+ * @param Max
+ * maximal value of the integers
+ * @return array containing the integers
+ */
+ public int[] generateClustered(int N, int Max) {
+ int[] array = new int[N];
+ fillClustered(array, 0, N, 0, Max);
+ return array;
+ }
- public static void main(String[] args) {
- int[] example = (new ClusteredDataGenerator()).generateClustered(20, 1000);
- for (int k = 0; k < example.length; ++k)
- System.out.println(example[k]);
- }
+ /**
+ * Little test program.
+ *
+ * @param args
+ * arguments are ignored
+ */
+ public static void main(final String[] args) {
+ int[] example = (new ClusteredDataGenerator())
+ .generateClustered(20, 1000);
+ for (int k = 0; k < example.length; ++k)
+ System.out.println(example[k]);
+ }
}
diff --git a/src/main/java/me/lemire/integercompression/synth/UniformDataGenerator.java b/src/main/java/me/lemire/integercompression/synth/UniformDataGenerator.java
index 4ac2ae4..a50497c 100644
--- a/src/main/java/me/lemire/integercompression/synth/UniformDataGenerator.java
+++ b/src/main/java/me/lemire/integercompression/synth/UniformDataGenerator.java
@@ -6,42 +6,109 @@
*/
package me.lemire.integercompression.synth;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
-import java.util.TreeSet;
/**
- * This class will generate "clustered" lists of random integers. That is, the
- * integers tend not to be randomly distributed.
- *
+ * This class will generate "uniform" lists of random integers.
+ *
* @author Daniel Lemire
*/
public class UniformDataGenerator {
- Random rand = new Random();
-
- public UniformDataGenerator() {
- }
-
- /**
- * generates randomly N distinct integers from 0 to Max.
- */
- int[] generateUniform(int N, int Max) {
- if (N > Max)
- throw new RuntimeException("not possible");
- int[] ans = new int[N];
- if (N == Max) {
- for (int k = 0; k < N; ++k)
- ans[k] = k;
- return ans;
+ /**
+ * construct generator of random arrays.
+ */
+ public UniformDataGenerator() {
+ this.rand = new Random();
+ }
+
+ /**
+ * @param seed
+ * random seed
+ */
+ public UniformDataGenerator(final int seed) {
+ this.rand = new Random(seed);
+ }
+
+ /**
+ * generates randomly N distinct integers from 0 to Max.
+ */
+ int[] generateUniformHash(int N, int Max) {
+ if (N > Max)
+ throw new RuntimeException("not possible");
+ int[] ans = new int[N];
+ HashSet s = new HashSet();
+ while (s.size() < N)
+ s.add(this.rand.nextInt(Max));
+ Iterator i = s.iterator();
+ for (int k = 0; k < N; ++k)
+ ans[k] = i.next().intValue();
+ Arrays.sort(ans);
+ return ans;
+ }
+
+ /**
+ * output all integers from the range [0,Max) that are not in the array
+ */
+ static int[] negate(int[] x, int Max) {
+ int[] ans = new int[Max - x.length];
+ int i = 0;
+ int c = 0;
+ for (int j = 0; j < x.length; ++j) {
+ int v = x[j];
+ for (; i < v; ++i)
+ ans[c++] = i;
+ ++i;
+ }
+ while (c < ans.length)
+ ans[c++] = i++;
+ return ans;
}
- // can be done faster:
- TreeSet s = new TreeSet();
- while (s.size() < N)
- s.add(new Integer(this.rand.nextInt(Max)));
- Iterator i = s.iterator();
- for (int k = 0; k < N; ++k)
- ans[k] = i.next().intValue();
- return ans;
- }
-
-}
+
+ /**
+ * generates randomly N distinct integers from 0 to Max.
+ *
+ * @param N
+ * number of integers to generate
+ * @param Max
+ * bound on the value of integers
+ * @return an array containing randomly selected integers
+ */
+ public int[] generateUniform(int N, int Max) {
+ if (N * 2 > Max) {
+ return negate(generateUniform(Max - N, Max), Max);
+ }
+ if (2048 * N > Max)
+ return generateUniformBitmap(N, Max);
+ return generateUniformHash(N, Max);
+ }
+
+ /**
+ * generates randomly N distinct integers from 0 to Max.
+ */
+ int[] generateUniformBitmap(int N, int Max) {
+ if (N > Max)
+ throw new RuntimeException("not possible");
+ int[] ans = new int[N];
+ BitSet bs = new BitSet(Max);
+ int cardinality = 0;
+ while (cardinality < N) {
+ int v = rand.nextInt(Max);
+ if (!bs.get(v)) {
+ bs.set(v);
+ cardinality++;
+ }
+ }
+ int pos = 0;
+ for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) {
+ ans[pos++] = i;
+ }
+ return ans;
+ }
+
+ Random rand = new Random();
+
+}
\ No newline at end of file
diff --git a/src/main/java/me/lemire/integercompression/vector/VectorBinaryPacking.java b/src/main/java/me/lemire/integercompression/vector/VectorBinaryPacking.java
new file mode 100644
index 0000000..6517357
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/vector/VectorBinaryPacking.java
@@ -0,0 +1,166 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ * (c) Intel Corp. (for Vector implementation)
+ */
+package me.lemire.integercompression.vector;
+
+import jdk.incubator.vector.IntVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
+import me.lemire.integercompression.IntWrapper;
+import me.lemire.integercompression.IntegerCODEC;
+import me.lemire.integercompression.SkippableIntegerCODEC;
+import me.lemire.integercompression.Util;
+import me.lemire.integercompression.vector.VectorBitPackerKernels.LaneWidth;
+
+/**
+ * BinaryPacking using the Vector API pack/unpack kernels: each block is packed at
+ * its own maximum bit width with no exceptions, so encoding is a single maxbits
+ * pass plus a vectorized pack. It encodes integers in blocks of BLOCK_SIZE
+ * integers. For arrays containing an arbitrary number of integers, you should use
+ * it in conjunction with another CODEC:
+ *
+ *
IntegerCODEC ic =
+ * new Composition(new VectorBinaryPacking(), new VariableByte()).
+ *
+ * Note that this does not use differential coding: if you are working on sorted
+ * lists, use IntegratedBinaryPacking instead.
+ *
+ * Blocks are packed in a vectorized layout that differs by hardware vector lane
+ * width. The lane width is fixed at construction and not stored on the wire, so a
+ * stream must be decoded at the same lane width it was encoded at. The default
+ * constructor packs at this machine's preferred width; the {@code (LaneWidth)}
+ * constructor pins a width so a heterogeneous cluster can decode on its narrowest
+ * node.
+ *
+ * @author Daniel Lemire
+ */
+public final class VectorBinaryPacking implements IntegerCODEC, SkippableIntegerCODEC {
+ public final static int BLOCK_SIZE = 256;
+ private static final int MAX_BIT_WIDTH = Integer.SIZE;
+ // Output words a packed block occupies per bit of width (BLOCK_SIZE / Integer.SIZE).
+ private static final int WORDS_PER_BLOCK_BIT = BLOCK_SIZE / Integer.SIZE;
+ // Blocks sharing one packed header word (four max-bit values, one byte each).
+ private static final int GROUP_SIZE_IN_BLOCKS = 4;
+ // The OR-reduction result is independent of vector width, so it uses the widest
+ // available species regardless of the wire lane width.
+ private static final VectorSpecies MAXBITS_SPECIES = IntVector.SPECIES_PREFERRED;
+
+ private final VectorBitPackerKernels kernel;
+
+ /** Packs at this machine's preferred vector lane width. */
+ public VectorBinaryPacking() {
+ this(LaneWidth.PREFERRED);
+ }
+
+ /** Pins the lane width so a heterogeneous cluster can decode on its narrowest node. */
+ public VectorBinaryPacking(LaneWidth laneWidth) {
+ this.kernel = laneWidth.kernel;
+ }
+
+ @Override
+ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ if (inlength == 0)
+ return;
+ out[outpos.get()] = inlength;
+ outpos.increment();
+ headlessCompress(in, inpos, inlength, out, outpos);
+ }
+
+ @Override
+ public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) {
+ inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
+ int tmpoutpos = outpos.get();
+ int s = inpos.get();
+ for (; s + BLOCK_SIZE * 4 - 1 < inpos.get() + inlength; s += BLOCK_SIZE * 4) {
+ final int mbits1 = maxbits(in, s);
+ final int mbits2 = maxbits(in, s + BLOCK_SIZE);
+ final int mbits3 = maxbits(in, s + 2 * BLOCK_SIZE);
+ final int mbits4 = maxbits(in, s + 3 * BLOCK_SIZE);
+ out[tmpoutpos++] = (mbits1 << 24) | (mbits2 << 16) | (mbits3 << 8) | (mbits4);
+ kernel.fastpackNoMask(in, s, out, tmpoutpos, mbits1);
+ tmpoutpos += WORDS_PER_BLOCK_BIT * mbits1;
+ kernel.fastpackNoMask(in, s + BLOCK_SIZE, out, tmpoutpos, mbits2);
+ tmpoutpos += WORDS_PER_BLOCK_BIT * mbits2;
+ kernel.fastpackNoMask(in, s + 2 * BLOCK_SIZE, out, tmpoutpos, mbits3);
+ tmpoutpos += WORDS_PER_BLOCK_BIT * mbits3;
+ kernel.fastpackNoMask(in, s + 3 * BLOCK_SIZE, out, tmpoutpos, mbits4);
+ tmpoutpos += WORDS_PER_BLOCK_BIT * mbits4;
+ }
+ for (; s < inpos.get() + inlength; s += BLOCK_SIZE) {
+ final int mbits = maxbits(in, s);
+ out[tmpoutpos++] = mbits;
+ kernel.fastpackNoMask(in, s, out, tmpoutpos, mbits);
+ tmpoutpos += WORDS_PER_BLOCK_BIT * mbits;
+ }
+ inpos.add(inlength);
+ outpos.set(tmpoutpos);
+ }
+
+ @Override
+ public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) {
+ if (inlength == 0)
+ return;
+ final int outlength = in[inpos.get()];
+ inpos.increment();
+ headlessUncompress(in, inpos, inlength, out, outpos, outlength);
+ }
+
+ @Override
+ public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos, int num) {
+ final int outlength = Util.greatestMultiple(num, BLOCK_SIZE);
+ int tmpinpos = inpos.get();
+ int s = outpos.get();
+ for (; s + BLOCK_SIZE * 4 - 1 < outpos.get() + outlength; s += BLOCK_SIZE * 4) {
+ final int mbits1 = (in[tmpinpos] >>> 24);
+ final int mbits2 = (in[tmpinpos] >>> 16) & 0xFF;
+ final int mbits3 = (in[tmpinpos] >>> 8) & 0xFF;
+ final int mbits4 = (in[tmpinpos]) & 0xFF;
+ ++tmpinpos;
+ kernel.fastunpack(in, tmpinpos, out, s, mbits1);
+ tmpinpos += WORDS_PER_BLOCK_BIT * mbits1;
+ kernel.fastunpack(in, tmpinpos, out, s + BLOCK_SIZE, mbits2);
+ tmpinpos += WORDS_PER_BLOCK_BIT * mbits2;
+ kernel.fastunpack(in, tmpinpos, out, s + 2 * BLOCK_SIZE, mbits3);
+ tmpinpos += WORDS_PER_BLOCK_BIT * mbits3;
+ kernel.fastunpack(in, tmpinpos, out, s + 3 * BLOCK_SIZE, mbits4);
+ tmpinpos += WORDS_PER_BLOCK_BIT * mbits4;
+ }
+ for (; s < outpos.get() + outlength; s += BLOCK_SIZE) {
+ final int mbits = in[tmpinpos];
+ ++tmpinpos;
+ kernel.fastunpack(in, tmpinpos, out, s, mbits);
+ tmpinpos += WORDS_PER_BLOCK_BIT * mbits;
+ }
+ outpos.add(outlength);
+ inpos.set(tmpinpos);
+ }
+
+ @Override
+ public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) {
+ int blockCount = inlength / BLOCK_SIZE;
+ int headersSizeInInts = blockCount / GROUP_SIZE_IN_BLOCKS + (blockCount % GROUP_SIZE_IN_BLOCKS);
+ int blocksSizeInInts = blockCount * MAX_BIT_WIDTH * WORDS_PER_BLOCK_BIT;
+ compressedPositions.add(blockCount * BLOCK_SIZE);
+ return headersSizeInInts + blocksSizeInInts;
+ }
+
+ // Maximum bit width needed for a BLOCK_SIZE-value block: OR-reduce the values, then count significant bits.
+ private static int maxbits(int[] in, int pos) {
+ IntVector accumulator = IntVector.zero(MAXBITS_SPECIES);
+ for (int offset = 0; offset < BLOCK_SIZE; offset += MAXBITS_SPECIES.length()) {
+ accumulator = accumulator.or(IntVector.fromArray(MAXBITS_SPECIES, in, pos + offset));
+ }
+ int mask = accumulator.reduceLanes(VectorOperators.OR);
+ return Integer.SIZE - Integer.numberOfLeadingZeros(mask);
+ }
+
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName() + "(" + kernel.getClass().getSimpleName() + ")";
+ }
+}
diff --git a/src/main/java/me/lemire/integercompression/vector/VectorBitPacker.java b/src/main/java/me/lemire/integercompression/vector/VectorBitPacker.java
new file mode 100644
index 0000000..1b0df04
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/vector/VectorBitPacker.java
@@ -0,0 +1,4289 @@
+// Copyright (C) 2022 Intel Corporation
+
+// SPDX-License-Identifier: Apache-2.0
+
+package me.lemire.integercompression.vector;
+
+import java.util.Arrays;
+import jdk.incubator.vector.*;
+
+/**
+ * Vectorized bitpacking routines. This class is a version of the
+ * VectorBitPackerTerse class that with less branch instructions.
+ *
+ * The code is machine generated from VectorBitPackerTerse.java using helper
+ * classes.
+ *
+ */
+public class VectorBitPacker implements VectorBitPackerKernels {
+ private static final VectorSpecies SPECIES_512 =
+ IntVector.SPECIES_512;
+ private static final int VLEN_512 = 16;
+ private static final int BLOCK_SIZE = 256;
+
+ private static final IntVector MASK_2 =
+ IntVector.broadcast(SPECIES_512, (1 << 2) - 1);
+ private static final IntVector MASK_4 =
+ IntVector.broadcast(SPECIES_512, (1 << 4) - 1);
+ private static final IntVector MASK_6 =
+ IntVector.broadcast(SPECIES_512, (1 << 6) - 1);
+ private static final IntVector MASK_8 =
+ IntVector.broadcast(SPECIES_512, (1 << 8) - 1);
+ private static final IntVector MASK_10 =
+ IntVector.broadcast(SPECIES_512, (1 << 10) - 1);
+ private static final IntVector MASK_12 =
+ IntVector.broadcast(SPECIES_512, (1 << 12) - 1);
+ private static final IntVector MASK_14 =
+ IntVector.broadcast(SPECIES_512, (1 << 14) - 1);
+ private static final IntVector MASK_16 =
+ IntVector.broadcast(SPECIES_512, (1 << 16) - 1);
+ private static final IntVector MASK_18 =
+ IntVector.broadcast(SPECIES_512, (1 << 18) - 1);
+ private static final IntVector MASK_20 =
+ IntVector.broadcast(SPECIES_512, (1 << 20) - 1);
+ private static final IntVector MASK_22 =
+ IntVector.broadcast(SPECIES_512, (1 << 22) - 1);
+ private static final IntVector MASK_24 =
+ IntVector.broadcast(SPECIES_512, (1 << 24) - 1);
+ private static final IntVector MASK_26 =
+ IntVector.broadcast(SPECIES_512, (1 << 26) - 1);
+ private static final IntVector MASK_28 =
+ IntVector.broadcast(SPECIES_512, (1 << 28) - 1);
+ private static final IntVector MASK_30 =
+ IntVector.broadcast(SPECIES_512, (1 << 30) - 1);
+
+ /**
+ * Pack 32 integers
+ *
+ * @param in
+ * source array
+ * @param inpos
+ * position in source array
+ * @param out
+ * output array
+ * @param outpos
+ * position in output array
+ * @param b
+ * number of bits to use per integer
+ */
+ @Override
+ public void fastpack(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ break;
+ case 1:
+ VectorBitPacker256.fastpack1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastpack2(in, inpos, out, outpos);
+ break;
+ case 3:
+ VectorBitPacker256.fastpack3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastpack4(in, inpos, out, outpos);
+ break;
+ case 5:
+ VectorBitPacker256.fastpack5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastpack6(in, inpos, out, outpos);
+ break;
+ case 7:
+ VectorBitPacker256.fastpack7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastpack8(in, inpos, out, outpos);
+ break;
+ case 9:
+ VectorBitPacker256.fastpack9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastpack10(in, inpos, out, outpos);
+ break;
+ case 11:
+ VectorBitPacker256.fastpack11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastpack12(in, inpos, out, outpos);
+ break;
+ case 13:
+ VectorBitPacker256.fastpack13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastpack14(in, inpos, out, outpos);
+ break;
+ case 15:
+ VectorBitPacker256.fastpack15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastpack16(in, inpos, out, outpos);
+ break;
+ case 17:
+ VectorBitPacker256.fastpack17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastpack18(in, inpos, out, outpos);
+ break;
+ case 19:
+ VectorBitPacker256.fastpack19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastpack20(in, inpos, out, outpos);
+ break;
+ case 21:
+ VectorBitPacker256.fastpack21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastpack22(in, inpos, out, outpos);
+ break;
+ case 23:
+ VectorBitPacker256.fastpack23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastpack24(in, inpos, out, outpos);
+ break;
+ case 25:
+ VectorBitPacker256.fastpack25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastpack26(in, inpos, out, outpos);
+ break;
+ case 27:
+ VectorBitPacker256.fastpack27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastpack28(in, inpos, out, outpos);
+ break;
+ case 29:
+ VectorBitPacker256.fastpack29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastpack30(in, inpos, out, outpos);
+ break;
+ case 31:
+ VectorBitPacker256.fastpack31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ @Override
+ public void fastpackNoMask(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ break;
+ case 1:
+ VectorBitPacker256.fastpackNoMask1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastpackNoMask2(in, inpos, out, outpos);
+ break;
+ case 3:
+ VectorBitPacker256.fastpackNoMask3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastpackNoMask4(in, inpos, out, outpos);
+ break;
+ case 5:
+ VectorBitPacker256.fastpackNoMask5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastpackNoMask6(in, inpos, out, outpos);
+ break;
+ case 7:
+ VectorBitPacker256.fastpackNoMask7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastpackNoMask8(in, inpos, out, outpos);
+ break;
+ case 9:
+ VectorBitPacker256.fastpackNoMask9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastpackNoMask10(in, inpos, out, outpos);
+ break;
+ case 11:
+ VectorBitPacker256.fastpackNoMask11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastpackNoMask12(in, inpos, out, outpos);
+ break;
+ case 13:
+ VectorBitPacker256.fastpackNoMask13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastpackNoMask14(in, inpos, out, outpos);
+ break;
+ case 15:
+ VectorBitPacker256.fastpackNoMask15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastpackNoMask16(in, inpos, out, outpos);
+ break;
+ case 17:
+ VectorBitPacker256.fastpackNoMask17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastpackNoMask18(in, inpos, out, outpos);
+ break;
+ case 19:
+ VectorBitPacker256.fastpackNoMask19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastpackNoMask20(in, inpos, out, outpos);
+ break;
+ case 21:
+ VectorBitPacker256.fastpackNoMask21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastpackNoMask22(in, inpos, out, outpos);
+ break;
+ case 23:
+ VectorBitPacker256.fastpackNoMask23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastpackNoMask24(in, inpos, out, outpos);
+ break;
+ case 25:
+ VectorBitPacker256.fastpackNoMask25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastpackNoMask26(in, inpos, out, outpos);
+ break;
+ case 27:
+ VectorBitPacker256.fastpackNoMask27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastpackNoMask28(in, inpos, out, outpos);
+ break;
+ case 29:
+ VectorBitPacker256.fastpackNoMask29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastpackNoMask30(in, inpos, out, outpos);
+ break;
+ case 31:
+ VectorBitPacker256.fastpackNoMask31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ /**
+ * Unpack 32 integers
+ *
+ * @param in
+ * source array
+ * @param inpos
+ * position in source array
+ * @param out
+ * output array
+ * @param outpos
+ * position in output array
+ * @param b
+ * number of bits to use per integer
+ */
+ @Override
+ public void fastunpack(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ Arrays.fill(out, outpos, outpos + 256, 0);
+ break;
+ case 1:
+ VectorBitPacker256.fastunpack1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastunpack2(in, inpos, out, outpos);
+ break;
+ case 3:
+ VectorBitPacker256.fastunpack3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastunpack4(in, inpos, out, outpos);
+ break;
+ case 5:
+ VectorBitPacker256.fastunpack5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastunpack6(in, inpos, out, outpos);
+ break;
+ case 7:
+ VectorBitPacker256.fastunpack7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastunpack8(in, inpos, out, outpos);
+ break;
+ case 9:
+ VectorBitPacker256.fastunpack9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastunpack10(in, inpos, out, outpos);
+ break;
+ case 11:
+ VectorBitPacker256.fastunpack11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastunpack12(in, inpos, out, outpos);
+ break;
+ case 13:
+ VectorBitPacker256.fastunpack13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastunpack14(in, inpos, out, outpos);
+ break;
+ case 15:
+ VectorBitPacker256.fastunpack15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastunpack16(in, inpos, out, outpos);
+ break;
+ case 17:
+ VectorBitPacker256.fastunpack17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastunpack18(in, inpos, out, outpos);
+ break;
+ case 19:
+ VectorBitPacker256.fastunpack19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastunpack20(in, inpos, out, outpos);
+ break;
+ case 21:
+ VectorBitPacker256.fastunpack21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastunpack22(in, inpos, out, outpos);
+ break;
+ case 23:
+ VectorBitPacker256.fastunpack23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastunpack24(in, inpos, out, outpos);
+ break;
+ case 25:
+ VectorBitPacker256.fastunpack25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastunpack26(in, inpos, out, outpos);
+ break;
+ case 27:
+ VectorBitPacker256.fastunpack27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastunpack28(in, inpos, out, outpos);
+ break;
+ case 29:
+ VectorBitPacker256.fastunpack29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastunpack30(in, inpos, out, outpos);
+ break;
+ case 31:
+ VectorBitPacker256.fastunpack31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ private static void fastpack2(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_2);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack4(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_4);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack6(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_6);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack8(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_8);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack10(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_10);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack12(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_12);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack14(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_14);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack16(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_16);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack18(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_18);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack20(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_20);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack22(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_22);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack24(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_24);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack26(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_26);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack28(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_28);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpack30(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(MASK_30);
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask2(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask4(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask6(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask8(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask10(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask12(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask14(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask16(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask18(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask20(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask22(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask24(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask26(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask28(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.or(oV);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask30(final int[] in, int inpos,
+ final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack2(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack4(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.and(MASK_4);
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xf).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack6(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack8(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.and(MASK_8);
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0xff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack10(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack12(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xfff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack14(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack16(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.and(MASK_16);
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0xffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0xffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0xffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0xffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(0xffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack18(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack20(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0xfffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack22(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack24(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xffffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0xffffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(0xffffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack26(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack28(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = oV.zero(SPECIES_512);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(0xfffffff).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+ private static void fastunpack30(final int[] in, int inpos, final int[] out,
+ int outpos) {
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ iV.and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 16);
+ oV = iV.and(0xfffffff).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 32);
+ oV = iV.and(0x3ffffff).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 48);
+ oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 64);
+ oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 80);
+ oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 96);
+ oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 112);
+ oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 128);
+ oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 144);
+ oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 160);
+ oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 176);
+ oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 192);
+ oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 208);
+ oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + 224);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/vector/VectorBitPacker128.java b/src/main/java/me/lemire/integercompression/vector/VectorBitPacker128.java
new file mode 100644
index 0000000..6e08546
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/vector/VectorBitPacker128.java
@@ -0,0 +1,31953 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+package me.lemire.integercompression.vector;
+
+import java.util.Arrays;
+import jdk.incubator.vector.*;
+
+/**
+ * Vectorized bit-packing routines using 128-bit (4 x int32) vectors.
+ *
+ * A 256-integer block is packed across 4 SIMD lanes, each lane packing 64
+ * values into 2*b 32-bit words. Selected at runtime by VectorBitPackerKernels
+ * when the preferred hardware vector width is 128 bits (e.g. Arm NEON, Graviton).
+ */
+public class VectorBitPacker128 implements VectorBitPackerKernels {
+ private static final VectorSpecies SPECIES_128 =
+ IntVector.SPECIES_128;
+ private static final int VLEN_128 = 4;
+ private static final int BLOCK_SIZE = 256;
+
+ private static final IntVector MASK_1 =
+ IntVector.broadcast(SPECIES_128, (1 << 1) - 1);
+ private static final IntVector MASK_2 =
+ IntVector.broadcast(SPECIES_128, (1 << 2) - 1);
+ private static final IntVector MASK_3 =
+ IntVector.broadcast(SPECIES_128, (1 << 3) - 1);
+ private static final IntVector MASK_4 =
+ IntVector.broadcast(SPECIES_128, (1 << 4) - 1);
+ private static final IntVector MASK_5 =
+ IntVector.broadcast(SPECIES_128, (1 << 5) - 1);
+ private static final IntVector MASK_6 =
+ IntVector.broadcast(SPECIES_128, (1 << 6) - 1);
+ private static final IntVector MASK_7 =
+ IntVector.broadcast(SPECIES_128, (1 << 7) - 1);
+ private static final IntVector MASK_8 =
+ IntVector.broadcast(SPECIES_128, (1 << 8) - 1);
+ private static final IntVector MASK_9 =
+ IntVector.broadcast(SPECIES_128, (1 << 9) - 1);
+ private static final IntVector MASK_10 =
+ IntVector.broadcast(SPECIES_128, (1 << 10) - 1);
+ private static final IntVector MASK_11 =
+ IntVector.broadcast(SPECIES_128, (1 << 11) - 1);
+ private static final IntVector MASK_12 =
+ IntVector.broadcast(SPECIES_128, (1 << 12) - 1);
+ private static final IntVector MASK_13 =
+ IntVector.broadcast(SPECIES_128, (1 << 13) - 1);
+ private static final IntVector MASK_14 =
+ IntVector.broadcast(SPECIES_128, (1 << 14) - 1);
+ private static final IntVector MASK_15 =
+ IntVector.broadcast(SPECIES_128, (1 << 15) - 1);
+ private static final IntVector MASK_16 =
+ IntVector.broadcast(SPECIES_128, (1 << 16) - 1);
+ private static final IntVector MASK_17 =
+ IntVector.broadcast(SPECIES_128, (1 << 17) - 1);
+ private static final IntVector MASK_18 =
+ IntVector.broadcast(SPECIES_128, (1 << 18) - 1);
+ private static final IntVector MASK_19 =
+ IntVector.broadcast(SPECIES_128, (1 << 19) - 1);
+ private static final IntVector MASK_20 =
+ IntVector.broadcast(SPECIES_128, (1 << 20) - 1);
+ private static final IntVector MASK_21 =
+ IntVector.broadcast(SPECIES_128, (1 << 21) - 1);
+ private static final IntVector MASK_22 =
+ IntVector.broadcast(SPECIES_128, (1 << 22) - 1);
+ private static final IntVector MASK_23 =
+ IntVector.broadcast(SPECIES_128, (1 << 23) - 1);
+ private static final IntVector MASK_24 =
+ IntVector.broadcast(SPECIES_128, (1 << 24) - 1);
+ private static final IntVector MASK_25 =
+ IntVector.broadcast(SPECIES_128, (1 << 25) - 1);
+ private static final IntVector MASK_26 =
+ IntVector.broadcast(SPECIES_128, (1 << 26) - 1);
+ private static final IntVector MASK_27 =
+ IntVector.broadcast(SPECIES_128, (1 << 27) - 1);
+ private static final IntVector MASK_28 =
+ IntVector.broadcast(SPECIES_128, (1 << 28) - 1);
+ private static final IntVector MASK_29 =
+ IntVector.broadcast(SPECIES_128, (1 << 29) - 1);
+ private static final IntVector MASK_30 =
+ IntVector.broadcast(SPECIES_128, (1 << 30) - 1);
+ private static final IntVector MASK_31 =
+ IntVector.broadcast(SPECIES_128, (1 << 31) - 1);
+
+ @Override
+ public void fastpack(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ break;
+ case 1:
+ fastpack1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastpack2(in, inpos, out, outpos);
+ break;
+ case 3:
+ fastpack3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastpack4(in, inpos, out, outpos);
+ break;
+ case 5:
+ fastpack5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastpack6(in, inpos, out, outpos);
+ break;
+ case 7:
+ fastpack7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastpack8(in, inpos, out, outpos);
+ break;
+ case 9:
+ fastpack9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastpack10(in, inpos, out, outpos);
+ break;
+ case 11:
+ fastpack11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastpack12(in, inpos, out, outpos);
+ break;
+ case 13:
+ fastpack13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastpack14(in, inpos, out, outpos);
+ break;
+ case 15:
+ fastpack15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastpack16(in, inpos, out, outpos);
+ break;
+ case 17:
+ fastpack17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastpack18(in, inpos, out, outpos);
+ break;
+ case 19:
+ fastpack19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastpack20(in, inpos, out, outpos);
+ break;
+ case 21:
+ fastpack21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastpack22(in, inpos, out, outpos);
+ break;
+ case 23:
+ fastpack23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastpack24(in, inpos, out, outpos);
+ break;
+ case 25:
+ fastpack25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastpack26(in, inpos, out, outpos);
+ break;
+ case 27:
+ fastpack27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastpack28(in, inpos, out, outpos);
+ break;
+ case 29:
+ fastpack29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastpack30(in, inpos, out, outpos);
+ break;
+ case 31:
+ fastpack31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ @Override
+ public void fastpackNoMask(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ break;
+ case 1:
+ fastpackNoMask1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastpackNoMask2(in, inpos, out, outpos);
+ break;
+ case 3:
+ fastpackNoMask3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastpackNoMask4(in, inpos, out, outpos);
+ break;
+ case 5:
+ fastpackNoMask5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastpackNoMask6(in, inpos, out, outpos);
+ break;
+ case 7:
+ fastpackNoMask7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastpackNoMask8(in, inpos, out, outpos);
+ break;
+ case 9:
+ fastpackNoMask9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastpackNoMask10(in, inpos, out, outpos);
+ break;
+ case 11:
+ fastpackNoMask11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastpackNoMask12(in, inpos, out, outpos);
+ break;
+ case 13:
+ fastpackNoMask13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastpackNoMask14(in, inpos, out, outpos);
+ break;
+ case 15:
+ fastpackNoMask15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastpackNoMask16(in, inpos, out, outpos);
+ break;
+ case 17:
+ fastpackNoMask17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastpackNoMask18(in, inpos, out, outpos);
+ break;
+ case 19:
+ fastpackNoMask19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastpackNoMask20(in, inpos, out, outpos);
+ break;
+ case 21:
+ fastpackNoMask21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastpackNoMask22(in, inpos, out, outpos);
+ break;
+ case 23:
+ fastpackNoMask23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastpackNoMask24(in, inpos, out, outpos);
+ break;
+ case 25:
+ fastpackNoMask25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastpackNoMask26(in, inpos, out, outpos);
+ break;
+ case 27:
+ fastpackNoMask27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastpackNoMask28(in, inpos, out, outpos);
+ break;
+ case 29:
+ fastpackNoMask29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastpackNoMask30(in, inpos, out, outpos);
+ break;
+ case 31:
+ fastpackNoMask31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ @Override
+ public void fastunpack(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ Arrays.fill(out, outpos, outpos + 256, 0);
+ break;
+ case 1:
+ fastunpack1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastunpack2(in, inpos, out, outpos);
+ break;
+ case 3:
+ fastunpack3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastunpack4(in, inpos, out, outpos);
+ break;
+ case 5:
+ fastunpack5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastunpack6(in, inpos, out, outpos);
+ break;
+ case 7:
+ fastunpack7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastunpack8(in, inpos, out, outpos);
+ break;
+ case 9:
+ fastunpack9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastunpack10(in, inpos, out, outpos);
+ break;
+ case 11:
+ fastunpack11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastunpack12(in, inpos, out, outpos);
+ break;
+ case 13:
+ fastunpack13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastunpack14(in, inpos, out, outpos);
+ break;
+ case 15:
+ fastunpack15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastunpack16(in, inpos, out, outpos);
+ break;
+ case 17:
+ fastunpack17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastunpack18(in, inpos, out, outpos);
+ break;
+ case 19:
+ fastunpack19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastunpack20(in, inpos, out, outpos);
+ break;
+ case 21:
+ fastunpack21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastunpack22(in, inpos, out, outpos);
+ break;
+ case 23:
+ fastunpack23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastunpack24(in, inpos, out, outpos);
+ break;
+ case 25:
+ fastunpack25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastunpack26(in, inpos, out, outpos);
+ break;
+ case 27:
+ fastunpack27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastunpack28(in, inpos, out, outpos);
+ break;
+ case 29:
+ fastunpack29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastunpack30(in, inpos, out, outpos);
+ break;
+ case 31:
+ fastunpack31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ private static void fastpack1(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask1(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack1(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 29).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 31).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ iV.and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 29).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 31).and(MASK_1).intoArray(out, outpos);
+ }
+
+ private static void fastpack2(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask2(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack2(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ iV.and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ iV.and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ iV.and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_2).intoArray(out, outpos);
+ }
+
+ private static void fastpack3(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask3(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack3(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 29).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ iV.and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 29).and(MASK_3).intoArray(out, outpos);
+ }
+
+ private static void fastpack4(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask4(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack4(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ }
+
+ private static void fastpack5(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask5(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack5(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ iV.and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_5).intoArray(out, outpos);
+ }
+
+ private static void fastpack6(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask6(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack6(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ iV.and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ iV.and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ iV.and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_6).intoArray(out, outpos);
+ }
+
+ private static void fastpack7(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask7(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack7(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ iV.and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_7).intoArray(out, outpos);
+ }
+
+ private static void fastpack8(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask8(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack8(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ }
+
+ private static void fastpack9(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask9(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack9(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ iV.and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_9).intoArray(out, outpos);
+ }
+
+ private static void fastpack10(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask10(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack10(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ iV.and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ iV.and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ iV.and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_10).intoArray(out, outpos);
+ }
+
+ private static void fastpack11(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask11(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack11(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ iV.and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_11).intoArray(out, outpos);
+ }
+
+ private static void fastpack12(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask12(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack12(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ }
+
+ private static void fastpack13(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask13(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack13(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ iV.and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_13).intoArray(out, outpos);
+ }
+
+ private static void fastpack14(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask14(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack14(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ iV.and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ iV.and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ iV.and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_14).intoArray(out, outpos);
+ }
+
+ private static void fastpack15(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask15(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack15(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ iV.and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_15).intoArray(out, outpos);
+ }
+
+ private static void fastpack16(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask16(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack16(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ }
+
+ private static void fastpack17(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask17(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack17(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ iV.and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_17).intoArray(out, outpos);
+ }
+
+ private static void fastpack18(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask18(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack18(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ iV.and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ iV.and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ iV.and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_18).intoArray(out, outpos);
+ }
+
+ private static void fastpack19(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask19(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack19(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ iV.and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_19).intoArray(out, outpos);
+ }
+
+ private static void fastpack20(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask20(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack20(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ }
+
+ private static void fastpack21(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask21(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack21(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ iV.and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_21).intoArray(out, outpos);
+ }
+
+ private static void fastpack22(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask22(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack22(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ iV.and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ iV.and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ iV.and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_22).intoArray(out, outpos);
+ }
+
+ private static void fastpack23(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask23(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack23(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ iV.and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_23).intoArray(out, outpos);
+ }
+
+ private static void fastpack24(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask24(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack24(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ }
+
+ private static void fastpack25(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask25(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack25(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ iV.and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_25).intoArray(out, outpos);
+ }
+
+ private static void fastpack26(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask26(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack26(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ iV.and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ iV.and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ iV.and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_26).intoArray(out, outpos);
+ }
+
+ private static void fastpack27(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask27(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack27(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ iV.and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_27).intoArray(out, outpos);
+ }
+
+ private static void fastpack28(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask28(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack28(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ }
+
+ private static void fastpack29(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask29(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack29(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(134217727).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ iV.and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(134217727).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_29).intoArray(out, outpos);
+ }
+
+ private static void fastpack30(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask30(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack30(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ iV.and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ iV.and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ iV.and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_30).intoArray(out, outpos);
+ }
+
+ private static void fastpack31(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV.and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastpackNoMask31(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 252);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ private static void fastunpack31(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_128, in, inpos);
+ iV.and(MASK_31).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 4);
+ oV = iV.and(1073741823).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 8);
+ oV = iV.and(536870911).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 12);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 16);
+ oV = iV.and(134217727).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 20);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 24);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 28);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 32);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 36);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 40);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 44);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 48);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 52);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 56);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 60);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 64);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 68);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 72);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 76);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 80);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 84);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 88);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 92);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 96);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 100);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 104);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 108);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 112);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 116);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 120);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_31).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 124);
+ iV.and(MASK_31).intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 128);
+ oV = iV.and(1073741823).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 132);
+ oV = iV.and(536870911).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 136);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 140);
+ oV = iV.and(134217727).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 144);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 148);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 152);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 156);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 160);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 164);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 168);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 172);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 176);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 180);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 184);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 188);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 192);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 196);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 200);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 204);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 208);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 212);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 216);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 220);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 224);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 228);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 232);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 236);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 240);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_128, in, inpos + 244);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_128;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_31).intoArray(out, outpos);
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/vector/VectorBitPacker256.java b/src/main/java/me/lemire/integercompression/vector/VectorBitPacker256.java
new file mode 100644
index 0000000..02596f5
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/vector/VectorBitPacker256.java
@@ -0,0 +1,16226 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+package me.lemire.integercompression.vector;
+
+import java.util.Arrays;
+import jdk.incubator.vector.*;
+
+/**
+ * Vectorized bit-packing routines using 256-bit (8 x int32) vectors.
+ *
+ * A 256-integer block is packed across 8 SIMD lanes, each lane packing 32
+ * values into b 32-bit words. Selected at runtime by VectorBitPackerKernels
+ * when the preferred hardware vector width is 256 bits (e.g. AVX2, Graviton3),
+ * where the 512-bit paths of VectorBitPacker fall back to slow emulation.
+ */
+public class VectorBitPacker256 implements VectorBitPackerKernels {
+ private static final VectorSpecies SPECIES_256 =
+ IntVector.SPECIES_256;
+ private static final int VLEN_256 = 8;
+ private static final int BLOCK_SIZE = 256;
+
+ private static final IntVector MASK_1 =
+ IntVector.broadcast(SPECIES_256, (1 << 1) - 1);
+ private static final IntVector MASK_2 =
+ IntVector.broadcast(SPECIES_256, (1 << 2) - 1);
+ private static final IntVector MASK_3 =
+ IntVector.broadcast(SPECIES_256, (1 << 3) - 1);
+ private static final IntVector MASK_4 =
+ IntVector.broadcast(SPECIES_256, (1 << 4) - 1);
+ private static final IntVector MASK_5 =
+ IntVector.broadcast(SPECIES_256, (1 << 5) - 1);
+ private static final IntVector MASK_6 =
+ IntVector.broadcast(SPECIES_256, (1 << 6) - 1);
+ private static final IntVector MASK_7 =
+ IntVector.broadcast(SPECIES_256, (1 << 7) - 1);
+ private static final IntVector MASK_8 =
+ IntVector.broadcast(SPECIES_256, (1 << 8) - 1);
+ private static final IntVector MASK_9 =
+ IntVector.broadcast(SPECIES_256, (1 << 9) - 1);
+ private static final IntVector MASK_10 =
+ IntVector.broadcast(SPECIES_256, (1 << 10) - 1);
+ private static final IntVector MASK_11 =
+ IntVector.broadcast(SPECIES_256, (1 << 11) - 1);
+ private static final IntVector MASK_12 =
+ IntVector.broadcast(SPECIES_256, (1 << 12) - 1);
+ private static final IntVector MASK_13 =
+ IntVector.broadcast(SPECIES_256, (1 << 13) - 1);
+ private static final IntVector MASK_14 =
+ IntVector.broadcast(SPECIES_256, (1 << 14) - 1);
+ private static final IntVector MASK_15 =
+ IntVector.broadcast(SPECIES_256, (1 << 15) - 1);
+ private static final IntVector MASK_16 =
+ IntVector.broadcast(SPECIES_256, (1 << 16) - 1);
+ private static final IntVector MASK_17 =
+ IntVector.broadcast(SPECIES_256, (1 << 17) - 1);
+ private static final IntVector MASK_18 =
+ IntVector.broadcast(SPECIES_256, (1 << 18) - 1);
+ private static final IntVector MASK_19 =
+ IntVector.broadcast(SPECIES_256, (1 << 19) - 1);
+ private static final IntVector MASK_20 =
+ IntVector.broadcast(SPECIES_256, (1 << 20) - 1);
+ private static final IntVector MASK_21 =
+ IntVector.broadcast(SPECIES_256, (1 << 21) - 1);
+ private static final IntVector MASK_22 =
+ IntVector.broadcast(SPECIES_256, (1 << 22) - 1);
+ private static final IntVector MASK_23 =
+ IntVector.broadcast(SPECIES_256, (1 << 23) - 1);
+ private static final IntVector MASK_24 =
+ IntVector.broadcast(SPECIES_256, (1 << 24) - 1);
+ private static final IntVector MASK_25 =
+ IntVector.broadcast(SPECIES_256, (1 << 25) - 1);
+ private static final IntVector MASK_26 =
+ IntVector.broadcast(SPECIES_256, (1 << 26) - 1);
+ private static final IntVector MASK_27 =
+ IntVector.broadcast(SPECIES_256, (1 << 27) - 1);
+ private static final IntVector MASK_28 =
+ IntVector.broadcast(SPECIES_256, (1 << 28) - 1);
+ private static final IntVector MASK_29 =
+ IntVector.broadcast(SPECIES_256, (1 << 29) - 1);
+ private static final IntVector MASK_30 =
+ IntVector.broadcast(SPECIES_256, (1 << 30) - 1);
+ private static final IntVector MASK_31 =
+ IntVector.broadcast(SPECIES_256, (1 << 31) - 1);
+
+ @Override
+ public void fastpack(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ break;
+ case 1:
+ fastpack1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastpack2(in, inpos, out, outpos);
+ break;
+ case 3:
+ fastpack3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastpack4(in, inpos, out, outpos);
+ break;
+ case 5:
+ fastpack5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastpack6(in, inpos, out, outpos);
+ break;
+ case 7:
+ fastpack7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastpack8(in, inpos, out, outpos);
+ break;
+ case 9:
+ fastpack9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastpack10(in, inpos, out, outpos);
+ break;
+ case 11:
+ fastpack11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastpack12(in, inpos, out, outpos);
+ break;
+ case 13:
+ fastpack13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastpack14(in, inpos, out, outpos);
+ break;
+ case 15:
+ fastpack15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastpack16(in, inpos, out, outpos);
+ break;
+ case 17:
+ fastpack17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastpack18(in, inpos, out, outpos);
+ break;
+ case 19:
+ fastpack19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastpack20(in, inpos, out, outpos);
+ break;
+ case 21:
+ fastpack21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastpack22(in, inpos, out, outpos);
+ break;
+ case 23:
+ fastpack23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastpack24(in, inpos, out, outpos);
+ break;
+ case 25:
+ fastpack25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastpack26(in, inpos, out, outpos);
+ break;
+ case 27:
+ fastpack27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastpack28(in, inpos, out, outpos);
+ break;
+ case 29:
+ fastpack29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastpack30(in, inpos, out, outpos);
+ break;
+ case 31:
+ fastpack31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ @Override
+ public void fastpackNoMask(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ break;
+ case 1:
+ fastpackNoMask1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastpackNoMask2(in, inpos, out, outpos);
+ break;
+ case 3:
+ fastpackNoMask3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastpackNoMask4(in, inpos, out, outpos);
+ break;
+ case 5:
+ fastpackNoMask5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastpackNoMask6(in, inpos, out, outpos);
+ break;
+ case 7:
+ fastpackNoMask7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastpackNoMask8(in, inpos, out, outpos);
+ break;
+ case 9:
+ fastpackNoMask9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastpackNoMask10(in, inpos, out, outpos);
+ break;
+ case 11:
+ fastpackNoMask11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastpackNoMask12(in, inpos, out, outpos);
+ break;
+ case 13:
+ fastpackNoMask13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastpackNoMask14(in, inpos, out, outpos);
+ break;
+ case 15:
+ fastpackNoMask15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastpackNoMask16(in, inpos, out, outpos);
+ break;
+ case 17:
+ fastpackNoMask17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastpackNoMask18(in, inpos, out, outpos);
+ break;
+ case 19:
+ fastpackNoMask19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastpackNoMask20(in, inpos, out, outpos);
+ break;
+ case 21:
+ fastpackNoMask21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastpackNoMask22(in, inpos, out, outpos);
+ break;
+ case 23:
+ fastpackNoMask23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastpackNoMask24(in, inpos, out, outpos);
+ break;
+ case 25:
+ fastpackNoMask25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastpackNoMask26(in, inpos, out, outpos);
+ break;
+ case 27:
+ fastpackNoMask27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastpackNoMask28(in, inpos, out, outpos);
+ break;
+ case 29:
+ fastpackNoMask29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastpackNoMask30(in, inpos, out, outpos);
+ break;
+ case 31:
+ fastpackNoMask31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ @Override
+ public void fastunpack(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ Arrays.fill(out, outpos, outpos + 256, 0);
+ break;
+ case 1:
+ fastunpack1(in, inpos, out, outpos);
+ break;
+ case 2:
+ fastunpack2(in, inpos, out, outpos);
+ break;
+ case 3:
+ fastunpack3(in, inpos, out, outpos);
+ break;
+ case 4:
+ fastunpack4(in, inpos, out, outpos);
+ break;
+ case 5:
+ fastunpack5(in, inpos, out, outpos);
+ break;
+ case 6:
+ fastunpack6(in, inpos, out, outpos);
+ break;
+ case 7:
+ fastunpack7(in, inpos, out, outpos);
+ break;
+ case 8:
+ fastunpack8(in, inpos, out, outpos);
+ break;
+ case 9:
+ fastunpack9(in, inpos, out, outpos);
+ break;
+ case 10:
+ fastunpack10(in, inpos, out, outpos);
+ break;
+ case 11:
+ fastunpack11(in, inpos, out, outpos);
+ break;
+ case 12:
+ fastunpack12(in, inpos, out, outpos);
+ break;
+ case 13:
+ fastunpack13(in, inpos, out, outpos);
+ break;
+ case 14:
+ fastunpack14(in, inpos, out, outpos);
+ break;
+ case 15:
+ fastunpack15(in, inpos, out, outpos);
+ break;
+ case 16:
+ fastunpack16(in, inpos, out, outpos);
+ break;
+ case 17:
+ fastunpack17(in, inpos, out, outpos);
+ break;
+ case 18:
+ fastunpack18(in, inpos, out, outpos);
+ break;
+ case 19:
+ fastunpack19(in, inpos, out, outpos);
+ break;
+ case 20:
+ fastunpack20(in, inpos, out, outpos);
+ break;
+ case 21:
+ fastunpack21(in, inpos, out, outpos);
+ break;
+ case 22:
+ fastunpack22(in, inpos, out, outpos);
+ break;
+ case 23:
+ fastunpack23(in, inpos, out, outpos);
+ break;
+ case 24:
+ fastunpack24(in, inpos, out, outpos);
+ break;
+ case 25:
+ fastunpack25(in, inpos, out, outpos);
+ break;
+ case 26:
+ fastunpack26(in, inpos, out, outpos);
+ break;
+ case 27:
+ fastunpack27(in, inpos, out, outpos);
+ break;
+ case 28:
+ fastunpack28(in, inpos, out, outpos);
+ break;
+ case 29:
+ fastunpack29(in, inpos, out, outpos);
+ break;
+ case 30:
+ fastunpack30(in, inpos, out, outpos);
+ break;
+ case 31:
+ fastunpack31(in, inpos, out, outpos);
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE);
+ break;
+ }
+ }
+
+ static void fastpack1(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask1(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack1(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 29).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_1).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 31).and(MASK_1).intoArray(out, outpos);
+ }
+
+ static void fastpack2(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask2(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack2(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ iV.and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_2).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 30).and(MASK_2).intoArray(out, outpos);
+ }
+
+ static void fastpack3(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask3(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack3(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_3).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 29).and(MASK_3).intoArray(out, outpos);
+ }
+
+ static void fastpack4(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask4(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack4(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ iV.and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos);
+ }
+
+ static void fastpack5(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask5(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack5(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_5).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 27).and(MASK_5).intoArray(out, outpos);
+ }
+
+ static void fastpack6(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask6(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack6(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ iV.and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_6).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 26).and(MASK_6).intoArray(out, outpos);
+ }
+
+ static void fastpack7(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask7(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack7(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_7).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 25).and(MASK_7).intoArray(out, outpos);
+ }
+
+ static void fastpack8(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask8(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack8(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ iV.and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos);
+ }
+
+ static void fastpack9(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask9(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack9(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_9).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 23).and(MASK_9).intoArray(out, outpos);
+ }
+
+ static void fastpack10(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask10(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack10(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ iV.and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_10).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 22).and(MASK_10).intoArray(out, outpos);
+ }
+
+ static void fastpack11(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask11(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack11(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_11).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 21).and(MASK_11).intoArray(out, outpos);
+ }
+
+ static void fastpack12(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask12(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack12(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ iV.and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos);
+ }
+
+ static void fastpack13(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask13(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack13(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_13).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 19).and(MASK_13).intoArray(out, outpos);
+ }
+
+ static void fastpack14(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask14(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack14(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ iV.and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_14).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 18).and(MASK_14).intoArray(out, outpos);
+ }
+
+ static void fastpack15(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask15(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack15(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_15).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 17).and(MASK_15).intoArray(out, outpos);
+ }
+
+ static void fastpack16(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask16(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack16(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ iV.and(MASK_16).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos);
+ }
+
+ static void fastpack17(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask17(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack17(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_17).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 15).and(MASK_17).intoArray(out, outpos);
+ }
+
+ static void fastpack18(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask18(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack18(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ iV.and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_18).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 14).and(MASK_18).intoArray(out, outpos);
+ }
+
+ static void fastpack19(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask19(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack19(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_19).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 13).and(MASK_19).intoArray(out, outpos);
+ }
+
+ static void fastpack20(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask20(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack20(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ iV.and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos);
+ }
+
+ static void fastpack21(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask21(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack21(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_21).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 11).and(MASK_21).intoArray(out, outpos);
+ }
+
+ static void fastpack22(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask22(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack22(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ iV.and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_22).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 10).and(MASK_22).intoArray(out, outpos);
+ }
+
+ static void fastpack23(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask23(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack23(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_23).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 9).and(MASK_23).intoArray(out, outpos);
+ }
+
+ static void fastpack24(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask24(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack24(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ iV.and(MASK_24).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos);
+ }
+
+ static void fastpack25(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask25(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack25(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_25).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 7).and(MASK_25).intoArray(out, outpos);
+ }
+
+ static void fastpack26(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask26(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack26(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ iV.and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_26).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 6).and(MASK_26).intoArray(out, outpos);
+ }
+
+ static void fastpack27(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask27(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack27(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_27).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 5).and(MASK_27).intoArray(out, outpos);
+ }
+
+ static void fastpack28(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask28(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack28(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ iV.and(MASK_28).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos);
+ }
+
+ static void fastpack29(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask29(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack29(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_29).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(134217727).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 3).and(MASK_29).intoArray(out, outpos);
+ }
+
+ static void fastpack30(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask30(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack30(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ iV.and(MASK_30).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 2).and(MASK_30).intoArray(out, outpos);
+ }
+
+ static void fastpack31(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastpackNoMask31(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 1);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 248);
+ oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ }
+
+ static void fastunpack31(final int[] in, int inpos, final int[] out, int outpos) {
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ iV.and(MASK_31).intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ var oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 8);
+ oV = iV.and(1073741823).lanewise(VectorOperators.LSHL, 1).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 16);
+ oV = iV.and(536870911).lanewise(VectorOperators.LSHL, 2).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 24);
+ oV = iV.and(268435455).lanewise(VectorOperators.LSHL, 3).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 32);
+ oV = iV.and(134217727).lanewise(VectorOperators.LSHL, 4).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 40);
+ oV = iV.and(67108863).lanewise(VectorOperators.LSHL, 5).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 48);
+ oV = iV.and(33554431).lanewise(VectorOperators.LSHL, 6).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 56);
+ oV = iV.and(16777215).lanewise(VectorOperators.LSHL, 7).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 64);
+ oV = iV.and(8388607).lanewise(VectorOperators.LSHL, 8).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 72);
+ oV = iV.and(4194303).lanewise(VectorOperators.LSHL, 9).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 80);
+ oV = iV.and(2097151).lanewise(VectorOperators.LSHL, 10).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 88);
+ oV = iV.and(1048575).lanewise(VectorOperators.LSHL, 11).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 96);
+ oV = iV.and(524287).lanewise(VectorOperators.LSHL, 12).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 104);
+ oV = iV.and(262143).lanewise(VectorOperators.LSHL, 13).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 112);
+ oV = iV.and(131071).lanewise(VectorOperators.LSHL, 14).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 120);
+ oV = iV.and(65535).lanewise(VectorOperators.LSHL, 15).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 128);
+ oV = iV.and(32767).lanewise(VectorOperators.LSHL, 16).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 136);
+ oV = iV.and(16383).lanewise(VectorOperators.LSHL, 17).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 144);
+ oV = iV.and(8191).lanewise(VectorOperators.LSHL, 18).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 152);
+ oV = iV.and(4095).lanewise(VectorOperators.LSHL, 19).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 160);
+ oV = iV.and(2047).lanewise(VectorOperators.LSHL, 20).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 168);
+ oV = iV.and(1023).lanewise(VectorOperators.LSHL, 21).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 176);
+ oV = iV.and(511).lanewise(VectorOperators.LSHL, 22).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 184);
+ oV = iV.and(255).lanewise(VectorOperators.LSHL, 23).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 192);
+ oV = iV.and(127).lanewise(VectorOperators.LSHL, 24).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 200);
+ oV = iV.and(63).lanewise(VectorOperators.LSHL, 25).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 208);
+ oV = iV.and(31).lanewise(VectorOperators.LSHL, 26).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 5).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 216);
+ oV = iV.and(15).lanewise(VectorOperators.LSHL, 27).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 224);
+ oV = iV.and(7).lanewise(VectorOperators.LSHL, 28).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 3).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 232);
+ oV = iV.and(3).lanewise(VectorOperators.LSHL, 29).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ oV = iV.lanewise(VectorOperators.LSHR, 2).and(MASK_31);
+
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + 240);
+ oV = iV.and(1).lanewise(VectorOperators.LSHL, 30).or(oV);
+
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ iV.lanewise(VectorOperators.LSHR, 1).and(MASK_31).intoArray(out, outpos);
+ }
+
+}
diff --git a/src/main/java/me/lemire/integercompression/vector/VectorBitPackerKernels.java b/src/main/java/me/lemire/integercompression/vector/VectorBitPackerKernels.java
new file mode 100644
index 0000000..9179827
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/vector/VectorBitPackerKernels.java
@@ -0,0 +1,78 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+package me.lemire.integercompression.vector;
+
+import jdk.incubator.vector.IntVector;
+
+/**
+ * Width-specific vectorized bit-packing kernels for a 256-integer block.
+ * Implemented by VectorBitPacker (512-bit lanes), VectorBitPacker256 (256-bit
+ * lanes) and VectorBitPacker128 (128-bit lanes). The packed layout differs per
+ * width, so a stream is decoded by the same kernel that packed it.
+ */
+public interface VectorBitPackerKernels {
+
+ void fastpack(int[] in, int inpos, int[] out, int outpos, int b);
+
+ void fastpackNoMask(int[] in, int inpos, int[] out, int outpos, int b);
+
+ void fastunpack(int[] in, int inpos, int[] out, int outpos, int b);
+
+ /**
+ * Hardware vector lane width a stream was packed for. The packed byte layout
+ * differs per width and is not interchangeable across widths, so the stream
+ * carries its width (as {@link #code}) and is decoded by {@link #kernel}.
+ */
+ enum LaneWidth {
+ BITS_128(0, 128, new VectorBitPacker128()),
+ BITS_256(1, 256, new VectorBitPacker256()),
+ BITS_512(2, 512, new VectorBitPacker());
+
+ /** Compact wire tag stored in the stream (fits in 2 bits). */
+ public final int code;
+ /** Native vector lane width in bits. */
+ public final int bits;
+ /** Kernel that packs and unpacks at this width. */
+ public final VectorBitPackerKernels kernel;
+
+ LaneWidth(int code, int bits, VectorBitPackerKernels kernel) {
+ this.code = code;
+ this.bits = bits;
+ this.kernel = kernel;
+ }
+
+ /** Width whose kernel runs natively on this machine (encode default). */
+ public static final LaneWidth PREFERRED =
+ forHost(IntVector.SPECIES_PREFERRED.vectorBitSize());
+
+ /** Largest kernel width that runs natively on a machine of {@code hostBits}. */
+ public static LaneWidth forHost(int hostBits) {
+ LaneWidth best = null;
+ for (LaneWidth width : values()) {
+ if (width.bits <= hostBits && (best == null || width.bits > best.bits)) {
+ best = width;
+ }
+ }
+ if (best == null) {
+ throw new IllegalStateException(
+ "no vector bit-packing kernel fits this machine's preferred vector width of "
+ + hostBits + " bits");
+ }
+ return best;
+ }
+
+ /** Maps a stream wire tag back to its width. */
+ public static LaneWidth fromCode(int code) {
+ for (LaneWidth width : values()) {
+ if (width.code == code) {
+ return width;
+ }
+ }
+ throw new IllegalArgumentException("unknown vector lane-width tag " + code);
+ }
+ }
+}
diff --git a/src/main/java/me/lemire/integercompression/vector/VectorBitPackerTerse.java b/src/main/java/me/lemire/integercompression/vector/VectorBitPackerTerse.java
new file mode 100644
index 0000000..62a8cc7
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/vector/VectorBitPackerTerse.java
@@ -0,0 +1,963 @@
+// Copyright (C) 2022 Intel Corporation
+
+// SPDX-License-Identifier: Apache-2.0
+
+package me.lemire.integercompression.vector;
+
+import java.util.Arrays;
+import jdk.incubator.vector.*;
+
+/**
+ * This is a readable but less efficient version of the VectorBitPacker class.
+ *
+ */
+public class VectorBitPackerTerse {
+ static final VectorSpecies SPECIES_512 = IntVector.SPECIES_512;
+ static final VectorSpecies SPECIES_256 = IntVector.SPECIES_256;
+ static final int VLEN_512 = 16;
+ static final int VLEN_256 = 8;
+ static final int BLOCK_SIZE = 256;
+
+ private static void fastpackOddBit(final int[] in, int inpos, final int[] out,
+ int outpos, int b, final int[] ho,
+ final int[] lc) {
+ final int mask = (1 << b) - 1;
+ final int N = 31 / b;
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV.and(mask);
+ int n = 1;
+ for (; n <= N; n++) {
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + n * VLEN_256);
+ oV = iV.and(mask).lanewise(VectorOperators.LSHL, b * n).or(oV);
+ }
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ final int L = b - 1;
+ for (int i = 0; i < L; i++) {
+ oV = iV.and(mask).lanewise(VectorOperators.LSHR, ho[i]);
+ for (int j = 0; j < lc[i]; j++) {
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + n * VLEN_256);
+ oV = iV.and(mask)
+ .lanewise(VectorOperators.LSHL, b * j + (b - ho[i]))
+ .or(oV);
+ n++;
+ }
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+ }
+ }
+
+ private static void fastpackOddBitNoMask(final int[] in, int inpos,
+ final int[] out, int outpos, int b,
+ final int[] ho, final int[] lc) {
+ final int N = 31 / b;
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ var oV = iV;
+ int n = 1;
+ for (; n <= N; n++) {
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + n * VLEN_256);
+ oV = iV.lanewise(VectorOperators.LSHL, b * n).or(oV);
+ }
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+
+ final int L = b - 1;
+ for (int i = 0; i < L; i++) {
+ oV = iV.lanewise(VectorOperators.LSHR, ho[i]);
+ for (int j = 0; j < lc[i]; j++) {
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + n * VLEN_256);
+ oV = iV.lanewise(VectorOperators.LSHL, b * j + (b - ho[i])).or(oV);
+ n++;
+ }
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+ }
+ }
+
+ private static void fastUnpackOddBit(final int[] in, int inpos,
+ final int[] out, int outpos, int b,
+ final int[] lo, int[] masks, int[] lc) {
+ final int mask = (1 << b) - 1;
+ final int N = 32 / b;
+ var iV = IntVector.fromArray(SPECIES_256, in, inpos);
+ int n = 0;
+ for (; n < N; n++) {
+ iV.lanewise(VectorOperators.LSHR, b * n).and(mask).intoArray(out, outpos);
+ outpos += VLEN_256;
+ }
+ var oV = iV.lanewise(VectorOperators.LSHR, b * n).and(mask);
+
+ final int L = b - 1;
+ for (int i = 0; i < L; i++) {
+ iV = IntVector.fromArray(SPECIES_256, in, inpos + (i + 1) * VLEN_256);
+ oV = iV.and(masks[i]).lanewise(VectorOperators.LSHL, b - lo[i]).or(oV);
+ oV.intoArray(out, outpos);
+ outpos += VLEN_256;
+ int j = 0;
+ for (; j < lc[i]; j++) {
+ iV.lanewise(VectorOperators.LSHR, b * j + lo[i])
+ .and(mask)
+ .intoArray(out, outpos);
+ outpos += VLEN_256;
+ n++;
+ }
+ oV = iV.lanewise(VectorOperators.LSHR, b * j + lo[i]).and(mask);
+ }
+ }
+
+ private static void fastpackEvenBit(final int[] in, int inpos,
+ final int[] out, int outpos, int b,
+ final int[] ho, final int[] lc) {
+ final int mask = (1 << b) - 1;
+ final int N = 32 % b == 0 ? (32 / b) - 1 : 32 / b;
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV.and(mask);
+ int n = 1;
+ for (; n <= N; n++) {
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + n * VLEN_512);
+ oV = iV.and(mask).lanewise(VectorOperators.LSHL, b * n).or(oV);
+ }
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ final int L = (b >>> 1) - 1;
+ for (int i = 0; i < L; i++) {
+ if (ho[i] != b)
+ oV = iV.and(mask).lanewise(VectorOperators.LSHR, ho[i]);
+ else
+ oV = oV.zero(SPECIES_512);
+ for (int j = 0; j < lc[i]; j++) {
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + n * VLEN_512);
+ oV = iV.and(mask)
+ .lanewise(VectorOperators.LSHL, b * j + (b - ho[i]))
+ .or(oV);
+ n++;
+ }
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+ }
+
+ private static void fastpackEvenBitNoMask(final int[] in, int inpos,
+ final int[] out, int outpos, int b,
+ final int[] ho, final int[] lc) {
+ final int N = 32 % b == 0 ? (32 / b) - 1 : 32 / b;
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ var oV = iV;
+ int n = 1;
+ for (; n <= N; n++) {
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + n * VLEN_512);
+ oV = iV.lanewise(VectorOperators.LSHL, b * n).or(oV);
+ }
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+
+ final int L = (b >>> 1) - 1;
+ for (int i = 0; i < L; i++) {
+ if (ho[i] != b)
+ oV = iV.lanewise(VectorOperators.LSHR, ho[i]);
+ else
+ oV = oV.zero(SPECIES_512);
+ for (int j = 0; j < lc[i]; j++) {
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + n * VLEN_512);
+ oV = iV.lanewise(VectorOperators.LSHL, b * j + (b - ho[i])).or(oV);
+ n++;
+ }
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+ }
+
+ private static void fastUnpackEventBit(final int[] in, int inpos,
+ final int[] out, int outpos, int b,
+ final int[] lo, int[] masks,
+ int[] lc) {
+ final int mask = (1 << b) - 1;
+ final int N = 32 / b;
+ var iV = IntVector.fromArray(SPECIES_512, in, inpos);
+ int n = 0;
+ for (; n < N; n++) {
+ iV.lanewise(VectorOperators.LSHR, b * n).and(mask).intoArray(out, outpos);
+ outpos += VLEN_512;
+ }
+ var oV = iV.lanewise(VectorOperators.LSHR, b * n).and(mask);
+ if ((b & (b - 1)) == 0)
+ oV = oV.zero(SPECIES_512);
+
+ final int L = (b >>> 1) - 1;
+ for (int i = 0; i < L; i++) {
+ iV = IntVector.fromArray(SPECIES_512, in, inpos + (i + 1) * VLEN_512);
+ oV = iV.and(masks[i]).lanewise(VectorOperators.LSHL, b - lo[i]).or(oV);
+ oV.intoArray(out, outpos);
+ outpos += VLEN_512;
+ int j = 0;
+ for (; j < lc[i]; j++) {
+ iV.lanewise(VectorOperators.LSHR, b * j + lo[i])
+ .and(mask)
+ .intoArray(out, outpos);
+ outpos += VLEN_512;
+ n++;
+ }
+ if ((32 - lo[i]) % b != 0)
+ oV = iV.lanewise(VectorOperators.LSHR, b * j + lo[i]).and(mask);
+ else
+ oV = oV.zero(SPECIES_512);
+ }
+ }
+
+ public static int slowpack(final int[] in, int inpos, int inlen,
+ final int[] out, int outpos, int b) {
+ if (inlen == 0)
+ return outpos;
+ if (b == 32) {
+ System.arraycopy(in, inpos, out, outpos, inlen);
+ return outpos + inlen;
+ }
+ int mask = (1 << b) - 1;
+ int c = 0;
+ int l = 0;
+ int r = 0;
+ int val = 0;
+ for (int i = 0; i < inlen; i++) {
+ val = in[inpos + i] & mask;
+ out[outpos] |= val << (c + r);
+ c += b;
+ l = (32 - r) % b;
+ if (c + r >= 32) {
+ if (i < inlen - 1 || l != 0)
+ outpos++;
+ r = l == 0 ? 0 : b - l;
+ if (l != 0)
+ out[outpos] = val >> (b - r);
+ c = 0;
+ }
+ }
+ return outpos;
+ }
+
+ public static int slowunpack(final int[] in, int inpos, final int[] out,
+ int outpos, int outlen, int b) {
+ if (outlen == 0) {
+ return inpos;
+ }
+ if (b == 32) {
+ System.arraycopy(in, inpos, out, outpos, outlen);
+ return inpos + outlen;
+ }
+ int mask = (1 << b) - 1;
+ int limit = outpos + outlen;
+ int r = 0;
+ int val = 0;
+ int i = 0;
+ for (; outpos < limit; i++) {
+ if (r > 0)
+ out[outpos++] =
+ (val >>> (32 - (b - r))) | ((in[inpos + i] << (b - r)) & mask);
+ val = in[inpos + i];
+ int j = 0;
+ int l = 32 - r;
+ int ll = l % b == 0 ? l : l - b;
+ while (j < ll && outpos < limit) {
+ out[outpos++] = (val >> (j + r)) & mask;
+ j += b;
+ }
+ r = l % b == 0 ? 0 : b - (l % b);
+ }
+ return inpos + i;
+ }
+
+ public static int numCompressedInts(int n, int b) {
+ int width = b % 2 == 0 ? VLEN_512 : VLEN_256;
+ if (n <= width)
+ return n;
+ int intsPerVec = (32 / b) * width;
+ int q = (n + intsPerVec - 1) / intsPerVec;
+ return q * width;
+ }
+
+ public static void fastpack(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ break;
+ case 1:
+ fastpackOddBit(in, inpos, out, outpos, 1, new int[] {}, new int[] {});
+ break;
+ case 2:
+ fastpackEvenBit(in, inpos, out, outpos, 2, new int[] {}, new int[] {});
+ break;
+ case 3:
+ fastpackOddBit(in, inpos, out, outpos, 3, new int[] {0x2, 0x1},
+ new int[] {0xb, 0xa});
+ break;
+ case 4:
+ fastpackEvenBit(in, inpos, out, outpos, 4, new int[] {0x4},
+ new int[] {0x8});
+ break;
+ case 5:
+ fastpackOddBit(in, inpos, out, outpos, 5, new int[] {0x2, 0x4, 0x1, 0x3},
+ new int[] {0x6, 0x7, 0x6, 0x6});
+ break;
+ case 6:
+ fastpackEvenBit(in, inpos, out, outpos, 6, new int[] {0x2, 0x4},
+ new int[] {0x5, 0x5});
+ break;
+ case 7:
+ fastpackOddBit(in, inpos, out, outpos, 7,
+ new int[] {0x4, 0x1, 0x5, 0x2, 0x6, 0x3},
+ new int[] {0x5, 0x4, 0x5, 0x4, 0x5, 0x4});
+ break;
+ case 8:
+ fastpackEvenBit(in, inpos, out, outpos, 8, new int[] {0x8, 0x8, 0x8},
+ new int[] {0x4, 0x4, 0x4});
+ break;
+ case 9:
+ fastpackOddBit(in, inpos, out, outpos, 9,
+ new int[] {0x5, 0x1, 0x6, 0x2, 0x7, 0x3, 0x8, 0x4},
+ new int[] {0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3});
+ break;
+ case 10:
+ fastpackEvenBit(in, inpos, out, outpos, 10,
+ new int[] {0x2, 0x4, 0x6, 0x8},
+ new int[] {0x3, 0x3, 0x3, 0x3});
+ break;
+ case 11:
+ fastpackOddBit(
+ in, inpos, out, outpos, 11,
+ new int[] {0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1},
+ new int[] {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x2});
+ break;
+ case 12:
+ fastpackEvenBit(in, inpos, out, outpos, 12,
+ new int[] {0x8, 0x4, 0xc, 0x8, 0x4},
+ new int[] {0x3, 0x2, 0x3, 0x3, 0x2});
+ break;
+ case 13:
+ fastpackOddBit(in, inpos, out, outpos, 13,
+ new int[] {0x6, 0xc, 0x5, 0xb, 0x4, 0xa, 0x3, 0x9, 0x2,
+ 0x8, 0x1, 0x7},
+ new int[] {0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2,
+ 0x3, 0x2, 0x2});
+ break;
+ case 14:
+ fastpackEvenBit(in, inpos, out, outpos, 14,
+ new int[] {0x4, 0x8, 0xc, 0x2, 0x6, 0xa},
+ new int[] {0x2, 0x2, 0x3, 0x2, 0x2, 0x2});
+ break;
+ case 15:
+ fastpackOddBit(in, inpos, out, outpos, 15,
+ new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x1, 0x3,
+ 0x5, 0x7, 0x9, 0xb, 0xd},
+ new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x2, 0x2,
+ 0x2, 0x2, 0x2, 0x2, 0x2});
+ break;
+ case 16:
+ fastpackEvenBit(in, inpos, out, outpos, 16,
+ new int[] {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10},
+ new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2});
+ break;
+ case 17:
+ fastpackOddBit(in, inpos, out, outpos, 17,
+ new int[] {0xf, 0xd, 0xb, 0x9, 0x7, 0x5, 0x3, 0x1, 0x10,
+ 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2},
+ new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2,
+ 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1});
+ break;
+ case 18:
+ fastpackEvenBit(in, inpos, out, outpos, 18,
+ new int[] {0xe, 0xa, 0x6, 0x2, 0x10, 0xc, 0x8, 0x4},
+ new int[] {0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x1});
+ break;
+ case 19:
+ fastpackOddBit(in, inpos, out, outpos, 19,
+ new int[] {0xd, 0x7, 0x1, 0xe, 0x8, 0x2, 0xf, 0x9, 0x3,
+ 0x10, 0xa, 0x4, 0x11, 0xb, 0x5, 0x12, 0xc, 0x6},
+ new int[] {0x2, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x1,
+ 0x2, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x1});
+ break;
+ case 20:
+ fastpackEvenBit(
+ in, inpos, out, outpos, 20,
+ new int[] {0xc, 0x4, 0x10, 0x8, 0x14, 0xc, 0x4, 0x10, 0x8},
+ new int[] {0x2, 0x1, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x1});
+ break;
+ case 21:
+ fastpackOddBit(
+ in, inpos, out, outpos, 21,
+ new int[] {0xb, 0x1, 0xc, 0x2, 0xd, 0x3, 0xe, 0x4, 0xf, 0x5,
+ 0x10, 0x6, 0x11, 0x7, 0x12, 0x8, 0x13, 0x9, 0x14, 0xa},
+ new int[] {0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1,
+ 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1});
+ break;
+ case 22:
+ fastpackEvenBit(
+ in, inpos, out, outpos, 22,
+ new int[] {0xa, 0x14, 0x8, 0x12, 0x6, 0x10, 0x4, 0xe, 0x2, 0xc},
+ new int[] {0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x1});
+ break;
+ case 23:
+ fastpackOddBit(in, inpos, out, outpos, 23,
+ new int[] {0x9, 0x12, 0x4, 0xd, 0x16, 0x8, 0x11, 0x3,
+ 0xc, 0x15, 0x7, 0x10, 0x2, 0xb, 0x14, 0x6,
+ 0xf, 0x1, 0xa, 0x13, 0x5, 0xe},
+ new int[] {0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1,
+ 0x1, 0x2, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1,
+ 0x2, 0x1, 0x1, 0x2, 0x1, 0x1});
+ break;
+ case 24:
+ fastpackEvenBit(
+ in, inpos, out, outpos, 24,
+ new int[] {0x8, 0x10, 0x18, 0x8, 0x10, 0x18, 0x8, 0x10, 0x18, 0x8,
+ 0x10},
+ new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1});
+ break;
+ case 25:
+ fastpackOddBit(in, inpos, out, outpos, 25,
+ new int[] {0x7, 0xe, 0x15, 0x3, 0xa, 0x11, 0x18, 0x6,
+ 0xd, 0x14, 0x2, 0x9, 0x10, 0x17, 0x5, 0xc,
+ 0x13, 0x1, 0x8, 0xf, 0x16, 0x4, 0xb, 0x12},
+ new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1,
+ 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1,
+ 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1});
+ break;
+ case 26:
+ fastpackEvenBit(in, inpos, out, outpos, 26,
+ new int[] {0x6, 0xc, 0x12, 0x18, 0x4, 0xa, 0x10, 0x16,
+ 0x2, 0x8, 0xe, 0x14},
+ new int[] {0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1,
+ 0x1, 0x1, 0x1});
+ break;
+ case 27:
+ fastpackOddBit(in, inpos, out, outpos, 27,
+ new int[] {0x5, 0xa, 0xf, 0x14, 0x19, 0x3, 0x8,
+ 0xd, 0x12, 0x17, 0x1, 0x6, 0xb, 0x10,
+ 0x15, 0x1a, 0x4, 0x9, 0xe, 0x13, 0x18,
+ 0x2, 0x7, 0xc, 0x11, 0x16},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1,
+ 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1,
+ 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 28:
+ fastpackEvenBit(in, inpos, out, outpos, 28,
+ new int[] {0x4, 0x8, 0xc, 0x10, 0x14, 0x18, 0x1c, 0x4,
+ 0x8, 0xc, 0x10, 0x14, 0x18},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 29:
+ fastpackOddBit(
+ in, inpos, out, outpos, 29,
+ new int[] {0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x18, 0x1b, 0x1,
+ 0x4, 0x7, 0xa, 0xd, 0x10, 0x13, 0x16, 0x19, 0x1c, 0x2,
+ 0x5, 0x8, 0xb, 0xe, 0x11, 0x14, 0x17, 0x1a},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 30:
+ fastpackEvenBit(in, inpos, out, outpos, 30,
+ new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12,
+ 0x14, 0x16, 0x18, 0x1a, 0x1c},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 31:
+ fastpackOddBit(in, inpos, out, outpos, 31,
+ new int[] {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
+ 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10,
+ 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+ 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, 256);
+ break;
+ }
+ }
+
+ public static void fastpackNoMask(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ break;
+ case 1:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 1, new int[] {},
+ new int[] {});
+ break;
+ case 2:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 2, new int[] {},
+ new int[] {});
+ break;
+ case 3:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 3, new int[] {0x2, 0x1},
+ new int[] {0xb, 0xa});
+ break;
+ case 4:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 4, new int[] {0x4},
+ new int[] {0x8});
+ break;
+ case 5:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 5,
+ new int[] {0x2, 0x4, 0x1, 0x3},
+ new int[] {0x6, 0x7, 0x6, 0x6});
+ break;
+ case 6:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 6, new int[] {0x2, 0x4},
+ new int[] {0x5, 0x5});
+ break;
+ case 7:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 7,
+ new int[] {0x4, 0x1, 0x5, 0x2, 0x6, 0x3},
+ new int[] {0x5, 0x4, 0x5, 0x4, 0x5, 0x4});
+ break;
+ case 8:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 8,
+ new int[] {0x8, 0x8, 0x8},
+ new int[] {0x4, 0x4, 0x4});
+ break;
+ case 9:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 9,
+ new int[] {0x5, 0x1, 0x6, 0x2, 0x7, 0x3, 0x8, 0x4},
+ new int[] {0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3});
+ break;
+ case 10:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 10,
+ new int[] {0x2, 0x4, 0x6, 0x8},
+ new int[] {0x3, 0x3, 0x3, 0x3});
+ break;
+ case 11:
+ fastpackOddBitNoMask(
+ in, inpos, out, outpos, 11,
+ new int[] {0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1},
+ new int[] {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x2});
+ break;
+ case 12:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 12,
+ new int[] {0x8, 0x4, 0xc, 0x8, 0x4},
+ new int[] {0x3, 0x2, 0x3, 0x3, 0x2});
+ break;
+ case 13:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 13,
+ new int[] {0x6, 0xc, 0x5, 0xb, 0x4, 0xa, 0x3, 0x9,
+ 0x2, 0x8, 0x1, 0x7},
+ new int[] {0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3,
+ 0x2, 0x3, 0x2, 0x2});
+ break;
+ case 14:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 14,
+ new int[] {0x4, 0x8, 0xc, 0x2, 0x6, 0xa},
+ new int[] {0x2, 0x2, 0x3, 0x2, 0x2, 0x2});
+ break;
+ case 15:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 15,
+ new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x1,
+ 0x3, 0x5, 0x7, 0x9, 0xb, 0xd},
+ new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x2, 0x2, 0x2});
+ break;
+ case 16:
+ fastpackEvenBitNoMask(
+ in, inpos, out, outpos, 16,
+ new int[] {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10},
+ new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2});
+ break;
+ case 17:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 17,
+ new int[] {0xf, 0xd, 0xb, 0x9, 0x7, 0x5, 0x3, 0x1,
+ 0x10, 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2},
+ new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1,
+ 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1});
+ break;
+ case 18:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 18,
+ new int[] {0xe, 0xa, 0x6, 0x2, 0x10, 0xc, 0x8, 0x4},
+ new int[] {0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x1});
+ break;
+ case 19:
+ fastpackOddBitNoMask(
+ in, inpos, out, outpos, 19,
+ new int[] {0xd, 0x7, 0x1, 0xe, 0x8, 0x2, 0xf, 0x9, 0x3, 0x10, 0xa,
+ 0x4, 0x11, 0xb, 0x5, 0x12, 0xc, 0x6},
+ new int[] {0x2, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x1,
+ 0x2, 0x2, 0x1, 0x2, 0x2, 0x1});
+ break;
+ case 20:
+ fastpackEvenBitNoMask(
+ in, inpos, out, outpos, 20,
+ new int[] {0xc, 0x4, 0x10, 0x8, 0x14, 0xc, 0x4, 0x10, 0x8},
+ new int[] {0x2, 0x1, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x1});
+ break;
+ case 21:
+ fastpackOddBitNoMask(
+ in, inpos, out, outpos, 21,
+ new int[] {0xb, 0x1, 0xc, 0x2, 0xd, 0x3, 0xe, 0x4, 0xf, 0x5,
+ 0x10, 0x6, 0x11, 0x7, 0x12, 0x8, 0x13, 0x9, 0x14, 0xa},
+ new int[] {0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1,
+ 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1});
+ break;
+ case 22:
+ fastpackEvenBitNoMask(
+ in, inpos, out, outpos, 22,
+ new int[] {0xa, 0x14, 0x8, 0x12, 0x6, 0x10, 0x4, 0xe, 0x2, 0xc},
+ new int[] {0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x1});
+ break;
+ case 23:
+ fastpackOddBitNoMask(
+ in, inpos, out, outpos, 23,
+ new int[] {0x9, 0x12, 0x4, 0xd, 0x16, 0x8, 0x11, 0x3,
+ 0xc, 0x15, 0x7, 0x10, 0x2, 0xb, 0x14, 0x6,
+ 0xf, 0x1, 0xa, 0x13, 0x5, 0xe},
+ new int[] {0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1,
+ 0x2, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1});
+ break;
+ case 24:
+ fastpackEvenBitNoMask(
+ in, inpos, out, outpos, 24,
+ new int[] {0x8, 0x10, 0x18, 0x8, 0x10, 0x18, 0x8, 0x10, 0x18, 0x8,
+ 0x10},
+ new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1});
+ break;
+ case 25:
+ fastpackOddBitNoMask(in, inpos, out, outpos, 25,
+ new int[] {0x7, 0xe, 0x15, 0x3, 0xa, 0x11,
+ 0x18, 0x6, 0xd, 0x14, 0x2, 0x9,
+ 0x10, 0x17, 0x5, 0xc, 0x13, 0x1,
+ 0x8, 0xf, 0x16, 0x4, 0xb, 0x12},
+ new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1,
+ 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1,
+ 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1});
+ break;
+ case 26:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 26,
+ new int[] {0x6, 0xc, 0x12, 0x18, 0x4, 0xa, 0x10,
+ 0x16, 0x2, 0x8, 0xe, 0x14},
+ new int[] {0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x2,
+ 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 27:
+ fastpackOddBitNoMask(
+ in, inpos, out, outpos, 27,
+ new int[] {0x5, 0xa, 0xf, 0x14, 0x19, 0x3, 0x8, 0xd, 0x12,
+ 0x17, 0x1, 0x6, 0xb, 0x10, 0x15, 0x1a, 0x4, 0x9,
+ 0xe, 0x13, 0x18, 0x2, 0x7, 0xc, 0x11, 0x16},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1,
+ 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1,
+ 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 28:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 28,
+ new int[] {0x4, 0x8, 0xc, 0x10, 0x14, 0x18, 0x1c,
+ 0x4, 0x8, 0xc, 0x10, 0x14, 0x18},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 29:
+ fastpackOddBitNoMask(
+ in, inpos, out, outpos, 29,
+ new int[] {0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x18, 0x1b, 0x1,
+ 0x4, 0x7, 0xa, 0xd, 0x10, 0x13, 0x16, 0x19, 0x1c, 0x2,
+ 0x5, 0x8, 0xb, 0xe, 0x11, 0x14, 0x17, 0x1a},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 30:
+ fastpackEvenBitNoMask(in, inpos, out, outpos, 30,
+ new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10,
+ 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 31:
+ fastpackOddBitNoMask(
+ in, inpos, out, outpos, 31,
+ new int[] {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
+ 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10,
+ 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+ 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, 256);
+ break;
+ }
+ }
+
+ public static void fastunpack(final int[] in, int inpos, final int[] out,
+ int outpos, int b) {
+ switch (b) {
+ case 0:
+ Arrays.fill(out, outpos, outpos + 256, 0);
+ break;
+ case 1:
+ fastUnpackOddBit(in, inpos, out, outpos, 1, new int[] {}, new int[] {},
+ new int[] {});
+ break;
+ case 2:
+ fastUnpackEventBit(in, inpos, out, outpos, 2, new int[] {}, new int[] {},
+ new int[] {});
+ break;
+ case 3:
+ fastUnpackOddBit(in, inpos, out, outpos, 3, new int[] {0x1, 0x2},
+ new int[] {0x1, 0x3}, new int[] {0xa, 0xa});
+ break;
+ case 4:
+ fastUnpackEventBit(in, inpos, out, outpos, 4, new int[] {0x4},
+ new int[] {0xf}, new int[] {0x7});
+ break;
+ case 5:
+ fastUnpackOddBit(
+ in, inpos, out, outpos, 5, new int[] {0x3, 0x1, 0x4, 0x2},
+ new int[] {0x7, 0x1, 0xf, 0x3}, new int[] {0x5, 0x6, 0x5, 0x6});
+ break;
+ case 6:
+ fastUnpackEventBit(in, inpos, out, outpos, 6, new int[] {0x4, 0x2},
+ new int[] {0xf, 0x3}, new int[] {0x4, 0x5});
+ break;
+ case 7:
+ fastUnpackOddBit(in, inpos, out, outpos, 7,
+ new int[] {0x3, 0x6, 0x2, 0x5, 0x1, 0x4},
+ new int[] {0x7, 0x3f, 0x3, 0x1f, 0x1, 0xf},
+ new int[] {0x4, 0x3, 0x4, 0x3, 0x4, 0x4});
+ break;
+ case 8:
+ fastUnpackEventBit(in, inpos, out, outpos, 8, new int[] {0x8, 0x8, 0x8},
+ new int[] {0xff, 0xff, 0xff},
+ new int[] {0x3, 0x3, 0x3});
+ break;
+ case 9:
+ fastUnpackOddBit(in, inpos, out, outpos, 9,
+ new int[] {0x4, 0x8, 0x3, 0x7, 0x2, 0x6, 0x1, 0x5},
+ new int[] {0xf, 0xff, 0x7, 0x7f, 0x3, 0x3f, 0x1, 0x1f},
+ new int[] {0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3});
+ break;
+ case 10:
+ fastUnpackEventBit(
+ in, inpos, out, outpos, 10, new int[] {0x8, 0x6, 0x4, 0x2},
+ new int[] {0xff, 0x3f, 0xf, 0x3}, new int[] {0x2, 0x2, 0x2, 0x3});
+ break;
+ case 11:
+ fastUnpackOddBit(
+ in, inpos, out, outpos, 11,
+ new int[] {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa},
+ new int[] {0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff},
+ new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2});
+ break;
+ case 12:
+ fastUnpackEventBit(in, inpos, out, outpos, 12,
+ new int[] {0x4, 0x8, 0xc, 0x4, 0x8},
+ new int[] {0xf, 0xff, 0xfff, 0xf, 0xff},
+ new int[] {0x2, 0x2, 0x1, 0x2, 0x2});
+ break;
+ case 13:
+ fastUnpackOddBit(in, inpos, out, outpos, 13,
+ new int[] {0x7, 0x1, 0x8, 0x2, 0x9, 0x3, 0xa, 0x4, 0xb,
+ 0x5, 0xc, 0x6},
+ new int[] {0x7f, 0x1, 0xff, 0x3, 0x1ff, 0x7, 0x3ff, 0xf,
+ 0x7ff, 0x1f, 0xfff, 0x3f},
+ new int[] {0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1,
+ 0x2, 0x1, 0x2});
+ break;
+ case 14:
+ fastUnpackEventBit(in, inpos, out, outpos, 14,
+ new int[] {0xa, 0x6, 0x2, 0xc, 0x8, 0x4},
+ new int[] {0x3ff, 0x3f, 0x3, 0xfff, 0xff, 0xf},
+ new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x2});
+ break;
+ case 15:
+ fastUnpackOddBit(in, inpos, out, outpos, 15,
+ new int[] {0xd, 0xb, 0x9, 0x7, 0x5, 0x3, 0x1, 0xe, 0xc,
+ 0xa, 0x8, 0x6, 0x4, 0x2},
+ new int[] {0x1fff, 0x7ff, 0x1ff, 0x7f, 0x1f, 0x7, 0x1,
+ 0x3fff, 0xfff, 0x3ff, 0xff, 0x3f, 0xf, 0x3},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x2});
+ break;
+ case 16:
+ fastUnpackEventBit(
+ in, inpos, out, outpos, 16,
+ new int[] {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10},
+ new int[] {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 17:
+ fastUnpackOddBit(in, inpos, out, outpos, 17,
+ new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x1,
+ 0x3, 0x5, 0x7, 0x9, 0xb, 0xd, 0xf},
+ new int[] {0x3, 0xf, 0x3f, 0xff, 0x3ff, 0xfff, 0x3fff,
+ 0xffff, 0x1, 0x7, 0x1f, 0x7f, 0x1ff, 0x7ff,
+ 0x1fff, 0x7fff},
+ new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1,
+ 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 18:
+ fastUnpackEventBit(
+ in, inpos, out, outpos, 18,
+ new int[] {0x4, 0x8, 0xc, 0x10, 0x2, 0x6, 0xa, 0xe},
+ new int[] {0xf, 0xff, 0xfff, 0xffff, 0x3, 0x3f, 0x3ff, 0x3fff},
+ new int[] {0x1, 0x1, 0x1, 0x0, 0x1, 0x1, 0x1, 0x1});
+ break;
+ case 19:
+ fastUnpackOddBit(in, inpos, out, outpos, 19,
+ new int[] {0x6, 0xc, 0x12, 0x5, 0xb, 0x11, 0x4, 0xa,
+ 0x10, 0x3, 0x9, 0xf, 0x2, 0x8, 0xe, 0x1, 0x7,
+ 0xd},
+ new int[] {0x3f, 0xfff, 0x3ffff, 0x1f, 0x7ff, 0x1ffff,
+ 0xf, 0x3ff, 0xffff, 0x7, 0x1ff, 0x7fff, 0x3,
+ 0xff, 0x3fff, 0x1, 0x7f, 0x1fff},
+ new int[] {0x1, 0x1, 0x0, 0x1, 0x1, 0x0, 0x1, 0x1, 0x0,
+ 0x1, 0x1, 0x0, 0x1, 0x1, 0x0, 0x1, 0x1, 0x1});
+ break;
+ case 20:
+ fastUnpackEventBit(
+ in, inpos, out, outpos, 20,
+ new int[] {0x8, 0x10, 0x4, 0xc, 0x14, 0x8, 0x10, 0x4, 0xc},
+ new int[] {0xff, 0xffff, 0xf, 0xfff, 0xfffff, 0xff, 0xffff, 0xf,
+ 0xfff},
+ new int[] {0x1, 0x0, 0x1, 0x1, 0x0, 0x1, 0x0, 0x1, 0x1});
+ break;
+ case 21:
+ fastUnpackOddBit(
+ in, inpos, out, outpos, 21,
+ new int[] {0xa, 0x14, 0x9, 0x13, 0x8, 0x12, 0x7, 0x11, 0x6, 0x10,
+ 0x5, 0xf, 0x4, 0xe, 0x3, 0xd, 0x2, 0xc, 0x1, 0xb},
+ new int[] {0x3ff, 0xfffff, 0x1ff, 0x7ffff, 0xff, 0x3ffff, 0x7f,
+ 0x1ffff, 0x3f, 0xffff, 0x1f, 0x7fff, 0xf, 0x3fff,
+ 0x7, 0x1fff, 0x3, 0xfff, 0x1, 0x7ff},
+ new int[] {0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0,
+ 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x1});
+ break;
+ case 22:
+ fastUnpackEventBit(
+ in, inpos, out, outpos, 22,
+ new int[] {0xc, 0x2, 0xe, 0x4, 0x10, 0x6, 0x12, 0x8, 0x14, 0xa},
+ new int[] {0xfff, 0x3, 0x3fff, 0xf, 0xffff, 0x3f, 0x3ffff, 0xff,
+ 0xfffff, 0x3ff},
+ new int[] {0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1});
+ break;
+ case 23:
+ fastUnpackOddBit(
+ in, inpos, out, outpos, 23,
+ new int[] {0xe, 0x5, 0x13, 0xa, 0x1, 0xf, 0x6, 0x14,
+ 0xb, 0x2, 0x10, 0x7, 0x15, 0xc, 0x3, 0x11,
+ 0x8, 0x16, 0xd, 0x4, 0x12, 0x9},
+ new int[] {0x3fff, 0x1f, 0x7ffff, 0x3ff, 0x1, 0x7fff,
+ 0x3f, 0xfffff, 0x7ff, 0x3, 0xffff, 0x7f,
+ 0x1fffff, 0xfff, 0x7, 0x1ffff, 0xff, 0x3fffff,
+ 0x1fff, 0xf, 0x3ffff, 0x1ff},
+ new int[] {0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0, 0x1, 0x0,
+ 0x1, 0x0, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x1});
+ break;
+ case 24:
+ fastUnpackEventBit(
+ in, inpos, out, outpos, 24,
+ new int[] {0x10, 0x8, 0x18, 0x10, 0x8, 0x18, 0x10, 0x8, 0x18, 0x10,
+ 0x8},
+ new int[] {0xffff, 0xff, 0xffffff, 0xffff, 0xff, 0xffffff, 0xffff,
+ 0xff, 0xffffff, 0xffff, 0xff},
+ new int[] {0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x0, 0x1});
+ break;
+ case 25:
+ fastUnpackOddBit(
+ in, inpos, out, outpos, 25,
+ new int[] {0x12, 0xb, 0x4, 0x16, 0xf, 0x8, 0x1, 0x13,
+ 0xc, 0x5, 0x17, 0x10, 0x9, 0x2, 0x14, 0xd,
+ 0x6, 0x18, 0x11, 0xa, 0x3, 0x15, 0xe, 0x7},
+ new int[] {0x3ffff, 0x7ff, 0xf, 0x3fffff, 0x7fff, 0xff,
+ 0x1, 0x7ffff, 0xfff, 0x1f, 0x7fffff, 0xffff,
+ 0x1ff, 0x3, 0xfffff, 0x1fff, 0x3f, 0xffffff,
+ 0x1ffff, 0x3ff, 0x7, 0x1fffff, 0x3fff, 0x7f},
+ new int[] {0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0,
+ 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0,
+ 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x1});
+ break;
+ case 26:
+ fastUnpackEventBit(in, inpos, out, outpos, 26,
+ new int[] {0x14, 0xe, 0x8, 0x2, 0x16, 0x10, 0xa, 0x4,
+ 0x18, 0x12, 0xc, 0x6},
+ new int[] {0xfffff, 0x3fff, 0xff, 0x3, 0x3fffff,
+ 0xffff, 0x3ff, 0xf, 0xffffff, 0x3ffff,
+ 0xfff, 0x3f},
+ new int[] {0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0,
+ 0x0, 0x0, 0x1});
+ break;
+ case 27:
+ fastUnpackOddBit(
+ in, inpos, out, outpos, 27,
+ new int[] {0x16, 0x11, 0xc, 0x7, 0x2, 0x18, 0x13, 0xe, 0x9,
+ 0x4, 0x1a, 0x15, 0x10, 0xb, 0x6, 0x1, 0x17, 0x12,
+ 0xd, 0x8, 0x3, 0x19, 0x14, 0xf, 0xa, 0x5},
+ new int[] {0x3fffff, 0x1ffff, 0xfff, 0x7f, 0x3, 0xffffff,
+ 0x7ffff, 0x3fff, 0x1ff, 0xf, 0x3ffffff, 0x1fffff,
+ 0xffff, 0x7ff, 0x3f, 0x1, 0x7fffff, 0x3ffff,
+ 0x1fff, 0xff, 0x7, 0x1ffffff, 0xfffff, 0x7fff,
+ 0x3ff, 0x1f},
+ new int[] {0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0,
+ 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0,
+ 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1});
+ break;
+ case 28:
+ fastUnpackEventBit(in, inpos, out, outpos, 28,
+ new int[] {0x18, 0x14, 0x10, 0xc, 0x8, 0x4, 0x1c, 0x18,
+ 0x14, 0x10, 0xc, 0x8, 0x4},
+ new int[] {0xffffff, 0xfffff, 0xffff, 0xfff, 0xff, 0xf,
+ 0xfffffff, 0xffffff, 0xfffff, 0xffff, 0xfff,
+ 0xff, 0xf},
+ new int[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x1});
+ break;
+ case 29:
+ fastUnpackOddBit(
+ in, inpos, out, outpos, 29,
+ new int[] {0x1a, 0x17, 0x14, 0x11, 0xe, 0xb, 0x8, 0x5, 0x2, 0x1c,
+ 0x19, 0x16, 0x13, 0x10, 0xd, 0xa, 0x7, 0x4, 0x1, 0x1b,
+ 0x18, 0x15, 0x12, 0xf, 0xc, 0x9, 0x6, 0x3},
+ new int[] {0x3ffffff, 0x7fffff, 0xfffff, 0x1ffff, 0x3fff,
+ 0x7ff, 0xff, 0x1f, 0x3, 0xfffffff,
+ 0x1ffffff, 0x3fffff, 0x7ffff, 0xffff, 0x1fff,
+ 0x3ff, 0x7f, 0xf, 0x1, 0x7ffffff,
+ 0xffffff, 0x1fffff, 0x3ffff, 0x7fff, 0xfff,
+ 0x1ff, 0x3f, 0x7},
+ new int[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1});
+ break;
+ case 30:
+ fastUnpackEventBit(in, inpos, out, outpos, 30,
+ new int[] {0x1c, 0x1a, 0x18, 0x16, 0x14, 0x12, 0x10,
+ 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2},
+ new int[] {0xfffffff, 0x3ffffff, 0xffffff, 0x3fffff,
+ 0xfffff, 0x3ffff, 0xffff, 0x3fff, 0xfff,
+ 0x3ff, 0xff, 0x3f, 0xf, 0x3},
+ new int[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1});
+ break;
+ case 31:
+ fastUnpackOddBit(
+ in, inpos, out, outpos, 31,
+ new int[] {0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x15,
+ 0x14, 0x13, 0x12, 0x11, 0x10, 0xf, 0xe, 0xd, 0xc, 0xb,
+ 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1},
+ new int[] {0x3fffffff, 0x1fffffff, 0xfffffff, 0x7ffffff, 0x3ffffff,
+ 0x1ffffff, 0xffffff, 0x7fffff, 0x3fffff, 0x1fffff,
+ 0xfffff, 0x7ffff, 0x3ffff, 0x1ffff, 0xffff,
+ 0x7fff, 0x3fff, 0x1fff, 0xfff, 0x7ff,
+ 0x3ff, 0x1ff, 0xff, 0x7f, 0x3f,
+ 0x1f, 0xf, 0x7, 0x3, 0x1},
+ new int[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1});
+ break;
+
+ case 32:
+ System.arraycopy(in, inpos, out, outpos, 256);
+ break;
+ }
+ }
+}
diff --git a/src/main/java/me/lemire/integercompression/vector/VectorFastPFOR.java b/src/main/java/me/lemire/integercompression/vector/VectorFastPFOR.java
new file mode 100644
index 0000000..cc755c8
--- /dev/null
+++ b/src/main/java/me/lemire/integercompression/vector/VectorFastPFOR.java
@@ -0,0 +1,486 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ * (c) Intel Corp. (for Vector implementation)
+ */
+package me.lemire.integercompression.vector;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import me.lemire.integercompression.IntegerCODEC;
+import me.lemire.integercompression.SkippableIntegerCODEC;
+import me.lemire.integercompression.IntWrapper;
+import me.lemire.integercompression.vector.VectorBitPackerKernels.LaneWidth;
+
+/**
+ * This is a patching scheme designed for speed.
+ * It encodes integers in blocks of integers within pages of
+ * up to 65536 integers. Note that it is important, to get good
+ * compression and good performance, to use sizeable arrays (greater than 1024
+ * integers). For arrays containing a number of integers that is not divisible
+ * by BLOCK_SIZE, you should use it in conjunction with another CODEC:
+ *
+ * IntegerCODEC ic = new Composition(new VectorFastPFOR(), new VariableByte()).
+ *