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;

public final class BitPacking {
	
	


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




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




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




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




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




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




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




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




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




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




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




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




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




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




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




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




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




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




public static void fastpackwithoutmask19(final int [] in, int inpos,  final int [] out, int outpos) {
    out[ 0  + outpos] = in[ 0  + inpos] 
    | (( in[ 1  + inpos]  ) <<  19 )
    ;
    out[ 1  + outpos] =  (( in[ 1  + inpos] ) >>> ( 19  -  6 ))
    | (( in[ 2  + inpos]  ) <<  6 )
    | (( in[ 3  + inpos]  ) <<  25 )
    ;
    out[ 2  + outpos] =  (( in[ 3  + inpos] ) >>> ( 19  -  12 ))