API tools faq
paste
Advertisement
dlemire

blogbitdetect.cpp

dlemire
Apr 5th, 2012
144
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 59.17 KB | None | 0 0
raw download clone embed print report
  1. /**
  2.  * blogbitdetect.cpp
  3.  * Daniel Lemire, April 2012
  4.  * http://lemire.me/en/
  5.  * This software is in the public domain.
  6.  
  7.  $ g++-4 --version
  8.  g++-4 (GCC) 4.6.2
  9.  $ g++-4 -Ofast -o blogbitdetect blogbitdetect.cpp
  10.  $ ./blogbitdetect
  11.  1  189.6 1 325.8 1 754 1   197.4 1 105.2 1 1049 1  1917
  12.  2  174.3 2 318.1 2 754 2   296.9 2 105.2 2 1032 2  1864
  13.  3  161.7 3 324.2 3 754 3   397.1 3 106.5 3 1032 3  1864
  14.  4  151.1 4 318.1 4 762.6 4 482.8 4 105.2 4 1032 4  2097
  15.  5  137 5   316.6 5 754 5   536.9 5 107 5   1049 5  1864
  16.  6  127.3 6 318.1 6 762.6 6 578.5 6 104.2 6 1017 6  1721
  17.  7  117.3 7 319.6 7 745.7 7 588.7 7 104.7 7 1049 7  1561
  18.  8  106.7 8 327.4 8 762.6 8 599.2 8 105.2 8 1049 8  2165
  19.  9  97.83 9 325.8 9 762.6 9 615.7 9 104.9 9 1082 9  2165
  20.  10 94.79 10    324.2 10    737.5 10    604.6 10    105.5 10    1065 10 1491
  21.  11 86.37 11    318.1 11    762.6 11    615.7 11    106.2 11    1049 11 1459
  22.  12 81.54 12    324.2 12    745.7 12    615.7 12    106 12  1065 12 1428
  23.  13 77.58 13    322.6 13    754 13  621.4 13    104.5 13    1032 13 1291
  24.  14 72.01 14    324.2 14    745.7 14    621.4 14    102.6 14    1032 14 1316
  25.  15 67.31 15    321.1 15    745.7 15    615.7 15    103.9 15    1049 15 1428
  26.  16 65.41 16    324.2 16    745.7 16    615.7 16    106.7 16    1065 16 1917
  27.  17 63.61 17    322.6 17    745.7 17    610.1 17    104.4 17    1032 17 1220
  28.  18 60.51 18    325.8 18    771.4 18    610.1 18    104.5 18    1032 18 1157
  29.  19 57.41 19    324.2 19    745.7 19    610.1 19    105.2 19    1032 19 1137
  30.  20 54.65 20    319.6 20    762.6 20    604.6 20    105.5 20    1017 20 1137
  31.  21 52.68 21    316.6 21    762.6 21    615.7 21    104.5 21    1049 21 1100
  32.  22 50.12 22    321.1 22    745.7 22    615.7 22    105 22  1049 22 1177
  33.  23 49.56 23    324.2 23    745.7 23    610.1 23    102.9 23    1032 23 1049
  34.  24 47.83 24    325.8 24    754 24  615.7 24    106.7 24    1032 24 1157
  35.  25 46.38 25    324.2 25    754 25  627.2 25    103.9 25    1049 25 1049
  36.  26 44.8 26 322.6 26    754 26  615.7 26    105.5 26    1032 26 1002
  37.  27 43.07 27    313.6 27    633.1 27    532.6 27    105.2 27    958.7 27    1002
  38.  28 41.27 28    318.1 28    737.5 28    610.1 28    103.7 28    1049 28 1002
  39.  29 39.48 29    315.1 29    780.3 29    621.4 29    105.4 29    1032 29 945.2
  40.  30 38.37 30    318.1 30    771.4 30    615.7 30    104.9 30    1032 30 945.2
  41.  31 38.22 31    315.1 31    745.7 31    604.6 31    103.2 31    1032 31 932.1
  42.  32 849.5 0 318.1 0 745.7 1 1157 0  104 0   1032 0  8389
  43.  */
  44. #include <iostream>
  45. #include <iomanip>
  46. #include <sys/stat.h>
  47. #include <sys/time.h>
  48. #include <sys/types.h>
  49. #include <vector>
  50. #include <cstdlib>
  51.  
  52. typedef unsigned int uint32;
  53.  
  54. using namespace std;
  55.  
  56. vector<uint32> generateArray32(uint N, const uint mask = 0xFFFFFFFF) {
  57.     vector<uint32> ans(N);
  58.     for (size_t k = 0; k < N; ++k)
  59.         ans[k] = rand() & mask;
  60.     return ans;
  61. }
  62.  
  63. class ZTimer {
  64. public:
  65.     struct timeval t1, t2;
  66. public:
  67.     ZTimer() :
  68.         t1(), t2() {
  69.         gettimeofday(&t1, 0);
  70.         t2 = t1;
  71.     }
  72.     void reset() {
  73.         gettimeofday(&t1, 0);
  74.         t2 = t1;
  75.     }
  76.     int elapsed() {
  77.         return ((t2.tv_sec - t1.tv_sec) * 1000) + ((t2.tv_usec - t1. tv_usec)
  78.                 / 1000);
  79.     }
  80.     int split() {
  81.         gettimeofday(&t2, 0);
  82.         return elapsed();
  83.     }
  84. };
  85.  
  86. /*
  87.  uint asmbits(const uint v) {
  88.  if(v==0) return 0;
  89.  uint32       answer;
  90.  __asm__("bsr %1, %0;" :"=r"(answer) :"r"(v));
  91.  return answer+1;
  92.  }*/
  93.  
  94. uint gccbits(const uint v) {
  95.     if (v == 0)
  96.         return 0;
  97.     return 32 - __builtin_clz(v);
  98. }
  99.  
  100. uint slowbits(uint v) {
  101.     uint r = 0;
  102.     while (v) {
  103.         r++;
  104.         v = v >> 1;
  105.     }
  106.     return r;
  107. }
  108. uint bits(uint v) {
  109.     uint r(0);
  110.     if (v >= (1U << 15)) {
  111.         v >>= 16;
  112.         r += 16;
  113.     }
  114.     if (v >= (1U << 7)) {
  115.         v >>= 8;
  116.         r += 8;
  117.     }
  118.     if (v >= (1U << 3)) {
  119.         v >>= 4;
  120.         r += 4;
  121.     }
  122.     if (v >= (1U << 1)) {
  123.         v >>= 2;
  124.         r += 2;
  125.     }
  126.     if (v >= (1U << 0)) {
  127.         v >>= 1;
  128.         r += 1;
  129.     }
  130.     return r;
  131. }
  132.  
  133. /*assumes that integers fit in the prescribed number of bits */
  134. void __fastpackwithoutmask1(const uint32 * __restrict__ in,
  135.         uint32 * __restrict__ out) {
  136.     *out |= (*in);
  137.     ++in;
  138.     *out |= ((*in)) << 1;
  139.     ++in;
  140.     *out |= ((*in)) << 2;
  141.     ++in;
  142.     *out |= ((*in)) << 3;
  143.     ++in;
  144.     *out |= ((*in)) << 4;
  145.     ++in;
  146.     *out |= ((*in)) << 5;
  147.     ++in;
  148.     *out |= ((*in)) << 6;
  149.     ++in;
  150.     *out |= ((*in)) << 7;
  151.     ++in;
  152.     *out |= ((*in)) << 8;
  153.     ++in;
  154.     *out |= ((*in)) << 9;
  155.     ++in;
  156.     *out |= ((*in)) << 10;
  157.     ++in;
  158.     *out |= ((*in)) << 11;
  159.     ++in;
  160.     *out |= ((*in)) << 12;
  161.     ++in;
  162.     *out |= ((*in)) << 13;
  163.     ++in;
  164.     *out |= ((*in)) << 14;
  165.     ++in;
  166.     *out |= ((*in)) << 15;
  167.     ++in;
  168.     *out |= ((*in)) << 16;
  169.     ++in;
  170.     *out |= ((*in)) << 17;
  171.     ++in;
  172.     *out |= ((*in)) << 18;
  173.     ++in;
  174.     *out |= ((*in)) << 19;
  175.     ++in;
  176.     *out |= ((*in)) << 20;
  177.     ++in;
  178.     *out |= ((*in)) << 21;
  179.     ++in;
  180.     *out |= ((*in)) << 22;
  181.     ++in;
  182.     *out |= ((*in)) << 23;
  183.     ++in;
  184.     *out |= ((*in)) << 24;
  185.     ++in;
  186.     *out |= ((*in)) << 25;
  187.     ++in;
  188.     *out |= ((*in)) << 26;
  189.     ++in;
  190.     *out |= ((*in)) << 27;
  191.     ++in;
  192.     *out |= ((*in)) << 28;
  193.     ++in;
  194.     *out |= ((*in)) << 29;
  195.     ++in;
  196.     *out |= ((*in)) << 30;
  197.     ++in;
  198.     *out |= ((*in)) << 31;
  199. }
  200.  
  201. /*assumes that integers fit in the prescribed number of bits */
  202. void __fastpackwithoutmask2(const uint32 * __restrict__ in,
  203.         uint32 * __restrict__ out) {
  204.     *out |= (*in);
  205.     ++in;
  206.     *out |= ((*in)) << 2;
  207.     ++in;
  208.     *out |= ((*in)) << 4;
  209.     ++in;
  210.     *out |= ((*in)) << 6;
  211.     ++in;
  212.     *out |= ((*in)) << 8;
  213.     ++in;
  214.     *out |= ((*in)) << 10;
  215.     ++in;
  216.     *out |= ((*in)) << 12;
  217.     ++in;
  218.     *out |= ((*in)) << 14;
  219.     ++in;
  220.     *out |= ((*in)) << 16;
  221.     ++in;
  222.     *out |= ((*in)) << 18;
  223.     ++in;
  224.     *out |= ((*in)) << 20;
  225.     ++in;
  226.     *out |= ((*in)) << 22;
  227.     ++in;
  228.     *out |= ((*in)) << 24;
  229.     ++in;
  230.     *out |= ((*in)) << 26;
  231.     ++in;
  232.     *out |= ((*in)) << 28;
  233.     ++in;
  234.     *out |= ((*in)) << 30;
  235.     ++out;
  236.     ++in;
  237.     *out |= (*in);
  238.     ++in;
  239.     *out |= ((*in)) << 2;
  240.     ++in;
  241.     *out |= ((*in)) << 4;
  242.     ++in;
  243.     *out |= ((*in)) << 6;
  244.     ++in;
  245.     *out |= ((*in)) << 8;
  246.     ++in;
  247.     *out |= ((*in)) << 10;
  248.     ++in;
  249.     *out |= ((*in)) << 12;
  250.     ++in;
  251.     *out |= ((*in)) << 14;
  252.     ++in;
  253.     *out |= ((*in)) << 16;
  254.     ++in;
  255.     *out |= ((*in)) << 18;
  256.     ++in;
  257.     *out |= ((*in)) << 20;
  258.     ++in;
  259.     *out |= ((*in)) << 22;
  260.     ++in;
  261.     *out |= ((*in)) << 24;
  262.     ++in;
  263.     *out |= ((*in)) << 26;
  264.     ++in;
  265.     *out |= ((*in)) << 28;
  266.     ++in;
  267.     *out |= ((*in)) << 30;
  268. }
  269.  
  270. /*assumes that integers fit in the prescribed number of bits */
  271. void __fastpackwithoutmask3(const uint32 * __restrict__ in,
  272.         uint32 * __restrict__ out) {
  273.     *out |= (*in);
  274.     ++in;
  275.     *out |= ((*in)) << 3;
  276.     ++in;
  277.     *out |= ((*in)) << 6;
  278.     ++in;
  279.     *out |= ((*in)) << 9;
  280.     ++in;
  281.     *out |= ((*in)) << 12;
  282.     ++in;
  283.     *out |= ((*in)) << 15;
  284.     ++in;
  285.     *out |= ((*in)) << 18;
  286.     ++in;
  287.     *out |= ((*in)) << 21;
  288.     ++in;
  289.     *out |= ((*in)) << 24;
  290.     ++in;
  291.     *out |= ((*in)) << 27;
  292.     ++in;
  293.     *out |= ((*in)) << 30;
  294.     ++out;
  295.     *out |= ((*in)) >> (3 - 1);
  296.     ++in;
  297.     *out |= ((*in)) << 1;
  298.     ++in;
  299.     *out |= ((*in)) << 4;
  300.     ++in;
  301.     *out |= ((*in)) << 7;
  302.     ++in;
  303.     *out |= ((*in)) << 10;
  304.     ++in;
  305.     *out |= ((*in)) << 13;
  306.     ++in;
  307.     *out |= ((*in)) << 16;
  308.     ++in;
  309.     *out |= ((*in)) << 19;
  310.     ++in;
  311.     *out |= ((*in)) << 22;
  312.     ++in;
  313.     *out |= ((*in)) << 25;
  314.     ++in;
  315.     *out |= ((*in)) << 28;
  316.     ++in;
  317.     *out |= ((*in)) << 31;
  318.     ++out;
  319.     *out |= ((*in)) >> (3 - 2);
  320.     ++in;
  321.     *out |= ((*in)) << 2;
  322.     ++in;
  323.     *out |= ((*in)) << 5;
  324.     ++in;
  325.     *out |= ((*in)) << 8;
  326.     ++in;
  327.     *out |= ((*in)) << 11;
  328.     ++in;
  329.     *out |= ((*in)) << 14;
  330.     ++in;
  331.     *out |= ((*in)) << 17;
  332.     ++in;
  333.     *out |= ((*in)) << 20;
  334.     ++in;
  335.     *out |= ((*in)) << 23;
  336.     ++in;
  337.     *out |= ((*in)) << 26;
  338.     ++in;
  339.     *out |= ((*in)) << 29;
  340. }
  341.  
  342. /*assumes that integers fit in the prescribed number of bits */
  343. void __fastpackwithoutmask5(const uint32 * __restrict__ in,
  344.         uint32 * __restrict__ out) {
  345.     *out |= (*in);
  346.     ++in;
  347.     *out |= ((*in)) << 5;
  348.     ++in;
  349.     *out |= ((*in)) << 10;
  350.     ++in;
  351.     *out |= ((*in)) << 15;
  352.     ++in;
  353.     *out |= ((*in)) << 20;
  354.     ++in;
  355.     *out |= ((*in)) << 25;
  356.     ++in;
  357.     *out |= ((*in)) << 30;
  358.     ++out;
  359.     *out |= ((*in)) >> (5 - 3);
  360.     ++in;
  361.     *out |= ((*in)) << 3;
  362.     ++in;
  363.     *out |= ((*in)) << 8;
  364.     ++in;
  365.     *out |= ((*in)) << 13;
  366.     ++in;
  367.     *out |= ((*in)) << 18;
  368.     ++in;
  369.     *out |= ((*in)) << 23;
  370.     ++in;
  371.     *out |= ((*in)) << 28;
  372.     ++out;
  373.     *out |= ((*in)) >> (5 - 1);
  374.     ++in;
  375.     *out |= ((*in)) << 1;
  376.     ++in;
  377.     *out |= ((*in)) << 6;
  378.     ++in;
  379.     *out |= ((*in)) << 11;
  380.     ++in;
  381.     *out |= ((*in)) << 16;
  382.     ++in;
  383.     *out |= ((*in)) << 21;
  384.     ++in;
  385.     *out |= ((*in)) << 26;
  386.     ++in;
  387.     *out |= ((*in)) << 31;
  388.     ++out;
  389.     *out |= ((*in)) >> (5 - 4);
  390.     ++in;
  391.     *out |= ((*in)) << 4;
  392.     ++in;
  393.     *out |= ((*in)) << 9;
  394.     ++in;
  395.     *out |= ((*in)) << 14;
  396.     ++in;
  397.     *out |= ((*in)) << 19;
  398.     ++in;
  399.     *out |= ((*in)) << 24;
  400.     ++in;
  401.     *out |= ((*in)) << 29;
  402.     ++out;
  403.     *out |= ((*in)) >> (5 - 2);
  404.     ++in;
  405.     *out |= ((*in)) << 2;
  406.     ++in;
  407.     *out |= ((*in)) << 7;
  408.     ++in;
  409.     *out |= ((*in)) << 12;
  410.     ++in;
  411.     *out |= ((*in)) << 17;
  412.     ++in;
  413.     *out |= ((*in)) << 22;
  414.     ++in;
  415.     *out |= ((*in)) << 27;
  416. }
  417.  
  418. /*assumes that integers fit in the prescribed number of bits */
  419. void __fastpackwithoutmask6(const uint32 * __restrict__ in,
  420.         uint32 * __restrict__ out) {
  421.     *out |= (*in);
  422.     ++in;
  423.     *out |= ((*in)) << 6;
  424.     ++in;
  425.     *out |= ((*in)) << 12;
  426.     ++in;
  427.     *out |= ((*in)) << 18;
  428.     ++in;
  429.     *out |= ((*in)) << 24;
  430.     ++in;
  431.     *out |= ((*in)) << 30;
  432.     ++out;
  433.     *out |= ((*in)) >> (6 - 4);
  434.     ++in;
  435.     *out |= ((*in)) << 4;
  436.     ++in;
  437.     *out |= ((*in)) << 10;
  438.     ++in;
  439.     *out |= ((*in)) << 16;
  440.     ++in;
  441.     *out |= ((*in)) << 22;
  442.     ++in;
  443.     *out |= ((*in)) << 28;
  444.     ++out;
  445.     *out |= ((*in)) >> (6 - 2);
  446.     ++in;
  447.     *out |= ((*in)) << 2;
  448.     ++in;
  449.     *out |= ((*in)) << 8;
  450.     ++in;
  451.     *out |= ((*in)) << 14;
  452.     ++in;
  453.     *out |= ((*in)) << 20;
  454.     ++in;
  455.     *out |= ((*in)) << 26;
  456.     ++out;
  457.     ++in;
  458.     *out |= (*in);
  459.     ++in;
  460.     *out |= ((*in)) << 6;
  461.     ++in;
  462.     *out |= ((*in)) << 12;
  463.     ++in;
  464.     *out |= ((*in)) << 18;
  465.     ++in;
  466.     *out |= ((*in)) << 24;
  467.     ++in;
  468.     *out |= ((*in)) << 30;
  469.     ++out;
  470.     *out |= ((*in)) >> (6 - 4);
  471.     ++in;
  472.     *out |= ((*in)) << 4;
  473.     ++in;
  474.     *out |= ((*in)) << 10;
  475.     ++in;
  476.     *out |= ((*in)) << 16;
  477.     ++in;
  478.     *out |= ((*in)) << 22;
  479.     ++in;
  480.     *out |= ((*in)) << 28;
  481.     ++out;
  482.     *out |= ((*in)) >> (6 - 2);
  483.     ++in;
  484.     *out |= ((*in)) << 2;
  485.     ++in;
  486.     *out |= ((*in)) << 8;
  487.     ++in;
  488.     *out |= ((*in)) << 14;
  489.     ++in;
  490.     *out |= ((*in)) << 20;
  491.     ++in;
  492.     *out |= ((*in)) << 26;
  493. }
  494.  
  495. /*assumes that integers fit in the prescribed number of bits */
  496. void __fastpackwithoutmask7(const uint32 * __restrict__ in,
  497.         uint32 * __restrict__ out) {
  498.     *out |= (*in);
  499.     ++in;
  500.     *out |= ((*in)) << 7;
  501.     ++in;
  502.     *out |= ((*in)) << 14;
  503.     ++in;
  504.     *out |= ((*in)) << 21;
  505.     ++in;
  506.     *out |= ((*in)) << 28;
  507.     ++out;
  508.     *out |= ((*in)) >> (7 - 3);
  509.     ++in;
  510.     *out |= ((*in)) << 3;
  511.     ++in;
  512.     *out |= ((*in)) << 10;
  513.     ++in;
  514.     *out |= ((*in)) << 17;
  515.     ++in;
  516.     *out |= ((*in)) << 24;
  517.     ++in;
  518.     *out |= ((*in)) << 31;
  519.     ++out;
  520.     *out |= ((*in)) >> (7 - 6);
  521.     ++in;
  522.     *out |= ((*in)) << 6;
  523.     ++in;
  524.     *out |= ((*in)) << 13;
  525.     ++in;
  526.     *out |= ((*in)) << 20;
  527.     ++in;
  528.     *out |= ((*in)) << 27;
  529.     ++out;
  530.     *out |= ((*in)) >> (7 - 2);
  531.     ++in;
  532.     *out |= ((*in)) << 2;
  533.     ++in;
  534.     *out |= ((*in)) << 9;
  535.     ++in;
  536.     *out |= ((*in)) << 16;
  537.     ++in;
  538.     *out |= ((*in)) << 23;
  539.     ++in;
  540.     *out |= ((*in)) << 30;
  541.     ++out;
  542.     *out |= ((*in)) >> (7 - 5);
  543.     ++in;
  544.     *out |= ((*in)) << 5;
  545.     ++in;
  546.     *out |= ((*in)) << 12;
  547.     ++in;
  548.     *out |= ((*in)) << 19;
  549.     ++in;
  550.     *out |= ((*in)) << 26;
  551.     ++out;
  552.     *out |= ((*in)) >> (7 - 1);
  553.     ++in;
  554.     *out |= ((*in)) << 1;
  555.     ++in;
  556.     *out |= ((*in)) << 8;
  557.     ++in;
  558.     *out |= ((*in)) << 15;
  559.     ++in;
  560.     *out |= ((*in)) << 22;
  561.     ++in;
  562.     *out |= ((*in)) << 29;
  563.     ++out;
  564.     *out |= ((*in)) >> (7 - 4);
  565.     ++in;
  566.     *out |= ((*in)) << 4;
  567.     ++in;
  568.     *out |= ((*in)) << 11;
  569.     ++in;
  570.     *out |= ((*in)) << 18;
  571.     ++in;
  572.     *out |= ((*in)) << 25;
  573. }
  574.  
  575. /*assumes that integers fit in the prescribed number of bits */
  576. void __fastpackwithoutmask9(const uint32 * __restrict__ in,
  577.         uint32 * __restrict__ out) {
  578.     *out |= (*in);
  579.     ++in;
  580.     *out |= ((*in)) << 9;
  581.     ++in;
  582.     *out |= ((*in)) << 18;
  583.     ++in;
  584.     *out |= ((*in)) << 27;
  585.     ++out;
  586.     *out |= ((*in)) >> (9 - 4);
  587.     ++in;
  588.     *out |= ((*in)) << 4;
  589.     ++in;
  590.     *out |= ((*in)) << 13;
  591.     ++in;
  592.     *out |= ((*in)) << 22;
  593.     ++in;
  594.     *out |= ((*in)) << 31;
  595.     ++out;
  596.     *out |= ((*in)) >> (9 - 8);
  597.     ++in;
  598.     *out |= ((*in)) << 8;
  599.     ++in;
  600.     *out |= ((*in)) << 17;
  601.     ++in;
  602.     *out |= ((*in)) << 26;
  603.     ++out;
  604.     *out |= ((*in)) >> (9 - 3);
  605.     ++in;
  606.     *out |= ((*in)) << 3;
  607.     ++in;
  608.     *out |= ((*in)) << 12;
  609.     ++in;
  610.     *out |= ((*in)) << 21;
  611.     ++in;
  612.     *out |= ((*in)) << 30;
  613.     ++out;
  614.     *out |= ((*in)) >> (9 - 7);
  615.     ++in;
  616.     *out |= ((*in)) << 7;
  617.     ++in;
  618.     *out |= ((*in)) << 16;
  619.     ++in;
  620.     *out |= ((*in)) << 25;
  621.     ++out;
  622.     *out |= ((*in)) >> (9 - 2);
  623.     ++in;
  624.     *out |= ((*in)) << 2;
  625.     ++in;
  626.     *out |= ((*in)) << 11;
  627.     ++in;
  628.     *out |= ((*in)) << 20;
  629.     ++in;
  630.     *out |= ((*in)) << 29;
  631.     ++out;
  632.     *out |= ((*in)) >> (9 - 6);
  633.     ++in;
  634.     *out |= ((*in)) << 6;
  635.     ++in;
  636.     *out |= ((*in)) << 15;
  637.     ++in;
  638.     *out |= ((*in)) << 24;
  639.     ++out;
  640.     *out |= ((*in)) >> (9 - 1);
  641.     ++in;
  642.     *out |= ((*in)) << 1;
  643.     ++in;
  644.     *out |= ((*in)) << 10;
  645.     ++in;
  646.     *out |= ((*in)) << 19;
  647.     ++in;
  648.     *out |= ((*in)) << 28;
  649.     ++out;
  650.     *out |= ((*in)) >> (9 - 5);
  651.     ++in;
  652.     *out |= ((*in)) << 5;
  653.     ++in;
  654.     *out |= ((*in)) << 14;
  655.     ++in;
  656.     *out |= ((*in)) << 23;
  657. }
  658.  
  659. /*assumes that integers fit in the prescribed number of bits */
  660. void __fastpackwithoutmask10(const uint32 * __restrict__ in,
  661.         uint32 * __restrict__ out) {
  662.     *out |= (*in);
  663.     ++in;
  664.     *out |= ((*in)) << 10;
  665.     ++in;
  666.     *out |= ((*in)) << 20;
  667.     ++in;
  668.     *out |= ((*in)) << 30;
  669.     ++out;
  670.     *out |= ((*in)) >> (10 - 8);
  671.     ++in;
  672.     *out |= ((*in)) << 8;
  673.     ++in;
  674.     *out |= ((*in)) << 18;
  675.     ++in;
  676.     *out |= ((*in)) << 28;
  677.     ++out;
  678.     *out |= ((*in)) >> (10 - 6);
  679.     ++in;
  680.     *out |= ((*in)) << 6;
  681.     ++in;
  682.     *out |= ((*in)) << 16;
  683.     ++in;
  684.     *out |= ((*in)) << 26;
  685.     ++out;
  686.     *out |= ((*in)) >> (10 - 4);
  687.     ++in;
  688.     *out |= ((*in)) << 4;
  689.     ++in;
  690.     *out |= ((*in)) << 14;
  691.     ++in;
  692.     *out |= ((*in)) << 24;
  693.     ++out;
  694.     *out |= ((*in)) >> (10 - 2);
  695.     ++in;
  696.     *out |= ((*in)) << 2;
  697.     ++in;
  698.     *out |= ((*in)) << 12;
  699.     ++in;
  700.     *out |= ((*in)) << 22;
  701.     ++out;
  702.     ++in;
  703.     *out |= (*in);
  704.     ++in;
  705.     *out |= ((*in)) << 10;
  706.     ++in;
  707.     *out |= ((*in)) << 20;
  708.     ++in;
  709.     *out |= ((*in)) << 30;
  710.     ++out;
  711.     *out |= ((*in)) >> (10 - 8);
  712.     ++in;
  713.     *out |= ((*in)) << 8;
  714.     ++in;
  715.     *out |= ((*in)) << 18;
  716.     ++in;
  717.     *out |= ((*in)) << 28;
  718.     ++out;
  719.     *out |= ((*in)) >> (10 - 6);
  720.     ++in;
  721.     *out |= ((*in)) << 6;
  722.     ++in;
  723.     *out |= ((*in)) << 16;
  724.     ++in;
  725.     *out |= ((*in)) << 26;
  726.     ++out;
  727.     *out |= ((*in)) >> (10 - 4);
  728.     ++in;
  729.     *out |= ((*in)) << 4;
  730.     ++in;
  731.     *out |= ((*in)) << 14;
  732.     ++in;
  733.     *out |= ((*in)) << 24;
  734.     ++out;
  735.     *out |= ((*in)) >> (10 - 2);
  736.     ++in;
  737.     *out |= ((*in)) << 2;
  738.     ++in;
  739.     *out |= ((*in)) << 12;
  740.     ++in;
  741.     *out |= ((*in)) << 22;
  742. }
  743.  
  744. /*assumes that integers fit in the prescribed number of bits */
  745. void __fastpackwithoutmask11(const uint32 * __restrict__ in,
  746.         uint32 * __restrict__ out) {
  747.     *out |= (*in);
  748.     ++in;
  749.     *out |= ((*in)) << 11;
  750.     ++in;
  751.     *out |= ((*in)) << 22;
  752.     ++out;
  753.     *out |= ((*in)) >> (11 - 1);
  754.     ++in;
  755.     *out |= ((*in)) << 1;
  756.     ++in;
  757.     *out |= ((*in)) << 12;
  758.     ++in;
  759.     *out |= ((*in)) << 23;
  760.     ++out;
  761.     *out |= ((*in)) >> (11 - 2);
  762.     ++in;
  763.     *out |= ((*in)) << 2;
  764.     ++in;
  765.     *out |= ((*in)) << 13;
  766.     ++in;
  767.     *out |= ((*in)) << 24;
  768.     ++out;
  769.     *out |= ((*in)) >> (11 - 3);
  770.     ++in;
  771.     *out |= ((*in)) << 3;
  772.     ++in;
  773.     *out |= ((*in)) << 14;
  774.     ++in;
  775.     *out |= ((*in)) << 25;
  776.     ++out;
  777.     *out |= ((*in)) >> (11 - 4);
  778.     ++in;
  779.     *out |= ((*in)) << 4;
  780.     ++in;
  781.     *out |= ((*in)) << 15;
  782.     ++in;
  783.     *out |= ((*in)) << 26;
  784.     ++out;
  785.     *out |= ((*in)) >> (11 - 5);
  786.     ++in;
  787.     *out |= ((*in)) << 5;
  788.     ++in;
  789.     *out |= ((*in)) << 16;
  790.     ++in;
  791.     *out |= ((*in)) << 27;
  792.     ++out;
  793.     *out |= ((*in)) >> (11 - 6);
  794.     ++in;
  795.     *out |= ((*in)) << 6;
  796.     ++in;
  797.     *out |= ((*in)) << 17;
  798.     ++in;
  799.     *out |= ((*in)) << 28;
  800.     ++out;
  801.     *out |= ((*in)) >> (11 - 7);
  802.     ++in;
  803.     *out |= ((*in)) << 7;
  804.     ++in;
  805.     *out |= ((*in)) << 18;
  806.     ++in;
  807.     *out |= ((*in)) << 29;
  808.     ++out;
  809.     *out |= ((*in)) >> (11 - 8);
  810.     ++in;
  811.     *out |= ((*in)) << 8;
  812.     ++in;
  813.     *out |= ((*in)) << 19;
  814.     ++in;
  815.     *out |= ((*in)) << 30;
  816.     ++out;
  817.     *out |= ((*in)) >> (11 - 9);
  818.     ++in;
  819.     *out |= ((*in)) << 9;
  820.     ++in;
  821.     *out |= ((*in)) << 20;
  822.     ++in;
  823.     *out |= ((*in)) << 31;
  824.     ++out;
  825.     *out |= ((*in)) >> (11 - 10);
  826.     ++in;
  827.     *out |= ((*in)) << 10;
  828.     ++in;
  829.     *out |= ((*in)) << 21;
  830. }
  831.  
  832. /*assumes that integers fit in the prescribed number of bits */
  833. void __fastpackwithoutmask12(const uint32 * __restrict__ in,
  834.         uint32 * __restrict__ out) {
  835.     *out |= (*in);
  836.     ++in;
  837.     *out |= ((*in)) << 12;
  838.     ++in;
  839.     *out |= ((*in)) << 24;
  840.     ++out;
  841.     *out |= ((*in)) >> (12 - 4);
  842.     ++in;
  843.     *out |= ((*in)) << 4;
  844.     ++in;
  845.     *out |= ((*in)) << 16;
  846.     ++in;
  847.     *out |= ((*in)) << 28;
  848.     ++out;
  849.     *out |= ((*in)) >> (12 - 8);
  850.     ++in;
  851.     *out |= ((*in)) << 8;
  852.     ++in;
  853.     *out |= ((*in)) << 20;
  854.     ++out;
  855.     ++in;
  856.     *out |= (*in);
  857.     ++in;
  858.     *out |= ((*in)) << 12;
  859.     ++in;
  860.     *out |= ((*in)) << 24;
  861.     ++out;
  862.     *out |= ((*in)) >> (12 - 4);
  863.     ++in;
  864.     *out |= ((*in)) << 4;
  865.     ++in;
  866.     *out |= ((*in)) << 16;
  867.     ++in;
  868.     *out |= ((*in)) << 28;
  869.     ++out;
  870.     *out |= ((*in)) >> (12 - 8);
  871.     ++in;
  872.     *out |= ((*in)) << 8;
  873.     ++in;
  874.     *out |= ((*in)) << 20;
  875.     ++out;
  876.     ++in;
  877.     *out |= (*in);
  878.     ++in;
  879.     *out |= ((*in)) << 12;
  880.     ++in;
  881.     *out |= ((*in)) << 24;
  882.     ++out;
  883.     *out |= ((*in)) >> (12 - 4);
  884.     ++in;
  885.     *out |= ((*in)) << 4;
  886.     ++in;
  887.     *out |= ((*in)) << 16;
  888.     ++in;
  889.     *out |= ((*in)) << 28;
  890.     ++out;
  891.     *out |= ((*in)) >> (12 - 8);
  892.     ++in;
  893.     *out |= ((*in)) << 8;
  894.     ++in;
  895.     *out |= ((*in)) << 20;
  896.     ++out;
  897.     ++in;
  898.     *out |= (*in);
  899.     ++in;
  900.     *out |= ((*in)) << 12;
  901.     ++in;
  902.     *out |= ((*in)) << 24;
  903.     ++out;
  904.     *out |= ((*in)) >> (12 - 4);
  905.     ++in;
  906.     *out |= ((*in)) << 4;
  907.     ++in;
  908.     *out |= ((*in)) << 16;
  909.     ++in;
  910.     *out |= ((*in)) << 28;
  911.     ++out;
  912.     *out |= ((*in)) >> (12 - 8);
  913.     ++in;
  914.     *out |= ((*in)) << 8;
  915.     ++in;
  916.     *out |= ((*in)) << 20;
  917. }
  918.  
  919. /*assumes that integers fit in the prescribed number of bits */
  920. void __fastpackwithoutmask13(const uint32 * __restrict__ in,
  921.         uint32 * __restrict__ out) {
  922.     *out |= (*in);
  923.     ++in;
  924.     *out |= ((*in)) << 13;
  925.     ++in;
  926.     *out |= ((*in)) << 26;
  927.     ++out;
  928.     *out |= ((*in)) >> (13 - 7);
  929.     ++in;
  930.     *out |= ((*in)) << 7;
  931.     ++in;
  932.     *out |= ((*in)) << 20;
  933.     ++out;
  934.     *out |= ((*in)) >> (13 - 1);
  935.     ++in;
  936.     *out |= ((*in)) << 1;
  937.     ++in;
  938.     *out |= ((*in)) << 14;
  939.     ++in;
  940.     *out |= ((*in)) << 27;
  941.     ++out;
  942.     *out |= ((*in)) >> (13 - 8);
  943.     ++in;
  944.     *out |= ((*in)) << 8;
  945.     ++in;
  946.     *out |= ((*in)) << 21;
  947.     ++out;
  948.     *out |= ((*in)) >> (13 - 2);
  949.     ++in;
  950.     *out |= ((*in)) << 2;
  951.     ++in;
  952.     *out |= ((*in)) << 15;
  953.     ++in;
  954.     *out |= ((*in)) << 28;
  955.     ++out;
  956.     *out |= ((*in)) >> (13 - 9);
  957.     ++in;
  958.     *out |= ((*in)) << 9;
  959.     ++in;
  960.     *out |= ((*in)) << 22;
  961.     ++out;
  962.     *out |= ((*in)) >> (13 - 3);
  963.     ++in;
  964.     *out |= ((*in)) << 3;
  965.     ++in;
  966.     *out |= ((*in)) << 16;
  967.     ++in;
  968.     *out |= ((*in)) << 29;
  969.     ++out;
  970.     *out |= ((*in)) >> (13 - 10);
  971.     ++in;
  972.     *out |= ((*in)) << 10;
  973.     ++in;
  974.     *out |= ((*in)) << 23;
  975.     ++out;
  976.     *out |= ((*in)) >> (13 - 4);
  977.     ++in;
  978.     *out |= ((*in)) << 4;
  979.     ++in;
  980.     *out |= ((*in)) << 17;
  981.     ++in;
  982.     *out |= ((*in)) << 30;
  983.     ++out;
  984.     *out |= ((*in)) >> (13 - 11);
  985.     ++in;
  986.     *out |= ((*in)) << 11;
  987.     ++in;
  988.     *out |= ((*in)) << 24;
  989.     ++out;
  990.     *out |= ((*in)) >> (13 - 5);
  991.     ++in;
  992.     *out |= ((*in)) << 5;
  993.     ++in;
  994.     *out |= ((*in)) << 18;
  995.     ++in;
  996.     *out |= ((*in)) << 31;
  997.     ++out;
  998.     *out |= ((*in)) >> (13 - 12);
  999.     ++in;
  1000.     *out |= ((*in)) << 12;
  1001.     ++in;
  1002.     *out |= ((*in)) << 25;
  1003.     ++out;
  1004.     *out |= ((*in)) >> (13 - 6);
  1005.     ++in;
  1006.     *out |= ((*in)) << 6;
  1007.     ++in;
  1008.     *out |= ((*in)) << 19;
  1009. }
  1010.  
  1011. /*assumes that integers fit in the prescribed number of bits */
  1012. void __fastpackwithoutmask14(const uint32 * __restrict__ in,
  1013.         uint32 * __restrict__ out) {
  1014.     *out |= (*in);
  1015.     ++in;
  1016.     *out |= ((*in)) << 14;
  1017.     ++in;
  1018.     *out |= ((*in)) << 28;
  1019.     ++out;
  1020.     *out |= ((*in)) >> (14 - 10);
  1021.     ++in;
  1022.     *out |= ((*in)) << 10;
  1023.     ++in;
  1024.     *out |= ((*in)) << 24;
  1025.     ++out;
  1026.     *out |= ((*in)) >> (14 - 6);
  1027.     ++in;
  1028.     *out |= ((*in)) << 6;
  1029.     ++in;
  1030.     *out |= ((*in)) << 20;
  1031.     ++out;
  1032.     *out |= ((*in)) >> (14 - 2);
  1033.     ++in;
  1034.     *out |= ((*in)) << 2;
  1035.     ++in;
  1036.     *out |= ((*in)) << 16;
  1037.     ++in;
  1038.     *out |= ((*in)) << 30;
  1039.     ++out;
  1040.     *out |= ((*in)) >> (14 - 12);
  1041.     ++in;
  1042.     *out |= ((*in)) << 12;
  1043.     ++in;
  1044.     *out |= ((*in)) << 26;
  1045.     ++out;
  1046.     *out |= ((*in)) >> (14 - 8);
  1047.     ++in;
  1048.     *out |= ((*in)) << 8;
  1049.     ++in;
  1050.     *out |= ((*in)) << 22;
  1051.     ++out;
  1052.     *out |= ((*in)) >> (14 - 4);
  1053.     ++in;
  1054.     *out |= ((*in)) << 4;
  1055.     ++in;
  1056.     *out |= ((*in)) << 18;
  1057.     ++out;
  1058.     ++in;
  1059.     *out |= (*in);
  1060.     ++in;
  1061.     *out |= ((*in)) << 14;
  1062.     ++in;
  1063.     *out |= ((*in)) << 28;
  1064.     ++out;
  1065.     *out |= ((*in)) >> (14 - 10);
  1066.     ++in;
  1067.     *out |= ((*in)) << 10;
  1068.     ++in;
  1069.     *out |= ((*in)) << 24;
  1070.     ++out;
  1071.     *out |= ((*in)) >> (14 - 6);
  1072.     ++in;
  1073.     *out |= ((*in)) << 6;
  1074.     ++in;
  1075.     *out |= ((*in)) << 20;
  1076.     ++out;
  1077.     *out |= ((*in)) >> (14 - 2);
  1078.     ++in;
  1079.     *out |= ((*in)) << 2;
  1080.     ++in;
  1081.     *out |= ((*in)) << 16;
  1082.     ++in;
  1083.     *out |= ((*in)) << 30;
  1084.     ++out;
  1085.     *out |= ((*in)) >> (14 - 12);
  1086.     ++in;
  1087.     *out |= ((*in)) << 12;
  1088.     ++in;
  1089.     *out |= ((*in)) << 26;
  1090.     ++out;
  1091.     *out |= ((*in)) >> (14 - 8);
  1092.     ++in;
  1093.     *out |= ((*in)) << 8;
  1094.     ++in;
  1095.     *out |= ((*in)) << 22;
  1096.     ++out;
  1097.     *out |= ((*in)) >> (14 - 4);
  1098.     ++in;
  1099.     *out |= ((*in)) << 4;
  1100.     ++in;
  1101.     *out |= ((*in)) << 18;
  1102. }
  1103.  
  1104. /*assumes that integers fit in the prescribed number of bits */
  1105. void __fastpackwithoutmask15(const uint32 * __restrict__ in,
  1106.         uint32 * __restrict__ out) {
  1107.     *out |= (*in);
  1108.     ++in;
  1109.     *out |= ((*in)) << 15;
  1110.     ++in;
  1111.     *out |= ((*in)) << 30;
  1112.     ++out;
  1113.     *out |= ((*in)) >> (15 - 13);
  1114.     ++in;
  1115.     *out |= ((*in)) << 13;
  1116.     ++in;
  1117.     *out |= ((*in)) << 28;
  1118.     ++out;
  1119.     *out |= ((*in)) >> (15 - 11);
  1120.     ++in;
  1121.     *out |= ((*in)) << 11;
  1122.     ++in;
  1123.     *out |= ((*in)) << 26;
  1124.     ++out;
  1125.     *out |= ((*in)) >> (15 - 9);
  1126.     ++in;
  1127.     *out |= ((*in)) << 9;
  1128.     ++in;
  1129.     *out |= ((*in)) << 24;
  1130.     ++out;
  1131.     *out |= ((*in)) >> (15 - 7);
  1132.     ++in;
  1133.     *out |= ((*in)) << 7;
  1134.     ++in;
  1135.     *out |= ((*in)) << 22;
  1136.     ++out;
  1137.     *out |= ((*in)) >> (15 - 5);
  1138.     ++in;
  1139.     *out |= ((*in)) << 5;
  1140.     ++in;
  1141.     *out |= ((*in)) << 20;
  1142.     ++out;
  1143.     *out |= ((*in)) >> (15 - 3);
  1144.     ++in;
  1145.     *out |= ((*in)) << 3;
  1146.     ++in;
  1147.     *out |= ((*in)) << 18;
  1148.     ++out;
  1149.     *out |= ((*in)) >> (15 - 1);
  1150.     ++in;
  1151.     *out |= ((*in)) << 1;
  1152.     ++in;
  1153.     *out |= ((*in)) << 16;
  1154.     ++in;
  1155.     *out |= ((*in)) << 31;
  1156.     ++out;
  1157.     *out |= ((*in)) >> (15 - 14);
  1158.     ++in;
  1159.     *out |= ((*in)) << 14;
  1160.     ++in;
  1161.     *out |= ((*in)) << 29;
  1162.     ++out;
  1163.     *out |= ((*in)) >> (15 - 12);
  1164.     ++in;
  1165.     *out |= ((*in)) << 12;
  1166.     ++in;
  1167.     *out |= ((*in)) << 27;
  1168.     ++out;
  1169.     *out |= ((*in)) >> (15 - 10);
  1170.     ++in;
  1171.     *out |= ((*in)) << 10;
  1172.     ++in;
  1173.     *out |= ((*in)) << 25;
  1174.     ++out;
  1175.     *out |= ((*in)) >> (15 - 8);
  1176.     ++in;
  1177.     *out |= ((*in)) << 8;
  1178.     ++in;
  1179.     *out |= ((*in)) << 23;
  1180.     ++out;
  1181.     *out |= ((*in)) >> (15 - 6);
  1182.     ++in;
  1183.     *out |= ((*in)) << 6;
  1184.     ++in;
  1185.     *out |= ((*in)) << 21;
  1186.     ++out;
  1187.     *out |= ((*in)) >> (15 - 4);
  1188.     ++in;
  1189.     *out |= ((*in)) << 4;
  1190.     ++in;
  1191.     *out |= ((*in)) << 19;
  1192.     ++out;
  1193.     *out |= ((*in)) >> (15 - 2);
  1194.     ++in;
  1195.     *out |= ((*in)) << 2;
  1196.     ++in;
  1197.     *out |= ((*in)) << 17;
  1198. }
  1199.  
  1200. /*assumes that integers fit in the prescribed number of bits */
  1201. void __fastpackwithoutmask17(const uint32 * __restrict__ in,
  1202.         uint32 * __restrict__ out) {
  1203.     *out |= (*in);
  1204.     ++in;
  1205.     *out |= ((*in)) << 17;
  1206.     ++out;
  1207.     *out |= ((*in)) >> (17 - 2);
  1208.     ++in;
  1209.     *out |= ((*in)) << 2;
  1210.     ++in;
  1211.     *out |= ((*in)) << 19;
  1212.     ++out;
  1213.     *out |= ((*in)) >> (17 - 4);
  1214.     ++in;
  1215.     *out |= ((*in)) << 4;
  1216.     ++in;
  1217.     *out |= ((*in)) << 21;
  1218.     ++out;
  1219.     *out |= ((*in)) >> (17 - 6);
  1220.     ++in;
  1221.     *out |= ((*in)) << 6;
  1222.     ++in;
  1223.     *out |= ((*in)) << 23;
  1224.     ++out;
  1225.     *out |= ((*in)) >> (17 - 8);
  1226.     ++in;
  1227.     *out |= ((*in)) << 8;
  1228.     ++in;
  1229.     *out |= ((*in)) << 25;
  1230.     ++out;
  1231.     *out |= ((*in)) >> (17 - 10);
  1232.     ++in;
  1233.     *out |= ((*in)) << 10;
  1234.     ++in;
  1235.     *out |= ((*in)) << 27;
  1236.     ++out;
  1237.     *out |= ((*in)) >> (17 - 12);
  1238.     ++in;
  1239.     *out |= ((*in)) << 12;
  1240.     ++in;
  1241.     *out |= ((*in)) << 29;
  1242.     ++out;
  1243.     *out |= ((*in)) >> (17 - 14);
  1244.     ++in;
  1245.     *out |= ((*in)) << 14;
  1246.     ++in;
  1247.     *out |= ((*in)) << 31;
  1248.     ++out;
  1249.     *out |= ((*in)) >> (17 - 16);
  1250.     ++in;
  1251.     *out |= ((*in)) << 16;
  1252.     ++out;
  1253.     *out |= ((*in)) >> (17 - 1);
  1254.     ++in;
  1255.     *out |= ((*in)) << 1;
  1256.     ++in;
  1257.     *out |= ((*in)) << 18;
  1258.     ++out;
  1259.     *out |= ((*in)) >> (17 - 3);
  1260.     ++in;
  1261.     *out |= ((*in)) << 3;
  1262.     ++in;
  1263.     *out |= ((*in)) << 20;
  1264.     ++out;
  1265.     *out |= ((*in)) >> (17 - 5);
  1266.     ++in;
  1267.     *out |= ((*in)) << 5;
  1268.     ++in;
  1269.     *out |= ((*in)) << 22;
  1270.     ++out;
  1271.     *out |= ((*in)) >> (17 - 7);
  1272.     ++in;
  1273.     *out |= ((*in)) << 7;
  1274.     ++in;
  1275.     *out |= ((*in)) << 24;
  1276.     ++out;
  1277.     *out |= ((*in)) >> (17 - 9);
  1278.     ++in;
  1279.     *out |= ((*in)) << 9;
  1280.     ++in;
  1281.     *out |= ((*in)) << 26;
  1282.     ++out;
  1283.     *out |= ((*in)) >> (17 - 11);
  1284.     ++in;
  1285.     *out |= ((*in)) << 11;
  1286.     ++in;
  1287.     *out |= ((*in)) << 28;
  1288.     ++out;
  1289.     *out |= ((*in)) >> (17 - 13);
  1290.     ++in;
  1291.     *out |= ((*in)) << 13;
  1292.     ++in;
  1293.     *out |= ((*in)) << 30;
  1294.     ++out;
  1295.     *out |= ((*in)) >> (17 - 15);
  1296.     ++in;
  1297.     *out |= ((*in)) << 15;
  1298. }
  1299.  
  1300. /*assumes that integers fit in the prescribed number of bits */
  1301. void __fastpackwithoutmask18(const uint32 * __restrict__ in,
  1302.         uint32 * __restrict__ out) {
  1303.     *out |= (*in);
  1304.     ++in;
  1305.     *out |= ((*in)) << 18;
  1306.     ++out;
  1307.     *out |= ((*in)) >> (18 - 4);
  1308.     ++in;
  1309.     *out |= ((*in)) << 4;
  1310.     ++in;
  1311.     *out |= ((*in)) << 22;
  1312.     ++out;
  1313.     *out |= ((*in)) >> (18 - 8);
  1314.     ++in;
  1315.     *out |= ((*in)) << 8;
  1316.     ++in;
  1317.     *out |= ((*in)) << 26;
  1318.     ++out;
  1319.     *out |= ((*in)) >> (18 - 12);
  1320.     ++in;
  1321.     *out |= ((*in)) << 12;
  1322.     ++in;
  1323.     *out |= ((*in)) << 30;
  1324.     ++out;
  1325.     *out |= ((*in)) >> (18 - 16);
  1326.     ++in;
  1327.     *out |= ((*in)) << 16;
  1328.     ++out;
  1329.     *out |= ((*in)) >> (18 - 2);
  1330.     ++in;
  1331.     *out |= ((*in)) << 2;
  1332.     ++in;
  1333.     *out |= ((*in)) << 20;
  1334.     ++out;
  1335.     *out |= ((*in)) >> (18 - 6);
  1336.     ++in;
  1337.     *out |= ((*in)) << 6;
  1338.     ++in;
  1339.     *out |= ((*in)) << 24;
  1340.     ++out;
  1341.     *out |= ((*in)) >> (18 - 10);
  1342.     ++in;
  1343.     *out |= ((*in)) << 10;
  1344.     ++in;
  1345.     *out |= ((*in)) << 28;
  1346.     ++out;
  1347.     *out |= ((*in)) >> (18 - 14);
  1348.     ++in;
  1349.     *out |= ((*in)) << 14;
  1350.     ++out;
  1351.     ++in;
  1352.     *out |= (*in);
  1353.     ++in;
  1354.     *out |= ((*in)) << 18;
  1355.     ++out;
  1356.     *out |= ((*in)) >> (18 - 4);
  1357.     ++in;
  1358.     *out |= ((*in)) << 4;
  1359.     ++in;
  1360.     *out |= ((*in)) << 22;
  1361.     ++out;
  1362.     *out |= ((*in)) >> (18 - 8);
  1363.     ++in;
  1364.     *out |= ((*in)) << 8;
  1365.     ++in;
  1366.     *out |= ((*in)) << 26;
  1367.     ++out;
  1368.     *out |= ((*in)) >> (18 - 12);
  1369.     ++in;
  1370.     *out |= ((*in)) << 12;
  1371.     ++in;
  1372.     *out |= ((*in)) << 30;
  1373.     ++out;
  1374.     *out |= ((*in)) >> (18 - 16);
  1375.     ++in;
  1376.     *out |= ((*in)) << 16;
  1377.     ++out;
  1378.     *out |= ((*in)) >> (18 - 2);
  1379.     ++in;
  1380.     *out |= ((*in)) << 2;
  1381.     ++in;
  1382.     *out |= ((*in)) << 20;
  1383.     ++out;
  1384.     *out |= ((*in)) >> (18 - 6);
  1385.     ++in;
  1386.     *out |= ((*in)) << 6;
  1387.     ++in;
  1388.     *out |= ((*in)) << 24;
  1389.     ++out;
  1390.     *out |= ((*in)) >> (18 - 10);
  1391.     ++in;
  1392.     *out |= ((*in)) << 10;
  1393.     ++in;
  1394.     *out |= ((*in)) << 28;
  1395.     ++out;
  1396.     *out |= ((*in)) >> (18 - 14);
  1397.     ++in;
  1398.     *out |= ((*in)) << 14;
  1399. }
  1400.  
  1401. /*assumes that integers fit in the prescribed number of bits */
  1402. void __fastpackwithoutmask19(const uint32 * __restrict__ in,
  1403.         uint32 * __restrict__ out) {
  1404.     *out |= (*in);
  1405.     ++in;
  1406.     *out |= ((*in)) << 19;
  1407.     ++out;
  1408.     *out |= ((*in)) >> (19 - 6);
  1409.     ++in;
  1410.     *out |= ((*in)) << 6;
  1411.     ++in;
  1412.     *out |= ((*in)) << 25;
  1413.     ++out;
  1414.     *out |= ((*in)) >> (19 - 12);
  1415.     ++in;
  1416.     *out |= ((*in)) << 12;
  1417.     ++in;
  1418.     *out |= ((*in)) << 31;
  1419.     ++out;
  1420.     *out |= ((*in)) >> (19 - 18);
  1421.     ++in;
  1422.     *out |= ((*in)) << 18;
  1423.     ++out;
  1424.     *out |= ((*in)) >> (19 - 5);
  1425.     ++in;
  1426.     *out |= ((*in)) << 5;
  1427.     ++in;
  1428.     *out |= ((*in)) << 24;
  1429.     ++out;
  1430.     *out |= ((*in)) >> (19 - 11);
  1431.     ++in;
  1432.     *out |= ((*in)) << 11;
  1433.     ++in;
  1434.     *out |= ((*in)) << 30;
  1435.     ++out;
  1436.     *out |= ((*in)) >> (19 - 17);
  1437.     ++in;
  1438.     *out |= ((*in)) << 17;
  1439.     ++out;
  1440.     *out |= ((*in)) >> (19 - 4);
  1441.     ++in;
  1442.     *out |= ((*in)) << 4;
  1443.     ++in;
  1444.     *out |= ((*in)) << 23;
  1445.     ++out;
  1446.     *out |= ((*in)) >> (19 - 10);
  1447.     ++in;
  1448.     *out |= ((*in)) << 10;
  1449.     ++in;
  1450.     *out |= ((*in)) << 29;
  1451.     ++out;
  1452.     *out |= ((*in)) >> (19 - 16);
  1453.     ++in;
  1454.     *out |= ((*in)) << 16;
  1455.     ++out;
  1456.     *out |= ((*in)) >> (19 - 3);
  1457.     ++in;
  1458.     *out |= ((*in)) << 3;
  1459.     ++in;
  1460.     *out |= ((*in)) << 22;
  1461.     ++out;
  1462.     *out |= ((*in)) >> (19 - 9);
  1463.     ++in;
  1464.     *out |= ((*in)) << 9;
  1465.     ++in;
  1466.     *out |= ((*in)) << 28;
  1467.     ++out;
  1468.     *out |= ((*in)) >> (19 - 15);
  1469.     ++in;
  1470.     *out |= ((*in)) << 15;
  1471.     ++out;
  1472.     *out |= ((*in)) >> (19 - 2);
  1473.     ++in;
  1474.     *out |= ((*in)) << 2;
  1475.     ++in;
  1476.     *out |= ((*in)) << 21;
  1477.     ++out;
  1478.     *out |= ((*in)) >> (19 - 8);
  1479.     ++in;
  1480.     *out |= ((*in)) << 8;
  1481.     ++in;
  1482.     *out |= ((*in)) << 27;
  1483.     ++out;
  1484.     *out |= ((*in)) >> (19 - 14);
  1485.     ++in;
  1486.     *out |= ((*in)) << 14;
  1487.     ++out;
  1488.     *out |= ((*in)) >> (19 - 1);
  1489.     ++in;
  1490.     *out |= ((*in)) << 1;
  1491.     ++in;
  1492.     *out |= ((*in)) << 20;
  1493.     ++out;
  1494.     *out |= ((*in)) >> (19 - 7);
  1495.     ++in;
  1496.     *out |= ((*in)) << 7;
  1497.     ++in;
  1498.     *out |= ((*in)) << 26;
  1499.     ++out;
  1500.     *out |= ((*in)) >> (19 - 13);
  1501.     ++in;
  1502.     *out |= ((*in)) << 13;
  1503. }
  1504.  
  1505. /*assumes that integers fit in the prescribed number of bits */
  1506. void __fastpackwithoutmask20(const uint32 * __restrict__ in,
  1507.         uint32 * __restrict__ out) {
  1508.     *out |= (*in);
  1509.     ++in;
  1510.     *out |= ((*in)) << 20;
  1511.     ++out;
  1512.     *out |= ((*in)) >> (20 - 8);
  1513.     ++in;
  1514.     *out |= ((*in)) << 8;
  1515.     ++in;
  1516.     *out |= ((*in)) << 28;
  1517.     ++out;
  1518.     *out |= ((*in)) >> (20 - 16);
  1519.     ++in;
  1520.     *out |= ((*in)) << 16;
  1521.     ++out;
  1522.     *out |= ((*in)) >> (20 - 4);
  1523.     ++in;
  1524.     *out |= ((*in)) << 4;
  1525.     ++in;
  1526.     *out |= ((*in)) << 24;
  1527.     ++out;
  1528.     *out |= ((*in)) >> (20 - 12);
  1529.     ++in;
  1530.     *out |= ((*in)) << 12;
  1531.     ++out;
  1532.     ++in;
  1533.     *out |= (*in);
  1534.     ++in;
  1535.     *out |= ((*in)) << 20;
  1536.     ++out;
  1537.     *out |= ((*in)) >> (20 - 8);
  1538.     ++in;
  1539.     *out |= ((*in)) << 8;
  1540.     ++in;
  1541.     *out |= ((*in)) << 28;
  1542.     ++out;
  1543.     *out |= ((*in)) >> (20 - 16);
  1544.     ++in;
  1545.     *out |= ((*in)) << 16;
  1546.     ++out;
  1547.     *out |= ((*in)) >> (20 - 4);
  1548.     ++in;
  1549.     *out |= ((*in)) << 4;
  1550.     ++in;
  1551.     *out |= ((*in)) << 24;
  1552.     ++out;
  1553.     *out |= ((*in)) >> (20 - 12);
  1554.     ++in;
  1555.     *out |= ((*in)) << 12;
  1556.     ++out;
  1557.     ++in;
  1558.     *out |= (*in);
  1559.     ++in;
  1560.     *out |= ((*in)) << 20;
  1561.     ++out;
  1562.     *out |= ((*in)) >> (20 - 8);
  1563.     ++in;
  1564.     *out |= ((*in)) << 8;
  1565.     ++in;
  1566.     *out |= ((*in)) << 28;
  1567.     ++out;
  1568.     *out |= ((*in)) >> (20 - 16);
  1569.     ++in;
  1570.     *out |= ((*in)) << 16;
  1571.     ++out;
  1572.     *out |= ((*in)) >> (20 - 4);
  1573.     ++in;
  1574.     *out |= ((*in)) << 4;
  1575.     ++in;
  1576.     *out |= ((*in)) << 24;
  1577.     ++out;
  1578.     *out |= ((*in)) >> (20 - 12);
  1579.     ++in;
  1580.     *out |= ((*in)) << 12;
  1581.     ++out;
  1582.     ++in;
  1583.     *out |= (*in);
  1584.     ++in;
  1585.     *out |= ((*in)) << 20;
  1586.     ++out;
  1587.     *out |= ((*in)) >> (20 - 8);
  1588.     ++in;
  1589.     *out |= ((*in)) << 8;
  1590.     ++in;
  1591.     *out |= ((*in)) << 28;
  1592.     ++out;
  1593.     *out |= ((*in)) >> (20 - 16);
  1594.     ++in;
  1595.     *out |= ((*in)) << 16;
  1596.     ++out;
  1597.     *out |= ((*in)) >> (20 - 4);
  1598.     ++in;
  1599.     *out |= ((*in)) << 4;
  1600.     ++in;
  1601.     *out |= ((*in)) << 24;
  1602.     ++out;
  1603.     *out |= ((*in)) >> (20 - 12);
  1604.     ++in;
  1605.     *out |= ((*in)) << 12;
  1606. }
  1607.  
  1608. /*assumes that integers fit in the prescribed number of bits */
  1609. void __fastpackwithoutmask21(const uint32 * __restrict__ in,
  1610.         uint32 * __restrict__ out) {
  1611.     *out |= (*in);
  1612.     ++in;
  1613.     *out |= ((*in)) << 21;
  1614.     ++out;
  1615.     *out |= ((*in)) >> (21 - 10);
  1616.     ++in;
  1617.     *out |= ((*in)) << 10;
  1618.     ++in;
  1619.     *out |= ((*in)) << 31;
  1620.     ++out;
  1621.     *out |= ((*in)) >> (21 - 20);
  1622.     ++in;
  1623.     *out |= ((*in)) << 20;
  1624.     ++out;
  1625.     *out |= ((*in)) >> (21 - 9);
  1626.     ++in;
  1627.     *out |= ((*in)) << 9;
  1628.     ++in;
  1629.     *out |= ((*in)) << 30;
  1630.     ++out;
  1631.     *out |= ((*in)) >> (21 - 19);
  1632.     ++in;
  1633.     *out |= ((*in)) << 19;
  1634.     ++out;
  1635.     *out |= ((*in)) >> (21 - 8);
  1636.     ++in;
  1637.     *out |= ((*in)) << 8;
  1638.     ++in;
  1639.     *out |= ((*in)) << 29;
  1640.     ++out;
  1641.     *out |= ((*in)) >> (21 - 18);
  1642.     ++in;
  1643.     *out |= ((*in)) << 18;
  1644.     ++out;
  1645.     *out |= ((*in)) >> (21 - 7);
  1646.     ++in;
  1647.     *out |= ((*in)) << 7;
  1648.     ++in;
  1649.     *out |= ((*in)) << 28;
  1650.     ++out;
  1651.     *out |= ((*in)) >> (21 - 17);
  1652.     ++in;
  1653.     *out |= ((*in)) << 17;
  1654.     ++out;
  1655.     *out |= ((*in)) >> (21 - 6);
  1656.     ++in;
  1657.     *out |= ((*in)) << 6;
  1658.     ++in;
  1659.     *out |= ((*in)) << 27;
  1660.     ++out;
  1661.     *out |= ((*in)) >> (21 - 16);
  1662.     ++in;
  1663.     *out |= ((*in)) << 16;
  1664.     ++out;
  1665.     *out |= ((*in)) >> (21 - 5);
  1666.     ++in;
  1667.     *out |= ((*in)) << 5;
  1668.     ++in;
  1669.     *out |= ((*in)) << 26;
  1670.     ++out;
  1671.     *out |= ((*in)) >> (21 - 15);
  1672.     ++in;
  1673.     *out |= ((*in)) << 15;
  1674.     ++out;
  1675.     *out |= ((*in)) >> (21 - 4);
  1676.     ++in;
  1677.     *out |= ((*in)) << 4;
  1678.     ++in;
  1679.     *out |= ((*in)) << 25;
  1680.     ++out;
  1681.     *out |= ((*in)) >> (21 - 14);
  1682.     ++in;
  1683.     *out |= ((*in)) << 14;
  1684.     ++out;
  1685.     *out |= ((*in)) >> (21 - 3);
  1686.     ++in;
  1687.     *out |= ((*in)) << 3;
  1688.     ++in;
  1689.     *out |= ((*in)) << 24;
  1690.     ++out;
  1691.     *out |= ((*in)) >> (21 - 13);
  1692.     ++in;
  1693.     *out |= ((*in)) << 13;
  1694.     ++out;
  1695.     *out |= ((*in)) >> (21 - 2);
  1696.     ++in;
  1697.     *out |= ((*in)) << 2;
  1698.     ++in;
  1699.     *out |= ((*in)) << 23;
  1700.     ++out;
  1701.     *out |= ((*in)) >> (21 - 12);
  1702.     ++in;
  1703.     *out |= ((*in)) << 12;
  1704.     ++out;
  1705.     *out |= ((*in)) >> (21 - 1);
  1706.     ++in;
  1707.     *out |= ((*in)) << 1;
  1708.     ++in;
  1709.     *out |= ((*in)) << 22;
  1710.     ++out;
  1711.     *out |= ((*in)) >> (21 - 11);
  1712.     ++in;
  1713.     *out |= ((*in)) << 11;
  1714. }
  1715.  
  1716. /*assumes that integers fit in the prescribed number of bits */
  1717. void __fastpackwithoutmask22(const uint32 * __restrict__ in,
  1718.         uint32 * __restrict__ out) {
  1719.     *out |= (*in);
  1720.     ++in;
  1721.     *out |= ((*in)) << 22;
  1722.     ++out;
  1723.     *out |= ((*in)) >> (22 - 12);
  1724.     ++in;
  1725.     *out |= ((*in)) << 12;
  1726.     ++out;
  1727.     *out |= ((*in)) >> (22 - 2);
  1728.     ++in;
  1729.     *out |= ((*in)) << 2;
  1730.     ++in;
  1731.     *out |= ((*in)) << 24;
  1732.     ++out;
  1733.     *out |= ((*in)) >> (22 - 14);
  1734.     ++in;
  1735.     *out |= ((*in)) << 14;
  1736.     ++out;
  1737.     *out |= ((*in)) >> (22 - 4);
  1738.     ++in;
  1739.     *out |= ((*in)) << 4;
  1740.     ++in;
  1741.     *out |= ((*in)) << 26;
  1742.     ++out;
  1743.     *out |= ((*in)) >> (22 - 16);
  1744.     ++in;
  1745.     *out |= ((*in)) << 16;
  1746.     ++out;
  1747.     *out |= ((*in)) >> (22 - 6);
  1748.     ++in;
  1749.     *out |= ((*in)) << 6;
  1750.     ++in;
  1751.     *out |= ((*in)) << 28;
  1752.     ++out;
  1753.     *out |= ((*in)) >> (22 - 18);
  1754.     ++in;
  1755.     *out |= ((*in)) << 18;
  1756.     ++out;
  1757.     *out |= ((*in)) >> (22 - 8);
  1758.     ++in;
  1759.     *out |= ((*in)) << 8;
  1760.     ++in;
  1761.     *out |= ((*in)) << 30;
  1762.     ++out;
  1763.     *out |= ((*in)) >> (22 - 20);
  1764.     ++in;
  1765.     *out |= ((*in)) << 20;
  1766.     ++out;
  1767.     *out |= ((*in)) >> (22 - 10);
  1768.     ++in;
  1769.     *out |= ((*in)) << 10;
  1770.     ++out;
  1771.     ++in;
  1772.     *out |= (*in);
  1773.     ++in;
  1774.     *out |= ((*in)) << 22;
  1775.     ++out;
  1776.     *out |= ((*in)) >> (22 - 12);
  1777.     ++in;
  1778.     *out |= ((*in)) << 12;
  1779.     ++out;
  1780.     *out |= ((*in)) >> (22 - 2);
  1781.     ++in;
  1782.     *out |= ((*in)) << 2;
  1783.     ++in;
  1784.     *out |= ((*in)) << 24;
  1785.     ++out;
  1786.     *out |= ((*in)) >> (22 - 14);
  1787.     ++in;
  1788.     *out |= ((*in)) << 14;
  1789.     ++out;
  1790.     *out |= ((*in)) >> (22 - 4);
  1791.     ++in;
  1792.     *out |= ((*in)) << 4;
  1793.     ++in;
  1794.     *out |= ((*in)) << 26;
  1795.     ++out;
  1796.     *out |= ((*in)) >> (22 - 16);
  1797.     ++in;
  1798.     *out |= ((*in)) << 16;
  1799.     ++out;
  1800.     *out |= ((*in)) >> (22 - 6);
  1801.     ++in;
  1802.     *out |= ((*in)) << 6;
  1803.     ++in;
  1804.     *out |= ((*in)) << 28;
  1805.     ++out;
  1806.     *out |= ((*in)) >> (22 - 18);
  1807.     ++in;
  1808.     *out |= ((*in)) << 18;
  1809.     ++out;
  1810.     *out |= ((*in)) >> (22 - 8);
  1811.     ++in;
  1812.     *out |= ((*in)) << 8;
  1813.     ++in;
  1814.     *out |= ((*in)) << 30;
  1815.     ++out;
  1816.     *out |= ((*in)) >> (22 - 20);
  1817.     ++in;
  1818.     *out |= ((*in)) << 20;
  1819.     ++out;
  1820.     *out |= ((*in)) >> (22 - 10);
  1821.     ++in;
  1822.     *out |= ((*in)) << 10;
  1823. }
  1824.  
  1825. /*assumes that integers fit in the prescribed number of bits */
  1826. void __fastpackwithoutmask23(const uint32 * __restrict__ in,
  1827.         uint32 * __restrict__ out) {
  1828.     *out |= (*in);
  1829.     ++in;
  1830.     *out |= ((*in)) << 23;
  1831.     ++out;
  1832.     *out |= ((*in)) >> (23 - 14);
  1833.     ++in;
  1834.     *out |= ((*in)) << 14;
  1835.     ++out;
  1836.     *out |= ((*in)) >> (23 - 5);
  1837.     ++in;
  1838.     *out |= ((*in)) << 5;
  1839.     ++in;
  1840.     *out |= ((*in)) << 28;
  1841.     ++out;
  1842.     *out |= ((*in)) >> (23 - 19);
  1843.     ++in;
  1844.     *out |= ((*in)) << 19;
  1845.     ++out;
  1846.     *out |= ((*in)) >> (23 - 10);
  1847.     ++in;
  1848.     *out |= ((*in)) << 10;
  1849.     ++out;
  1850.     *out |= ((*in)) >> (23 - 1);
  1851.     ++in;
  1852.     *out |= ((*in)) << 1;
  1853.     ++in;
  1854.     *out |= ((*in)) << 24;
  1855.     ++out;
  1856.     *out |= ((*in)) >> (23 - 15);
  1857.     ++in;
  1858.     *out |= ((*in)) << 15;
  1859.     ++out;
  1860.     *out |= ((*in)) >> (23 - 6);
  1861.     ++in;
  1862.     *out |= ((*in)) << 6;
  1863.     ++in;
  1864.     *out |= ((*in)) << 29;
  1865.     ++out;
  1866.     *out |= ((*in)) >> (23 - 20);
  1867.     ++in;
  1868.     *out |= ((*in)) << 20;
  1869.     ++out;
  1870.     *out |= ((*in)) >> (23 - 11);
  1871.     ++in;
  1872.     *out |= ((*in)) << 11;
  1873.     ++out;
  1874.     *out |= ((*in)) >> (23 - 2);
  1875.     ++in;
  1876.     *out |= ((*in)) << 2;
  1877.     ++in;
  1878.     *out |= ((*in)) << 25;
  1879.     ++out;
  1880.     *out |= ((*in)) >> (23 - 16);
  1881.     ++in;
  1882.     *out |= ((*in)) << 16;
  1883.     ++out;
  1884.     *out |= ((*in)) >> (23 - 7);
  1885.     ++in;
  1886.     *out |= ((*in)) << 7;
  1887.     ++in;
  1888.     *out |= ((*in)) << 30;
  1889.     ++out;
  1890.     *out |= ((*in)) >> (23 - 21);
  1891.     ++in;
  1892.     *out |= ((*in)) << 21;
  1893.     ++out;
  1894.     *out |= ((*in)) >> (23 - 12);
  1895.     ++in;
  1896.     *out |= ((*in)) << 12;
  1897.     ++out;
  1898.     *out |= ((*in)) >> (23 - 3);
  1899.     ++in;
  1900.     *out |= ((*in)) << 3;
  1901.     ++in;
  1902.     *out |= ((*in)) << 26;
  1903.     ++out;
  1904.     *out |= ((*in)) >> (23 - 17);
  1905.     ++in;
  1906.     *out |= ((*in)) << 17;
  1907.     ++out;
  1908.     *out |= ((*in)) >> (23 - 8);
  1909.     ++in;
  1910.     *out |= ((*in)) << 8;
  1911.     ++in;
  1912.     *out |= ((*in)) << 31;
  1913.     ++out;
  1914.     *out |= ((*in)) >> (23 - 22);
  1915.     ++in;
  1916.     *out |= ((*in)) << 22;
  1917.     ++out;
  1918.     *out |= ((*in)) >> (23 - 13);
  1919.     ++in;
  1920.     *out |= ((*in)) << 13;
  1921.     ++out;
  1922.     *out |= ((*in)) >> (23 - 4);
  1923.     ++in;
  1924.     *out |= ((*in)) << 4;
  1925.     ++in;
  1926.     *out |= ((*in)) << 27;
  1927.     ++out;
  1928.     *out |= ((*in)) >> (23 - 18);
  1929.     ++in;
  1930.     *out |= ((*in)) << 18;
  1931.     ++out;
  1932.     *out |= ((*in)) >> (23 - 9);
  1933.     ++in;
  1934.     *out |= ((*in)) << 9;
  1935. }
  1936.  
  1937. /*assumes that integers fit in the prescribed number of bits */
  1938. void __fastpackwithoutmask24(const uint32 * __restrict__ in,
  1939.         uint32 * __restrict__ out) {
  1940.     *out |= (*in);
  1941.     ++in;
  1942.     *out |= ((*in)) << 24;
  1943.     ++out;
  1944.     *out |= ((*in)) >> (24 - 16);
  1945.     ++in;
  1946.     *out |= ((*in)) << 16;
  1947.     ++out;
  1948.     *out |= ((*in)) >> (24 - 8);
  1949.     ++in;
  1950.     *out |= ((*in)) << 8;
  1951.     ++out;
  1952.     ++in;
  1953.     *out |= (*in);
  1954.     ++in;
  1955.     *out |= ((*in)) << 24;
  1956.     ++out;
  1957.     *out |= ((*in)) >> (24 - 16);
  1958.     ++in;
  1959.     *out |= ((*in)) << 16;
  1960.     ++out;
  1961.     *out |= ((*in)) >> (24 - 8);
  1962.     ++in;
  1963.     *out |= ((*in)) << 8;
  1964.     ++out;
  1965.     ++in;
  1966.     *out |= (*in);
  1967.     ++in;
  1968.     *out |= ((*in)) << 24;
  1969.     ++out;
  1970.     *out |= ((*in)) >> (24 - 16);
  1971.     ++in;
  1972.     *out |= ((*in)) << 16;
  1973.     ++out;
  1974.     *out |= ((*in)) >> (24 - 8);
  1975.     ++in;
  1976.     *out |= ((*in)) << 8;
  1977.     ++out;
  1978.     ++in;
  1979.     *out |= (*in);
  1980.     ++in;
  1981.     *out |= ((*in)) << 24;
  1982.     ++out;
  1983.     *out |= ((*in)) >> (24 - 16);
  1984.     ++in;
  1985.     *out |= ((*in)) << 16;
  1986.     ++out;
  1987.     *out |= ((*in)) >> (24 - 8);
  1988.     ++in;
  1989.     *out |= ((*in)) << 8;
  1990.     ++out;
  1991.     ++in;
  1992.     *out |= (*in);
  1993.     ++in;
  1994.     *out |= ((*in)) << 24;
  1995.     ++out;
  1996.     *out |= ((*in)) >> (24 - 16);
  1997.     ++in;
  1998.     *out |= ((*in)) << 16;
  1999.     ++out;
  2000.     *out |= ((*in)) >> (24 - 8);
  2001.     ++in;
  2002.     *out |= ((*in)) << 8;
  2003.     ++out;
  2004.     ++in;
  2005.     *out |= (*in);
  2006.     ++in;
  2007.     *out |= ((*in)) << 24;
  2008.     ++out;
  2009.     *out |= ((*in)) >> (24 - 16);
  2010.     ++in;
  2011.     *out |= ((*in)) << 16;
  2012.     ++out;
  2013.     *out |= ((*in)) >> (24 - 8);
  2014.     ++in;
  2015.     *out |= ((*in)) << 8;
  2016.     ++out;
  2017.     ++in;
  2018.     *out |= (*in);
  2019.     ++in;
  2020.     *out |= ((*in)) << 24;
  2021.     ++out;
  2022.     *out |= ((*in)) >> (24 - 16);
  2023.     ++in;
  2024.     *out |= ((*in)) << 16;
  2025.     ++out;
  2026.     *out |= ((*in)) >> (24 - 8);
  2027.     ++in;
  2028.     *out |= ((*in)) << 8;
  2029.     ++out;
  2030.     ++in;
  2031.     *out |= (*in);
  2032.     ++in;
  2033.     *out |= ((*in)) << 24;
  2034.     ++out;
  2035.     *out |= ((*in)) >> (24 - 16);
  2036.     ++in;
  2037.     *out |= ((*in)) << 16;
  2038.     ++out;
  2039.     *out |= ((*in)) >> (24 - 8);
  2040.     ++in;
  2041.     *out |= ((*in)) << 8;
  2042. }
  2043.  
  2044. /*assumes that integers fit in the prescribed number of bits */
  2045. void __fastpackwithoutmask25(const uint32 * __restrict__ in,
  2046.         uint32 * __restrict__ out) {
  2047.     *out |= (*in);
  2048.     ++in;
  2049.     *out |= ((*in)) << 25;
  2050.     ++out;
  2051.     *out |= ((*in)) >> (25 - 18);
  2052.     ++in;
  2053.     *out |= ((*in)) << 18;
  2054.     ++out;
  2055.     *out |= ((*in)) >> (25 - 11);
  2056.     ++in;
  2057.     *out |= ((*in)) << 11;
  2058.     ++out;
  2059.     *out |= ((*in)) >> (25 - 4);
  2060.     ++in;
  2061.     *out |= ((*in)) << 4;
  2062.     ++in;
  2063.     *out |= ((*in)) << 29;
  2064.     ++out;
  2065.     *out |= ((*in)) >> (25 - 22);
  2066.     ++in;
  2067.     *out |= ((*in)) << 22;
  2068.     ++out;
  2069.     *out |= ((*in)) >> (25 - 15);
  2070.     ++in;
  2071.     *out |= ((*in)) << 15;
  2072.     ++out;
  2073.     *out |= ((*in)) >> (25 - 8);
  2074.     ++in;
  2075.     *out |= ((*in)) << 8;
  2076.     ++out;
  2077.     *out |= ((*in)) >> (25 - 1);
  2078.     ++in;
  2079.     *out |= ((*in)) << 1;
  2080.     ++in;
  2081.     *out |= ((*in)) << 26;
  2082.     ++out;
  2083.     *out |= ((*in)) >> (25 - 19);
  2084.     ++in;
  2085.     *out |= ((*in)) << 19;
  2086.     ++out;
  2087.     *out |= ((*in)) >> (25 - 12);
  2088.     ++in;
  2089.     *out |= ((*in)) << 12;
  2090.     ++out;
  2091.     *out |= ((*in)) >> (25 - 5);
  2092.     ++in;
  2093.     *out |= ((*in)) << 5;
  2094.     ++in;
  2095.     *out |= ((*in)) << 30;
  2096.     ++out;
  2097.     *out |= ((*in)) >> (25 - 23);
  2098.     ++in;
  2099.     *out |= ((*in)) << 23;
  2100.     ++out;
  2101.     *out |= ((*in)) >> (25 - 16);
  2102.     ++in;
  2103.     *out |= ((*in)) << 16;
  2104.     ++out;
  2105.     *out |= ((*in)) >> (25 - 9);
  2106.     ++in;
  2107.     *out |= ((*in)) << 9;
  2108.     ++out;
  2109.     *out |= ((*in)) >> (25 - 2);
  2110.     ++in;
  2111.     *out |= ((*in)) << 2;
  2112.     ++in;
  2113.     *out |= ((*in)) << 27;
  2114.     ++out;
  2115.     *out |= ((*in)) >> (25 - 20);
  2116.     ++in;
  2117.     *out |= ((*in)) << 20;
  2118.     ++out;
  2119.     *out |= ((*in)) >> (25 - 13);
  2120.     ++in;
  2121.     *out |= ((*in)) << 13;
  2122.     ++out;
  2123.     *out |= ((*in)) >> (25 - 6);
  2124.     ++in;
  2125.     *out |= ((*in)) << 6;
  2126.     ++in;
  2127.     *out |= ((*in)) << 31;
  2128.     ++out;
  2129.     *out |= ((*in)) >> (25 - 24);
  2130.     ++in;
  2131.     *out |= ((*in)) << 24;
  2132.     ++out;
  2133.     *out |= ((*in)) >> (25 - 17);
  2134.     ++in;
  2135.     *out |= ((*in)) << 17;
  2136.     ++out;
  2137.     *out |= ((*in)) >> (25 - 10);
  2138.     ++in;
  2139.     *out |= ((*in)) << 10;
  2140.     ++out;
  2141.     *out |= ((*in)) >> (25 - 3);
  2142.     ++in;
  2143.     *out |= ((*in)) << 3;
  2144.     ++in;
  2145.     *out |= ((*in)) << 28;
  2146.     ++out;
  2147.     *out |= ((*in)) >> (25 - 21);
  2148.     ++in;
  2149.     *out |= ((*in)) << 21;
  2150.     ++out;
  2151.     *out |= ((*in)) >> (25 - 14);
  2152.     ++in;
  2153.     *out |= ((*in)) << 14;
  2154.     ++out;
  2155.     *out |= ((*in)) >> (25 - 7);
  2156.     ++in;
  2157.     *out |= ((*in)) << 7;
  2158. }
  2159.  
  2160. /*assumes that integers fit in the prescribed number of bits */
  2161. void __fastpackwithoutmask26(const uint32 * __restrict__ in,
  2162.         uint32 * __restrict__ out) {
  2163.     *out |= (*in);
  2164.     ++in;
  2165.     *out |= ((*in)) << 26;
  2166.     ++out;
  2167.     *out |= ((*in)) >> (26 - 20);
  2168.     ++in;
  2169.     *out |= ((*in)) << 20;
  2170.     ++out;
  2171.     *out |= ((*in)) >> (26 - 14);
  2172.     ++in;
  2173.     *out |= ((*in)) << 14;
  2174.     ++out;
  2175.     *out |= ((*in)) >> (26 - 8);
  2176.     ++in;
  2177.     *out |= ((*in)) << 8;
  2178.     ++out;
  2179.     *out |= ((*in)) >> (26 - 2);
  2180.     ++in;
  2181.     *out |= ((*in)) << 2;
  2182.     ++in;
  2183.     *out |= ((*in)) << 28;
  2184.     ++out;
  2185.     *out |= ((*in)) >> (26 - 22);
  2186.     ++in;
  2187.     *out |= ((*in)) << 22;
  2188.     ++out;
  2189.     *out |= ((*in)) >> (26 - 16);
  2190.     ++in;
  2191.     *out |= ((*in)) << 16;
  2192.     ++out;
  2193.     *out |= ((*in)) >> (26 - 10);
  2194.     ++in;
  2195.     *out |= ((*in)) << 10;
  2196.     ++out;
  2197.     *out |= ((*in)) >> (26 - 4);
  2198.     ++in;
  2199.     *out |= ((*in)) << 4;
  2200.     ++in;
  2201.     *out |= ((*in)) << 30;
  2202.     ++out;
  2203.     *out |= ((*in)) >> (26 - 24);
  2204.     ++in;
  2205.     *out |= ((*in)) << 24;
  2206.     ++out;
  2207.     *out |= ((*in)) >> (26 - 18);
  2208.     ++in;
  2209.     *out |= ((*in)) << 18;
  2210.     ++out;
  2211.     *out |= ((*in)) >> (26 - 12);
  2212.     ++in;
  2213.     *out |= ((*in)) << 12;
  2214.     ++out;
  2215.     *out |= ((*in)) >> (26 - 6);
  2216.     ++in;
  2217.     *out |= ((*in)) << 6;
  2218.     ++out;
  2219.     ++in;
  2220.     *out |= (*in);
  2221.     ++in;
  2222.     *out |= ((*in)) << 26;
  2223.     ++out;
  2224.     *out |= ((*in)) >> (26 - 20);
  2225.     ++in;
  2226.     *out |= ((*in)) << 20;
  2227.     ++out;
  2228.     *out |= ((*in)) >> (26 - 14);
  2229.     ++in;
  2230.     *out |= ((*in)) << 14;
  2231.     ++out;
  2232.     *out |= ((*in)) >> (26 - 8);
  2233.     ++in;
  2234.     *out |= ((*in)) << 8;
  2235.     ++out;
  2236.     *out |= ((*in)) >> (26 - 2);
  2237.     ++in;
  2238.     *out |= ((*in)) << 2;
  2239.     ++in;
  2240.     *out |= ((*in)) << 28;
  2241.     ++out;
  2242.     *out |= ((*in)) >> (26 - 22);
  2243.     ++in;
  2244.     *out |= ((*in)) << 22;
  2245.     ++out;
  2246.     *out |= ((*in)) >> (26 - 16);
  2247.     ++in;
  2248.     *out |= ((*in)) << 16;
  2249.     ++out;
  2250.     *out |= ((*in)) >> (26 - 10);
  2251.     ++in;
  2252.     *out |= ((*in)) << 10;
  2253.     ++out;
  2254.     *out |= ((*in)) >> (26 - 4);
  2255.     ++in;
  2256.     *out |= ((*in)) << 4;
  2257.     ++in;
  2258.     *out |= ((*in)) << 30;
  2259.     ++out;
  2260.     *out |= ((*in)) >> (26 - 24);
  2261.     ++in;
  2262.     *out |= ((*in)) << 24;
  2263.     ++out;
  2264.     *out |= ((*in)) >> (26 - 18);
  2265.     ++in;
  2266.     *out |= ((*in)) << 18;
  2267.     ++out;
  2268.     *out |= ((*in)) >> (26 - 12);
  2269.     ++in;
  2270.     *out |= ((*in)) << 12;
  2271.     ++out;
  2272.     *out |= ((*in)) >> (26 - 6);
  2273.     ++in;
  2274.     *out |= ((*in)) << 6;
  2275. }
  2276.  
  2277. /*assumes that integers fit in the prescribed number of bits */
  2278. void __fastpackwithoutmask27(const uint32 * __restrict__ in,
  2279.         uint32 * __restrict__ out) {
  2280.     *out |= (*in);
  2281.     ++in;
  2282.     *out |= ((*in)) << 27;
  2283.     ++out;
  2284.     *out |= ((*in)) >> (27 - 22);
  2285.     ++in;
  2286.     *out |= ((*in)) << 22;
  2287.     ++out;
  2288.     *out |= ((*in)) >> (27 - 17);
  2289.     ++in;
  2290.     *out |= ((*in)) << 17;
  2291.     ++out;
  2292.     *out |= ((*in)) >> (27 - 12);
  2293.     ++in;
  2294.     *out |= ((*in)) << 12;
  2295.     ++out;
  2296.     *out |= ((*in)) >> (27 - 7);
  2297.     ++in;
  2298.     *out |= ((*in)) << 7;
  2299.     ++out;
  2300.     *out |= ((*in)) >> (27 - 2);
  2301.     ++in;
  2302.     *out |= ((*in)) << 2;
  2303.     ++in;
  2304.     *out |= ((*in)) << 29;
  2305.     ++out;
  2306.     *out |= ((*in)) >> (27 - 24);
  2307.     ++in;
  2308.     *out |= ((*in)) << 24;
  2309.     ++out;
  2310.     *out |= ((*in)) >> (27 - 19);
  2311.     ++in;
  2312.     *out |= ((*in)) << 19;
  2313.     ++out;
  2314.     *out |= ((*in)) >> (27 - 14);
  2315.     ++in;
  2316.     *out |= ((*in)) << 14;
  2317.     ++out;
  2318.     *out |= ((*in)) >> (27 - 9);
  2319.     ++in;
  2320.     *out |= ((*in)) << 9;
  2321.     ++out;
  2322.     *out |= ((*in)) >> (27 - 4);
  2323.     ++in;
  2324.     *out |= ((*in)) << 4;
  2325.     ++in;
  2326.     *out |= ((*in)) << 31;
  2327.     ++out;
  2328.     *out |= ((*in)) >> (27 - 26);
  2329.     ++in;
  2330.     *out |= ((*in)) << 26;
  2331.     ++out;
  2332.     *out |= ((*in)) >> (27 - 21);
  2333.     ++in;
  2334.     *out |= ((*in)) << 21;
  2335.     ++out;
  2336.     *out |= ((*in)) >> (27 - 16);
  2337.     ++in;
  2338.     *out |= ((*in)) << 16;
  2339.     ++out;
  2340.     *out |= ((*in)) >> (27 - 11);
  2341.     ++in;
  2342.     *out |= ((*in)) << 11;
  2343.     ++out;
  2344.     *out |= ((*in)) >> (27 - 6);
  2345.     ++in;
  2346.     *out |= ((*in)) << 6;
  2347.     ++out;
  2348.     *out |= ((*in)) >> (27 - 1);
  2349.     ++in;
  2350.     *out |= ((*in)) << 1;
  2351.     ++in;
  2352.     *out |= ((*in)) << 28;
  2353.     ++out;
  2354.     *out |= ((*in)) >> (27 - 23);
  2355.     ++in;
  2356.     *out |= ((*in)) << 23;
  2357.     ++out;
  2358.     *out |= ((*in)) >> (27 - 18);
  2359.     ++in;
  2360.     *out |= ((*in)) << 18;
  2361.     ++out;
  2362.     *out |= ((*in)) >> (27 - 13);
  2363.     ++in;
  2364.     *out |= ((*in)) << 13;
  2365.     ++out;
  2366.     *out |= ((*in)) >> (27 - 8);
  2367.     ++in;
  2368.     *out |= ((*in)) << 8;
  2369.     ++out;
  2370.     *out |= ((*in)) >> (27 - 3);
  2371.     ++in;
  2372.     *out |= ((*in)) << 3;
  2373.     ++in;
  2374.     *out |= ((*in)) << 30;
  2375.     ++out;
  2376.     *out |= ((*in)) >> (27 - 25);
  2377.     ++in;
  2378.     *out |= ((*in)) << 25;
  2379.     ++out;
  2380.     *out |= ((*in)) >> (27 - 20);
  2381.     ++in;
  2382.     *out |= ((*in)) << 20;
  2383.     ++out;
  2384.     *out |= ((*in)) >> (27 - 15);
  2385.     ++in;
  2386.     *out |= ((*in)) << 15;
  2387.     ++out;
  2388.     *out |= ((*in)) >> (27 - 10);
  2389.     ++in;
  2390.     *out |= ((*in)) << 10;
  2391.     ++out;
  2392.     *out |= ((*in)) >> (27 - 5);
  2393.     ++in;
  2394.     *out |= ((*in)) << 5;
  2395. }
  2396.  
  2397. /*assumes that integers fit in the prescribed number of bits */
  2398. void __fastpackwithoutmask28(const uint32 * __restrict__ in,
  2399.         uint32 * __restrict__ out) {
  2400.     *out |= (*in);
  2401.     ++in;
  2402.     *out |= ((*in)) << 28;
  2403.     ++out;
  2404.     *out |= ((*in)) >> (28 - 24);
  2405.     ++in;
  2406.     *out |= ((*in)) << 24;
  2407.     ++out;
  2408.     *out |= ((*in)) >> (28 - 20);
  2409.     ++in;
  2410.     *out |= ((*in)) << 20;
  2411.     ++out;
  2412.     *out |= ((*in)) >> (28 - 16);
  2413.     ++in;
  2414.     *out |= ((*in)) << 16;
  2415.     ++out;
  2416.     *out |= ((*in)) >> (28 - 12);
  2417.     ++in;
  2418.     *out |= ((*in)) << 12;
  2419.     ++out;
  2420.     *out |= ((*in)) >> (28 - 8);
  2421.     ++in;
  2422.     *out |= ((*in)) << 8;
  2423.     ++out;
  2424.     *out |= ((*in)) >> (28 - 4);
  2425.     ++in;
  2426.     *out |= ((*in)) << 4;
  2427.     ++out;
  2428.     ++in;
  2429.     *out |= (*in);
  2430.     ++in;
  2431.     *out |= ((*in)) << 28;
  2432.     ++out;
  2433.     *out |= ((*in)) >> (28 - 24);
  2434.     ++in;
  2435.     *out |= ((*in)) << 24;
  2436.     ++out;
  2437.     *out |= ((*in)) >> (28 - 20);
  2438.     ++in;
  2439.     *out |= ((*in)) << 20;
  2440.     ++out;
  2441.     *out |= ((*in)) >> (28 - 16);
  2442.     ++in;
  2443.     *out |= ((*in)) << 16;
  2444.     ++out;
  2445.     *out |= ((*in)) >> (28 - 12);
  2446.     ++in;
  2447.     *out |= ((*in)) << 12;
  2448.     ++out;
  2449.     *out |= ((*in)) >> (28 - 8);
  2450.     ++in;
  2451.     *out |= ((*in)) << 8;
  2452.     ++out;
  2453.     *out |= ((*in)) >> (28 - 4);
  2454.     ++in;
  2455.     *out |= ((*in)) << 4;
  2456.     ++out;
  2457.     ++in;
  2458.     *out |= (*in);
  2459.     ++in;
  2460.     *out |= ((*in)) << 28;
  2461.     ++out;
  2462.     *out |= ((*in)) >> (28 - 24);
  2463.     ++in;
  2464.     *out |= ((*in)) << 24;
  2465.     ++out;
  2466.     *out |= ((*in)) >> (28 - 20);
  2467.     ++in;
  2468.     *out |= ((*in)) << 20;
  2469.     ++out;
  2470.     *out |= ((*in)) >> (28 - 16);
  2471.     ++in;
  2472.     *out |= ((*in)) << 16;
  2473.     ++out;
  2474.     *out |= ((*in)) >> (28 - 12);
  2475.     ++in;
  2476.     *out |= ((*in)) << 12;
  2477.     ++out;
  2478.     *out |= ((*in)) >> (28 - 8);
  2479.     ++in;
  2480.     *out |= ((*in)) << 8;
  2481.     ++out;
  2482.     *out |= ((*in)) >> (28 - 4);
  2483.     ++in;
  2484.     *out |= ((*in)) << 4;
  2485.     ++out;
  2486.     ++in;
  2487.     *out |= (*in);
  2488.     ++in;
  2489.     *out |= ((*in)) << 28;
  2490.     ++out;
  2491.     *out |= ((*in)) >> (28 - 24);
  2492.     ++in;
  2493.     *out |= ((*in)) << 24;
  2494.     ++out;
  2495.     *out |= ((*in)) >> (28 - 20);
  2496.     ++in;
  2497.     *out |= ((*in)) << 20;
  2498.     ++out;
  2499.     *out |= ((*in)) >> (28 - 16);
  2500.     ++in;
  2501.     *out |= ((*in)) << 16;
  2502.     ++out;
  2503.     *out |= ((*in)) >> (28 - 12);
  2504.     ++in;
  2505.     *out |= ((*in)) << 12;
  2506.     ++out;
  2507.     *out |= ((*in)) >> (28 - 8);
  2508.     ++in;
  2509.     *out |= ((*in)) << 8;
  2510.     ++out;
  2511.     *out |= ((*in)) >> (28 - 4);
  2512.     ++in;
  2513.     *out |= ((*in)) << 4;
  2514. }
  2515.  
  2516. /*assumes that integers fit in the prescribed number of bits */
  2517. void __fastpackwithoutmask29(const uint32 * __restrict__ in,
  2518.         uint32 * __restrict__ out) {
  2519.     *out |= (*in);
  2520.     ++in;
  2521.     *out |= ((*in)) << 29;
  2522.     ++out;
  2523.     *out |= ((*in)) >> (29 - 26);
  2524.     ++in;
  2525.     *out |= ((*in)) << 26;
  2526.     ++out;
  2527.     *out |= ((*in)) >> (29 - 23);
  2528.     ++in;
  2529.     *out |= ((*in)) << 23;
  2530.     ++out;
  2531.     *out |= ((*in)) >> (29 - 20);
  2532.     ++in;
  2533.     *out |= ((*in)) << 20;
  2534.     ++out;
  2535.     *out |= ((*in)) >> (29 - 17);
  2536.     ++in;
  2537.     *out |= ((*in)) << 17;
  2538.     ++out;
  2539.     *out |= ((*in)) >> (29 - 14);
  2540.     ++in;
  2541.     *out |= ((*in)) << 14;
  2542.     ++out;
  2543.     *out |= ((*in)) >> (29 - 11);
  2544.     ++in;
  2545.     *out |= ((*in)) << 11;
  2546.     ++out;
  2547.     *out |= ((*in)) >> (29 - 8);
  2548.     ++in;
  2549.     *out |= ((*in)) << 8;
  2550.     ++out;
  2551.     *out |= ((*in)) >> (29 - 5);
  2552.     ++in;
  2553.     *out |= ((*in)) << 5;
  2554.     ++out;
  2555.     *out |= ((*in)) >> (29 - 2);
  2556.     ++in;
  2557.     *out |= ((*in)) << 2;
  2558.     ++in;
  2559.     *out |= ((*in)) << 31;
  2560.     ++out;
  2561.     *out |= ((*in)) >> (29 - 28);
  2562.     ++in;
  2563.     *out |= ((*in)) << 28;
  2564.     ++out;
  2565.     *out |= ((*in)) >> (29 - 25);
  2566.     ++in;
  2567.     *out |= ((*in)) << 25;
  2568.     ++out;
  2569.     *out |= ((*in)) >> (29 - 22);
  2570.     ++in;
  2571.     *out |= ((*in)) << 22;
  2572.     ++out;
  2573.     *out |= ((*in)) >> (29 - 19);
  2574.     ++in;
  2575.     *out |= ((*in)) << 19;
  2576.     ++out;
  2577.     *out |= ((*in)) >> (29 - 16);
  2578.     ++in;
  2579.     *out |= ((*in)) << 16;
  2580.     ++out;
  2581.     *out |= ((*in)) >> (29 - 13);
  2582.     ++in;
  2583.     *out |= ((*in)) << 13;
  2584.     ++out;
  2585.     *out |= ((*in)) >> (29 - 10);
  2586.     ++in;
  2587.     *out |= ((*in)) << 10;
  2588.     ++out;
  2589.     *out |= ((*in)) >> (29 - 7);
  2590.     ++in;
  2591.     *out |= ((*in)) << 7;
  2592.     ++out;
  2593.     *out |= ((*in)) >> (29 - 4);
  2594.     ++in;
  2595.     *out |= ((*in)) << 4;
  2596.     ++out;
  2597.     *out |= ((*in)) >> (29 - 1);
  2598.     ++in;
  2599.     *out |= ((*in)) << 1;
  2600.     ++in;
  2601.     *out |= ((*in)) << 30;
  2602.     ++out;
  2603.     *out |= ((*in)) >> (29 - 27);
  2604.     ++in;
  2605.     *out |= ((*in)) << 27;
  2606.     ++out;
  2607.     *out |= ((*in)) >> (29 - 24);
  2608.     ++in;
  2609.     *out |= ((*in)) << 24;
  2610.     ++out;
  2611.     *out |= ((*in)) >> (29 - 21);
  2612.     ++in;
  2613.     *out |= ((*in)) << 21;
  2614.     ++out;
  2615.     *out |= ((*in)) >> (29 - 18);
  2616.     ++in;
  2617.     *out |= ((*in)) << 18;
  2618.     ++out;
  2619.     *out |= ((*in)) >> (29 - 15);
  2620.     ++in;
  2621.     *out |= ((*in)) << 15;
  2622.     ++out;
  2623.     *out |= ((*in)) >> (29 - 12);
  2624.     ++in;
  2625.     *out |= ((*in)) << 12;
  2626.     ++out;
  2627.     *out |= ((*in)) >> (29 - 9);
  2628.     ++in;
  2629.     *out |= ((*in)) << 9;
  2630.     ++out;
  2631.     *out |= ((*in)) >> (29 - 6);
  2632.     ++in;
  2633.     *out |= ((*in)) << 6;
  2634.     ++out;
  2635.     *out |= ((*in)) >> (29 - 3);
  2636.     ++in;
  2637.     *out |= ((*in)) << 3;
  2638. }
  2639.  
  2640. /*assumes that integers fit in the prescribed number of bits */
  2641. void __fastpackwithoutmask30(const uint32 * __restrict__ in,
  2642.         uint32 * __restrict__ out) {
  2643.     *out |= (*in);
  2644.     ++in;
  2645.     *out |= ((*in)) << 30;
  2646.     ++out;
  2647.     *out |= ((*in)) >> (30 - 28);
  2648.     ++in;
  2649.     *out |= ((*in)) << 28;
  2650.     ++out;
  2651.     *out |= ((*in)) >> (30 - 26);
  2652.     ++in;
  2653.     *out |= ((*in)) << 26;
  2654.     ++out;
  2655.     *out |= ((*in)) >> (30 - 24);
  2656.     ++in;
  2657.     *out |= ((*in)) << 24;
  2658.     ++out;
  2659.     *out |= ((*in)) >> (30 - 22);
  2660.     ++in;
  2661.     *out |= ((*in)) << 22;
  2662.     ++out;
  2663.     *out |= ((*in)) >> (30 - 20);
  2664.     ++in;
  2665.     *out |= ((*in)) << 20;
  2666.     ++out;
  2667.     *out |= ((*in)) >> (30 - 18);
  2668.     ++in;
  2669.     *out |= ((*in)) << 18;
  2670.     ++out;
  2671.     *out |= ((*in)) >> (30 - 16);
  2672.     ++in;
  2673.     *out |= ((*in)) << 16;
  2674.     ++out;
  2675.     *out |= ((*in)) >> (30 - 14);
  2676.     ++in;
  2677.     *out |= ((*in)) << 14;
  2678.     ++out;
  2679.     *out |= ((*in)) >> (30 - 12);
  2680.     ++in;
  2681.     *out |= ((*in)) << 12;
  2682.     ++out;
  2683.     *out |= ((*in)) >> (30 - 10);
  2684.     ++in;
  2685.     *out |= ((*in)) << 10;
  2686.     ++out;
  2687.     *out |= ((*in)) >> (30 - 8);
  2688.     ++in;
  2689.     *out |= ((*in)) << 8;
  2690.     ++out;
  2691.     *out |= ((*in)) >> (30 - 6);
  2692.     ++in;
  2693.     *out |= ((*in)) << 6;
  2694.     ++out;
  2695.     *out |= ((*in)) >> (30 - 4);
  2696.     ++in;
  2697.     *out |= ((*in)) << 4;
  2698.     ++out;
  2699.     *out |= ((*in)) >> (30 - 2);
  2700.     ++in;
  2701.     *out |= ((*in)) << 2;
  2702.     ++out;
  2703.     ++in;
  2704.     *out |= (*in);
  2705.     ++in;
  2706.     *out |= ((*in)) << 30;
  2707.     ++out;
  2708.     *out |= ((*in)) >> (30 - 28);
  2709.     ++in;
  2710.     *out |= ((*in)) << 28;
  2711.     ++out;
  2712.     *out |= ((*in)) >> (30 - 26);
  2713.     ++in;
  2714.     *out |= ((*in)) << 26;
  2715.     ++out;
  2716.     *out |= ((*in)) >> (30 - 24);
  2717.     ++in;
  2718.     *out |= ((*in)) << 24;
  2719.     ++out;
  2720.     *out |= ((*in)) >> (30 - 22);
  2721.     ++in;
  2722.     *out |= ((*in)) << 22;
  2723.     ++out;
  2724.     *out |= ((*in)) >> (30 - 20);
  2725.     ++in;
  2726.     *out |= ((*in)) << 20;
  2727.     ++out;
  2728.     *out |= ((*in)) >> (30 - 18);
  2729.     ++in;
  2730.     *out |= ((*in)) << 18;
  2731.     ++out;
  2732.     *out |= ((*in)) >> (30 - 16);
  2733.     ++in;
  2734.     *out |= ((*in)) << 16;
  2735.     ++out;
  2736.     *out |= ((*in)) >> (30 - 14);
  2737.     ++in;
  2738.     *out |= ((*in)) << 14;
  2739.     ++out;
  2740.     *out |= ((*in)) >> (30 - 12);
  2741.     ++in;
  2742.     *out |= ((*in)) << 12;
  2743.     ++out;
  2744.     *out |= ((*in)) >> (30 - 10);
  2745.     ++in;
  2746.     *out |= ((*in)) << 10;
  2747.     ++out;
  2748.     *out |= ((*in)) >> (30 - 8);
  2749.     ++in;
  2750.     *out |= ((*in)) << 8;
  2751.     ++out;
  2752.     *out |= ((*in)) >> (30 - 6);
  2753.     ++in;
  2754.     *out |= ((*in)) << 6;
  2755.     ++out;
  2756.     *out |= ((*in)) >> (30 - 4);
  2757.     ++in;
  2758.     *out |= ((*in)) << 4;
  2759.     ++out;
  2760.     *out |= ((*in)) >> (30 - 2);
  2761.     ++in;
  2762.     *out |= ((*in)) << 2;
  2763. }
  2764.  
  2765. /*assumes that integers fit in the prescribed number of bits */
  2766. void __fastpackwithoutmask31(const uint32 * __restrict__ in,
  2767.         uint32 * __restrict__ out) {
  2768.     *out |= (*in);
  2769.     ++in;
  2770.     *out |= ((*in)) << 31;
  2771.     ++out;
  2772.     *out |= ((*in)) >> (31 - 30);
  2773.     ++in;
  2774.     *out |= ((*in)) << 30;
  2775.     ++out;
  2776.     *out |= ((*in)) >> (31 - 29);
  2777.     ++in;
  2778.     *out |= ((*in)) << 29;
  2779.     ++out;
  2780.     *out |= ((*in)) >> (31 - 28);
  2781.     ++in;
  2782.     *out |= ((*in)) << 28;
  2783.     ++out;
  2784.     *out |= ((*in)) >> (31 - 27);
  2785.     ++in;
  2786.     *out |= ((*in)) << 27;
  2787.     ++out;
  2788.     *out |= ((*in)) >> (31 - 26);
  2789.     ++in;
  2790.     *out |= ((*in)) << 26;
  2791.     ++out;
  2792.     *out |= ((*in)) >> (31 - 25);
  2793.     ++in;
  2794.     *out |= ((*in)) << 25;
  2795.     ++out;
  2796.     *out |= ((*in)) >> (31 - 24);
  2797.     ++in;
  2798.     *out |= ((*in)) << 24;
  2799.     ++out;
  2800.     *out |= ((*in)) >> (31 - 23);
  2801.     ++in;
  2802.     *out |= ((*in)) << 23;
  2803.     ++out;
  2804.     *out |= ((*in)) >> (31 - 22);
  2805.     ++in;
  2806.     *out |= ((*in)) << 22;
  2807.     ++out;
  2808.     *out |= ((*in)) >> (31 - 21);
  2809.     ++in;
  2810.     *out |= ((*in)) << 21;
  2811.     ++out;
  2812.     *out |= ((*in)) >> (31 - 20);
  2813.     ++in;
  2814.     *out |= ((*in)) << 20;
  2815.     ++out;
  2816.     *out |= ((*in)) >> (31 - 19);
  2817.     ++in;
  2818.     *out |= ((*in)) << 19;
  2819.     ++out;
  2820.     *out |= ((*in)) >> (31 - 18);
  2821.     ++in;
  2822.     *out |= ((*in)) << 18;
  2823.     ++out;
  2824.     *out |= ((*in)) >> (31 - 17);
  2825.     ++in;
  2826.     *out |= ((*in)) << 17;
  2827.     ++out;
  2828.     *out |= ((*in)) >> (31 - 16);
  2829.     ++in;
  2830.     *out |= ((*in)) << 16;
  2831.     ++out;
  2832.     *out |= ((*in)) >> (31 - 15);
  2833.     ++in;
  2834.     *out |= ((*in)) << 15;
  2835.     ++out;
  2836.     *out |= ((*in)) >> (31 - 14);
  2837.     ++in;
  2838.     *out |= ((*in)) << 14;
  2839.     ++out;
  2840.     *out |= ((*in)) >> (31 - 13);
  2841.     ++in;
  2842.     *out |= ((*in)) << 13;
  2843.     ++out;
  2844.     *out |= ((*in)) >> (31 - 12);
  2845.     ++in;
  2846.     *out |= ((*in)) << 12;
  2847.     ++out;
  2848.     *out |= ((*in)) >> (31 - 11);
  2849.     ++in;
  2850.     *out |= ((*in)) << 11;
  2851.     ++out;
  2852.     *out |= ((*in)) >> (31 - 10);
  2853.     ++in;
  2854.     *out |= ((*in)) << 10;
  2855.     ++out;
  2856.     *out |= ((*in)) >> (31 - 9);
  2857.     ++in;
  2858.     *out |= ((*in)) << 9;
  2859.     ++out;
  2860.     *out |= ((*in)) >> (31 - 8);
  2861.     ++in;
  2862.     *out |= ((*in)) << 8;
  2863.     ++out;
  2864.     *out |= ((*in)) >> (31 - 7);
  2865.     ++in;
  2866.     *out |= ((*in)) << 7;
  2867.     ++out;
  2868.     *out |= ((*in)) >> (31 - 6);
  2869.     ++in;
  2870.     *out |= ((*in)) << 6;
  2871.     ++out;
  2872.     *out |= ((*in)) >> (31 - 5);
  2873.     ++in;
  2874.     *out |= ((*in)) << 5;
  2875.     ++out;
  2876.     *out |= ((*in)) >> (31 - 4);
  2877.     ++in;
  2878.     *out |= ((*in)) << 4;
  2879.     ++out;
  2880.     *out |= ((*in)) >> (31 - 3);
  2881.     ++in;
  2882.     *out |= ((*in)) << 3;
  2883.     ++out;
  2884.     *out |= ((*in)) >> (31 - 2);
  2885.     ++in;
  2886.     *out |= ((*in)) << 2;
  2887.     ++out;
  2888.     *out |= ((*in)) >> (31 - 1);
  2889.     ++in;
  2890.     *out |= ((*in)) << 1;
  2891. }
  2892.  
  2893. /*assumes that integers fit in the prescribed number of bits */
  2894. void __fastpackwithoutmask32(const uint32 * __restrict__ in,
  2895.         uint32 * __restrict__ out) {
  2896.     *out = *in;
  2897.     ++out;
  2898.     ++in;
  2899.     *out = *in;
  2900.     ++out;
  2901.     ++in;
  2902.     *out = *in;
  2903.     ++out;
  2904.     ++in;
  2905.     *out = *in;
  2906.     ++out;
  2907.     ++in;
  2908.     *out = *in;
  2909.     ++out;
  2910.     ++in;
  2911.     *out = *in;
  2912.     ++out;
  2913.     ++in;
  2914.     *out = *in;
  2915.     ++out;
  2916.     ++in;
  2917.     *out = *in;
  2918.     ++out;
  2919.     ++in;
  2920.     *out = *in;
  2921.     ++out;
  2922.     ++in;
  2923.     *out = *in;
  2924.     ++out;
  2925.     ++in;
  2926.     *out = *in;
  2927.     ++out;
  2928.     ++in;
  2929.     *out = *in;
  2930.     ++out;
  2931.     ++in;
  2932.     *out = *in;
  2933.     ++out;
  2934.     ++in;
  2935.     *out = *in;
  2936.     ++out;
  2937.     ++in;
  2938.     *out = *in;
  2939.     ++out;
  2940.     ++in;
  2941.     *out = *in;
  2942.     ++out;
  2943.     ++in;
  2944.     *out = *in;
  2945.     ++out;
  2946.     ++in;
  2947.     *out = *in;
  2948.     ++out;
  2949.     ++in;
  2950.     *out = *in;
  2951.     ++out;
  2952.     ++in;
  2953.     *out = *in;
  2954.     ++out;
  2955.     ++in;
  2956.     *out = *in;
  2957.     ++out;
  2958.     ++in;
  2959.     *out = *in;
  2960.     ++out;
  2961.     ++in;
  2962.     *out = *in;
  2963.     ++out;
  2964.     ++in;
  2965.     *out = *in;
  2966.     ++out;
  2967.     ++in;
  2968.     *out = *in;
  2969.     ++out;
  2970.     ++in;
  2971.     *out = *in;
  2972.     ++out;
  2973.     ++in;
  2974.     *out = *in;
  2975.     ++out;
  2976.     ++in;
  2977.     *out = *in;
  2978.     ++out;
  2979.     ++in;
  2980.     *out = *in;
  2981.     ++out;
  2982.     ++in;
  2983.     *out = *in;
  2984.     ++out;
  2985.     ++in;
  2986.     *out = *in;
  2987.     ++out;
  2988.     ++in;
  2989.     *out = *in;
  2990. }
  2991.  
  2992. /*assumes that integers fit in the prescribed number of bits*/
  2993. void __fastpackwithoutmask4(const uint32 * __restrict__ in,
  2994.         uint32 * __restrict__ out) {
  2995.     for (uint outer = 0; outer < 4; ++outer) {
  2996.         for (uint inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
  2997.             *out |= ((*(in++))) << inwordpointer;
  2998.         ++out;
  2999.     }
  3000. }
  3001.  
  3002. /*assumes that integers fit in the prescribed number of bits*/
  3003. void __fastpackwithoutmask8(const uint32 * __restrict__ in,
  3004.         uint32 * __restrict__ out) {
  3005.     for (uint outer = 0; outer < 8; ++outer) {
  3006.         for (uint inwordpointer = 0; inwordpointer < 32; inwordpointer += 8)
  3007.             *out |= ((*(in++))) << inwordpointer;
  3008.         ++out;
  3009.     }
  3010. }
  3011.  
  3012. /*assumes that integers fit in the prescribed number of bits*/
  3013. void __fastpackwithoutmask16(const uint32 * __restrict__ in,
  3014.         uint32 * __restrict__ out) {
  3015.     for (uint outer = 0; outer < 16; ++outer) {
  3016.         for (uint inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
  3017.             *out |= ((*(in++))) << inwordpointer;
  3018.         ++out;
  3019.     }
  3020. }
  3021.  
  3022. /*assumes that integers fit in the prescribed number of bits*/
  3023. void fastpackwithoutmask(const uint32 * __restrict__ in,
  3024.         uint32 * __restrict__ out, const uint bit) {
  3025.     // Could have used function pointers instead of switch.
  3026.     // Switch calls do offer the compiler more opportunities for optimization in
  3027.     // theory. In this case, it makes no difference with a good compiler.
  3028.     switch (bit) {
  3029.     case 1:
  3030.         __fastpackwithoutmask1(in, out);
  3031.         break;
  3032.     case 2:
  3033.         __fastpackwithoutmask2(in, out);
  3034.         break;
  3035.     case 3:
  3036.         __fastpackwithoutmask3(in, out);
  3037.         break;
  3038.     case 4:
  3039.         __fastpackwithoutmask4(in, out);
  3040.         break;
  3041.     case 5:
  3042.         __fastpackwithoutmask5(in, out);
  3043.         break;
  3044.     case 6:
  3045.         __fastpackwithoutmask6(in, out);
  3046.         break;
  3047.     case 7:
  3048.         __fastpackwithoutmask7(in, out);
  3049.         break;
  3050.     case 8:
  3051.         __fastpackwithoutmask8(in, out);
  3052.         break;
  3053.     case 9:
  3054.         __fastpackwithoutmask9(in, out);
  3055.         break;
  3056.     case 10:
  3057.         __fastpackwithoutmask10(in, out);
  3058.         break;
  3059.     case 11:
  3060.         __fastpackwithoutmask11(in, out);
  3061.         break;
  3062.     case 12:
  3063.         __fastpackwithoutmask12(in, out);
  3064.         break;
  3065.     case 13:
  3066.         __fastpackwithoutmask13(in, out);
  3067.         break;
  3068.     case 14:
  3069.         __fastpackwithoutmask14(in, out);
  3070.         break;
  3071.     case 15:
  3072.         __fastpackwithoutmask15(in, out);
  3073.         break;
  3074.     case 16:
  3075.         __fastpackwithoutmask16(in, out);
  3076.         break;
  3077.     case 17:
  3078.         __fastpackwithoutmask17(in, out);
  3079.         break;
  3080.     case 18:
  3081.         __fastpackwithoutmask18(in, out);
  3082.         break;
  3083.     case 19:
  3084.         __fastpackwithoutmask19(in, out);
  3085.         break;
  3086.     case 20:
  3087.         __fastpackwithoutmask20(in, out);
  3088.         break;
  3089.     case 21:
  3090.         __fastpackwithoutmask21(in, out);
  3091.         break;
  3092.     case 22:
  3093.         __fastpackwithoutmask22(in, out);
  3094.         break;
  3095.     case 23:
  3096.         __fastpackwithoutmask23(in, out);
  3097.         break;
  3098.     case 24:
  3099.         __fastpackwithoutmask24(in, out);
  3100.         break;
  3101.     case 25:
  3102.         __fastpackwithoutmask25(in, out);
  3103.         break;
  3104.     case 26:
  3105.         __fastpackwithoutmask26(in, out);
  3106.         break;
  3107.     case 27:
  3108.         __fastpackwithoutmask27(in, out);
  3109.         break;
  3110.     case 28:
  3111.         __fastpackwithoutmask28(in, out);
  3112.         break;
  3113.     case 29:
  3114.         __fastpackwithoutmask29(in, out);
  3115.         break;
  3116.     case 30:
  3117.         __fastpackwithoutmask30(in, out);
  3118.         break;
  3119.     case 31:
  3120.         __fastpackwithoutmask31(in, out);
  3121.         break;
  3122.     case 32:
  3123.         __fastpackwithoutmask32(in, out);
  3124.         break;
  3125.     default:
  3126.         break;
  3127.     }
  3128. }
  3129.  
  3130. int main() {
  3131.     const uint N = 1U << 26;
  3132.  
  3133.     for (uint b = 1; b <= 32; ++b) {
  3134.         cout << b << "\t";
  3135.         const uint MAXV = b < 32 ? (1U << b) - 1 : 0xFFFFFFFF;
  3136.         vector<uint32> data = generateArray32(N, MAXV);
  3137.         for (int k = 0; k < 16; ++k)
  3138.             data.push_back(MAXV);
  3139.         vector<uint32> out(N);// just a tmp store
  3140.  
  3141.  
  3142.         ZTimer z;
  3143.         uint detectedb = 0;
  3144.  
  3145.         z.reset();
  3146.         detectedb = 0;
  3147.         for (vector<uint32>::const_iterator i = data.begin(); i != data.end(); ++i) {
  3148.             const uint tmpbits = slowbits(*i);
  3149.             if (detectedb < tmpbits)
  3150.                 detectedb = tmpbits;
  3151.         }
  3152.         cout << std::setprecision(4) << N * 0.001 / z.split() << " "
  3153.                 << detectedb << "\t";
  3154.  
  3155.         z.reset();
  3156.         detectedb = 0;
  3157.         for (vector<uint32>::const_iterator i = data.begin(); i != data.end(); ++i) {
  3158.             const uint tmpbits = bits(*i);
  3159.             if (detectedb < tmpbits)
  3160.                 detectedb = tmpbits;
  3161.         }
  3162.  
  3163.         cout << std::setprecision(4) << N * 0.001 / z.split() << " "
  3164.                 << detectedb << "\t";
  3165.         z.reset();
  3166.         uint myclz = 32;
  3167.         for (vector<uint32>::const_iterator i = data.begin(); i != data.end(); ++i) {
  3168.             if (*i == 0)
  3169.                 continue;
  3170.             const uint tmpbits = __builtin_clz(*i);
  3171.             if (myclz > tmpbits)
  3172.                 myclz = tmpbits;
  3173.         }
  3174.         detectedb = 32 - myclz;
  3175.  
  3176.         cout << std::setprecision(4) << N * 0.001 / z.split() << " "
  3177.                 << detectedb << "\t";
  3178.  
  3179.         z.reset();
  3180.         detectedb = bits(data[0]);
  3181.         if (data.size() % 1 != 0) {
  3182.             for (vector<uint32>::const_iterator i = data.begin() + 1; i
  3183.                     != data.end(); i += 2) {
  3184.                 if ((*i >> detectedb) > 0)
  3185.                     detectedb = bits(*i);
  3186.                 if ((*(i + 1) >> detectedb) > 0)
  3187.                     detectedb = bits(*(i + 1));
  3188.             }
  3189.         } else {
  3190.             for (vector<uint32>::const_iterator i = data.begin(); i
  3191.                     != data.end(); i += 2) {
  3192.                 if ((*i >> detectedb) > 0)
  3193.                     detectedb = bits(*i);
  3194.                 if ((*(i + 1) >> detectedb) > 0)
  3195.                     detectedb = bits(*(i + 1));
  3196.             }
  3197.         }
  3198.         cout << std::setprecision(4) << N * 0.001 / z.split() << " "
  3199.                 << detectedb << "\t";
  3200.  
  3201.         z.reset();
  3202.         detectedb = bits(data[0]);
  3203.         const size_t N = data.size();
  3204.         for (uint k = 0; k < N / 32; ++k) {
  3205.             fastpackwithoutmask(&data[0] + 32 * k,
  3206.                     &out[0] + (32 * detectedb) * k / 32, detectedb);
  3207.         }
  3208.         cout << std::setprecision(4) << N * 0.001 / z.split() << "\t";
  3209.  
  3210.         cout << endl;
  3211.     }
  3212.     return 0;
  3213. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!