IntegratedBitPacking.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.differential;

import java.util.Arrays;

/**
 * "Integrated" bit packing routines: they include both the bit packing and the
 * differential coding.
 * 
 * For details, please see
 * <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 IntegratedBitPacking {

        /**
         * Pack 32 integers as deltas with an initial value 
         * 
         * @param initoffset initial value (used to compute first delta)
         * @param in input array
         * @param inpos initial position in input array
         * @param out output array
         * @param outpos initial position in output array
         * @param bit number of bits to use per integer
         */
        public static void integratedpack(final int initoffset, final int[] in,
                final int inpos, final int[] out, final int outpos, final int bit) {
                switch (bit) {
                case 0:
                        integratedpack0(initoffset, in, inpos, out, outpos);
                        break;
                case 1:
                        integratedpack1(initoffset, in, inpos, out, outpos);
                        break;
                case 2:
                        integratedpack2(initoffset, in, inpos, out, outpos);
                        break;
                case 3:
                        integratedpack3(initoffset, in, inpos, out, outpos);
                        break;
                case 4:
                        integratedpack4(initoffset, in, inpos, out, outpos);
                        break;
                case 5:
                        integratedpack5(initoffset, in, inpos, out, outpos);
                        break;
                case 6:
                        integratedpack6(initoffset, in, inpos, out, outpos);
                        break;
                case 7:
                        integratedpack7(initoffset, in, inpos, out, outpos);
                        break;
                case 8:
                        integratedpack8(initoffset, in, inpos, out, outpos);
                        break;
                case 9:
                        integratedpack9(initoffset, in, inpos, out, outpos);
                        break;
                case 10:
                        integratedpack10(initoffset, in, inpos, out, outpos);
                        break;
                case 11:
                        integratedpack11(initoffset, in, inpos, out, outpos);
                        break;
                case 12:
                        integratedpack12(initoffset, in, inpos, out, outpos);
                        break;
                case 13:
                        integratedpack13(initoffset, in, inpos, out, outpos);
                        break;
                case 14:
                        integratedpack14(initoffset, in, inpos, out, outpos);
                        break;
                case 15:
                        integratedpack15(initoffset, in, inpos, out, outpos);
                        break;
                case 16:
                        integratedpack16(initoffset, in, inpos, out, outpos);
                        break;
                case 17:
                        integratedpack17(initoffset, in, inpos, out, outpos);
                        break;
                case 18:
                        integratedpack18(initoffset, in, inpos, out, outpos);
                        break;
                case 19:
                        integratedpack19(initoffset, in, inpos, out, outpos);
                        break;
                case 20:
                        integratedpack20(initoffset, in, inpos, out, outpos);
                        break;
                case 21:
                        integratedpack21(initoffset, in, inpos, out, outpos);
                        break;
                case 22:
                        integratedpack22(initoffset, in, inpos, out, outpos);
                        break;
                case 23:
                        integratedpack23(initoffset, in, inpos, out, outpos);
                        break;
                case 24:
                        integratedpack24(initoffset, in, inpos, out, outpos);
                        break;
                case 25:
                        integratedpack25(initoffset, in, inpos, out, outpos);
                        break;
                case 26:
                        integratedpack26(initoffset, in, inpos, out, outpos);
                        break;
                case 27:
                        integratedpack27(initoffset, in, inpos, out, outpos);
                        break;
                case 28:
                        integratedpack28(initoffset, in, inpos, out, outpos);
                        break;
                case 29:
                        integratedpack29(initoffset, in, inpos, out, outpos);
                        break;
                case 30:
                        integratedpack30(initoffset, in, inpos, out, outpos);
                        break;
                case 31:
                        integratedpack31(initoffset, in, inpos, out, outpos);
                        break;
                case 32:
                        integratedpack32(initoffset, in, inpos, out, outpos);
                        break;
                default:
                        throw new IllegalArgumentException(
                                "Unsupported bit width.");
                }
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        protected static void integratedpack25(final int initoffset,
                final int[] in, int inpos, final int[] out, int outpos) {
                out[0 + outpos] = (in[0 + inpos] - initoffset)
                        | ((in[1 + inpos] - in[1 + inpos - 1]) << 25);
                out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (25 - 18)
                        | ((in[2 + inpos] - in[2 + inpos - 1]) << 18);
                out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (25 - 11)
                        | ((in[3 + inpos] - in[3 + inpos - 1]) << 11);
                out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (25 - 4)
                        | ((in[4 + inpos] - in[4 + inpos - 1]) << 4)
                        | ((in[5 + inpos] - in[5 + inpos - 1]) << 29);
                out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (25 - 22)
                        | ((in[6 + inpos] - in[6 + inpos - 1]) << 22);
                out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (25 - 15)
                        | ((in[7 + inpos] - in[7 + inpos - 1]) << 15);
                out[6 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (25 - 8)
                        | ((in[8 + inpos] - in[8 + inpos - 1]) << 8);
                out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (25 - 1)
                        | ((in[9 + inpos] - in[9 + inpos - 1]) << 1)
                        | ((in[10 + inpos] - in[10 + inpos - 1]) << 26);
                out[8 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (25 - 19)
                        | ((in[11 + inpos] - in[11 + inpos - 1]) << 19);
                out[9 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (25 - 12)
                        | ((in[12 + inpos] - in[12 + inpos - 1]) << 12);
                out[10 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (25 - 5)
                        | ((in[13 + inpos] - in[13 + inpos - 1]) << 5)
                        | ((in[14 + inpos] - in[14 + inpos - 1]) << 30);
                out[11 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (25 - 23)
                        | ((in[15 + inpos] - in[15 + inpos - 1]) << 23);