BitPacking.java

/**
 * 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;

import java.util.Arrays;

/**
 * Bitpacking routines
 * 
 * <p>For details, please see</p>
 * <p>
 * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second
 * through vectorization Software: Practice &amp; Experience
 * <a href="http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract">http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract</a>
 * <a href="http://arxiv.org/abs/1209.2137">http://arxiv.org/abs/1209.2137</a>
 * </p>
 * 
 * @author Daniel Lemire
 * 
 */
public final class BitPacking {

        /**
         * Pack 32 integers
         * 
         * @param in
         *                source array
         * @param inpos
         *                position in source array
         * @param out
         *                output array
         * @param outpos
         *                position in output array
         * @param bit
         *                number of bits to use per integer
         */
        public static void fastpack(final int[] in, final int inpos,
                final int[] out, final int outpos, final int bit) {
                switch (bit) {
                case 0:
                        fastpack0(in, inpos, out, outpos);
                        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:
                        fastpack32(in, inpos, out, outpos);
                        break;
                default:
                        throw new IllegalArgumentException(
                                "Unsupported bit width.");
                        /**
                         * @param in
                         * @param inpos
                         * @param out
                         * @param outpos
                         * @param bit
                         */
                }
        }

        protected static void fastpack0(final int[] in, int inpos,
                final int[] out, int outpos) {
                // nothing
        }

        protected static void fastpack1(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 1)
                        | ((in[1 + inpos] & 1) << 1)
                        | ((in[2 + inpos] & 1) << 2)
                        | ((in[3 + inpos] & 1) << 3)
                        | ((in[4 + inpos] & 1) << 4)
                        | ((in[5 + inpos] & 1) << 5)
                        | ((in[6 + inpos] & 1) << 6)
                        | ((in[7 + inpos] & 1) << 7)
                        | ((in[8 + inpos] & 1) << 8)
                        | ((in[9 + inpos] & 1) << 9)
                        | ((in[10 + inpos] & 1) << 10)
                        | ((in[11 + inpos] & 1) << 11)
                        | ((in[12 + inpos] & 1) << 12)
                        | ((in[13 + inpos] & 1) << 13)
                        | ((in[14 + inpos] & 1) << 14)
                        | ((in[15 + inpos] & 1) << 15)
                        | ((in[16 + inpos] & 1) << 16)
                        | ((in[17 + inpos] & 1) << 17)
                        | ((in[18 + inpos] & 1) << 18)
                        | ((in[19 + inpos] & 1) << 19)
                        | ((in[20 + inpos] & 1) << 20)
                        | ((in[21 + inpos] & 1) << 21)
                        | ((in[22 + inpos] & 1) << 22)
                        | ((in[23 + inpos] & 1) << 23)
                        | ((in[24 + inpos] & 1) << 24)
                        | ((in[25 + inpos] & 1) << 25)
                        | ((in[26 + inpos] & 1) << 26)
                        | ((in[27 + inpos] & 1) << 27)
                        | ((in[28 + inpos] & 1) << 28)
                        | ((in[29 + inpos] & 1) << 29)
                        | ((in[30 + inpos] & 1) << 30)
                        | ((in[31 + inpos]) << 31);
        }

        protected static void fastpack10(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 1023)
                        | ((in[1 + inpos] & 1023) << 10)
                        | ((in[2 + inpos] & 1023) << 20)
                        | ((in[3 + inpos]) << 30);
                out[1 + outpos] = ((in[3 + inpos] & 1023) >>> (10 - 8))
                        | ((in[4 + inpos] & 1023) << 8)
                        | ((in[5 + inpos] & 1023) << 18)
                        | ((in[6 + inpos]) << 28);
                out[2 + outpos] = ((in[6 + inpos] & 1023) >>> (10 - 6))
                        | ((in[7 + inpos] & 1023) << 6)
                        | ((in[8 + inpos] & 1023) << 16)
                        | ((in[9 + inpos]) << 26);
                out[3 + outpos] = ((in[9 + inpos] & 1023) >>> (10 - 4))
                        | ((in[10 + inpos] & 1023) << 4)
                        | ((in[11 + inpos] & 1023) << 14)
                        | ((in[12 + inpos]) << 24);
                out[4 + outpos] = ((in[12 + inpos] & 1023) >>> (10 - 2))
                        | ((in[13 + inpos] & 1023) << 2)
                        | ((in[14 + inpos] & 1023) << 12)
                        | ((in[15 + inpos]) << 22);
                out[5 + outpos] = (in[16 + inpos] & 1023)
                        | ((in[17 + inpos] & 1023) << 10)
                        | ((in[18 + inpos] & 1023) << 20)
                        | ((in[19 + inpos]) << 30);
                out[6 + outpos] = ((in[19 + inpos] & 1023) >>> (10 - 8))
                        | ((in[20 + inpos] & 1023) << 8)
                        | ((in[21 + inpos] & 1023) << 18)
                        | ((in[22 + inpos]) << 28);
                out[7 + outpos] = ((in[22 + inpos] & 1023) >>> (10 - 6))
                        | ((in[23 + inpos] & 1023) << 6)
                        | ((in[24 + inpos] & 1023) << 16)
                        | ((in[25 + inpos]) << 26);
                out[8 + outpos] = ((in[25 + inpos] & 1023) >>> (10 - 4))
                        | ((in[26 + inpos] & 1023) << 4)
                        | ((in[27 + inpos] & 1023) << 14)
                        | ((in[28 + inpos]) << 24);
                out[9 + outpos] = ((in[28 + inpos] & 1023) >>> (10 - 2))
                        | ((in[29 + inpos] & 1023) << 2)
                        | ((in[30 + inpos] & 1023) << 12)
                        | ((in[31 + inpos]) << 22);
        }

        protected static void fastpack11(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 2047)
                        | ((in[1 + inpos] & 2047) << 11)
                        | ((in[2 + inpos]) << 22);
                out[1 + outpos] = ((in[2 + inpos] & 2047) >>> (11 - 1))
                        | ((in[3 + inpos] & 2047) << 1)
                        | ((in[4 + inpos] & 2047) << 12)
                        | ((in[5 + inpos]) << 23);
                out[2 + outpos] = ((in[5 + inpos] & 2047) >>> (11 - 2))
                        | ((in[6 + inpos] & 2047) << 2)
                        | ((in[7 + inpos] & 2047) << 13)
                        | ((in[8 + inpos]) << 24);
                out[3 + outpos] = ((in[8 + inpos] & 2047) >>> (11 - 3))
                        | ((in[9 + inpos] & 2047) << 3)
                        | ((in[10 + inpos] & 2047) << 14)
                        | ((in[11 + inpos]) << 25);
                out[4 + outpos] = ((in[11 + inpos] & 2047) >>> (11 - 4))
                        | ((in[12 + inpos] & 2047) << 4)
                        | ((in[13 + inpos] & 2047) << 15)
                        | ((in[14 + inpos]) << 26);
                out[5 + outpos] = ((in[14 + inpos] & 2047) >>> (11 - 5))
                        | ((in[15 + inpos] & 2047) << 5)
                        | ((in[16 + inpos] & 2047) << 16)
                        | ((in[17 + inpos]) << 27);
                out[6 + outpos] = ((in[17 + inpos] & 2047) >>> (11 - 6))
                        | ((in[18 + inpos] & 2047) << 6)
                        | ((in[19 + inpos] & 2047) << 17)
                        | ((in[20 + inpos]) << 28);
                out[7 + outpos] = ((in[20 + inpos] & 2047) >>> (11 - 7))
                        | ((in[21 + inpos] & 2047) << 7)
                        | ((in[22 + inpos] & 2047) << 18)
                        | ((in[23 + inpos]) << 29);
                out[8 + outpos] = ((in[23 + inpos] & 2047) >>> (11 - 8))
                        | ((in[24 + inpos] & 2047) << 8)
                        | ((in[25 + inpos] & 2047) << 19)
                        | ((in[26 + inpos]) << 30);
                out[9 + outpos] = ((in[26 + inpos] & 2047) >>> (11 - 9))
                        | ((in[27 + inpos] & 2047) << 9)
                        | ((in[28 + inpos] & 2047) << 20)
                        | ((in[29 + inpos]) << 31);
                out[10 + outpos] = ((in[29 + inpos] & 2047) >>> (11 - 10))
                        | ((in[30 + inpos] & 2047) << 10)
                        | ((in[31 + inpos]) << 21);
        }

        protected static void fastpack12(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 4095)
                        | ((in[1 + inpos] & 4095) << 12)
                        | ((in[2 + inpos]) << 24);
                out[1 + outpos] = ((in[2 + inpos] & 4095) >>> (12 - 4))
                        | ((in[3 + inpos] & 4095) << 4)
                        | ((in[4 + inpos] & 4095) << 16)
                        | ((in[5 + inpos]) << 28);
                out[2 + outpos] = ((in[5 + inpos] & 4095) >>> (12 - 8))
                        | ((in[6 + inpos] & 4095) << 8)
                        | ((in[7 + inpos]) << 20);
                out[3 + outpos] = (in[8 + inpos] & 4095)
                        | ((in[9 + inpos] & 4095) << 12)
                        | ((in[10 + inpos]) << 24);
                out[4 + outpos] = ((in[10 + inpos] & 4095) >>> (12 - 4))
                        | ((in[11 + inpos] & 4095) << 4)
                        | ((in[12 + inpos] & 4095) << 16)
                        | ((in[13 + inpos]) << 28);
                out[5 + outpos] = ((in[13 + inpos] & 4095) >>> (12 - 8))
                        | ((in[14 + inpos] & 4095) << 8)
                        | ((in[15 + inpos]) << 20);
                out[6 + outpos] = (in[16 + inpos] & 4095)
                        | ((in[17 + inpos] & 4095) << 12)
                        | ((in[18 + inpos]) << 24);
                out[7 + outpos] = ((in[18 + inpos] & 4095) >>> (12 - 4))
                        | ((in[19 + inpos] & 4095) << 4)
                        | ((in[20 + inpos] & 4095) << 16)
                        | ((in[21 + inpos]) << 28);
                out[8 + outpos] = ((in[21 + inpos] & 4095) >>> (12 - 8))
                        | ((in[22 + inpos] & 4095) << 8)
                        | ((in[23 + inpos]) << 20);
                out[9 + outpos] = (in[24 + inpos] & 4095)
                        | ((in[25 + inpos] & 4095) << 12)
                        | ((in[26 + inpos]) << 24);
                out[10 + outpos] = ((in[26 + inpos] & 4095) >>> (12 - 4))
                        | ((in[27 + inpos] & 4095) << 4)
                        | ((in[28 + inpos] & 4095) << 16)
                        | ((in[29 + inpos]) << 28);
                out[11 + outpos] = ((in[29 + inpos] & 4095) >>> (12 - 8))
                        | ((in[30 + inpos] & 4095) << 8)
                        | ((in[31 + inpos]) << 20);
        }

        protected static void fastpack13(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 8191)
                        | ((in[1 + inpos] & 8191) << 13)
                        | ((in[2 + inpos]) << 26);
                out[1 + outpos] = ((in[2 + inpos] & 8191) >>> (13 - 7))
                        | ((in[3 + inpos] & 8191) << 7)
                        | ((in[4 + inpos]) << 20);
                out[2 + outpos] = ((in[4 + inpos] & 8191) >>> (13 - 1))
                        | ((in[5 + inpos] & 8191) << 1)
                        | ((in[6 + inpos] & 8191) << 14)
                        | ((in[7 + inpos]) << 27);
                out[3 + outpos] = ((in[7 + inpos] & 8191) >>> (13 - 8))
                        | ((in[8 + inpos] & 8191) << 8)
                        | ((in[9 + inpos]) << 21);
                out[4 + outpos] = ((in[9 + inpos] & 8191) >>> (13 - 2))
                        | ((in[10 + inpos] & 8191) << 2)
                        | ((in[11 + inpos] & 8191) << 15)
                        | ((in[12 + inpos]) << 28);
                out[5 + outpos] = ((in[12 + inpos] & 8191) >>> (13 - 9))
                        | ((in[13 + inpos] & 8191) << 9)
                        | ((in[14 + inpos]) << 22);
                out[6 + outpos] = ((in[14 + inpos] & 8191) >>> (13 - 3))
                        | ((in[15 + inpos] & 8191) << 3)
                        | ((in[16 + inpos] & 8191) << 16)
                        | ((in[17 + inpos]) << 29);
                out[7 + outpos] = ((in[17 + inpos] & 8191) >>> (13 - 10))
                        | ((in[18 + inpos] & 8191) << 10)
                        | ((in[19 + inpos]) << 23);
                out[8 + outpos] = ((in[19 + inpos] & 8191) >>> (13 - 4))
                        | ((in[20 + inpos] & 8191) << 4)
                        | ((in[21 + inpos] & 8191) << 17)
                        | ((in[22 + inpos]) << 30);
                out[9 + outpos] = ((in[22 + inpos] & 8191) >>> (13 - 11))
                        | ((in[23 + inpos] & 8191) << 11)
                        | ((in[24 + inpos]) << 24);
                out[10 + outpos] = ((in[24 + inpos] & 8191) >>> (13 - 5))
                        | ((in[25 + inpos] & 8191) << 5)
                        | ((in[26 + inpos] & 8191) << 18)
                        | ((in[27 + inpos]) << 31);
                out[11 + outpos] = ((in[27 + inpos] & 8191) >>> (13 - 12))
                        | ((in[28 + inpos] & 8191) << 12)
                        | ((in[29 + inpos]) << 25);
                out[12 + outpos] = ((in[29 + inpos] & 8191) >>> (13 - 6))
                        | ((in[30 + inpos] & 8191) << 6)
                        | ((in[31 + inpos]) << 19);
        }

        protected static void fastpack14(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 16383)
                        | ((in[1 + inpos] & 16383) << 14)
                        | ((in[2 + inpos]) << 28);
                out[1 + outpos] = ((in[2 + inpos] & 16383) >>> (14 - 10))
                        | ((in[3 + inpos] & 16383) << 10)
                        | ((in[4 + inpos]) << 24);
                out[2 + outpos] = ((in[4 + inpos] & 16383) >>> (14 - 6))
                        | ((in[5 + inpos] & 16383) << 6)
                        | ((in[6 + inpos]) << 20);
                out[3 + outpos] = ((in[6 + inpos] & 16383) >>> (14 - 2))
                        | ((in[7 + inpos] & 16383) << 2)
                        | ((in[8 + inpos] & 16383) << 16)
                        | ((in[9 + inpos]) << 30);
                out[4 + outpos] = ((in[9 + inpos] & 16383) >>> (14 - 12))
                        | ((in[10 + inpos] & 16383) << 12)
                        | ((in[11 + inpos]) << 26);
                out[5 + outpos] = ((in[11 + inpos] & 16383) >>> (14 - 8))
                        | ((in[12 + inpos] & 16383) << 8)
                        | ((in[13 + inpos]) << 22);
                out[6 + outpos] = ((in[13 + inpos] & 16383) >>> (14 - 4))
                        | ((in[14 + inpos] & 16383) << 4)
                        | ((in[15 + inpos]) << 18);
                out[7 + outpos] = (in[16 + inpos] & 16383)
                        | ((in[17 + inpos] & 16383) << 14)
                        | ((in[18 + inpos]) << 28);
                out[8 + outpos] = ((in[18 + inpos] & 16383) >>> (14 - 10))
                        | ((in[19 + inpos] & 16383) << 10)
                        | ((in[20 + inpos]) << 24);
                out[9 + outpos] = ((in[20 + inpos] & 16383) >>> (14 - 6))
                        | ((in[21 + inpos] & 16383) << 6)
                        | ((in[22 + inpos]) << 20);
                out[10 + outpos] = ((in[22 + inpos] & 16383) >>> (14 - 2))
                        | ((in[23 + inpos] & 16383) << 2)
                        | ((in[24 + inpos] & 16383) << 16)
                        | ((in[25 + inpos]) << 30);
                out[11 + outpos] = ((in[25 + inpos] & 16383) >>> (14 - 12))
                        | ((in[26 + inpos] & 16383) << 12)
                        | ((in[27 + inpos]) << 26);
                out[12 + outpos] = ((in[27 + inpos] & 16383) >>> (14 - 8))
                        | ((in[28 + inpos] & 16383) << 8)
                        | ((in[29 + inpos]) << 22);
                out[13 + outpos] = ((in[29 + inpos] & 16383) >>> (14 - 4))
                        | ((in[30 + inpos] & 16383) << 4)
                        | ((in[31 + inpos]) << 18);
        }

        protected static void fastpack15(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 32767)
                        | ((in[1 + inpos] & 32767) << 15)
                        | ((in[2 + inpos]) << 30);
                out[1 + outpos] = ((in[2 + inpos] & 32767) >>> (15 - 13))
                        | ((in[3 + inpos] & 32767) << 13)
                        | ((in[4 + inpos]) << 28);
                out[2 + outpos] = ((in[4 + inpos] & 32767) >>> (15 - 11))
                        | ((in[5 + inpos] & 32767) << 11)
                        | ((in[6 + inpos]) << 26);
                out[3 + outpos] = ((in[6 + inpos] & 32767) >>> (15 - 9))
                        | ((in[7 + inpos] & 32767) << 9)
                        | ((in[8 + inpos]) << 24);
                out[4 + outpos] = ((in[8 + inpos] & 32767) >>> (15 - 7))
                        | ((in[9 + inpos] & 32767) << 7)
                        | ((in[10 + inpos]) << 22);
                out[5 + outpos] = ((in[10 + inpos] & 32767) >>> (15 - 5))
                        | ((in[11 + inpos] & 32767) << 5)
                        | ((in[12 + inpos]) << 20);
                out[6 + outpos] = ((in[12 + inpos] & 32767) >>> (15 - 3))
                        | ((in[13 + inpos] & 32767) << 3)
                        | ((in[14 + inpos]) << 18);
                out[7 + outpos] = ((in[14 + inpos] & 32767) >>> (15 - 1))
                        | ((in[15 + inpos] & 32767) << 1)
                        | ((in[16 + inpos] & 32767) << 16)
                        | ((in[17 + inpos]) << 31);
                out[8 + outpos] = ((in[17 + inpos] & 32767) >>> (15 - 14))
                        | ((in[18 + inpos] & 32767) << 14)
                        | ((in[19 + inpos]) << 29);
                out[9 + outpos] = ((in[19 + inpos] & 32767) >>> (15 - 12))
                        | ((in[20 + inpos] & 32767) << 12)
                        | ((in[21 + inpos]) << 27);
                out[10 + outpos] = ((in[21 + inpos] & 32767) >>> (15 - 10))
                        | ((in[22 + inpos] & 32767) << 10)
                        | ((in[23 + inpos]) << 25);
                out[11 + outpos] = ((in[23 + inpos] & 32767) >>> (15 - 8))
                        | ((in[24 + inpos] & 32767) << 8)
                        | ((in[25 + inpos]) << 23);
                out[12 + outpos] = ((in[25 + inpos] & 32767) >>> (15 - 6))
                        | ((in[26 + inpos] & 32767) << 6)
                        | ((in[27 + inpos]) << 21);
                out[13 + outpos] = ((in[27 + inpos] & 32767) >>> (15 - 4))
                        | ((in[28 + inpos] & 32767) << 4)
                        | ((in[29 + inpos]) << 19);
                out[14 + outpos] = ((in[29 + inpos] & 32767) >>> (15 - 2))
                        | ((in[30 + inpos] & 32767) << 2)
                        | ((in[31 + inpos]) << 17);
        }

        protected static void fastpack16(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 65535)
                        | ((in[1 + inpos]) << 16);
                out[1 + outpos] = (in[2 + inpos] & 65535)
                        | ((in[3 + inpos]) << 16);
                out[2 + outpos] = (in[4 + inpos] & 65535)
                        | ((in[5 + inpos]) << 16);
                out[3 + outpos] = (in[6 + inpos] & 65535)
                        | ((in[7 + inpos]) << 16);
                out[4 + outpos] = (in[8 + inpos] & 65535)
                        | ((in[9 + inpos]) << 16);
                out[5 + outpos] = (in[10 + inpos] & 65535)
                        | ((in[11 + inpos]) << 16);
                out[6 + outpos] = (in[12 + inpos] & 65535)
                        | ((in[13 + inpos]) << 16);
                out[7 + outpos] = (in[14 + inpos] & 65535)
                        | ((in[15 + inpos]) << 16);
                out[8 + outpos] = (in[16 + inpos] & 65535)
                        | ((in[17 + inpos]) << 16);
                out[9 + outpos] = (in[18 + inpos] & 65535)
                        | ((in[19 + inpos]) << 16);
                out[10 + outpos] = (in[20 + inpos] & 65535)
                        | ((in[21 + inpos]) << 16);
                out[11 + outpos] = (in[22 + inpos] & 65535)
                        | ((in[23 + inpos]) << 16);
                out[12 + outpos] = (in[24 + inpos] & 65535)
                        | ((in[25 + inpos]) << 16);
                out[13 + outpos] = (in[26 + inpos] & 65535)
                        | ((in[27 + inpos]) << 16);
                out[14 + outpos] = (in[28 + inpos] & 65535)
                        | ((in[29 + inpos]) << 16);
                out[15 + outpos] = (in[30 + inpos] & 65535)
                        | ((in[31 + inpos]) << 16);
        }

        protected static void fastpack17(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 131071)
                        | ((in[1 + inpos]) << 17);
                out[1 + outpos] = ((in[1 + inpos] & 131071) >>> (17 - 2))
                        | ((in[2 + inpos] & 131071) << 2)
                        | ((in[3 + inpos]) << 19);
                out[2 + outpos] = ((in[3 + inpos] & 131071) >>> (17 - 4))
                        | ((in[4 + inpos] & 131071) << 4)
                        | ((in[5 + inpos]) << 21);
                out[3 + outpos] = ((in[5 + inpos] & 131071) >>> (17 - 6))
                        | ((in[6 + inpos] & 131071) << 6)
                        | ((in[7 + inpos]) << 23);
                out[4 + outpos] = ((in[7 + inpos] & 131071) >>> (17 - 8))
                        | ((in[8 + inpos] & 131071) << 8)
                        | ((in[9 + inpos]) << 25);
                out[5 + outpos] = ((in[9 + inpos] & 131071) >>> (17 - 10))
                        | ((in[10 + inpos] & 131071) << 10)
                        | ((in[11 + inpos]) << 27);
                out[6 + outpos] = ((in[11 + inpos] & 131071) >>> (17 - 12))
                        | ((in[12 + inpos] & 131071) << 12)
                        | ((in[13 + inpos]) << 29);
                out[7 + outpos] = ((in[13 + inpos] & 131071) >>> (17 - 14))
                        | ((in[14 + inpos] & 131071) << 14)
                        | ((in[15 + inpos]) << 31);
                out[8 + outpos] = ((in[15 + inpos] & 131071) >>> (17 - 16))
                        | ((in[16 + inpos]) << 16);
                out[9 + outpos] = ((in[16 + inpos] & 131071) >>> (17 - 1))
                        | ((in[17 + inpos] & 131071) << 1)
                        | ((in[18 + inpos]) << 18);
                out[10 + outpos] = ((in[18 + inpos] & 131071) >>> (17 - 3))
                        | ((in[19 + inpos] & 131071) << 3)
                        | ((in[20 + inpos]) << 20);
                out[11 + outpos] = ((in[20 + inpos] & 131071) >>> (17 - 5))
                        | ((in[21 + inpos] & 131071) << 5)
                        | ((in[22 + inpos]) << 22);
                out[12 + outpos] = ((in[22 + inpos] & 131071) >>> (17 - 7))
                        | ((in[23 + inpos] & 131071) << 7)
                        | ((in[24 + inpos]) << 24);
                out[13 + outpos] = ((in[24 + inpos] & 131071) >>> (17 - 9))
                        | ((in[25 + inpos] & 131071) << 9)
                        | ((in[26 + inpos]) << 26);
                out[14 + outpos] = ((in[26 + inpos] & 131071) >>> (17 - 11))
                        | ((in[27 + inpos] & 131071) << 11)
                        | ((in[28 + inpos]) << 28);
                out[15 + outpos] = ((in[28 + inpos] & 131071) >>> (17 - 13))
                        | ((in[29 + inpos] & 131071) << 13)
                        | ((in[30 + inpos]) << 30);
                out[16 + outpos] = ((in[30 + inpos] & 131071) >>> (17 - 15))
                        | ((in[31 + inpos]) << 15);
        }

        protected static void fastpack18(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 262143)
                        | ((in[1 + inpos]) << 18);
                out[1 + outpos] = ((in[1 + inpos] & 262143) >>> (18 - 4))
                        | ((in[2 + inpos] & 262143) << 4)
                        | ((in[3 + inpos]) << 22);
                out[2 + outpos] = ((in[3 + inpos] & 262143) >>> (18 - 8))
                        | ((in[4 + inpos] & 262143) << 8)
                        | ((in[5 + inpos]) << 26);
                out[3 + outpos] = ((in[5 + inpos] & 262143) >>> (18 - 12))
                        | ((in[6 + inpos] & 262143) << 12)
                        | ((in[7 + inpos]) << 30);
                out[4 + outpos] = ((in[7 + inpos] & 262143) >>> (18 - 16))
                        | ((in[8 + inpos]) << 16);
                out[5 + outpos] = ((in[8 + inpos] & 262143) >>> (18 - 2))
                        | ((in[9 + inpos] & 262143) << 2)
                        | ((in[10 + inpos]) << 20);
                out[6 + outpos] = ((in[10 + inpos] & 262143) >>> (18 - 6))
                        | ((in[11 + inpos] & 262143) << 6)
                        | ((in[12 + inpos]) << 24);
                out[7 + outpos] = ((in[12 + inpos] & 262143) >>> (18 - 10))
                        | ((in[13 + inpos] & 262143) << 10)
                        | ((in[14 + inpos]) << 28);
                out[8 + outpos] = ((in[14 + inpos] & 262143) >>> (18 - 14))
                        | ((in[15 + inpos]) << 14);
                out[9 + outpos] = (in[16 + inpos] & 262143)
                        | ((in[17 + inpos]) << 18);
                out[10 + outpos] = ((in[17 + inpos] & 262143) >>> (18 - 4))
                        | ((in[18 + inpos] & 262143) << 4)
                        | ((in[19 + inpos]) << 22);
                out[11 + outpos] = ((in[19 + inpos] & 262143) >>> (18 - 8))
                        | ((in[20 + inpos] & 262143) << 8)
                        | ((in[21 + inpos]) << 26);
                out[12 + outpos] = ((in[21 + inpos] & 262143) >>> (18 - 12))
                        | ((in[22 + inpos] & 262143) << 12)
                        | ((in[23 + inpos]) << 30);
                out[13 + outpos] = ((in[23 + inpos] & 262143) >>> (18 - 16))
                        | ((in[24 + inpos]) << 16);
                out[14 + outpos] = ((in[24 + inpos] & 262143) >>> (18 - 2))
                        | ((in[25 + inpos] & 262143) << 2)
                        | ((in[26 + inpos]) << 20);
                out[15 + outpos] = ((in[26 + inpos] & 262143) >>> (18 - 6))
                        | ((in[27 + inpos] & 262143) << 6)
                        | ((in[28 + inpos]) << 24);
                out[16 + outpos] = ((in[28 + inpos] & 262143) >>> (18 - 10))
                        | ((in[29 + inpos] & 262143) << 10)
                        | ((in[30 + inpos]) << 28);
                out[17 + outpos] = ((in[30 + inpos] & 262143) >>> (18 - 14))
                        | ((in[31 + inpos]) << 14);
        }

        protected static void fastpack19(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 524287)
                        | ((in[1 + inpos]) << 19);
                out[1 + outpos] = ((in[1 + inpos] & 524287) >>> (19 - 6))
                        | ((in[2 + inpos] & 524287) << 6)
                        | ((in[3 + inpos]) << 25);
                out[2 + outpos] = ((in[3 + inpos] & 524287) >>> (19 - 12))
                        | ((in[4 + inpos] & 524287) << 12)
                        | ((in[5 + inpos]) << 31);
                out[3 + outpos] = ((in[5 + inpos] & 524287) >>> (19 - 18))
                        | ((in[6 + inpos]) << 18);
                out[4 + outpos] = ((in[6 + inpos] & 524287) >>> (19 - 5))
                        | ((in[7 + inpos] & 524287) << 5)
                        | ((in[8 + inpos]) << 24);
                out[5 + outpos] = ((in[8 + inpos] & 524287) >>> (19 - 11))
                        | ((in[9 + inpos] & 524287) << 11)
                        | ((in[10 + inpos]) << 30);
                out[6 + outpos] = ((in[10 + inpos] & 524287) >>> (19 - 17))
                        | ((in[11 + inpos]) << 17);
                out[7 + outpos] = ((in[11 + inpos] & 524287) >>> (19 - 4))
                        | ((in[12 + inpos] & 524287) << 4)
                        | ((in[13 + inpos]) << 23);
                out[8 + outpos] = ((in[13 + inpos] & 524287) >>> (19 - 10))
                        | ((in[14 + inpos] & 524287) << 10)
                        | ((in[15 + inpos]) << 29);
                out[9 + outpos] = ((in[15 + inpos] & 524287) >>> (19 - 16))
                        | ((in[16 + inpos]) << 16);
                out[10 + outpos] = ((in[16 + inpos] & 524287) >>> (19 - 3))
                        | ((in[17 + inpos] & 524287) << 3)
                        | ((in[18 + inpos]) << 22);
                out[11 + outpos] = ((in[18 + inpos] & 524287) >>> (19 - 9))
                        | ((in[19 + inpos] & 524287) << 9)
                        | ((in[20 + inpos]) << 28);
                out[12 + outpos] = ((in[20 + inpos] & 524287) >>> (19 - 15))
                        | ((in[21 + inpos]) << 15);
                out[13 + outpos] = ((in[21 + inpos] & 524287) >>> (19 - 2))
                        | ((in[22 + inpos] & 524287) << 2)
                        | ((in[23 + inpos]) << 21);
                out[14 + outpos] = ((in[23 + inpos] & 524287) >>> (19 - 8))
                        | ((in[24 + inpos] & 524287) << 8)
                        | ((in[25 + inpos]) << 27);
                out[15 + outpos] = ((in[25 + inpos] & 524287) >>> (19 - 14))
                        | ((in[26 + inpos]) << 14);
                out[16 + outpos] = ((in[26 + inpos] & 524287) >>> (19 - 1))
                        | ((in[27 + inpos] & 524287) << 1)
                        | ((in[28 + inpos]) << 20);
                out[17 + outpos] = ((in[28 + inpos] & 524287) >>> (19 - 7))
                        | ((in[29 + inpos] & 524287) << 7)
                        | ((in[30 + inpos]) << 26);
                out[18 + outpos] = ((in[30 + inpos] & 524287) >>> (19 - 13))
                        | ((in[31 + inpos]) << 13);
        }

        protected static void fastpack2(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 3)
                        | ((in[1 + inpos] & 3) << 2)
                        | ((in[2 + inpos] & 3) << 4)
                        | ((in[3 + inpos] & 3) << 6)
                        | ((in[4 + inpos] & 3) << 8)
                        | ((in[5 + inpos] & 3) << 10)
                        | ((in[6 + inpos] & 3) << 12)
                        | ((in[7 + inpos] & 3) << 14)
                        | ((in[8 + inpos] & 3) << 16)
                        | ((in[9 + inpos] & 3) << 18)
                        | ((in[10 + inpos] & 3) << 20)
                        | ((in[11 + inpos] & 3) << 22)
                        | ((in[12 + inpos] & 3) << 24)
                        | ((in[13 + inpos] & 3) << 26)
                        | ((in[14 + inpos] & 3) << 28)
                        | ((in[15 + inpos]) << 30);
                out[1 + outpos] = (in[16 + inpos] & 3)
                        | ((in[17 + inpos] & 3) << 2)
                        | ((in[18 + inpos] & 3) << 4)
                        | ((in[19 + inpos] & 3) << 6)
                        | ((in[20 + inpos] & 3) << 8)
                        | ((in[21 + inpos] & 3) << 10)
                        | ((in[22 + inpos] & 3) << 12)
                        | ((in[23 + inpos] & 3) << 14)
                        | ((in[24 + inpos] & 3) << 16)
                        | ((in[25 + inpos] & 3) << 18)
                        | ((in[26 + inpos] & 3) << 20)
                        | ((in[27 + inpos] & 3) << 22)
                        | ((in[28 + inpos] & 3) << 24)
                        | ((in[29 + inpos] & 3) << 26)
                        | ((in[30 + inpos] & 3) << 28)
                        | ((in[31 + inpos]) << 30);
        }

        protected static void fastpack20(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 1048575)
                        | ((in[1 + inpos]) << 20);
                out[1 + outpos] = ((in[1 + inpos] & 1048575) >>> (20 - 8))
                        | ((in[2 + inpos] & 1048575) << 8)
                        | ((in[3 + inpos]) << 28);
                out[2 + outpos] = ((in[3 + inpos] & 1048575) >>> (20 - 16))
                        | ((in[4 + inpos]) << 16);
                out[3 + outpos] = ((in[4 + inpos] & 1048575) >>> (20 - 4))
                        | ((in[5 + inpos] & 1048575) << 4)
                        | ((in[6 + inpos]) << 24);
                out[4 + outpos] = ((in[6 + inpos] & 1048575) >>> (20 - 12))
                        | ((in[7 + inpos]) << 12);
                out[5 + outpos] = (in[8 + inpos] & 1048575)
                        | ((in[9 + inpos]) << 20);
                out[6 + outpos] = ((in[9 + inpos] & 1048575) >>> (20 - 8))
                        | ((in[10 + inpos] & 1048575) << 8)
                        | ((in[11 + inpos]) << 28);
                out[7 + outpos] = ((in[11 + inpos] & 1048575) >>> (20 - 16))
                        | ((in[12 + inpos]) << 16);
                out[8 + outpos] = ((in[12 + inpos] & 1048575) >>> (20 - 4))
                        | ((in[13 + inpos] & 1048575) << 4)
                        | ((in[14 + inpos]) << 24);
                out[9 + outpos] = ((in[14 + inpos] & 1048575) >>> (20 - 12))
                        | ((in[15 + inpos]) << 12);
                out[10 + outpos] = (in[16 + inpos] & 1048575)
                        | ((in[17 + inpos]) << 20);
                out[11 + outpos] = ((in[17 + inpos] & 1048575) >>> (20 - 8))
                        | ((in[18 + inpos] & 1048575) << 8)
                        | ((in[19 + inpos]) << 28);
                out[12 + outpos] = ((in[19 + inpos] & 1048575) >>> (20 - 16))
                        | ((in[20 + inpos]) << 16);
                out[13 + outpos] = ((in[20 + inpos] & 1048575) >>> (20 - 4))
                        | ((in[21 + inpos] & 1048575) << 4)
                        | ((in[22 + inpos]) << 24);
                out[14 + outpos] = ((in[22 + inpos] & 1048575) >>> (20 - 12))
                        | ((in[23 + inpos]) << 12);
                out[15 + outpos] = (in[24 + inpos] & 1048575)
                        | ((in[25 + inpos]) << 20);
                out[16 + outpos] = ((in[25 + inpos] & 1048575) >>> (20 - 8))
                        | ((in[26 + inpos] & 1048575) << 8)
                        | ((in[27 + inpos]) << 28);
                out[17 + outpos] = ((in[27 + inpos] & 1048575) >>> (20 - 16))
                        | ((in[28 + inpos]) << 16);
                out[18 + outpos] = ((in[28 + inpos] & 1048575) >>> (20 - 4))
                        | ((in[29 + inpos] & 1048575) << 4)
                        | ((in[30 + inpos]) << 24);
                out[19 + outpos] = ((in[30 + inpos] & 1048575) >>> (20 - 12))
                        | ((in[31 + inpos]) << 12);
        }

        protected static void fastpack21(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 2097151)
                        | ((in[1 + inpos]) << 21);
                out[1 + outpos] = ((in[1 + inpos] & 2097151) >>> (21 - 10))
                        | ((in[2 + inpos] & 2097151) << 10)
                        | ((in[3 + inpos]) << 31);
                out[2 + outpos] = ((in[3 + inpos] & 2097151) >>> (21 - 20))
                        | ((in[4 + inpos]) << 20);
                out[3 + outpos] = ((in[4 + inpos] & 2097151) >>> (21 - 9))
                        | ((in[5 + inpos] & 2097151) << 9)
                        | ((in[6 + inpos]) << 30);
                out[4 + outpos] = ((in[6 + inpos] & 2097151) >>> (21 - 19))
                        | ((in[7 + inpos]) << 19);
                out[5 + outpos] = ((in[7 + inpos] & 2097151) >>> (21 - 8))
                        | ((in[8 + inpos] & 2097151) << 8)
                        | ((in[9 + inpos]) << 29);
                out[6 + outpos] = ((in[9 + inpos] & 2097151) >>> (21 - 18))
                        | ((in[10 + inpos]) << 18);
                out[7 + outpos] = ((in[10 + inpos] & 2097151) >>> (21 - 7))
                        | ((in[11 + inpos] & 2097151) << 7)
                        | ((in[12 + inpos]) << 28);
                out[8 + outpos] = ((in[12 + inpos] & 2097151) >>> (21 - 17))
                        | ((in[13 + inpos]) << 17);
                out[9 + outpos] = ((in[13 + inpos] & 2097151) >>> (21 - 6))
                        | ((in[14 + inpos] & 2097151) << 6)
                        | ((in[15 + inpos]) << 27);
                out[10 + outpos] = ((in[15 + inpos] & 2097151) >>> (21 - 16))
                        | ((in[16 + inpos]) << 16);
                out[11 + outpos] = ((in[16 + inpos] & 2097151) >>> (21 - 5))
                        | ((in[17 + inpos] & 2097151) << 5)
                        | ((in[18 + inpos]) << 26);
                out[12 + outpos] = ((in[18 + inpos] & 2097151) >>> (21 - 15))
                        | ((in[19 + inpos]) << 15);
                out[13 + outpos] = ((in[19 + inpos] & 2097151) >>> (21 - 4))
                        | ((in[20 + inpos] & 2097151) << 4)
                        | ((in[21 + inpos]) << 25);
                out[14 + outpos] = ((in[21 + inpos] & 2097151) >>> (21 - 14))
                        | ((in[22 + inpos]) << 14);
                out[15 + outpos] = ((in[22 + inpos] & 2097151) >>> (21 - 3))
                        | ((in[23 + inpos] & 2097151) << 3)
                        | ((in[24 + inpos]) << 24);
                out[16 + outpos] = ((in[24 + inpos] & 2097151) >>> (21 - 13))
                        | ((in[25 + inpos]) << 13);
                out[17 + outpos] = ((in[25 + inpos] & 2097151) >>> (21 - 2))
                        | ((in[26 + inpos] & 2097151) << 2)
                        | ((in[27 + inpos]) << 23);
                out[18 + outpos] = ((in[27 + inpos] & 2097151) >>> (21 - 12))
                        | ((in[28 + inpos]) << 12);
                out[19 + outpos] = ((in[28 + inpos] & 2097151) >>> (21 - 1))
                        | ((in[29 + inpos] & 2097151) << 1)
                        | ((in[30 + inpos]) << 22);
                out[20 + outpos] = ((in[30 + inpos] & 2097151) >>> (21 - 11))
                        | ((in[31 + inpos]) << 11);
        }

        protected static void fastpack22(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 4194303)
                        | ((in[1 + inpos]) << 22);
                out[1 + outpos] = ((in[1 + inpos] & 4194303) >>> (22 - 12))
                        | ((in[2 + inpos]) << 12);
                out[2 + outpos] = ((in[2 + inpos] & 4194303) >>> (22 - 2))
                        | ((in[3 + inpos] & 4194303) << 2)
                        | ((in[4 + inpos]) << 24);
                out[3 + outpos] = ((in[4 + inpos] & 4194303) >>> (22 - 14))
                        | ((in[5 + inpos]) << 14);
                out[4 + outpos] = ((in[5 + inpos] & 4194303) >>> (22 - 4))
                        | ((in[6 + inpos] & 4194303) << 4)
                        | ((in[7 + inpos]) << 26);
                out[5 + outpos] = ((in[7 + inpos] & 4194303) >>> (22 - 16))
                        | ((in[8 + inpos]) << 16);
                out[6 + outpos] = ((in[8 + inpos] & 4194303) >>> (22 - 6))
                        | ((in[9 + inpos] & 4194303) << 6)
                        | ((in[10 + inpos]) << 28);
                out[7 + outpos] = ((in[10 + inpos] & 4194303) >>> (22 - 18))
                        | ((in[11 + inpos]) << 18);
                out[8 + outpos] = ((in[11 + inpos] & 4194303) >>> (22 - 8))
                        | ((in[12 + inpos] & 4194303) << 8)
                        | ((in[13 + inpos]) << 30);
                out[9 + outpos] = ((in[13 + inpos] & 4194303) >>> (22 - 20))
                        | ((in[14 + inpos]) << 20);
                out[10 + outpos] = ((in[14 + inpos] & 4194303) >>> (22 - 10))
                        | ((in[15 + inpos]) << 10);
                out[11 + outpos] = (in[16 + inpos] & 4194303)
                        | ((in[17 + inpos]) << 22);
                out[12 + outpos] = ((in[17 + inpos] & 4194303) >>> (22 - 12))
                        | ((in[18 + inpos]) << 12);
                out[13 + outpos] = ((in[18 + inpos] & 4194303) >>> (22 - 2))
                        | ((in[19 + inpos] & 4194303) << 2)
                        | ((in[20 + inpos]) << 24);
                out[14 + outpos] = ((in[20 + inpos] & 4194303) >>> (22 - 14))
                        | ((in[21 + inpos]) << 14);
                out[15 + outpos] = ((in[21 + inpos] & 4194303) >>> (22 - 4))
                        | ((in[22 + inpos] & 4194303) << 4)
                        | ((in[23 + inpos]) << 26);
                out[16 + outpos] = ((in[23 + inpos] & 4194303) >>> (22 - 16))
                        | ((in[24 + inpos]) << 16);
                out[17 + outpos] = ((in[24 + inpos] & 4194303) >>> (22 - 6))
                        | ((in[25 + inpos] & 4194303) << 6)
                        | ((in[26 + inpos]) << 28);
                out[18 + outpos] = ((in[26 + inpos] & 4194303) >>> (22 - 18))
                        | ((in[27 + inpos]) << 18);
                out[19 + outpos] = ((in[27 + inpos] & 4194303) >>> (22 - 8))
                        | ((in[28 + inpos] & 4194303) << 8)
                        | ((in[29 + inpos]) << 30);
                out[20 + outpos] = ((in[29 + inpos] & 4194303) >>> (22 - 20))
                        | ((in[30 + inpos]) << 20);
                out[21 + outpos] = ((in[30 + inpos] & 4194303) >>> (22 - 10))
                        | ((in[31 + inpos]) << 10);
        }

        protected static void fastpack23(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 8388607)
                        | ((in[1 + inpos]) << 23);
                out[1 + outpos] = ((in[1 + inpos] & 8388607) >>> (23 - 14))
                        | ((in[2 + inpos]) << 14);
                out[2 + outpos] = ((in[2 + inpos] & 8388607) >>> (23 - 5))
                        | ((in[3 + inpos] & 8388607) << 5)
                        | ((in[4 + inpos]) << 28);
                out[3 + outpos] = ((in[4 + inpos] & 8388607) >>> (23 - 19))
                        | ((in[5 + inpos]) << 19);
                out[4 + outpos] = ((in[5 + inpos] & 8388607) >>> (23 - 10))
                        | ((in[6 + inpos]) << 10);
                out[5 + outpos] = ((in[6 + inpos] & 8388607) >>> (23 - 1))
                        | ((in[7 + inpos] & 8388607) << 1)
                        | ((in[8 + inpos]) << 24);
                out[6 + outpos] = ((in[8 + inpos] & 8388607) >>> (23 - 15))
                        | ((in[9 + inpos]) << 15);
                out[7 + outpos] = ((in[9 + inpos] & 8388607) >>> (23 - 6))
                        | ((in[10 + inpos] & 8388607) << 6)
                        | ((in[11 + inpos]) << 29);
                out[8 + outpos] = ((in[11 + inpos] & 8388607) >>> (23 - 20))
                        | ((in[12 + inpos]) << 20);
                out[9 + outpos] = ((in[12 + inpos] & 8388607) >>> (23 - 11))
                        | ((in[13 + inpos]) << 11);
                out[10 + outpos] = ((in[13 + inpos] & 8388607) >>> (23 - 2))
                        | ((in[14 + inpos] & 8388607) << 2)
                        | ((in[15 + inpos]) << 25);
                out[11 + outpos] = ((in[15 + inpos] & 8388607) >>> (23 - 16))
                        | ((in[16 + inpos]) << 16);
                out[12 + outpos] = ((in[16 + inpos] & 8388607) >>> (23 - 7))
                        | ((in[17 + inpos] & 8388607) << 7)
                        | ((in[18 + inpos]) << 30);
                out[13 + outpos] = ((in[18 + inpos] & 8388607) >>> (23 - 21))
                        | ((in[19 + inpos]) << 21);
                out[14 + outpos] = ((in[19 + inpos] & 8388607) >>> (23 - 12))
                        | ((in[20 + inpos]) << 12);
                out[15 + outpos] = ((in[20 + inpos] & 8388607) >>> (23 - 3))
                        | ((in[21 + inpos] & 8388607) << 3)
                        | ((in[22 + inpos]) << 26);
                out[16 + outpos] = ((in[22 + inpos] & 8388607) >>> (23 - 17))
                        | ((in[23 + inpos]) << 17);
                out[17 + outpos] = ((in[23 + inpos] & 8388607) >>> (23 - 8))
                        | ((in[24 + inpos] & 8388607) << 8)
                        | ((in[25 + inpos]) << 31);
                out[18 + outpos] = ((in[25 + inpos] & 8388607) >>> (23 - 22))
                        | ((in[26 + inpos]) << 22);
                out[19 + outpos] = ((in[26 + inpos] & 8388607) >>> (23 - 13))
                        | ((in[27 + inpos]) << 13);
                out[20 + outpos] = ((in[27 + inpos] & 8388607) >>> (23 - 4))
                        | ((in[28 + inpos] & 8388607) << 4)
                        | ((in[29 + inpos]) << 27);
                out[21 + outpos] = ((in[29 + inpos] & 8388607) >>> (23 - 18))
                        | ((in[30 + inpos]) << 18);
                out[22 + outpos] = ((in[30 + inpos] & 8388607) >>> (23 - 9))
                        | ((in[31 + inpos]) << 9);
        }

        protected static void fastpack24(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 16777215)
                        | ((in[1 + inpos]) << 24);
                out[1 + outpos] = ((in[1 + inpos] & 16777215) >>> (24 - 16))
                        | ((in[2 + inpos]) << 16);
                out[2 + outpos] = ((in[2 + inpos] & 16777215) >>> (24 - 8))
                        | ((in[3 + inpos]) << 8);
                out[3 + outpos] = (in[4 + inpos] & 16777215)
                        | ((in[5 + inpos]) << 24);
                out[4 + outpos] = ((in[5 + inpos] & 16777215) >>> (24 - 16))
                        | ((in[6 + inpos]) << 16);
                out[5 + outpos] = ((in[6 + inpos] & 16777215) >>> (24 - 8))
                        | ((in[7 + inpos]) << 8);
                out[6 + outpos] = (in[8 + inpos] & 16777215)
                        | ((in[9 + inpos]) << 24);
                out[7 + outpos] = ((in[9 + inpos] & 16777215) >>> (24 - 16))
                        | ((in[10 + inpos]) << 16);
                out[8 + outpos] = ((in[10 + inpos] & 16777215) >>> (24 - 8))
                        | ((in[11 + inpos]) << 8);
                out[9 + outpos] = (in[12 + inpos] & 16777215)
                        | ((in[13 + inpos]) << 24);
                out[10 + outpos] = ((in[13 + inpos] & 16777215) >>> (24 - 16))
                        | ((in[14 + inpos]) << 16);
                out[11 + outpos] = ((in[14 + inpos] & 16777215) >>> (24 - 8))
                        | ((in[15 + inpos]) << 8);
                out[12 + outpos] = (in[16 + inpos] & 16777215)
                        | ((in[17 + inpos]) << 24);
                out[13 + outpos] = ((in[17 + inpos] & 16777215) >>> (24 - 16))
                        | ((in[18 + inpos]) << 16);
                out[14 + outpos] = ((in[18 + inpos] & 16777215) >>> (24 - 8))
                        | ((in[19 + inpos]) << 8);
                out[15 + outpos] = (in[20 + inpos] & 16777215)
                        | ((in[21 + inpos]) << 24);
                out[16 + outpos] = ((in[21 + inpos] & 16777215) >>> (24 - 16))
                        | ((in[22 + inpos]) << 16);
                out[17 + outpos] = ((in[22 + inpos] & 16777215) >>> (24 - 8))
                        | ((in[23 + inpos]) << 8);
                out[18 + outpos] = (in[24 + inpos] & 16777215)
                        | ((in[25 + inpos]) << 24);
                out[19 + outpos] = ((in[25 + inpos] & 16777215) >>> (24 - 16))
                        | ((in[26 + inpos]) << 16);
                out[20 + outpos] = ((in[26 + inpos] & 16777215) >>> (24 - 8))
                        | ((in[27 + inpos]) << 8);
                out[21 + outpos] = (in[28 + inpos] & 16777215)
                        | ((in[29 + inpos]) << 24);
                out[22 + outpos] = ((in[29 + inpos] & 16777215) >>> (24 - 16))
                        | ((in[30 + inpos]) << 16);
                out[23 + outpos] = ((in[30 + inpos] & 16777215) >>> (24 - 8))
                        | ((in[31 + inpos]) << 8);
        }

        protected static void fastpack25(final int[] in, int inpos,
                final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] & 33554431)
                        | ((in[1 + inpos]) << 25);
                out[1 + outpos] = ((in[1 + inpos] & 33554431) >>> (25 - 18))
                        | ((in[2 + inpos]) << 18);
                out[2 + outpos] = ((in[2 + inpos] & 33554431) >>> (25 - 11))
                        | ((in[3 + inpos]) << 11);
                out[3 + outpos] = ((in[3 + inpos] & 33554431) >>> (25 - 4))
                        | ((in[4 + inpos] & 33554431) << 4)
                        | ((in[5 + inpos]) << 29);
                out[4 + outpos] = ((in[5 + inpos] & 33554431) >>> (25 - 22))
                        | ((in[6 + inpos]) << 22);
                out[5 + outpos] = ((in[6 + inpos] & 33554431) >>> (25 - 15))
                        | ((in[7 + inpos]) << 15);
                out[6 + outpos] = ((in[7 + inpos] & 33554431) >>> (25 - 8))
                        | ((in[8 + inpos]) << 8);
                out[7 + outpos] = ((in[8 + inpos] & 33554431) >>> (25 - 1))
                        | ((in[9 + inpos] & 33554431) << 1)