Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-08-28 08:27:07 

0001 // Licensed to the Apache Software Foundation (ASF) under one
0002 // or more contributor license agreements.  See the NOTICE file
0003 // distributed with this work for additional information
0004 // regarding copyright ownership.  The ASF licenses this file
0005 // to you under the Apache License, Version 2.0 (the
0006 // "License"); you may not use this file except in compliance
0007 // with the License.  You may obtain a copy of the License at
0008 //
0009 //   http://www.apache.org/licenses/LICENSE-2.0
0010 //
0011 // Unless required by applicable law or agreed to in writing,
0012 // software distributed under the License is distributed on an
0013 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
0014 // KIND, either express or implied.  See the License for the
0015 // specific language governing permissions and limitations
0016 // under the License.
0017 
0018 // This file was modified from its original version for inclusion in parquet-cpp.
0019 // Original source:
0020 // https://github.com/lemire/FrameOfReference/blob/6ccaf9e97160f9a3b299e23a8ef739e711ef0c71/src/bpacking.cpp
0021 // The original copyright notice follows.
0022 
0023 // This code is released under the
0024 // Apache License Version 2.0 http://www.apache.org/licenses/.
0025 // (c) Daniel Lemire 2013
0026 
0027 #pragma once
0028 
0029 #include "arrow/util/bit_util.h"
0030 #include "arrow/util/ubsan.h"
0031 
0032 namespace arrow {
0033 namespace internal {
0034 
0035 inline const uint32_t* unpack1_32(const uint32_t* in, uint32_t* out) {
0036   uint32_t inl = util::SafeLoad(in);
0037   inl = arrow::bit_util::FromLittleEndian(inl);
0038   *out = (inl >> 0) & 1;
0039   out++;
0040   *out = (inl >> 1) & 1;
0041   out++;
0042   *out = (inl >> 2) & 1;
0043   out++;
0044   *out = (inl >> 3) & 1;
0045   out++;
0046   *out = (inl >> 4) & 1;
0047   out++;
0048   *out = (inl >> 5) & 1;
0049   out++;
0050   *out = (inl >> 6) & 1;
0051   out++;
0052   *out = (inl >> 7) & 1;
0053   out++;
0054   *out = (inl >> 8) & 1;
0055   out++;
0056   *out = (inl >> 9) & 1;
0057   out++;
0058   *out = (inl >> 10) & 1;
0059   out++;
0060   *out = (inl >> 11) & 1;
0061   out++;
0062   *out = (inl >> 12) & 1;
0063   out++;
0064   *out = (inl >> 13) & 1;
0065   out++;
0066   *out = (inl >> 14) & 1;
0067   out++;
0068   *out = (inl >> 15) & 1;
0069   out++;
0070   *out = (inl >> 16) & 1;
0071   out++;
0072   *out = (inl >> 17) & 1;
0073   out++;
0074   *out = (inl >> 18) & 1;
0075   out++;
0076   *out = (inl >> 19) & 1;
0077   out++;
0078   *out = (inl >> 20) & 1;
0079   out++;
0080   *out = (inl >> 21) & 1;
0081   out++;
0082   *out = (inl >> 22) & 1;
0083   out++;
0084   *out = (inl >> 23) & 1;
0085   out++;
0086   *out = (inl >> 24) & 1;
0087   out++;
0088   *out = (inl >> 25) & 1;
0089   out++;
0090   *out = (inl >> 26) & 1;
0091   out++;
0092   *out = (inl >> 27) & 1;
0093   out++;
0094   *out = (inl >> 28) & 1;
0095   out++;
0096   *out = (inl >> 29) & 1;
0097   out++;
0098   *out = (inl >> 30) & 1;
0099   out++;
0100   *out = (inl >> 31);
0101   ++in;
0102   out++;
0103 
0104   return in;
0105 }
0106 
0107 inline const uint32_t* unpack2_32(const uint32_t* in, uint32_t* out) {
0108   uint32_t inl = util::SafeLoad(in);
0109   inl = arrow::bit_util::FromLittleEndian(inl);
0110   *out = (inl >> 0) % (1U << 2);
0111   out++;
0112   *out = (inl >> 2) % (1U << 2);
0113   out++;
0114   *out = (inl >> 4) % (1U << 2);
0115   out++;
0116   *out = (inl >> 6) % (1U << 2);
0117   out++;
0118   *out = (inl >> 8) % (1U << 2);
0119   out++;
0120   *out = (inl >> 10) % (1U << 2);
0121   out++;
0122   *out = (inl >> 12) % (1U << 2);
0123   out++;
0124   *out = (inl >> 14) % (1U << 2);
0125   out++;
0126   *out = (inl >> 16) % (1U << 2);
0127   out++;
0128   *out = (inl >> 18) % (1U << 2);
0129   out++;
0130   *out = (inl >> 20) % (1U << 2);
0131   out++;
0132   *out = (inl >> 22) % (1U << 2);
0133   out++;
0134   *out = (inl >> 24) % (1U << 2);
0135   out++;
0136   *out = (inl >> 26) % (1U << 2);
0137   out++;
0138   *out = (inl >> 28) % (1U << 2);
0139   out++;
0140   *out = (inl >> 30);
0141   ++in;
0142   inl = util::SafeLoad(in);
0143   inl = arrow::bit_util::FromLittleEndian(inl);
0144   out++;
0145   *out = (inl >> 0) % (1U << 2);
0146   out++;
0147   *out = (inl >> 2) % (1U << 2);
0148   out++;
0149   *out = (inl >> 4) % (1U << 2);
0150   out++;
0151   *out = (inl >> 6) % (1U << 2);
0152   out++;
0153   *out = (inl >> 8) % (1U << 2);
0154   out++;
0155   *out = (inl >> 10) % (1U << 2);
0156   out++;
0157   *out = (inl >> 12) % (1U << 2);
0158   out++;
0159   *out = (inl >> 14) % (1U << 2);
0160   out++;
0161   *out = (inl >> 16) % (1U << 2);
0162   out++;
0163   *out = (inl >> 18) % (1U << 2);
0164   out++;
0165   *out = (inl >> 20) % (1U << 2);
0166   out++;
0167   *out = (inl >> 22) % (1U << 2);
0168   out++;
0169   *out = (inl >> 24) % (1U << 2);
0170   out++;
0171   *out = (inl >> 26) % (1U << 2);
0172   out++;
0173   *out = (inl >> 28) % (1U << 2);
0174   out++;
0175   *out = (inl >> 30);
0176   ++in;
0177   out++;
0178 
0179   return in;
0180 }
0181 
0182 inline const uint32_t* unpack3_32(const uint32_t* in, uint32_t* out) {
0183   uint32_t inl = util::SafeLoad(in);
0184   inl = arrow::bit_util::FromLittleEndian(inl);
0185   *out = (inl >> 0) % (1U << 3);
0186   out++;
0187   *out = (inl >> 3) % (1U << 3);
0188   out++;
0189   *out = (inl >> 6) % (1U << 3);
0190   out++;
0191   *out = (inl >> 9) % (1U << 3);
0192   out++;
0193   *out = (inl >> 12) % (1U << 3);
0194   out++;
0195   *out = (inl >> 15) % (1U << 3);
0196   out++;
0197   *out = (inl >> 18) % (1U << 3);
0198   out++;
0199   *out = (inl >> 21) % (1U << 3);
0200   out++;
0201   *out = (inl >> 24) % (1U << 3);
0202   out++;
0203   *out = (inl >> 27) % (1U << 3);
0204   out++;
0205   *out = (inl >> 30);
0206   ++in;
0207   inl = util::SafeLoad(in);
0208   inl = arrow::bit_util::FromLittleEndian(inl);
0209   *out |= (inl % (1U << 1)) << (3 - 1);
0210   out++;
0211   *out = (inl >> 1) % (1U << 3);
0212   out++;
0213   *out = (inl >> 4) % (1U << 3);
0214   out++;
0215   *out = (inl >> 7) % (1U << 3);
0216   out++;
0217   *out = (inl >> 10) % (1U << 3);
0218   out++;
0219   *out = (inl >> 13) % (1U << 3);
0220   out++;
0221   *out = (inl >> 16) % (1U << 3);
0222   out++;
0223   *out = (inl >> 19) % (1U << 3);
0224   out++;
0225   *out = (inl >> 22) % (1U << 3);
0226   out++;
0227   *out = (inl >> 25) % (1U << 3);
0228   out++;
0229   *out = (inl >> 28) % (1U << 3);
0230   out++;
0231   *out = (inl >> 31);
0232   ++in;
0233   inl = util::SafeLoad(in);
0234   inl = arrow::bit_util::FromLittleEndian(inl);
0235   *out |= (inl % (1U << 2)) << (3 - 2);
0236   out++;
0237   *out = (inl >> 2) % (1U << 3);
0238   out++;
0239   *out = (inl >> 5) % (1U << 3);
0240   out++;
0241   *out = (inl >> 8) % (1U << 3);
0242   out++;
0243   *out = (inl >> 11) % (1U << 3);
0244   out++;
0245   *out = (inl >> 14) % (1U << 3);
0246   out++;
0247   *out = (inl >> 17) % (1U << 3);
0248   out++;
0249   *out = (inl >> 20) % (1U << 3);
0250   out++;
0251   *out = (inl >> 23) % (1U << 3);
0252   out++;
0253   *out = (inl >> 26) % (1U << 3);
0254   out++;
0255   *out = (inl >> 29);
0256   ++in;
0257   out++;
0258 
0259   return in;
0260 }
0261 
0262 inline const uint32_t* unpack4_32(const uint32_t* in, uint32_t* out) {
0263   uint32_t inl = util::SafeLoad(in);
0264   inl = arrow::bit_util::FromLittleEndian(inl);
0265   *out = (inl >> 0) % (1U << 4);
0266   out++;
0267   *out = (inl >> 4) % (1U << 4);
0268   out++;
0269   *out = (inl >> 8) % (1U << 4);
0270   out++;
0271   *out = (inl >> 12) % (1U << 4);
0272   out++;
0273   *out = (inl >> 16) % (1U << 4);
0274   out++;
0275   *out = (inl >> 20) % (1U << 4);
0276   out++;
0277   *out = (inl >> 24) % (1U << 4);
0278   out++;
0279   *out = (inl >> 28);
0280   ++in;
0281   inl = util::SafeLoad(in);
0282   inl = arrow::bit_util::FromLittleEndian(inl);
0283   out++;
0284   *out = (inl >> 0) % (1U << 4);
0285   out++;
0286   *out = (inl >> 4) % (1U << 4);
0287   out++;
0288   *out = (inl >> 8) % (1U << 4);
0289   out++;
0290   *out = (inl >> 12) % (1U << 4);
0291   out++;
0292   *out = (inl >> 16) % (1U << 4);
0293   out++;
0294   *out = (inl >> 20) % (1U << 4);
0295   out++;
0296   *out = (inl >> 24) % (1U << 4);
0297   out++;
0298   *out = (inl >> 28);
0299   ++in;
0300   inl = util::SafeLoad(in);
0301   inl = arrow::bit_util::FromLittleEndian(inl);
0302   out++;
0303   *out = (inl >> 0) % (1U << 4);
0304   out++;
0305   *out = (inl >> 4) % (1U << 4);
0306   out++;
0307   *out = (inl >> 8) % (1U << 4);
0308   out++;
0309   *out = (inl >> 12) % (1U << 4);
0310   out++;
0311   *out = (inl >> 16) % (1U << 4);
0312   out++;
0313   *out = (inl >> 20) % (1U << 4);
0314   out++;
0315   *out = (inl >> 24) % (1U << 4);
0316   out++;
0317   *out = (inl >> 28);
0318   ++in;
0319   inl = util::SafeLoad(in);
0320   inl = arrow::bit_util::FromLittleEndian(inl);
0321   out++;
0322   *out = (inl >> 0) % (1U << 4);
0323   out++;
0324   *out = (inl >> 4) % (1U << 4);
0325   out++;
0326   *out = (inl >> 8) % (1U << 4);
0327   out++;
0328   *out = (inl >> 12) % (1U << 4);
0329   out++;
0330   *out = (inl >> 16) % (1U << 4);
0331   out++;
0332   *out = (inl >> 20) % (1U << 4);
0333   out++;
0334   *out = (inl >> 24) % (1U << 4);
0335   out++;
0336   *out = (inl >> 28);
0337   ++in;
0338   out++;
0339 
0340   return in;
0341 }
0342 
0343 inline const uint32_t* unpack5_32(const uint32_t* in, uint32_t* out) {
0344   uint32_t inl = util::SafeLoad(in);
0345   inl = arrow::bit_util::FromLittleEndian(inl);
0346   *out = (inl >> 0) % (1U << 5);
0347   out++;
0348   *out = (inl >> 5) % (1U << 5);
0349   out++;
0350   *out = (inl >> 10) % (1U << 5);
0351   out++;
0352   *out = (inl >> 15) % (1U << 5);
0353   out++;
0354   *out = (inl >> 20) % (1U << 5);
0355   out++;
0356   *out = (inl >> 25) % (1U << 5);
0357   out++;
0358   *out = (inl >> 30);
0359   ++in;
0360   inl = util::SafeLoad(in);
0361   inl = arrow::bit_util::FromLittleEndian(inl);
0362   *out |= (inl % (1U << 3)) << (5 - 3);
0363   out++;
0364   *out = (inl >> 3) % (1U << 5);
0365   out++;
0366   *out = (inl >> 8) % (1U << 5);
0367   out++;
0368   *out = (inl >> 13) % (1U << 5);
0369   out++;
0370   *out = (inl >> 18) % (1U << 5);
0371   out++;
0372   *out = (inl >> 23) % (1U << 5);
0373   out++;
0374   *out = (inl >> 28);
0375   ++in;
0376   inl = util::SafeLoad(in);
0377   inl = arrow::bit_util::FromLittleEndian(inl);
0378   *out |= (inl % (1U << 1)) << (5 - 1);
0379   out++;
0380   *out = (inl >> 1) % (1U << 5);
0381   out++;
0382   *out = (inl >> 6) % (1U << 5);
0383   out++;
0384   *out = (inl >> 11) % (1U << 5);
0385   out++;
0386   *out = (inl >> 16) % (1U << 5);
0387   out++;
0388   *out = (inl >> 21) % (1U << 5);
0389   out++;
0390   *out = (inl >> 26) % (1U << 5);
0391   out++;
0392   *out = (inl >> 31);
0393   ++in;
0394   inl = util::SafeLoad(in);
0395   inl = arrow::bit_util::FromLittleEndian(inl);
0396   *out |= (inl % (1U << 4)) << (5 - 4);
0397   out++;
0398   *out = (inl >> 4) % (1U << 5);
0399   out++;
0400   *out = (inl >> 9) % (1U << 5);
0401   out++;
0402   *out = (inl >> 14) % (1U << 5);
0403   out++;
0404   *out = (inl >> 19) % (1U << 5);
0405   out++;
0406   *out = (inl >> 24) % (1U << 5);
0407   out++;
0408   *out = (inl >> 29);
0409   ++in;
0410   inl = util::SafeLoad(in);
0411   inl = arrow::bit_util::FromLittleEndian(inl);
0412   *out |= (inl % (1U << 2)) << (5 - 2);
0413   out++;
0414   *out = (inl >> 2) % (1U << 5);
0415   out++;
0416   *out = (inl >> 7) % (1U << 5);
0417   out++;
0418   *out = (inl >> 12) % (1U << 5);
0419   out++;
0420   *out = (inl >> 17) % (1U << 5);
0421   out++;
0422   *out = (inl >> 22) % (1U << 5);
0423   out++;
0424   *out = (inl >> 27);
0425   ++in;
0426   out++;
0427 
0428   return in;
0429 }
0430 
0431 inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
0432   uint32_t inl = util::SafeLoad(in);
0433   inl = arrow::bit_util::FromLittleEndian(inl);
0434   *out = (inl >> 0) % (1U << 6);
0435   out++;
0436   *out = (inl >> 6) % (1U << 6);
0437   out++;
0438   *out = (inl >> 12) % (1U << 6);
0439   out++;
0440   *out = (inl >> 18) % (1U << 6);
0441   out++;
0442   *out = (inl >> 24) % (1U << 6);
0443   out++;
0444   *out = (inl >> 30);
0445   ++in;
0446   inl = util::SafeLoad(in);
0447   inl = arrow::bit_util::FromLittleEndian(inl);
0448   *out |= (inl % (1U << 4)) << (6 - 4);
0449   out++;
0450   *out = (inl >> 4) % (1U << 6);
0451   out++;
0452   *out = (inl >> 10) % (1U << 6);
0453   out++;
0454   *out = (inl >> 16) % (1U << 6);
0455   out++;
0456   *out = (inl >> 22) % (1U << 6);
0457   out++;
0458   *out = (inl >> 28);
0459   ++in;
0460   inl = util::SafeLoad(in);
0461   inl = arrow::bit_util::FromLittleEndian(inl);
0462   *out |= (inl % (1U << 2)) << (6 - 2);
0463   out++;
0464   *out = (inl >> 2) % (1U << 6);
0465   out++;
0466   *out = (inl >> 8) % (1U << 6);
0467   out++;
0468   *out = (inl >> 14) % (1U << 6);
0469   out++;
0470   *out = (inl >> 20) % (1U << 6);
0471   out++;
0472   *out = (inl >> 26);
0473   ++in;
0474   inl = util::SafeLoad(in);
0475   inl = arrow::bit_util::FromLittleEndian(inl);
0476   out++;
0477   *out = (inl >> 0) % (1U << 6);
0478   out++;
0479   *out = (inl >> 6) % (1U << 6);
0480   out++;
0481   *out = (inl >> 12) % (1U << 6);
0482   out++;
0483   *out = (inl >> 18) % (1U << 6);
0484   out++;
0485   *out = (inl >> 24) % (1U << 6);
0486   out++;
0487   *out = (inl >> 30);
0488   ++in;
0489   inl = util::SafeLoad(in);
0490   inl = arrow::bit_util::FromLittleEndian(inl);
0491   *out |= (inl % (1U << 4)) << (6 - 4);
0492   out++;
0493   *out = (inl >> 4) % (1U << 6);
0494   out++;
0495   *out = (inl >> 10) % (1U << 6);
0496   out++;
0497   *out = (inl >> 16) % (1U << 6);
0498   out++;
0499   *out = (inl >> 22) % (1U << 6);
0500   out++;
0501   *out = (inl >> 28);
0502   ++in;
0503   inl = util::SafeLoad(in);
0504   inl = arrow::bit_util::FromLittleEndian(inl);
0505   *out |= (inl % (1U << 2)) << (6 - 2);
0506   out++;
0507   *out = (inl >> 2) % (1U << 6);
0508   out++;
0509   *out = (inl >> 8) % (1U << 6);
0510   out++;
0511   *out = (inl >> 14) % (1U << 6);
0512   out++;
0513   *out = (inl >> 20) % (1U << 6);
0514   out++;
0515   *out = (inl >> 26);
0516   ++in;
0517   out++;
0518 
0519   return in;
0520 }
0521 
0522 inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
0523   uint32_t inl = util::SafeLoad(in);
0524   inl = arrow::bit_util::FromLittleEndian(inl);
0525   *out = (inl >> 0) % (1U << 7);
0526   out++;
0527   *out = (inl >> 7) % (1U << 7);
0528   out++;
0529   *out = (inl >> 14) % (1U << 7);
0530   out++;
0531   *out = (inl >> 21) % (1U << 7);
0532   out++;
0533   *out = (inl >> 28);
0534   ++in;
0535   inl = util::SafeLoad(in);
0536   inl = arrow::bit_util::FromLittleEndian(inl);
0537   *out |= (inl % (1U << 3)) << (7 - 3);
0538   out++;
0539   *out = (inl >> 3) % (1U << 7);
0540   out++;
0541   *out = (inl >> 10) % (1U << 7);
0542   out++;
0543   *out = (inl >> 17) % (1U << 7);
0544   out++;
0545   *out = (inl >> 24) % (1U << 7);
0546   out++;
0547   *out = (inl >> 31);
0548   ++in;
0549   inl = util::SafeLoad(in);
0550   inl = arrow::bit_util::FromLittleEndian(inl);
0551   *out |= (inl % (1U << 6)) << (7 - 6);
0552   out++;
0553   *out = (inl >> 6) % (1U << 7);
0554   out++;
0555   *out = (inl >> 13) % (1U << 7);
0556   out++;
0557   *out = (inl >> 20) % (1U << 7);
0558   out++;
0559   *out = (inl >> 27);
0560   ++in;
0561   inl = util::SafeLoad(in);
0562   inl = arrow::bit_util::FromLittleEndian(inl);
0563   *out |= (inl % (1U << 2)) << (7 - 2);
0564   out++;
0565   *out = (inl >> 2) % (1U << 7);
0566   out++;
0567   *out = (inl >> 9) % (1U << 7);
0568   out++;
0569   *out = (inl >> 16) % (1U << 7);
0570   out++;
0571   *out = (inl >> 23) % (1U << 7);
0572   out++;
0573   *out = (inl >> 30);
0574   ++in;
0575   inl = util::SafeLoad(in);
0576   inl = arrow::bit_util::FromLittleEndian(inl);
0577   *out |= (inl % (1U << 5)) << (7 - 5);
0578   out++;
0579   *out = (inl >> 5) % (1U << 7);
0580   out++;
0581   *out = (inl >> 12) % (1U << 7);
0582   out++;
0583   *out = (inl >> 19) % (1U << 7);
0584   out++;
0585   *out = (inl >> 26);
0586   ++in;
0587   inl = util::SafeLoad(in);
0588   inl = arrow::bit_util::FromLittleEndian(inl);
0589   *out |= (inl % (1U << 1)) << (7 - 1);
0590   out++;
0591   *out = (inl >> 1) % (1U << 7);
0592   out++;
0593   *out = (inl >> 8) % (1U << 7);
0594   out++;
0595   *out = (inl >> 15) % (1U << 7);
0596   out++;
0597   *out = (inl >> 22) % (1U << 7);
0598   out++;
0599   *out = (inl >> 29);
0600   ++in;
0601   inl = util::SafeLoad(in);
0602   inl = arrow::bit_util::FromLittleEndian(inl);
0603   *out |= (inl % (1U << 4)) << (7 - 4);
0604   out++;
0605   *out = (inl >> 4) % (1U << 7);
0606   out++;
0607   *out = (inl >> 11) % (1U << 7);
0608   out++;
0609   *out = (inl >> 18) % (1U << 7);
0610   out++;
0611   *out = (inl >> 25);
0612   ++in;
0613   out++;
0614 
0615   return in;
0616 }
0617 
0618 inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
0619   uint32_t inl = util::SafeLoad(in);
0620   inl = arrow::bit_util::FromLittleEndian(inl);
0621   *out = (inl >> 0) % (1U << 8);
0622   out++;
0623   *out = (inl >> 8) % (1U << 8);
0624   out++;
0625   *out = (inl >> 16) % (1U << 8);
0626   out++;
0627   *out = (inl >> 24);
0628   ++in;
0629   inl = util::SafeLoad(in);
0630   inl = arrow::bit_util::FromLittleEndian(inl);
0631   out++;
0632   *out = (inl >> 0) % (1U << 8);
0633   out++;
0634   *out = (inl >> 8) % (1U << 8);
0635   out++;
0636   *out = (inl >> 16) % (1U << 8);
0637   out++;
0638   *out = (inl >> 24);
0639   ++in;
0640   inl = util::SafeLoad(in);
0641   inl = arrow::bit_util::FromLittleEndian(inl);
0642   out++;
0643   *out = (inl >> 0) % (1U << 8);
0644   out++;
0645   *out = (inl >> 8) % (1U << 8);
0646   out++;
0647   *out = (inl >> 16) % (1U << 8);
0648   out++;
0649   *out = (inl >> 24);
0650   ++in;
0651   inl = util::SafeLoad(in);
0652   inl = arrow::bit_util::FromLittleEndian(inl);
0653   out++;
0654   *out = (inl >> 0) % (1U << 8);
0655   out++;
0656   *out = (inl >> 8) % (1U << 8);
0657   out++;
0658   *out = (inl >> 16) % (1U << 8);
0659   out++;
0660   *out = (inl >> 24);
0661   ++in;
0662   inl = util::SafeLoad(in);
0663   inl = arrow::bit_util::FromLittleEndian(inl);
0664   out++;
0665   *out = (inl >> 0) % (1U << 8);
0666   out++;
0667   *out = (inl >> 8) % (1U << 8);
0668   out++;
0669   *out = (inl >> 16) % (1U << 8);
0670   out++;
0671   *out = (inl >> 24);
0672   ++in;
0673   inl = util::SafeLoad(in);
0674   inl = arrow::bit_util::FromLittleEndian(inl);
0675   out++;
0676   *out = (inl >> 0) % (1U << 8);
0677   out++;
0678   *out = (inl >> 8) % (1U << 8);
0679   out++;
0680   *out = (inl >> 16) % (1U << 8);
0681   out++;
0682   *out = (inl >> 24);
0683   ++in;
0684   inl = util::SafeLoad(in);
0685   inl = arrow::bit_util::FromLittleEndian(inl);
0686   out++;
0687   *out = (inl >> 0) % (1U << 8);
0688   out++;
0689   *out = (inl >> 8) % (1U << 8);
0690   out++;
0691   *out = (inl >> 16) % (1U << 8);
0692   out++;
0693   *out = (inl >> 24);
0694   ++in;
0695   inl = util::SafeLoad(in);
0696   inl = arrow::bit_util::FromLittleEndian(inl);
0697   out++;
0698   *out = (inl >> 0) % (1U << 8);
0699   out++;
0700   *out = (inl >> 8) % (1U << 8);
0701   out++;
0702   *out = (inl >> 16) % (1U << 8);
0703   out++;
0704   *out = (inl >> 24);
0705   ++in;
0706   out++;
0707 
0708   return in;
0709 }
0710 
0711 inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
0712   uint32_t inl = util::SafeLoad(in);
0713   inl = arrow::bit_util::FromLittleEndian(inl);
0714   *out = (inl >> 0) % (1U << 9);
0715   out++;
0716   *out = (inl >> 9) % (1U << 9);
0717   out++;
0718   *out = (inl >> 18) % (1U << 9);
0719   out++;
0720   *out = (inl >> 27);
0721   ++in;
0722   inl = util::SafeLoad(in);
0723   inl = arrow::bit_util::FromLittleEndian(inl);
0724   *out |= (inl % (1U << 4)) << (9 - 4);
0725   out++;
0726   *out = (inl >> 4) % (1U << 9);
0727   out++;
0728   *out = (inl >> 13) % (1U << 9);
0729   out++;
0730   *out = (inl >> 22) % (1U << 9);
0731   out++;
0732   *out = (inl >> 31);
0733   ++in;
0734   inl = util::SafeLoad(in);
0735   inl = arrow::bit_util::FromLittleEndian(inl);
0736   *out |= (inl % (1U << 8)) << (9 - 8);
0737   out++;
0738   *out = (inl >> 8) % (1U << 9);
0739   out++;
0740   *out = (inl >> 17) % (1U << 9);
0741   out++;
0742   *out = (inl >> 26);
0743   ++in;
0744   inl = util::SafeLoad(in);
0745   inl = arrow::bit_util::FromLittleEndian(inl);
0746   *out |= (inl % (1U << 3)) << (9 - 3);
0747   out++;
0748   *out = (inl >> 3) % (1U << 9);
0749   out++;
0750   *out = (inl >> 12) % (1U << 9);
0751   out++;
0752   *out = (inl >> 21) % (1U << 9);
0753   out++;
0754   *out = (inl >> 30);
0755   ++in;
0756   inl = util::SafeLoad(in);
0757   inl = arrow::bit_util::FromLittleEndian(inl);
0758   *out |= (inl % (1U << 7)) << (9 - 7);
0759   out++;
0760   *out = (inl >> 7) % (1U << 9);
0761   out++;
0762   *out = (inl >> 16) % (1U << 9);
0763   out++;
0764   *out = (inl >> 25);
0765   ++in;
0766   inl = util::SafeLoad(in);
0767   inl = arrow::bit_util::FromLittleEndian(inl);
0768   *out |= (inl % (1U << 2)) << (9 - 2);
0769   out++;
0770   *out = (inl >> 2) % (1U << 9);
0771   out++;
0772   *out = (inl >> 11) % (1U << 9);
0773   out++;
0774   *out = (inl >> 20) % (1U << 9);
0775   out++;
0776   *out = (inl >> 29);
0777   ++in;
0778   inl = util::SafeLoad(in);
0779   inl = arrow::bit_util::FromLittleEndian(inl);
0780   *out |= (inl % (1U << 6)) << (9 - 6);
0781   out++;
0782   *out = (inl >> 6) % (1U << 9);
0783   out++;
0784   *out = (inl >> 15) % (1U << 9);
0785   out++;
0786   *out = (inl >> 24);
0787   ++in;
0788   inl = util::SafeLoad(in);
0789   inl = arrow::bit_util::FromLittleEndian(inl);
0790   *out |= (inl % (1U << 1)) << (9 - 1);
0791   out++;
0792   *out = (inl >> 1) % (1U << 9);
0793   out++;
0794   *out = (inl >> 10) % (1U << 9);
0795   out++;
0796   *out = (inl >> 19) % (1U << 9);
0797   out++;
0798   *out = (inl >> 28);
0799   ++in;
0800   inl = util::SafeLoad(in);
0801   inl = arrow::bit_util::FromLittleEndian(inl);
0802   *out |= (inl % (1U << 5)) << (9 - 5);
0803   out++;
0804   *out = (inl >> 5) % (1U << 9);
0805   out++;
0806   *out = (inl >> 14) % (1U << 9);
0807   out++;
0808   *out = (inl >> 23);
0809   ++in;
0810   out++;
0811 
0812   return in;
0813 }
0814 
0815 inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
0816   uint32_t inl = util::SafeLoad(in);
0817   inl = arrow::bit_util::FromLittleEndian(inl);
0818   *out = (inl >> 0) % (1U << 10);
0819   out++;
0820   *out = (inl >> 10) % (1U << 10);
0821   out++;
0822   *out = (inl >> 20) % (1U << 10);
0823   out++;
0824   *out = (inl >> 30);
0825   ++in;
0826   inl = util::SafeLoad(in);
0827   inl = arrow::bit_util::FromLittleEndian(inl);
0828   *out |= (inl % (1U << 8)) << (10 - 8);
0829   out++;
0830   *out = (inl >> 8) % (1U << 10);
0831   out++;
0832   *out = (inl >> 18) % (1U << 10);
0833   out++;
0834   *out = (inl >> 28);
0835   ++in;
0836   inl = util::SafeLoad(in);
0837   inl = arrow::bit_util::FromLittleEndian(inl);
0838   *out |= (inl % (1U << 6)) << (10 - 6);
0839   out++;
0840   *out = (inl >> 6) % (1U << 10);
0841   out++;
0842   *out = (inl >> 16) % (1U << 10);
0843   out++;
0844   *out = (inl >> 26);
0845   ++in;
0846   inl = util::SafeLoad(in);
0847   inl = arrow::bit_util::FromLittleEndian(inl);
0848   *out |= (inl % (1U << 4)) << (10 - 4);
0849   out++;
0850   *out = (inl >> 4) % (1U << 10);
0851   out++;
0852   *out = (inl >> 14) % (1U << 10);
0853   out++;
0854   *out = (inl >> 24);
0855   ++in;
0856   inl = util::SafeLoad(in);
0857   inl = arrow::bit_util::FromLittleEndian(inl);
0858   *out |= (inl % (1U << 2)) << (10 - 2);
0859   out++;
0860   *out = (inl >> 2) % (1U << 10);
0861   out++;
0862   *out = (inl >> 12) % (1U << 10);
0863   out++;
0864   *out = (inl >> 22);
0865   ++in;
0866   inl = util::SafeLoad(in);
0867   inl = arrow::bit_util::FromLittleEndian(inl);
0868   out++;
0869   *out = (inl >> 0) % (1U << 10);
0870   out++;
0871   *out = (inl >> 10) % (1U << 10);
0872   out++;
0873   *out = (inl >> 20) % (1U << 10);
0874   out++;
0875   *out = (inl >> 30);
0876   ++in;
0877   inl = util::SafeLoad(in);
0878   inl = arrow::bit_util::FromLittleEndian(inl);
0879   *out |= (inl % (1U << 8)) << (10 - 8);
0880   out++;
0881   *out = (inl >> 8) % (1U << 10);
0882   out++;
0883   *out = (inl >> 18) % (1U << 10);
0884   out++;
0885   *out = (inl >> 28);
0886   ++in;
0887   inl = util::SafeLoad(in);
0888   inl = arrow::bit_util::FromLittleEndian(inl);
0889   *out |= (inl % (1U << 6)) << (10 - 6);
0890   out++;
0891   *out = (inl >> 6) % (1U << 10);
0892   out++;
0893   *out = (inl >> 16) % (1U << 10);
0894   out++;
0895   *out = (inl >> 26);
0896   ++in;
0897   inl = util::SafeLoad(in);
0898   inl = arrow::bit_util::FromLittleEndian(inl);
0899   *out |= (inl % (1U << 4)) << (10 - 4);
0900   out++;
0901   *out = (inl >> 4) % (1U << 10);
0902   out++;
0903   *out = (inl >> 14) % (1U << 10);
0904   out++;
0905   *out = (inl >> 24);
0906   ++in;
0907   inl = util::SafeLoad(in);
0908   inl = arrow::bit_util::FromLittleEndian(inl);
0909   *out |= (inl % (1U << 2)) << (10 - 2);
0910   out++;
0911   *out = (inl >> 2) % (1U << 10);
0912   out++;
0913   *out = (inl >> 12) % (1U << 10);
0914   out++;
0915   *out = (inl >> 22);
0916   ++in;
0917   out++;
0918 
0919   return in;
0920 }
0921 
0922 inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
0923   uint32_t inl = util::SafeLoad(in);
0924   inl = arrow::bit_util::FromLittleEndian(inl);
0925   *out = (inl >> 0) % (1U << 11);
0926   out++;
0927   *out = (inl >> 11) % (1U << 11);
0928   out++;
0929   *out = (inl >> 22);
0930   ++in;
0931   inl = util::SafeLoad(in);
0932   inl = arrow::bit_util::FromLittleEndian(inl);
0933   *out |= (inl % (1U << 1)) << (11 - 1);
0934   out++;
0935   *out = (inl >> 1) % (1U << 11);
0936   out++;
0937   *out = (inl >> 12) % (1U << 11);
0938   out++;
0939   *out = (inl >> 23);
0940   ++in;
0941   inl = util::SafeLoad(in);
0942   inl = arrow::bit_util::FromLittleEndian(inl);
0943   *out |= (inl % (1U << 2)) << (11 - 2);
0944   out++;
0945   *out = (inl >> 2) % (1U << 11);
0946   out++;
0947   *out = (inl >> 13) % (1U << 11);
0948   out++;
0949   *out = (inl >> 24);
0950   ++in;
0951   inl = util::SafeLoad(in);
0952   inl = arrow::bit_util::FromLittleEndian(inl);
0953   *out |= (inl % (1U << 3)) << (11 - 3);
0954   out++;
0955   *out = (inl >> 3) % (1U << 11);
0956   out++;
0957   *out = (inl >> 14) % (1U << 11);
0958   out++;
0959   *out = (inl >> 25);
0960   ++in;
0961   inl = util::SafeLoad(in);
0962   inl = arrow::bit_util::FromLittleEndian(inl);
0963   *out |= (inl % (1U << 4)) << (11 - 4);
0964   out++;
0965   *out = (inl >> 4) % (1U << 11);
0966   out++;
0967   *out = (inl >> 15) % (1U << 11);
0968   out++;
0969   *out = (inl >> 26);
0970   ++in;
0971   inl = util::SafeLoad(in);
0972   inl = arrow::bit_util::FromLittleEndian(inl);
0973   *out |= (inl % (1U << 5)) << (11 - 5);
0974   out++;
0975   *out = (inl >> 5) % (1U << 11);
0976   out++;
0977   *out = (inl >> 16) % (1U << 11);
0978   out++;
0979   *out = (inl >> 27);
0980   ++in;
0981   inl = util::SafeLoad(in);
0982   inl = arrow::bit_util::FromLittleEndian(inl);
0983   *out |= (inl % (1U << 6)) << (11 - 6);
0984   out++;
0985   *out = (inl >> 6) % (1U << 11);
0986   out++;
0987   *out = (inl >> 17) % (1U << 11);
0988   out++;
0989   *out = (inl >> 28);
0990   ++in;
0991   inl = util::SafeLoad(in);
0992   inl = arrow::bit_util::FromLittleEndian(inl);
0993   *out |= (inl % (1U << 7)) << (11 - 7);
0994   out++;
0995   *out = (inl >> 7) % (1U << 11);
0996   out++;
0997   *out = (inl >> 18) % (1U << 11);
0998   out++;
0999   *out = (inl >> 29);
1000   ++in;
1001   inl = util::SafeLoad(in);
1002   inl = arrow::bit_util::FromLittleEndian(inl);
1003   *out |= (inl % (1U << 8)) << (11 - 8);
1004   out++;
1005   *out = (inl >> 8) % (1U << 11);
1006   out++;
1007   *out = (inl >> 19) % (1U << 11);
1008   out++;
1009   *out = (inl >> 30);
1010   ++in;
1011   inl = util::SafeLoad(in);
1012   inl = arrow::bit_util::FromLittleEndian(inl);
1013   *out |= (inl % (1U << 9)) << (11 - 9);
1014   out++;
1015   *out = (inl >> 9) % (1U << 11);
1016   out++;
1017   *out = (inl >> 20) % (1U << 11);
1018   out++;
1019   *out = (inl >> 31);
1020   ++in;
1021   inl = util::SafeLoad(in);
1022   inl = arrow::bit_util::FromLittleEndian(inl);
1023   *out |= (inl % (1U << 10)) << (11 - 10);
1024   out++;
1025   *out = (inl >> 10) % (1U << 11);
1026   out++;
1027   *out = (inl >> 21);
1028   ++in;
1029   out++;
1030 
1031   return in;
1032 }
1033 
1034 inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
1035   uint32_t inl = util::SafeLoad(in);
1036   inl = arrow::bit_util::FromLittleEndian(inl);
1037   *out = (inl >> 0) % (1U << 12);
1038   out++;
1039   *out = (inl >> 12) % (1U << 12);
1040   out++;
1041   *out = (inl >> 24);
1042   ++in;
1043   inl = util::SafeLoad(in);
1044   inl = arrow::bit_util::FromLittleEndian(inl);
1045   *out |= (inl % (1U << 4)) << (12 - 4);
1046   out++;
1047   *out = (inl >> 4) % (1U << 12);
1048   out++;
1049   *out = (inl >> 16) % (1U << 12);
1050   out++;
1051   *out = (inl >> 28);
1052   ++in;
1053   inl = util::SafeLoad(in);
1054   inl = arrow::bit_util::FromLittleEndian(inl);
1055   *out |= (inl % (1U << 8)) << (12 - 8);
1056   out++;
1057   *out = (inl >> 8) % (1U << 12);
1058   out++;
1059   *out = (inl >> 20);
1060   ++in;
1061   inl = util::SafeLoad(in);
1062   inl = arrow::bit_util::FromLittleEndian(inl);
1063   out++;
1064   *out = (inl >> 0) % (1U << 12);
1065   out++;
1066   *out = (inl >> 12) % (1U << 12);
1067   out++;
1068   *out = (inl >> 24);
1069   ++in;
1070   inl = util::SafeLoad(in);
1071   inl = arrow::bit_util::FromLittleEndian(inl);
1072   *out |= (inl % (1U << 4)) << (12 - 4);
1073   out++;
1074   *out = (inl >> 4) % (1U << 12);
1075   out++;
1076   *out = (inl >> 16) % (1U << 12);
1077   out++;
1078   *out = (inl >> 28);
1079   ++in;
1080   inl = util::SafeLoad(in);
1081   inl = arrow::bit_util::FromLittleEndian(inl);
1082   *out |= (inl % (1U << 8)) << (12 - 8);
1083   out++;
1084   *out = (inl >> 8) % (1U << 12);
1085   out++;
1086   *out = (inl >> 20);
1087   ++in;
1088   inl = util::SafeLoad(in);
1089   inl = arrow::bit_util::FromLittleEndian(inl);
1090   out++;
1091   *out = (inl >> 0) % (1U << 12);
1092   out++;
1093   *out = (inl >> 12) % (1U << 12);
1094   out++;
1095   *out = (inl >> 24);
1096   ++in;
1097   inl = util::SafeLoad(in);
1098   inl = arrow::bit_util::FromLittleEndian(inl);
1099   *out |= (inl % (1U << 4)) << (12 - 4);
1100   out++;
1101   *out = (inl >> 4) % (1U << 12);
1102   out++;
1103   *out = (inl >> 16) % (1U << 12);
1104   out++;
1105   *out = (inl >> 28);
1106   ++in;
1107   inl = util::SafeLoad(in);
1108   inl = arrow::bit_util::FromLittleEndian(inl);
1109   *out |= (inl % (1U << 8)) << (12 - 8);
1110   out++;
1111   *out = (inl >> 8) % (1U << 12);
1112   out++;
1113   *out = (inl >> 20);
1114   ++in;
1115   inl = util::SafeLoad(in);
1116   inl = arrow::bit_util::FromLittleEndian(inl);
1117   out++;
1118   *out = (inl >> 0) % (1U << 12);
1119   out++;
1120   *out = (inl >> 12) % (1U << 12);
1121   out++;
1122   *out = (inl >> 24);
1123   ++in;
1124   inl = util::SafeLoad(in);
1125   inl = arrow::bit_util::FromLittleEndian(inl);
1126   *out |= (inl % (1U << 4)) << (12 - 4);
1127   out++;
1128   *out = (inl >> 4) % (1U << 12);
1129   out++;
1130   *out = (inl >> 16) % (1U << 12);
1131   out++;
1132   *out = (inl >> 28);
1133   ++in;
1134   inl = util::SafeLoad(in);
1135   inl = arrow::bit_util::FromLittleEndian(inl);
1136   *out |= (inl % (1U << 8)) << (12 - 8);
1137   out++;
1138   *out = (inl >> 8) % (1U << 12);
1139   out++;
1140   *out = (inl >> 20);
1141   ++in;
1142   out++;
1143 
1144   return in;
1145 }
1146 
1147 inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
1148   uint32_t inl = util::SafeLoad(in);
1149   inl = arrow::bit_util::FromLittleEndian(inl);
1150   *out = (inl >> 0) % (1U << 13);
1151   out++;
1152   *out = (inl >> 13) % (1U << 13);
1153   out++;
1154   *out = (inl >> 26);
1155   ++in;
1156   inl = util::SafeLoad(in);
1157   inl = arrow::bit_util::FromLittleEndian(inl);
1158   *out |= (inl % (1U << 7)) << (13 - 7);
1159   out++;
1160   *out = (inl >> 7) % (1U << 13);
1161   out++;
1162   *out = (inl >> 20);
1163   ++in;
1164   inl = util::SafeLoad(in);
1165   inl = arrow::bit_util::FromLittleEndian(inl);
1166   *out |= (inl % (1U << 1)) << (13 - 1);
1167   out++;
1168   *out = (inl >> 1) % (1U << 13);
1169   out++;
1170   *out = (inl >> 14) % (1U << 13);
1171   out++;
1172   *out = (inl >> 27);
1173   ++in;
1174   inl = util::SafeLoad(in);
1175   inl = arrow::bit_util::FromLittleEndian(inl);
1176   *out |= (inl % (1U << 8)) << (13 - 8);
1177   out++;
1178   *out = (inl >> 8) % (1U << 13);
1179   out++;
1180   *out = (inl >> 21);
1181   ++in;
1182   inl = util::SafeLoad(in);
1183   inl = arrow::bit_util::FromLittleEndian(inl);
1184   *out |= (inl % (1U << 2)) << (13 - 2);
1185   out++;
1186   *out = (inl >> 2) % (1U << 13);
1187   out++;
1188   *out = (inl >> 15) % (1U << 13);
1189   out++;
1190   *out = (inl >> 28);
1191   ++in;
1192   inl = util::SafeLoad(in);
1193   inl = arrow::bit_util::FromLittleEndian(inl);
1194   *out |= (inl % (1U << 9)) << (13 - 9);
1195   out++;
1196   *out = (inl >> 9) % (1U << 13);
1197   out++;
1198   *out = (inl >> 22);
1199   ++in;
1200   inl = util::SafeLoad(in);
1201   inl = arrow::bit_util::FromLittleEndian(inl);
1202   *out |= (inl % (1U << 3)) << (13 - 3);
1203   out++;
1204   *out = (inl >> 3) % (1U << 13);
1205   out++;
1206   *out = (inl >> 16) % (1U << 13);
1207   out++;
1208   *out = (inl >> 29);
1209   ++in;
1210   inl = util::SafeLoad(in);
1211   inl = arrow::bit_util::FromLittleEndian(inl);
1212   *out |= (inl % (1U << 10)) << (13 - 10);
1213   out++;
1214   *out = (inl >> 10) % (1U << 13);
1215   out++;
1216   *out = (inl >> 23);
1217   ++in;
1218   inl = util::SafeLoad(in);
1219   inl = arrow::bit_util::FromLittleEndian(inl);
1220   *out |= (inl % (1U << 4)) << (13 - 4);
1221   out++;
1222   *out = (inl >> 4) % (1U << 13);
1223   out++;
1224   *out = (inl >> 17) % (1U << 13);
1225   out++;
1226   *out = (inl >> 30);
1227   ++in;
1228   inl = util::SafeLoad(in);
1229   inl = arrow::bit_util::FromLittleEndian(inl);
1230   *out |= (inl % (1U << 11)) << (13 - 11);
1231   out++;
1232   *out = (inl >> 11) % (1U << 13);
1233   out++;
1234   *out = (inl >> 24);
1235   ++in;
1236   inl = util::SafeLoad(in);
1237   inl = arrow::bit_util::FromLittleEndian(inl);
1238   *out |= (inl % (1U << 5)) << (13 - 5);
1239   out++;
1240   *out = (inl >> 5) % (1U << 13);
1241   out++;
1242   *out = (inl >> 18) % (1U << 13);
1243   out++;
1244   *out = (inl >> 31);
1245   ++in;
1246   inl = util::SafeLoad(in);
1247   inl = arrow::bit_util::FromLittleEndian(inl);
1248   *out |= (inl % (1U << 12)) << (13 - 12);
1249   out++;
1250   *out = (inl >> 12) % (1U << 13);
1251   out++;
1252   *out = (inl >> 25);
1253   ++in;
1254   inl = util::SafeLoad(in);
1255   inl = arrow::bit_util::FromLittleEndian(inl);
1256   *out |= (inl % (1U << 6)) << (13 - 6);
1257   out++;
1258   *out = (inl >> 6) % (1U << 13);
1259   out++;
1260   *out = (inl >> 19);
1261   ++in;
1262   out++;
1263 
1264   return in;
1265 }
1266 
1267 inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
1268   uint32_t inl = util::SafeLoad(in);
1269   inl = arrow::bit_util::FromLittleEndian(inl);
1270   *out = (inl >> 0) % (1U << 14);
1271   out++;
1272   *out = (inl >> 14) % (1U << 14);
1273   out++;
1274   *out = (inl >> 28);
1275   ++in;
1276   inl = util::SafeLoad(in);
1277   inl = arrow::bit_util::FromLittleEndian(inl);
1278   *out |= (inl % (1U << 10)) << (14 - 10);
1279   out++;
1280   *out = (inl >> 10) % (1U << 14);
1281   out++;
1282   *out = (inl >> 24);
1283   ++in;
1284   inl = util::SafeLoad(in);
1285   inl = arrow::bit_util::FromLittleEndian(inl);
1286   *out |= (inl % (1U << 6)) << (14 - 6);
1287   out++;
1288   *out = (inl >> 6) % (1U << 14);
1289   out++;
1290   *out = (inl >> 20);
1291   ++in;
1292   inl = util::SafeLoad(in);
1293   inl = arrow::bit_util::FromLittleEndian(inl);
1294   *out |= (inl % (1U << 2)) << (14 - 2);
1295   out++;
1296   *out = (inl >> 2) % (1U << 14);
1297   out++;
1298   *out = (inl >> 16) % (1U << 14);
1299   out++;
1300   *out = (inl >> 30);
1301   ++in;
1302   inl = util::SafeLoad(in);
1303   inl = arrow::bit_util::FromLittleEndian(inl);
1304   *out |= (inl % (1U << 12)) << (14 - 12);
1305   out++;
1306   *out = (inl >> 12) % (1U << 14);
1307   out++;
1308   *out = (inl >> 26);
1309   ++in;
1310   inl = util::SafeLoad(in);
1311   inl = arrow::bit_util::FromLittleEndian(inl);
1312   *out |= (inl % (1U << 8)) << (14 - 8);
1313   out++;
1314   *out = (inl >> 8) % (1U << 14);
1315   out++;
1316   *out = (inl >> 22);
1317   ++in;
1318   inl = util::SafeLoad(in);
1319   inl = arrow::bit_util::FromLittleEndian(inl);
1320   *out |= (inl % (1U << 4)) << (14 - 4);
1321   out++;
1322   *out = (inl >> 4) % (1U << 14);
1323   out++;
1324   *out = (inl >> 18);
1325   ++in;
1326   inl = util::SafeLoad(in);
1327   inl = arrow::bit_util::FromLittleEndian(inl);
1328   out++;
1329   *out = (inl >> 0) % (1U << 14);
1330   out++;
1331   *out = (inl >> 14) % (1U << 14);
1332   out++;
1333   *out = (inl >> 28);
1334   ++in;
1335   inl = util::SafeLoad(in);
1336   inl = arrow::bit_util::FromLittleEndian(inl);
1337   *out |= (inl % (1U << 10)) << (14 - 10);
1338   out++;
1339   *out = (inl >> 10) % (1U << 14);
1340   out++;
1341   *out = (inl >> 24);
1342   ++in;
1343   inl = util::SafeLoad(in);
1344   inl = arrow::bit_util::FromLittleEndian(inl);
1345   *out |= (inl % (1U << 6)) << (14 - 6);
1346   out++;
1347   *out = (inl >> 6) % (1U << 14);
1348   out++;
1349   *out = (inl >> 20);
1350   ++in;
1351   inl = util::SafeLoad(in);
1352   inl = arrow::bit_util::FromLittleEndian(inl);
1353   *out |= (inl % (1U << 2)) << (14 - 2);
1354   out++;
1355   *out = (inl >> 2) % (1U << 14);
1356   out++;
1357   *out = (inl >> 16) % (1U << 14);
1358   out++;
1359   *out = (inl >> 30);
1360   ++in;
1361   inl = util::SafeLoad(in);
1362   inl = arrow::bit_util::FromLittleEndian(inl);
1363   *out |= (inl % (1U << 12)) << (14 - 12);
1364   out++;
1365   *out = (inl >> 12) % (1U << 14);
1366   out++;
1367   *out = (inl >> 26);
1368   ++in;
1369   inl = util::SafeLoad(in);
1370   inl = arrow::bit_util::FromLittleEndian(inl);
1371   *out |= (inl % (1U << 8)) << (14 - 8);
1372   out++;
1373   *out = (inl >> 8) % (1U << 14);
1374   out++;
1375   *out = (inl >> 22);
1376   ++in;
1377   inl = util::SafeLoad(in);
1378   inl = arrow::bit_util::FromLittleEndian(inl);
1379   *out |= (inl % (1U << 4)) << (14 - 4);
1380   out++;
1381   *out = (inl >> 4) % (1U << 14);
1382   out++;
1383   *out = (inl >> 18);
1384   ++in;
1385   out++;
1386 
1387   return in;
1388 }
1389 
1390 inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
1391   uint32_t inl = util::SafeLoad(in);
1392   inl = arrow::bit_util::FromLittleEndian(inl);
1393   *out = (inl >> 0) % (1U << 15);
1394   out++;
1395   *out = (inl >> 15) % (1U << 15);
1396   out++;
1397   *out = (inl >> 30);
1398   ++in;
1399   inl = util::SafeLoad(in);
1400   inl = arrow::bit_util::FromLittleEndian(inl);
1401   *out |= (inl % (1U << 13)) << (15 - 13);
1402   out++;
1403   *out = (inl >> 13) % (1U << 15);
1404   out++;
1405   *out = (inl >> 28);
1406   ++in;
1407   inl = util::SafeLoad(in);
1408   inl = arrow::bit_util::FromLittleEndian(inl);
1409   *out |= (inl % (1U << 11)) << (15 - 11);
1410   out++;
1411   *out = (inl >> 11) % (1U << 15);
1412   out++;
1413   *out = (inl >> 26);
1414   ++in;
1415   inl = util::SafeLoad(in);
1416   inl = arrow::bit_util::FromLittleEndian(inl);
1417   *out |= (inl % (1U << 9)) << (15 - 9);
1418   out++;
1419   *out = (inl >> 9) % (1U << 15);
1420   out++;
1421   *out = (inl >> 24);
1422   ++in;
1423   inl = util::SafeLoad(in);
1424   inl = arrow::bit_util::FromLittleEndian(inl);
1425   *out |= (inl % (1U << 7)) << (15 - 7);
1426   out++;
1427   *out = (inl >> 7) % (1U << 15);
1428   out++;
1429   *out = (inl >> 22);
1430   ++in;
1431   inl = util::SafeLoad(in);
1432   inl = arrow::bit_util::FromLittleEndian(inl);
1433   *out |= (inl % (1U << 5)) << (15 - 5);
1434   out++;
1435   *out = (inl >> 5) % (1U << 15);
1436   out++;
1437   *out = (inl >> 20);
1438   ++in;
1439   inl = util::SafeLoad(in);
1440   inl = arrow::bit_util::FromLittleEndian(inl);
1441   *out |= (inl % (1U << 3)) << (15 - 3);
1442   out++;
1443   *out = (inl >> 3) % (1U << 15);
1444   out++;
1445   *out = (inl >> 18);
1446   ++in;
1447   inl = util::SafeLoad(in);
1448   inl = arrow::bit_util::FromLittleEndian(inl);
1449   *out |= (inl % (1U << 1)) << (15 - 1);
1450   out++;
1451   *out = (inl >> 1) % (1U << 15);
1452   out++;
1453   *out = (inl >> 16) % (1U << 15);
1454   out++;
1455   *out = (inl >> 31);
1456   ++in;
1457   inl = util::SafeLoad(in);
1458   inl = arrow::bit_util::FromLittleEndian(inl);
1459   *out |= (inl % (1U << 14)) << (15 - 14);
1460   out++;
1461   *out = (inl >> 14) % (1U << 15);
1462   out++;
1463   *out = (inl >> 29);
1464   ++in;
1465   inl = util::SafeLoad(in);
1466   inl = arrow::bit_util::FromLittleEndian(inl);
1467   *out |= (inl % (1U << 12)) << (15 - 12);
1468   out++;
1469   *out = (inl >> 12) % (1U << 15);
1470   out++;
1471   *out = (inl >> 27);
1472   ++in;
1473   inl = util::SafeLoad(in);
1474   inl = arrow::bit_util::FromLittleEndian(inl);
1475   *out |= (inl % (1U << 10)) << (15 - 10);
1476   out++;
1477   *out = (inl >> 10) % (1U << 15);
1478   out++;
1479   *out = (inl >> 25);
1480   ++in;
1481   inl = util::SafeLoad(in);
1482   inl = arrow::bit_util::FromLittleEndian(inl);
1483   *out |= (inl % (1U << 8)) << (15 - 8);
1484   out++;
1485   *out = (inl >> 8) % (1U << 15);
1486   out++;
1487   *out = (inl >> 23);
1488   ++in;
1489   inl = util::SafeLoad(in);
1490   inl = arrow::bit_util::FromLittleEndian(inl);
1491   *out |= (inl % (1U << 6)) << (15 - 6);
1492   out++;
1493   *out = (inl >> 6) % (1U << 15);
1494   out++;
1495   *out = (inl >> 21);
1496   ++in;
1497   inl = util::SafeLoad(in);
1498   inl = arrow::bit_util::FromLittleEndian(inl);
1499   *out |= (inl % (1U << 4)) << (15 - 4);
1500   out++;
1501   *out = (inl >> 4) % (1U << 15);
1502   out++;
1503   *out = (inl >> 19);
1504   ++in;
1505   inl = util::SafeLoad(in);
1506   inl = arrow::bit_util::FromLittleEndian(inl);
1507   *out |= (inl % (1U << 2)) << (15 - 2);
1508   out++;
1509   *out = (inl >> 2) % (1U << 15);
1510   out++;
1511   *out = (inl >> 17);
1512   ++in;
1513   out++;
1514 
1515   return in;
1516 }
1517 
1518 inline const uint32_t* unpack16_32(const uint32_t* in, uint32_t* out) {
1519   uint32_t inl = util::SafeLoad(in);
1520   inl = arrow::bit_util::FromLittleEndian(inl);
1521   *out = (inl >> 0) % (1U << 16);
1522   out++;
1523   *out = (inl >> 16);
1524   ++in;
1525   inl = util::SafeLoad(in);
1526   inl = arrow::bit_util::FromLittleEndian(inl);
1527   out++;
1528   *out = (inl >> 0) % (1U << 16);
1529   out++;
1530   *out = (inl >> 16);
1531   ++in;
1532   inl = util::SafeLoad(in);
1533   inl = arrow::bit_util::FromLittleEndian(inl);
1534   out++;
1535   *out = (inl >> 0) % (1U << 16);
1536   out++;
1537   *out = (inl >> 16);
1538   ++in;
1539   inl = util::SafeLoad(in);
1540   inl = arrow::bit_util::FromLittleEndian(inl);
1541   out++;
1542   *out = (inl >> 0) % (1U << 16);
1543   out++;
1544   *out = (inl >> 16);
1545   ++in;
1546   inl = util::SafeLoad(in);
1547   inl = arrow::bit_util::FromLittleEndian(inl);
1548   out++;
1549   *out = (inl >> 0) % (1U << 16);
1550   out++;
1551   *out = (inl >> 16);
1552   ++in;
1553   inl = util::SafeLoad(in);
1554   inl = arrow::bit_util::FromLittleEndian(inl);
1555   out++;
1556   *out = (inl >> 0) % (1U << 16);
1557   out++;
1558   *out = (inl >> 16);
1559   ++in;
1560   inl = util::SafeLoad(in);
1561   inl = arrow::bit_util::FromLittleEndian(inl);
1562   out++;
1563   *out = (inl >> 0) % (1U << 16);
1564   out++;
1565   *out = (inl >> 16);
1566   ++in;
1567   inl = util::SafeLoad(in);
1568   inl = arrow::bit_util::FromLittleEndian(inl);
1569   out++;
1570   *out = (inl >> 0) % (1U << 16);
1571   out++;
1572   *out = (inl >> 16);
1573   ++in;
1574   inl = util::SafeLoad(in);
1575   inl = arrow::bit_util::FromLittleEndian(inl);
1576   out++;
1577   *out = (inl >> 0) % (1U << 16);
1578   out++;
1579   *out = (inl >> 16);
1580   ++in;
1581   inl = util::SafeLoad(in);
1582   inl = arrow::bit_util::FromLittleEndian(inl);
1583   out++;
1584   *out = (inl >> 0) % (1U << 16);
1585   out++;
1586   *out = (inl >> 16);
1587   ++in;
1588   inl = util::SafeLoad(in);
1589   inl = arrow::bit_util::FromLittleEndian(inl);
1590   out++;
1591   *out = (inl >> 0) % (1U << 16);
1592   out++;
1593   *out = (inl >> 16);
1594   ++in;
1595   inl = util::SafeLoad(in);
1596   inl = arrow::bit_util::FromLittleEndian(inl);
1597   out++;
1598   *out = (inl >> 0) % (1U << 16);
1599   out++;
1600   *out = (inl >> 16);
1601   ++in;
1602   inl = util::SafeLoad(in);
1603   inl = arrow::bit_util::FromLittleEndian(inl);
1604   out++;
1605   *out = (inl >> 0) % (1U << 16);
1606   out++;
1607   *out = (inl >> 16);
1608   ++in;
1609   inl = util::SafeLoad(in);
1610   inl = arrow::bit_util::FromLittleEndian(inl);
1611   out++;
1612   *out = (inl >> 0) % (1U << 16);
1613   out++;
1614   *out = (inl >> 16);
1615   ++in;
1616   inl = util::SafeLoad(in);
1617   inl = arrow::bit_util::FromLittleEndian(inl);
1618   out++;
1619   *out = (inl >> 0) % (1U << 16);
1620   out++;
1621   *out = (inl >> 16);
1622   ++in;
1623   inl = util::SafeLoad(in);
1624   inl = arrow::bit_util::FromLittleEndian(inl);
1625   out++;
1626   *out = (inl >> 0) % (1U << 16);
1627   out++;
1628   *out = (inl >> 16);
1629   ++in;
1630   out++;
1631 
1632   return in;
1633 }
1634 
1635 inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
1636   uint32_t inl = util::SafeLoad(in);
1637   inl = arrow::bit_util::FromLittleEndian(inl);
1638   *out = (inl >> 0) % (1U << 17);
1639   out++;
1640   *out = (inl >> 17);
1641   ++in;
1642   inl = util::SafeLoad(in);
1643   inl = arrow::bit_util::FromLittleEndian(inl);
1644   *out |= (inl % (1U << 2)) << (17 - 2);
1645   out++;
1646   *out = (inl >> 2) % (1U << 17);
1647   out++;
1648   *out = (inl >> 19);
1649   ++in;
1650   inl = util::SafeLoad(in);
1651   inl = arrow::bit_util::FromLittleEndian(inl);
1652   *out |= (inl % (1U << 4)) << (17 - 4);
1653   out++;
1654   *out = (inl >> 4) % (1U << 17);
1655   out++;
1656   *out = (inl >> 21);
1657   ++in;
1658   inl = util::SafeLoad(in);
1659   inl = arrow::bit_util::FromLittleEndian(inl);
1660   *out |= (inl % (1U << 6)) << (17 - 6);
1661   out++;
1662   *out = (inl >> 6) % (1U << 17);
1663   out++;
1664   *out = (inl >> 23);
1665   ++in;
1666   inl = util::SafeLoad(in);
1667   inl = arrow::bit_util::FromLittleEndian(inl);
1668   *out |= (inl % (1U << 8)) << (17 - 8);
1669   out++;
1670   *out = (inl >> 8) % (1U << 17);
1671   out++;
1672   *out = (inl >> 25);
1673   ++in;
1674   inl = util::SafeLoad(in);
1675   inl = arrow::bit_util::FromLittleEndian(inl);
1676   *out |= (inl % (1U << 10)) << (17 - 10);
1677   out++;
1678   *out = (inl >> 10) % (1U << 17);
1679   out++;
1680   *out = (inl >> 27);
1681   ++in;
1682   inl = util::SafeLoad(in);
1683   inl = arrow::bit_util::FromLittleEndian(inl);
1684   *out |= (inl % (1U << 12)) << (17 - 12);
1685   out++;
1686   *out = (inl >> 12) % (1U << 17);
1687   out++;
1688   *out = (inl >> 29);
1689   ++in;
1690   inl = util::SafeLoad(in);
1691   inl = arrow::bit_util::FromLittleEndian(inl);
1692   *out |= (inl % (1U << 14)) << (17 - 14);
1693   out++;
1694   *out = (inl >> 14) % (1U << 17);
1695   out++;
1696   *out = (inl >> 31);
1697   ++in;
1698   inl = util::SafeLoad(in);
1699   inl = arrow::bit_util::FromLittleEndian(inl);
1700   *out |= (inl % (1U << 16)) << (17 - 16);
1701   out++;
1702   *out = (inl >> 16);
1703   ++in;
1704   inl = util::SafeLoad(in);
1705   inl = arrow::bit_util::FromLittleEndian(inl);
1706   *out |= (inl % (1U << 1)) << (17 - 1);
1707   out++;
1708   *out = (inl >> 1) % (1U << 17);
1709   out++;
1710   *out = (inl >> 18);
1711   ++in;
1712   inl = util::SafeLoad(in);
1713   inl = arrow::bit_util::FromLittleEndian(inl);
1714   *out |= (inl % (1U << 3)) << (17 - 3);
1715   out++;
1716   *out = (inl >> 3) % (1U << 17);
1717   out++;
1718   *out = (inl >> 20);
1719   ++in;
1720   inl = util::SafeLoad(in);
1721   inl = arrow::bit_util::FromLittleEndian(inl);
1722   *out |= (inl % (1U << 5)) << (17 - 5);
1723   out++;
1724   *out = (inl >> 5) % (1U << 17);
1725   out++;
1726   *out = (inl >> 22);
1727   ++in;
1728   inl = util::SafeLoad(in);
1729   inl = arrow::bit_util::FromLittleEndian(inl);
1730   *out |= (inl % (1U << 7)) << (17 - 7);
1731   out++;
1732   *out = (inl >> 7) % (1U << 17);
1733   out++;
1734   *out = (inl >> 24);
1735   ++in;
1736   inl = util::SafeLoad(in);
1737   inl = arrow::bit_util::FromLittleEndian(inl);
1738   *out |= (inl % (1U << 9)) << (17 - 9);
1739   out++;
1740   *out = (inl >> 9) % (1U << 17);
1741   out++;
1742   *out = (inl >> 26);
1743   ++in;
1744   inl = util::SafeLoad(in);
1745   inl = arrow::bit_util::FromLittleEndian(inl);
1746   *out |= (inl % (1U << 11)) << (17 - 11);
1747   out++;
1748   *out = (inl >> 11) % (1U << 17);
1749   out++;
1750   *out = (inl >> 28);
1751   ++in;
1752   inl = util::SafeLoad(in);
1753   inl = arrow::bit_util::FromLittleEndian(inl);
1754   *out |= (inl % (1U << 13)) << (17 - 13);
1755   out++;
1756   *out = (inl >> 13) % (1U << 17);
1757   out++;
1758   *out = (inl >> 30);
1759   ++in;
1760   inl = util::SafeLoad(in);
1761   inl = arrow::bit_util::FromLittleEndian(inl);
1762   *out |= (inl % (1U << 15)) << (17 - 15);
1763   out++;
1764   *out = (inl >> 15);
1765   ++in;
1766   out++;
1767 
1768   return in;
1769 }
1770 
1771 inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
1772   uint32_t inl = util::SafeLoad(in);
1773   inl = arrow::bit_util::FromLittleEndian(inl);
1774   *out = (inl >> 0) % (1U << 18);
1775   out++;
1776   *out = (inl >> 18);
1777   ++in;
1778   inl = util::SafeLoad(in);
1779   inl = arrow::bit_util::FromLittleEndian(inl);
1780   *out |= (inl % (1U << 4)) << (18 - 4);
1781   out++;
1782   *out = (inl >> 4) % (1U << 18);
1783   out++;
1784   *out = (inl >> 22);
1785   ++in;
1786   inl = util::SafeLoad(in);
1787   inl = arrow::bit_util::FromLittleEndian(inl);
1788   *out |= (inl % (1U << 8)) << (18 - 8);
1789   out++;
1790   *out = (inl >> 8) % (1U << 18);
1791   out++;
1792   *out = (inl >> 26);
1793   ++in;
1794   inl = util::SafeLoad(in);
1795   inl = arrow::bit_util::FromLittleEndian(inl);
1796   *out |= (inl % (1U << 12)) << (18 - 12);
1797   out++;
1798   *out = (inl >> 12) % (1U << 18);
1799   out++;
1800   *out = (inl >> 30);
1801   ++in;
1802   inl = util::SafeLoad(in);
1803   inl = arrow::bit_util::FromLittleEndian(inl);
1804   *out |= (inl % (1U << 16)) << (18 - 16);
1805   out++;
1806   *out = (inl >> 16);
1807   ++in;
1808   inl = util::SafeLoad(in);
1809   inl = arrow::bit_util::FromLittleEndian(inl);
1810   *out |= (inl % (1U << 2)) << (18 - 2);
1811   out++;
1812   *out = (inl >> 2) % (1U << 18);
1813   out++;
1814   *out = (inl >> 20);
1815   ++in;
1816   inl = util::SafeLoad(in);
1817   inl = arrow::bit_util::FromLittleEndian(inl);
1818   *out |= (inl % (1U << 6)) << (18 - 6);
1819   out++;
1820   *out = (inl >> 6) % (1U << 18);
1821   out++;
1822   *out = (inl >> 24);
1823   ++in;
1824   inl = util::SafeLoad(in);
1825   inl = arrow::bit_util::FromLittleEndian(inl);
1826   *out |= (inl % (1U << 10)) << (18 - 10);
1827   out++;
1828   *out = (inl >> 10) % (1U << 18);
1829   out++;
1830   *out = (inl >> 28);
1831   ++in;
1832   inl = util::SafeLoad(in);
1833   inl = arrow::bit_util::FromLittleEndian(inl);
1834   *out |= (inl % (1U << 14)) << (18 - 14);
1835   out++;
1836   *out = (inl >> 14);
1837   ++in;
1838   inl = util::SafeLoad(in);
1839   inl = arrow::bit_util::FromLittleEndian(inl);
1840   out++;
1841   *out = (inl >> 0) % (1U << 18);
1842   out++;
1843   *out = (inl >> 18);
1844   ++in;
1845   inl = util::SafeLoad(in);
1846   inl = arrow::bit_util::FromLittleEndian(inl);
1847   *out |= (inl % (1U << 4)) << (18 - 4);
1848   out++;
1849   *out = (inl >> 4) % (1U << 18);
1850   out++;
1851   *out = (inl >> 22);
1852   ++in;
1853   inl = util::SafeLoad(in);
1854   inl = arrow::bit_util::FromLittleEndian(inl);
1855   *out |= (inl % (1U << 8)) << (18 - 8);
1856   out++;
1857   *out = (inl >> 8) % (1U << 18);
1858   out++;
1859   *out = (inl >> 26);
1860   ++in;
1861   inl = util::SafeLoad(in);
1862   inl = arrow::bit_util::FromLittleEndian(inl);
1863   *out |= (inl % (1U << 12)) << (18 - 12);
1864   out++;
1865   *out = (inl >> 12) % (1U << 18);
1866   out++;
1867   *out = (inl >> 30);
1868   ++in;
1869   inl = util::SafeLoad(in);
1870   inl = arrow::bit_util::FromLittleEndian(inl);
1871   *out |= (inl % (1U << 16)) << (18 - 16);
1872   out++;
1873   *out = (inl >> 16);
1874   ++in;
1875   inl = util::SafeLoad(in);
1876   inl = arrow::bit_util::FromLittleEndian(inl);
1877   *out |= (inl % (1U << 2)) << (18 - 2);
1878   out++;
1879   *out = (inl >> 2) % (1U << 18);
1880   out++;
1881   *out = (inl >> 20);
1882   ++in;
1883   inl = util::SafeLoad(in);
1884   inl = arrow::bit_util::FromLittleEndian(inl);
1885   *out |= (inl % (1U << 6)) << (18 - 6);
1886   out++;
1887   *out = (inl >> 6) % (1U << 18);
1888   out++;
1889   *out = (inl >> 24);
1890   ++in;
1891   inl = util::SafeLoad(in);
1892   inl = arrow::bit_util::FromLittleEndian(inl);
1893   *out |= (inl % (1U << 10)) << (18 - 10);
1894   out++;
1895   *out = (inl >> 10) % (1U << 18);
1896   out++;
1897   *out = (inl >> 28);
1898   ++in;
1899   inl = util::SafeLoad(in);
1900   inl = arrow::bit_util::FromLittleEndian(inl);
1901   *out |= (inl % (1U << 14)) << (18 - 14);
1902   out++;
1903   *out = (inl >> 14);
1904   ++in;
1905   out++;
1906 
1907   return in;
1908 }
1909 
1910 inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
1911   uint32_t inl = util::SafeLoad(in);
1912   inl = arrow::bit_util::FromLittleEndian(inl);
1913   *out = (inl >> 0) % (1U << 19);
1914   out++;
1915   *out = (inl >> 19);
1916   ++in;
1917   inl = util::SafeLoad(in);
1918   inl = arrow::bit_util::FromLittleEndian(inl);
1919   *out |= (inl % (1U << 6)) << (19 - 6);
1920   out++;
1921   *out = (inl >> 6) % (1U << 19);
1922   out++;
1923   *out = (inl >> 25);
1924   ++in;
1925   inl = util::SafeLoad(in);
1926   inl = arrow::bit_util::FromLittleEndian(inl);
1927   *out |= (inl % (1U << 12)) << (19 - 12);
1928   out++;
1929   *out = (inl >> 12) % (1U << 19);
1930   out++;
1931   *out = (inl >> 31);
1932   ++in;
1933   inl = util::SafeLoad(in);
1934   inl = arrow::bit_util::FromLittleEndian(inl);
1935   *out |= (inl % (1U << 18)) << (19 - 18);
1936   out++;
1937   *out = (inl >> 18);
1938   ++in;
1939   inl = util::SafeLoad(in);
1940   inl = arrow::bit_util::FromLittleEndian(inl);
1941   *out |= (inl % (1U << 5)) << (19 - 5);
1942   out++;
1943   *out = (inl >> 5) % (1U << 19);
1944   out++;
1945   *out = (inl >> 24);
1946   ++in;
1947   inl = util::SafeLoad(in);
1948   inl = arrow::bit_util::FromLittleEndian(inl);
1949   *out |= (inl % (1U << 11)) << (19 - 11);
1950   out++;
1951   *out = (inl >> 11) % (1U << 19);
1952   out++;
1953   *out = (inl >> 30);
1954   ++in;
1955   inl = util::SafeLoad(in);
1956   inl = arrow::bit_util::FromLittleEndian(inl);
1957   *out |= (inl % (1U << 17)) << (19 - 17);
1958   out++;
1959   *out = (inl >> 17);
1960   ++in;
1961   inl = util::SafeLoad(in);
1962   inl = arrow::bit_util::FromLittleEndian(inl);
1963   *out |= (inl % (1U << 4)) << (19 - 4);
1964   out++;
1965   *out = (inl >> 4) % (1U << 19);
1966   out++;
1967   *out = (inl >> 23);
1968   ++in;
1969   inl = util::SafeLoad(in);
1970   inl = arrow::bit_util::FromLittleEndian(inl);
1971   *out |= (inl % (1U << 10)) << (19 - 10);
1972   out++;
1973   *out = (inl >> 10) % (1U << 19);
1974   out++;
1975   *out = (inl >> 29);
1976   ++in;
1977   inl = util::SafeLoad(in);
1978   inl = arrow::bit_util::FromLittleEndian(inl);
1979   *out |= (inl % (1U << 16)) << (19 - 16);
1980   out++;
1981   *out = (inl >> 16);
1982   ++in;
1983   inl = util::SafeLoad(in);
1984   inl = arrow::bit_util::FromLittleEndian(inl);
1985   *out |= (inl % (1U << 3)) << (19 - 3);
1986   out++;
1987   *out = (inl >> 3) % (1U << 19);
1988   out++;
1989   *out = (inl >> 22);
1990   ++in;
1991   inl = util::SafeLoad(in);
1992   inl = arrow::bit_util::FromLittleEndian(inl);
1993   *out |= (inl % (1U << 9)) << (19 - 9);
1994   out++;
1995   *out = (inl >> 9) % (1U << 19);
1996   out++;
1997   *out = (inl >> 28);
1998   ++in;
1999   inl = util::SafeLoad(in);
2000   inl = arrow::bit_util::FromLittleEndian(inl);
2001   *out |= (inl % (1U << 15)) << (19 - 15);
2002   out++;
2003   *out = (inl >> 15);
2004   ++in;
2005   inl = util::SafeLoad(in);
2006   inl = arrow::bit_util::FromLittleEndian(inl);
2007   *out |= (inl % (1U << 2)) << (19 - 2);
2008   out++;
2009   *out = (inl >> 2) % (1U << 19);
2010   out++;
2011   *out = (inl >> 21);
2012   ++in;
2013   inl = util::SafeLoad(in);
2014   inl = arrow::bit_util::FromLittleEndian(inl);
2015   *out |= (inl % (1U << 8)) << (19 - 8);
2016   out++;
2017   *out = (inl >> 8) % (1U << 19);
2018   out++;
2019   *out = (inl >> 27);
2020   ++in;
2021   inl = util::SafeLoad(in);
2022   inl = arrow::bit_util::FromLittleEndian(inl);
2023   *out |= (inl % (1U << 14)) << (19 - 14);
2024   out++;
2025   *out = (inl >> 14);
2026   ++in;
2027   inl = util::SafeLoad(in);
2028   inl = arrow::bit_util::FromLittleEndian(inl);
2029   *out |= (inl % (1U << 1)) << (19 - 1);
2030   out++;
2031   *out = (inl >> 1) % (1U << 19);
2032   out++;
2033   *out = (inl >> 20);
2034   ++in;
2035   inl = util::SafeLoad(in);
2036   inl = arrow::bit_util::FromLittleEndian(inl);
2037   *out |= (inl % (1U << 7)) << (19 - 7);
2038   out++;
2039   *out = (inl >> 7) % (1U << 19);
2040   out++;
2041   *out = (inl >> 26);
2042   ++in;
2043   inl = util::SafeLoad(in);
2044   inl = arrow::bit_util::FromLittleEndian(inl);
2045   *out |= (inl % (1U << 13)) << (19 - 13);
2046   out++;
2047   *out = (inl >> 13);
2048   ++in;
2049   out++;
2050 
2051   return in;
2052 }
2053 
2054 inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
2055   uint32_t inl = util::SafeLoad(in);
2056   inl = arrow::bit_util::FromLittleEndian(inl);
2057   *out = (inl >> 0) % (1U << 20);
2058   out++;
2059   *out = (inl >> 20);
2060   ++in;
2061   inl = util::SafeLoad(in);
2062   inl = arrow::bit_util::FromLittleEndian(inl);
2063   *out |= (inl % (1U << 8)) << (20 - 8);
2064   out++;
2065   *out = (inl >> 8) % (1U << 20);
2066   out++;
2067   *out = (inl >> 28);
2068   ++in;
2069   inl = util::SafeLoad(in);
2070   inl = arrow::bit_util::FromLittleEndian(inl);
2071   *out |= (inl % (1U << 16)) << (20 - 16);
2072   out++;
2073   *out = (inl >> 16);
2074   ++in;
2075   inl = util::SafeLoad(in);
2076   inl = arrow::bit_util::FromLittleEndian(inl);
2077   *out |= (inl % (1U << 4)) << (20 - 4);
2078   out++;
2079   *out = (inl >> 4) % (1U << 20);
2080   out++;
2081   *out = (inl >> 24);
2082   ++in;
2083   inl = util::SafeLoad(in);
2084   inl = arrow::bit_util::FromLittleEndian(inl);
2085   *out |= (inl % (1U << 12)) << (20 - 12);
2086   out++;
2087   *out = (inl >> 12);
2088   ++in;
2089   inl = util::SafeLoad(in);
2090   inl = arrow::bit_util::FromLittleEndian(inl);
2091   out++;
2092   *out = (inl >> 0) % (1U << 20);
2093   out++;
2094   *out = (inl >> 20);
2095   ++in;
2096   inl = util::SafeLoad(in);
2097   inl = arrow::bit_util::FromLittleEndian(inl);
2098   *out |= (inl % (1U << 8)) << (20 - 8);
2099   out++;
2100   *out = (inl >> 8) % (1U << 20);
2101   out++;
2102   *out = (inl >> 28);
2103   ++in;
2104   inl = util::SafeLoad(in);
2105   inl = arrow::bit_util::FromLittleEndian(inl);
2106   *out |= (inl % (1U << 16)) << (20 - 16);
2107   out++;
2108   *out = (inl >> 16);
2109   ++in;
2110   inl = util::SafeLoad(in);
2111   inl = arrow::bit_util::FromLittleEndian(inl);
2112   *out |= (inl % (1U << 4)) << (20 - 4);
2113   out++;
2114   *out = (inl >> 4) % (1U << 20);
2115   out++;
2116   *out = (inl >> 24);
2117   ++in;
2118   inl = util::SafeLoad(in);
2119   inl = arrow::bit_util::FromLittleEndian(inl);
2120   *out |= (inl % (1U << 12)) << (20 - 12);
2121   out++;
2122   *out = (inl >> 12);
2123   ++in;
2124   inl = util::SafeLoad(in);
2125   inl = arrow::bit_util::FromLittleEndian(inl);
2126   out++;
2127   *out = (inl >> 0) % (1U << 20);
2128   out++;
2129   *out = (inl >> 20);
2130   ++in;
2131   inl = util::SafeLoad(in);
2132   inl = arrow::bit_util::FromLittleEndian(inl);
2133   *out |= (inl % (1U << 8)) << (20 - 8);
2134   out++;
2135   *out = (inl >> 8) % (1U << 20);
2136   out++;
2137   *out = (inl >> 28);
2138   ++in;
2139   inl = util::SafeLoad(in);
2140   inl = arrow::bit_util::FromLittleEndian(inl);
2141   *out |= (inl % (1U << 16)) << (20 - 16);
2142   out++;
2143   *out = (inl >> 16);
2144   ++in;
2145   inl = util::SafeLoad(in);
2146   inl = arrow::bit_util::FromLittleEndian(inl);
2147   *out |= (inl % (1U << 4)) << (20 - 4);
2148   out++;
2149   *out = (inl >> 4) % (1U << 20);
2150   out++;
2151   *out = (inl >> 24);
2152   ++in;
2153   inl = util::SafeLoad(in);
2154   inl = arrow::bit_util::FromLittleEndian(inl);
2155   *out |= (inl % (1U << 12)) << (20 - 12);
2156   out++;
2157   *out = (inl >> 12);
2158   ++in;
2159   inl = util::SafeLoad(in);
2160   inl = arrow::bit_util::FromLittleEndian(inl);
2161   out++;
2162   *out = (inl >> 0) % (1U << 20);
2163   out++;
2164   *out = (inl >> 20);
2165   ++in;
2166   inl = util::SafeLoad(in);
2167   inl = arrow::bit_util::FromLittleEndian(inl);
2168   *out |= (inl % (1U << 8)) << (20 - 8);
2169   out++;
2170   *out = (inl >> 8) % (1U << 20);
2171   out++;
2172   *out = (inl >> 28);
2173   ++in;
2174   inl = util::SafeLoad(in);
2175   inl = arrow::bit_util::FromLittleEndian(inl);
2176   *out |= (inl % (1U << 16)) << (20 - 16);
2177   out++;
2178   *out = (inl >> 16);
2179   ++in;
2180   inl = util::SafeLoad(in);
2181   inl = arrow::bit_util::FromLittleEndian(inl);
2182   *out |= (inl % (1U << 4)) << (20 - 4);
2183   out++;
2184   *out = (inl >> 4) % (1U << 20);
2185   out++;
2186   *out = (inl >> 24);
2187   ++in;
2188   inl = util::SafeLoad(in);
2189   inl = arrow::bit_util::FromLittleEndian(inl);
2190   *out |= (inl % (1U << 12)) << (20 - 12);
2191   out++;
2192   *out = (inl >> 12);
2193   ++in;
2194   out++;
2195 
2196   return in;
2197 }
2198 
2199 inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
2200   uint32_t inl = util::SafeLoad(in);
2201   inl = arrow::bit_util::FromLittleEndian(inl);
2202   *out = (inl >> 0) % (1U << 21);
2203   out++;
2204   *out = (inl >> 21);
2205   ++in;
2206   inl = util::SafeLoad(in);
2207   inl = arrow::bit_util::FromLittleEndian(inl);
2208   *out |= (inl % (1U << 10)) << (21 - 10);
2209   out++;
2210   *out = (inl >> 10) % (1U << 21);
2211   out++;
2212   *out = (inl >> 31);
2213   ++in;
2214   inl = util::SafeLoad(in);
2215   inl = arrow::bit_util::FromLittleEndian(inl);
2216   *out |= (inl % (1U << 20)) << (21 - 20);
2217   out++;
2218   *out = (inl >> 20);
2219   ++in;
2220   inl = util::SafeLoad(in);
2221   inl = arrow::bit_util::FromLittleEndian(inl);
2222   *out |= (inl % (1U << 9)) << (21 - 9);
2223   out++;
2224   *out = (inl >> 9) % (1U << 21);
2225   out++;
2226   *out = (inl >> 30);
2227   ++in;
2228   inl = util::SafeLoad(in);
2229   inl = arrow::bit_util::FromLittleEndian(inl);
2230   *out |= (inl % (1U << 19)) << (21 - 19);
2231   out++;
2232   *out = (inl >> 19);
2233   ++in;
2234   inl = util::SafeLoad(in);
2235   inl = arrow::bit_util::FromLittleEndian(inl);
2236   *out |= (inl % (1U << 8)) << (21 - 8);
2237   out++;
2238   *out = (inl >> 8) % (1U << 21);
2239   out++;
2240   *out = (inl >> 29);
2241   ++in;
2242   inl = util::SafeLoad(in);
2243   inl = arrow::bit_util::FromLittleEndian(inl);
2244   *out |= (inl % (1U << 18)) << (21 - 18);
2245   out++;
2246   *out = (inl >> 18);
2247   ++in;
2248   inl = util::SafeLoad(in);
2249   inl = arrow::bit_util::FromLittleEndian(inl);
2250   *out |= (inl % (1U << 7)) << (21 - 7);
2251   out++;
2252   *out = (inl >> 7) % (1U << 21);
2253   out++;
2254   *out = (inl >> 28);
2255   ++in;
2256   inl = util::SafeLoad(in);
2257   inl = arrow::bit_util::FromLittleEndian(inl);
2258   *out |= (inl % (1U << 17)) << (21 - 17);
2259   out++;
2260   *out = (inl >> 17);
2261   ++in;
2262   inl = util::SafeLoad(in);
2263   inl = arrow::bit_util::FromLittleEndian(inl);
2264   *out |= (inl % (1U << 6)) << (21 - 6);
2265   out++;
2266   *out = (inl >> 6) % (1U << 21);
2267   out++;
2268   *out = (inl >> 27);
2269   ++in;
2270   inl = util::SafeLoad(in);
2271   inl = arrow::bit_util::FromLittleEndian(inl);
2272   *out |= (inl % (1U << 16)) << (21 - 16);
2273   out++;
2274   *out = (inl >> 16);
2275   ++in;
2276   inl = util::SafeLoad(in);
2277   inl = arrow::bit_util::FromLittleEndian(inl);
2278   *out |= (inl % (1U << 5)) << (21 - 5);
2279   out++;
2280   *out = (inl >> 5) % (1U << 21);
2281   out++;
2282   *out = (inl >> 26);
2283   ++in;
2284   inl = util::SafeLoad(in);
2285   inl = arrow::bit_util::FromLittleEndian(inl);
2286   *out |= (inl % (1U << 15)) << (21 - 15);
2287   out++;
2288   *out = (inl >> 15);
2289   ++in;
2290   inl = util::SafeLoad(in);
2291   inl = arrow::bit_util::FromLittleEndian(inl);
2292   *out |= (inl % (1U << 4)) << (21 - 4);
2293   out++;
2294   *out = (inl >> 4) % (1U << 21);
2295   out++;
2296   *out = (inl >> 25);
2297   ++in;
2298   inl = util::SafeLoad(in);
2299   inl = arrow::bit_util::FromLittleEndian(inl);
2300   *out |= (inl % (1U << 14)) << (21 - 14);
2301   out++;
2302   *out = (inl >> 14);
2303   ++in;
2304   inl = util::SafeLoad(in);
2305   inl = arrow::bit_util::FromLittleEndian(inl);
2306   *out |= (inl % (1U << 3)) << (21 - 3);
2307   out++;
2308   *out = (inl >> 3) % (1U << 21);
2309   out++;
2310   *out = (inl >> 24);
2311   ++in;
2312   inl = util::SafeLoad(in);
2313   inl = arrow::bit_util::FromLittleEndian(inl);
2314   *out |= (inl % (1U << 13)) << (21 - 13);
2315   out++;
2316   *out = (inl >> 13);
2317   ++in;
2318   inl = util::SafeLoad(in);
2319   inl = arrow::bit_util::FromLittleEndian(inl);
2320   *out |= (inl % (1U << 2)) << (21 - 2);
2321   out++;
2322   *out = (inl >> 2) % (1U << 21);
2323   out++;
2324   *out = (inl >> 23);
2325   ++in;
2326   inl = util::SafeLoad(in);
2327   inl = arrow::bit_util::FromLittleEndian(inl);
2328   *out |= (inl % (1U << 12)) << (21 - 12);
2329   out++;
2330   *out = (inl >> 12);
2331   ++in;
2332   inl = util::SafeLoad(in);
2333   inl = arrow::bit_util::FromLittleEndian(inl);
2334   *out |= (inl % (1U << 1)) << (21 - 1);
2335   out++;
2336   *out = (inl >> 1) % (1U << 21);
2337   out++;
2338   *out = (inl >> 22);
2339   ++in;
2340   inl = util::SafeLoad(in);
2341   inl = arrow::bit_util::FromLittleEndian(inl);
2342   *out |= (inl % (1U << 11)) << (21 - 11);
2343   out++;
2344   *out = (inl >> 11);
2345   ++in;
2346   out++;
2347 
2348   return in;
2349 }
2350 
2351 inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
2352   uint32_t inl = util::SafeLoad(in);
2353   inl = arrow::bit_util::FromLittleEndian(inl);
2354   *out = (inl >> 0) % (1U << 22);
2355   out++;
2356   *out = (inl >> 22);
2357   ++in;
2358   inl = util::SafeLoad(in);
2359   inl = arrow::bit_util::FromLittleEndian(inl);
2360   *out |= (inl % (1U << 12)) << (22 - 12);
2361   out++;
2362   *out = (inl >> 12);
2363   ++in;
2364   inl = util::SafeLoad(in);
2365   inl = arrow::bit_util::FromLittleEndian(inl);
2366   *out |= (inl % (1U << 2)) << (22 - 2);
2367   out++;
2368   *out = (inl >> 2) % (1U << 22);
2369   out++;
2370   *out = (inl >> 24);
2371   ++in;
2372   inl = util::SafeLoad(in);
2373   inl = arrow::bit_util::FromLittleEndian(inl);
2374   *out |= (inl % (1U << 14)) << (22 - 14);
2375   out++;
2376   *out = (inl >> 14);
2377   ++in;
2378   inl = util::SafeLoad(in);
2379   inl = arrow::bit_util::FromLittleEndian(inl);
2380   *out |= (inl % (1U << 4)) << (22 - 4);
2381   out++;
2382   *out = (inl >> 4) % (1U << 22);
2383   out++;
2384   *out = (inl >> 26);
2385   ++in;
2386   inl = util::SafeLoad(in);
2387   inl = arrow::bit_util::FromLittleEndian(inl);
2388   *out |= (inl % (1U << 16)) << (22 - 16);
2389   out++;
2390   *out = (inl >> 16);
2391   ++in;
2392   inl = util::SafeLoad(in);
2393   inl = arrow::bit_util::FromLittleEndian(inl);
2394   *out |= (inl % (1U << 6)) << (22 - 6);
2395   out++;
2396   *out = (inl >> 6) % (1U << 22);
2397   out++;
2398   *out = (inl >> 28);
2399   ++in;
2400   inl = util::SafeLoad(in);
2401   inl = arrow::bit_util::FromLittleEndian(inl);
2402   *out |= (inl % (1U << 18)) << (22 - 18);
2403   out++;
2404   *out = (inl >> 18);
2405   ++in;
2406   inl = util::SafeLoad(in);
2407   inl = arrow::bit_util::FromLittleEndian(inl);
2408   *out |= (inl % (1U << 8)) << (22 - 8);
2409   out++;
2410   *out = (inl >> 8) % (1U << 22);
2411   out++;
2412   *out = (inl >> 30);
2413   ++in;
2414   inl = util::SafeLoad(in);
2415   inl = arrow::bit_util::FromLittleEndian(inl);
2416   *out |= (inl % (1U << 20)) << (22 - 20);
2417   out++;
2418   *out = (inl >> 20);
2419   ++in;
2420   inl = util::SafeLoad(in);
2421   inl = arrow::bit_util::FromLittleEndian(inl);
2422   *out |= (inl % (1U << 10)) << (22 - 10);
2423   out++;
2424   *out = (inl >> 10);
2425   ++in;
2426   inl = util::SafeLoad(in);
2427   inl = arrow::bit_util::FromLittleEndian(inl);
2428   out++;
2429   *out = (inl >> 0) % (1U << 22);
2430   out++;
2431   *out = (inl >> 22);
2432   ++in;
2433   inl = util::SafeLoad(in);
2434   inl = arrow::bit_util::FromLittleEndian(inl);
2435   *out |= (inl % (1U << 12)) << (22 - 12);
2436   out++;
2437   *out = (inl >> 12);
2438   ++in;
2439   inl = util::SafeLoad(in);
2440   inl = arrow::bit_util::FromLittleEndian(inl);
2441   *out |= (inl % (1U << 2)) << (22 - 2);
2442   out++;
2443   *out = (inl >> 2) % (1U << 22);
2444   out++;
2445   *out = (inl >> 24);
2446   ++in;
2447   inl = util::SafeLoad(in);
2448   inl = arrow::bit_util::FromLittleEndian(inl);
2449   *out |= (inl % (1U << 14)) << (22 - 14);
2450   out++;
2451   *out = (inl >> 14);
2452   ++in;
2453   inl = util::SafeLoad(in);
2454   inl = arrow::bit_util::FromLittleEndian(inl);
2455   *out |= (inl % (1U << 4)) << (22 - 4);
2456   out++;
2457   *out = (inl >> 4) % (1U << 22);
2458   out++;
2459   *out = (inl >> 26);
2460   ++in;
2461   inl = util::SafeLoad(in);
2462   inl = arrow::bit_util::FromLittleEndian(inl);
2463   *out |= (inl % (1U << 16)) << (22 - 16);
2464   out++;
2465   *out = (inl >> 16);
2466   ++in;
2467   inl = util::SafeLoad(in);
2468   inl = arrow::bit_util::FromLittleEndian(inl);
2469   *out |= (inl % (1U << 6)) << (22 - 6);
2470   out++;
2471   *out = (inl >> 6) % (1U << 22);
2472   out++;
2473   *out = (inl >> 28);
2474   ++in;
2475   inl = util::SafeLoad(in);
2476   inl = arrow::bit_util::FromLittleEndian(inl);
2477   *out |= (inl % (1U << 18)) << (22 - 18);
2478   out++;
2479   *out = (inl >> 18);
2480   ++in;
2481   inl = util::SafeLoad(in);
2482   inl = arrow::bit_util::FromLittleEndian(inl);
2483   *out |= (inl % (1U << 8)) << (22 - 8);
2484   out++;
2485   *out = (inl >> 8) % (1U << 22);
2486   out++;
2487   *out = (inl >> 30);
2488   ++in;
2489   inl = util::SafeLoad(in);
2490   inl = arrow::bit_util::FromLittleEndian(inl);
2491   *out |= (inl % (1U << 20)) << (22 - 20);
2492   out++;
2493   *out = (inl >> 20);
2494   ++in;
2495   inl = util::SafeLoad(in);
2496   inl = arrow::bit_util::FromLittleEndian(inl);
2497   *out |= (inl % (1U << 10)) << (22 - 10);
2498   out++;
2499   *out = (inl >> 10);
2500   ++in;
2501   out++;
2502 
2503   return in;
2504 }
2505 
2506 inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
2507   uint32_t inl = util::SafeLoad(in);
2508   inl = arrow::bit_util::FromLittleEndian(inl);
2509   *out = (inl >> 0) % (1U << 23);
2510   out++;
2511   *out = (inl >> 23);
2512   ++in;
2513   inl = util::SafeLoad(in);
2514   inl = arrow::bit_util::FromLittleEndian(inl);
2515   *out |= (inl % (1U << 14)) << (23 - 14);
2516   out++;
2517   *out = (inl >> 14);
2518   ++in;
2519   inl = util::SafeLoad(in);
2520   inl = arrow::bit_util::FromLittleEndian(inl);
2521   *out |= (inl % (1U << 5)) << (23 - 5);
2522   out++;
2523   *out = (inl >> 5) % (1U << 23);
2524   out++;
2525   *out = (inl >> 28);
2526   ++in;
2527   inl = util::SafeLoad(in);
2528   inl = arrow::bit_util::FromLittleEndian(inl);
2529   *out |= (inl % (1U << 19)) << (23 - 19);
2530   out++;
2531   *out = (inl >> 19);
2532   ++in;
2533   inl = util::SafeLoad(in);
2534   inl = arrow::bit_util::FromLittleEndian(inl);
2535   *out |= (inl % (1U << 10)) << (23 - 10);
2536   out++;
2537   *out = (inl >> 10);
2538   ++in;
2539   inl = util::SafeLoad(in);
2540   inl = arrow::bit_util::FromLittleEndian(inl);
2541   *out |= (inl % (1U << 1)) << (23 - 1);
2542   out++;
2543   *out = (inl >> 1) % (1U << 23);
2544   out++;
2545   *out = (inl >> 24);
2546   ++in;
2547   inl = util::SafeLoad(in);
2548   inl = arrow::bit_util::FromLittleEndian(inl);
2549   *out |= (inl % (1U << 15)) << (23 - 15);
2550   out++;
2551   *out = (inl >> 15);
2552   ++in;
2553   inl = util::SafeLoad(in);
2554   inl = arrow::bit_util::FromLittleEndian(inl);
2555   *out |= (inl % (1U << 6)) << (23 - 6);
2556   out++;
2557   *out = (inl >> 6) % (1U << 23);
2558   out++;
2559   *out = (inl >> 29);
2560   ++in;
2561   inl = util::SafeLoad(in);
2562   inl = arrow::bit_util::FromLittleEndian(inl);
2563   *out |= (inl % (1U << 20)) << (23 - 20);
2564   out++;
2565   *out = (inl >> 20);
2566   ++in;
2567   inl = util::SafeLoad(in);
2568   inl = arrow::bit_util::FromLittleEndian(inl);
2569   *out |= (inl % (1U << 11)) << (23 - 11);
2570   out++;
2571   *out = (inl >> 11);
2572   ++in;
2573   inl = util::SafeLoad(in);
2574   inl = arrow::bit_util::FromLittleEndian(inl);
2575   *out |= (inl % (1U << 2)) << (23 - 2);
2576   out++;
2577   *out = (inl >> 2) % (1U << 23);
2578   out++;
2579   *out = (inl >> 25);
2580   ++in;
2581   inl = util::SafeLoad(in);
2582   inl = arrow::bit_util::FromLittleEndian(inl);
2583   *out |= (inl % (1U << 16)) << (23 - 16);
2584   out++;
2585   *out = (inl >> 16);
2586   ++in;
2587   inl = util::SafeLoad(in);
2588   inl = arrow::bit_util::FromLittleEndian(inl);
2589   *out |= (inl % (1U << 7)) << (23 - 7);
2590   out++;
2591   *out = (inl >> 7) % (1U << 23);
2592   out++;
2593   *out = (inl >> 30);
2594   ++in;
2595   inl = util::SafeLoad(in);
2596   inl = arrow::bit_util::FromLittleEndian(inl);
2597   *out |= (inl % (1U << 21)) << (23 - 21);
2598   out++;
2599   *out = (inl >> 21);
2600   ++in;
2601   inl = util::SafeLoad(in);
2602   inl = arrow::bit_util::FromLittleEndian(inl);
2603   *out |= (inl % (1U << 12)) << (23 - 12);
2604   out++;
2605   *out = (inl >> 12);
2606   ++in;
2607   inl = util::SafeLoad(in);
2608   inl = arrow::bit_util::FromLittleEndian(inl);
2609   *out |= (inl % (1U << 3)) << (23 - 3);
2610   out++;
2611   *out = (inl >> 3) % (1U << 23);
2612   out++;
2613   *out = (inl >> 26);
2614   ++in;
2615   inl = util::SafeLoad(in);
2616   inl = arrow::bit_util::FromLittleEndian(inl);
2617   *out |= (inl % (1U << 17)) << (23 - 17);
2618   out++;
2619   *out = (inl >> 17);
2620   ++in;
2621   inl = util::SafeLoad(in);
2622   inl = arrow::bit_util::FromLittleEndian(inl);
2623   *out |= (inl % (1U << 8)) << (23 - 8);
2624   out++;
2625   *out = (inl >> 8) % (1U << 23);
2626   out++;
2627   *out = (inl >> 31);
2628   ++in;
2629   inl = util::SafeLoad(in);
2630   inl = arrow::bit_util::FromLittleEndian(inl);
2631   *out |= (inl % (1U << 22)) << (23 - 22);
2632   out++;
2633   *out = (inl >> 22);
2634   ++in;
2635   inl = util::SafeLoad(in);
2636   inl = arrow::bit_util::FromLittleEndian(inl);
2637   *out |= (inl % (1U << 13)) << (23 - 13);
2638   out++;
2639   *out = (inl >> 13);
2640   ++in;
2641   inl = util::SafeLoad(in);
2642   inl = arrow::bit_util::FromLittleEndian(inl);
2643   *out |= (inl % (1U << 4)) << (23 - 4);
2644   out++;
2645   *out = (inl >> 4) % (1U << 23);
2646   out++;
2647   *out = (inl >> 27);
2648   ++in;
2649   inl = util::SafeLoad(in);
2650   inl = arrow::bit_util::FromLittleEndian(inl);
2651   *out |= (inl % (1U << 18)) << (23 - 18);
2652   out++;
2653   *out = (inl >> 18);
2654   ++in;
2655   inl = util::SafeLoad(in);
2656   inl = arrow::bit_util::FromLittleEndian(inl);
2657   *out |= (inl % (1U << 9)) << (23 - 9);
2658   out++;
2659   *out = (inl >> 9);
2660   ++in;
2661   out++;
2662 
2663   return in;
2664 }
2665 
2666 inline const uint32_t* unpack24_32(const uint32_t* in, uint32_t* out) {
2667   uint32_t inl = util::SafeLoad(in);
2668   inl = arrow::bit_util::FromLittleEndian(inl);
2669   *out = (inl >> 0) % (1U << 24);
2670   out++;
2671   *out = (inl >> 24);
2672   ++in;
2673   inl = util::SafeLoad(in);
2674   inl = arrow::bit_util::FromLittleEndian(inl);
2675   *out |= (inl % (1U << 16)) << (24 - 16);
2676   out++;
2677   *out = (inl >> 16);
2678   ++in;
2679   inl = util::SafeLoad(in);
2680   inl = arrow::bit_util::FromLittleEndian(inl);
2681   *out |= (inl % (1U << 8)) << (24 - 8);
2682   out++;
2683   *out = (inl >> 8);
2684   ++in;
2685   inl = util::SafeLoad(in);
2686   inl = arrow::bit_util::FromLittleEndian(inl);
2687   out++;
2688   *out = (inl >> 0) % (1U << 24);
2689   out++;
2690   *out = (inl >> 24);
2691   ++in;
2692   inl = util::SafeLoad(in);
2693   inl = arrow::bit_util::FromLittleEndian(inl);
2694   *out |= (inl % (1U << 16)) << (24 - 16);
2695   out++;
2696   *out = (inl >> 16);
2697   ++in;
2698   inl = util::SafeLoad(in);
2699   inl = arrow::bit_util::FromLittleEndian(inl);
2700   *out |= (inl % (1U << 8)) << (24 - 8);
2701   out++;
2702   *out = (inl >> 8);
2703   ++in;
2704   inl = util::SafeLoad(in);
2705   inl = arrow::bit_util::FromLittleEndian(inl);
2706   out++;
2707   *out = (inl >> 0) % (1U << 24);
2708   out++;
2709   *out = (inl >> 24);
2710   ++in;
2711   inl = util::SafeLoad(in);
2712   inl = arrow::bit_util::FromLittleEndian(inl);
2713   *out |= (inl % (1U << 16)) << (24 - 16);
2714   out++;
2715   *out = (inl >> 16);
2716   ++in;
2717   inl = util::SafeLoad(in);
2718   inl = arrow::bit_util::FromLittleEndian(inl);
2719   *out |= (inl % (1U << 8)) << (24 - 8);
2720   out++;
2721   *out = (inl >> 8);
2722   ++in;
2723   inl = util::SafeLoad(in);
2724   inl = arrow::bit_util::FromLittleEndian(inl);
2725   out++;
2726   *out = (inl >> 0) % (1U << 24);
2727   out++;
2728   *out = (inl >> 24);
2729   ++in;
2730   inl = util::SafeLoad(in);
2731   inl = arrow::bit_util::FromLittleEndian(inl);
2732   *out |= (inl % (1U << 16)) << (24 - 16);
2733   out++;
2734   *out = (inl >> 16);
2735   ++in;
2736   inl = util::SafeLoad(in);
2737   inl = arrow::bit_util::FromLittleEndian(inl);
2738   *out |= (inl % (1U << 8)) << (24 - 8);
2739   out++;
2740   *out = (inl >> 8);
2741   ++in;
2742   inl = util::SafeLoad(in);
2743   inl = arrow::bit_util::FromLittleEndian(inl);
2744   out++;
2745   *out = (inl >> 0) % (1U << 24);
2746   out++;
2747   *out = (inl >> 24);
2748   ++in;
2749   inl = util::SafeLoad(in);
2750   inl = arrow::bit_util::FromLittleEndian(inl);
2751   *out |= (inl % (1U << 16)) << (24 - 16);
2752   out++;
2753   *out = (inl >> 16);
2754   ++in;
2755   inl = util::SafeLoad(in);
2756   inl = arrow::bit_util::FromLittleEndian(inl);
2757   *out |= (inl % (1U << 8)) << (24 - 8);
2758   out++;
2759   *out = (inl >> 8);
2760   ++in;
2761   inl = util::SafeLoad(in);
2762   inl = arrow::bit_util::FromLittleEndian(inl);
2763   out++;
2764   *out = (inl >> 0) % (1U << 24);
2765   out++;
2766   *out = (inl >> 24);
2767   ++in;
2768   inl = util::SafeLoad(in);
2769   inl = arrow::bit_util::FromLittleEndian(inl);
2770   *out |= (inl % (1U << 16)) << (24 - 16);
2771   out++;
2772   *out = (inl >> 16);
2773   ++in;
2774   inl = util::SafeLoad(in);
2775   inl = arrow::bit_util::FromLittleEndian(inl);
2776   *out |= (inl % (1U << 8)) << (24 - 8);
2777   out++;
2778   *out = (inl >> 8);
2779   ++in;
2780   inl = util::SafeLoad(in);
2781   inl = arrow::bit_util::FromLittleEndian(inl);
2782   out++;
2783   *out = (inl >> 0) % (1U << 24);
2784   out++;
2785   *out = (inl >> 24);
2786   ++in;
2787   inl = util::SafeLoad(in);
2788   inl = arrow::bit_util::FromLittleEndian(inl);
2789   *out |= (inl % (1U << 16)) << (24 - 16);
2790   out++;
2791   *out = (inl >> 16);
2792   ++in;
2793   inl = util::SafeLoad(in);
2794   inl = arrow::bit_util::FromLittleEndian(inl);
2795   *out |= (inl % (1U << 8)) << (24 - 8);
2796   out++;
2797   *out = (inl >> 8);
2798   ++in;
2799   inl = util::SafeLoad(in);
2800   inl = arrow::bit_util::FromLittleEndian(inl);
2801   out++;
2802   *out = (inl >> 0) % (1U << 24);
2803   out++;
2804   *out = (inl >> 24);
2805   ++in;
2806   inl = util::SafeLoad(in);
2807   inl = arrow::bit_util::FromLittleEndian(inl);
2808   *out |= (inl % (1U << 16)) << (24 - 16);
2809   out++;
2810   *out = (inl >> 16);
2811   ++in;
2812   inl = util::SafeLoad(in);
2813   inl = arrow::bit_util::FromLittleEndian(inl);
2814   *out |= (inl % (1U << 8)) << (24 - 8);
2815   out++;
2816   *out = (inl >> 8);
2817   ++in;
2818   out++;
2819 
2820   return in;
2821 }
2822 
2823 inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
2824   uint32_t inl = util::SafeLoad(in);
2825   inl = arrow::bit_util::FromLittleEndian(inl);
2826   *out = (inl >> 0) % (1U << 25);
2827   out++;
2828   *out = (inl >> 25);
2829   ++in;
2830   inl = util::SafeLoad(in);
2831   inl = arrow::bit_util::FromLittleEndian(inl);
2832   *out |= (inl % (1U << 18)) << (25 - 18);
2833   out++;
2834   *out = (inl >> 18);
2835   ++in;
2836   inl = util::SafeLoad(in);
2837   inl = arrow::bit_util::FromLittleEndian(inl);
2838   *out |= (inl % (1U << 11)) << (25 - 11);
2839   out++;
2840   *out = (inl >> 11);
2841   ++in;
2842   inl = util::SafeLoad(in);
2843   inl = arrow::bit_util::FromLittleEndian(inl);
2844   *out |= (inl % (1U << 4)) << (25 - 4);
2845   out++;
2846   *out = (inl >> 4) % (1U << 25);
2847   out++;
2848   *out = (inl >> 29);
2849   ++in;
2850   inl = util::SafeLoad(in);
2851   inl = arrow::bit_util::FromLittleEndian(inl);
2852   *out |= (inl % (1U << 22)) << (25 - 22);
2853   out++;
2854   *out = (inl >> 22);
2855   ++in;
2856   inl = util::SafeLoad(in);
2857   inl = arrow::bit_util::FromLittleEndian(inl);
2858   *out |= (inl % (1U << 15)) << (25 - 15);
2859   out++;
2860   *out = (inl >> 15);
2861   ++in;
2862   inl = util::SafeLoad(in);
2863   inl = arrow::bit_util::FromLittleEndian(inl);
2864   *out |= (inl % (1U << 8)) << (25 - 8);
2865   out++;
2866   *out = (inl >> 8);
2867   ++in;
2868   inl = util::SafeLoad(in);
2869   inl = arrow::bit_util::FromLittleEndian(inl);
2870   *out |= (inl % (1U << 1)) << (25 - 1);
2871   out++;
2872   *out = (inl >> 1) % (1U << 25);
2873   out++;
2874   *out = (inl >> 26);
2875   ++in;
2876   inl = util::SafeLoad(in);
2877   inl = arrow::bit_util::FromLittleEndian(inl);
2878   *out |= (inl % (1U << 19)) << (25 - 19);
2879   out++;
2880   *out = (inl >> 19);
2881   ++in;
2882   inl = util::SafeLoad(in);
2883   inl = arrow::bit_util::FromLittleEndian(inl);
2884   *out |= (inl % (1U << 12)) << (25 - 12);
2885   out++;
2886   *out = (inl >> 12);
2887   ++in;
2888   inl = util::SafeLoad(in);
2889   inl = arrow::bit_util::FromLittleEndian(inl);
2890   *out |= (inl % (1U << 5)) << (25 - 5);
2891   out++;
2892   *out = (inl >> 5) % (1U << 25);
2893   out++;
2894   *out = (inl >> 30);
2895   ++in;
2896   inl = util::SafeLoad(in);
2897   inl = arrow::bit_util::FromLittleEndian(inl);
2898   *out |= (inl % (1U << 23)) << (25 - 23);
2899   out++;
2900   *out = (inl >> 23);
2901   ++in;
2902   inl = util::SafeLoad(in);
2903   inl = arrow::bit_util::FromLittleEndian(inl);
2904   *out |= (inl % (1U << 16)) << (25 - 16);
2905   out++;
2906   *out = (inl >> 16);
2907   ++in;
2908   inl = util::SafeLoad(in);
2909   inl = arrow::bit_util::FromLittleEndian(inl);
2910   *out |= (inl % (1U << 9)) << (25 - 9);
2911   out++;
2912   *out = (inl >> 9);
2913   ++in;
2914   inl = util::SafeLoad(in);
2915   inl = arrow::bit_util::FromLittleEndian(inl);
2916   *out |= (inl % (1U << 2)) << (25 - 2);
2917   out++;
2918   *out = (inl >> 2) % (1U << 25);
2919   out++;
2920   *out = (inl >> 27);
2921   ++in;
2922   inl = util::SafeLoad(in);
2923   inl = arrow::bit_util::FromLittleEndian(inl);
2924   *out |= (inl % (1U << 20)) << (25 - 20);
2925   out++;
2926   *out = (inl >> 20);
2927   ++in;
2928   inl = util::SafeLoad(in);
2929   inl = arrow::bit_util::FromLittleEndian(inl);
2930   *out |= (inl % (1U << 13)) << (25 - 13);
2931   out++;
2932   *out = (inl >> 13);
2933   ++in;
2934   inl = util::SafeLoad(in);
2935   inl = arrow::bit_util::FromLittleEndian(inl);
2936   *out |= (inl % (1U << 6)) << (25 - 6);
2937   out++;
2938   *out = (inl >> 6) % (1U << 25);
2939   out++;
2940   *out = (inl >> 31);
2941   ++in;
2942   inl = util::SafeLoad(in);
2943   inl = arrow::bit_util::FromLittleEndian(inl);
2944   *out |= (inl % (1U << 24)) << (25 - 24);
2945   out++;
2946   *out = (inl >> 24);
2947   ++in;
2948   inl = util::SafeLoad(in);
2949   inl = arrow::bit_util::FromLittleEndian(inl);
2950   *out |= (inl % (1U << 17)) << (25 - 17);
2951   out++;
2952   *out = (inl >> 17);
2953   ++in;
2954   inl = util::SafeLoad(in);
2955   inl = arrow::bit_util::FromLittleEndian(inl);
2956   *out |= (inl % (1U << 10)) << (25 - 10);
2957   out++;
2958   *out = (inl >> 10);
2959   ++in;
2960   inl = util::SafeLoad(in);
2961   inl = arrow::bit_util::FromLittleEndian(inl);
2962   *out |= (inl % (1U << 3)) << (25 - 3);
2963   out++;
2964   *out = (inl >> 3) % (1U << 25);
2965   out++;
2966   *out = (inl >> 28);
2967   ++in;
2968   inl = util::SafeLoad(in);
2969   inl = arrow::bit_util::FromLittleEndian(inl);
2970   *out |= (inl % (1U << 21)) << (25 - 21);
2971   out++;
2972   *out = (inl >> 21);
2973   ++in;
2974   inl = util::SafeLoad(in);
2975   inl = arrow::bit_util::FromLittleEndian(inl);
2976   *out |= (inl % (1U << 14)) << (25 - 14);
2977   out++;
2978   *out = (inl >> 14);
2979   ++in;
2980   inl = util::SafeLoad(in);
2981   inl = arrow::bit_util::FromLittleEndian(inl);
2982   *out |= (inl % (1U << 7)) << (25 - 7);
2983   out++;
2984   *out = (inl >> 7);
2985   ++in;
2986   out++;
2987 
2988   return in;
2989 }
2990 
2991 inline const uint32_t* unpack26_32(const uint32_t* in, uint32_t* out) {
2992   uint32_t inl = util::SafeLoad(in);
2993   inl = arrow::bit_util::FromLittleEndian(inl);
2994   *out = (inl >> 0) % (1U << 26);
2995   out++;
2996   *out = (inl >> 26);
2997   ++in;
2998   inl = util::SafeLoad(in);
2999   inl = arrow::bit_util::FromLittleEndian(inl);
3000   *out |= (inl % (1U << 20)) << (26 - 20);
3001   out++;
3002   *out = (inl >> 20);
3003   ++in;
3004   inl = util::SafeLoad(in);
3005   inl = arrow::bit_util::FromLittleEndian(inl);
3006   *out |= (inl % (1U << 14)) << (26 - 14);
3007   out++;
3008   *out = (inl >> 14);
3009   ++in;
3010   inl = util::SafeLoad(in);
3011   inl = arrow::bit_util::FromLittleEndian(inl);
3012   *out |= (inl % (1U << 8)) << (26 - 8);
3013   out++;
3014   *out = (inl >> 8);
3015   ++in;
3016   inl = util::SafeLoad(in);
3017   inl = arrow::bit_util::FromLittleEndian(inl);
3018   *out |= (inl % (1U << 2)) << (26 - 2);
3019   out++;
3020   *out = (inl >> 2) % (1U << 26);
3021   out++;
3022   *out = (inl >> 28);
3023   ++in;
3024   inl = util::SafeLoad(in);
3025   inl = arrow::bit_util::FromLittleEndian(inl);
3026   *out |= (inl % (1U << 22)) << (26 - 22);
3027   out++;
3028   *out = (inl >> 22);
3029   ++in;
3030   inl = util::SafeLoad(in);
3031   inl = arrow::bit_util::FromLittleEndian(inl);
3032   *out |= (inl % (1U << 16)) << (26 - 16);
3033   out++;
3034   *out = (inl >> 16);
3035   ++in;
3036   inl = util::SafeLoad(in);
3037   inl = arrow::bit_util::FromLittleEndian(inl);
3038   *out |= (inl % (1U << 10)) << (26 - 10);
3039   out++;
3040   *out = (inl >> 10);
3041   ++in;
3042   inl = util::SafeLoad(in);
3043   inl = arrow::bit_util::FromLittleEndian(inl);
3044   *out |= (inl % (1U << 4)) << (26 - 4);
3045   out++;
3046   *out = (inl >> 4) % (1U << 26);
3047   out++;
3048   *out = (inl >> 30);
3049   ++in;
3050   inl = util::SafeLoad(in);
3051   inl = arrow::bit_util::FromLittleEndian(inl);
3052   *out |= (inl % (1U << 24)) << (26 - 24);
3053   out++;
3054   *out = (inl >> 24);
3055   ++in;
3056   inl = util::SafeLoad(in);
3057   inl = arrow::bit_util::FromLittleEndian(inl);
3058   *out |= (inl % (1U << 18)) << (26 - 18);
3059   out++;
3060   *out = (inl >> 18);
3061   ++in;
3062   inl = util::SafeLoad(in);
3063   inl = arrow::bit_util::FromLittleEndian(inl);
3064   *out |= (inl % (1U << 12)) << (26 - 12);
3065   out++;
3066   *out = (inl >> 12);
3067   ++in;
3068   inl = util::SafeLoad(in);
3069   inl = arrow::bit_util::FromLittleEndian(inl);
3070   *out |= (inl % (1U << 6)) << (26 - 6);
3071   out++;
3072   *out = (inl >> 6);
3073   ++in;
3074   inl = util::SafeLoad(in);
3075   inl = arrow::bit_util::FromLittleEndian(inl);
3076   out++;
3077   *out = (inl >> 0) % (1U << 26);
3078   out++;
3079   *out = (inl >> 26);
3080   ++in;
3081   inl = util::SafeLoad(in);
3082   inl = arrow::bit_util::FromLittleEndian(inl);
3083   *out |= (inl % (1U << 20)) << (26 - 20);
3084   out++;
3085   *out = (inl >> 20);
3086   ++in;
3087   inl = util::SafeLoad(in);
3088   inl = arrow::bit_util::FromLittleEndian(inl);
3089   *out |= (inl % (1U << 14)) << (26 - 14);
3090   out++;
3091   *out = (inl >> 14);
3092   ++in;
3093   inl = util::SafeLoad(in);
3094   inl = arrow::bit_util::FromLittleEndian(inl);
3095   *out |= (inl % (1U << 8)) << (26 - 8);
3096   out++;
3097   *out = (inl >> 8);
3098   ++in;
3099   inl = util::SafeLoad(in);
3100   inl = arrow::bit_util::FromLittleEndian(inl);
3101   *out |= (inl % (1U << 2)) << (26 - 2);
3102   out++;
3103   *out = (inl >> 2) % (1U << 26);
3104   out++;
3105   *out = (inl >> 28);
3106   ++in;
3107   inl = util::SafeLoad(in);
3108   inl = arrow::bit_util::FromLittleEndian(inl);
3109   *out |= (inl % (1U << 22)) << (26 - 22);
3110   out++;
3111   *out = (inl >> 22);
3112   ++in;
3113   inl = util::SafeLoad(in);
3114   inl = arrow::bit_util::FromLittleEndian(inl);
3115   *out |= (inl % (1U << 16)) << (26 - 16);
3116   out++;
3117   *out = (inl >> 16);
3118   ++in;
3119   inl = util::SafeLoad(in);
3120   inl = arrow::bit_util::FromLittleEndian(inl);
3121   *out |= (inl % (1U << 10)) << (26 - 10);
3122   out++;
3123   *out = (inl >> 10);
3124   ++in;
3125   inl = util::SafeLoad(in);
3126   inl = arrow::bit_util::FromLittleEndian(inl);
3127   *out |= (inl % (1U << 4)) << (26 - 4);
3128   out++;
3129   *out = (inl >> 4) % (1U << 26);
3130   out++;
3131   *out = (inl >> 30);
3132   ++in;
3133   inl = util::SafeLoad(in);
3134   inl = arrow::bit_util::FromLittleEndian(inl);
3135   *out |= (inl % (1U << 24)) << (26 - 24);
3136   out++;
3137   *out = (inl >> 24);
3138   ++in;
3139   inl = util::SafeLoad(in);
3140   inl = arrow::bit_util::FromLittleEndian(inl);
3141   *out |= (inl % (1U << 18)) << (26 - 18);
3142   out++;
3143   *out = (inl >> 18);
3144   ++in;
3145   inl = util::SafeLoad(in);
3146   inl = arrow::bit_util::FromLittleEndian(inl);
3147   *out |= (inl % (1U << 12)) << (26 - 12);
3148   out++;
3149   *out = (inl >> 12);
3150   ++in;
3151   inl = util::SafeLoad(in);
3152   inl = arrow::bit_util::FromLittleEndian(inl);
3153   *out |= (inl % (1U << 6)) << (26 - 6);
3154   out++;
3155   *out = (inl >> 6);
3156   ++in;
3157   out++;
3158 
3159   return in;
3160 }
3161 
3162 inline const uint32_t* unpack27_32(const uint32_t* in, uint32_t* out) {
3163   uint32_t inl = util::SafeLoad(in);
3164   inl = arrow::bit_util::FromLittleEndian(inl);
3165   *out = (inl >> 0) % (1U << 27);
3166   out++;
3167   *out = (inl >> 27);
3168   ++in;
3169   inl = util::SafeLoad(in);
3170   inl = arrow::bit_util::FromLittleEndian(inl);
3171   *out |= (inl % (1U << 22)) << (27 - 22);
3172   out++;
3173   *out = (inl >> 22);
3174   ++in;
3175   inl = util::SafeLoad(in);
3176   inl = arrow::bit_util::FromLittleEndian(inl);
3177   *out |= (inl % (1U << 17)) << (27 - 17);
3178   out++;
3179   *out = (inl >> 17);
3180   ++in;
3181   inl = util::SafeLoad(in);
3182   inl = arrow::bit_util::FromLittleEndian(inl);
3183   *out |= (inl % (1U << 12)) << (27 - 12);
3184   out++;
3185   *out = (inl >> 12);
3186   ++in;
3187   inl = util::SafeLoad(in);
3188   inl = arrow::bit_util::FromLittleEndian(inl);
3189   *out |= (inl % (1U << 7)) << (27 - 7);
3190   out++;
3191   *out = (inl >> 7);
3192   ++in;
3193   inl = util::SafeLoad(in);
3194   inl = arrow::bit_util::FromLittleEndian(inl);
3195   *out |= (inl % (1U << 2)) << (27 - 2);
3196   out++;
3197   *out = (inl >> 2) % (1U << 27);
3198   out++;
3199   *out = (inl >> 29);
3200   ++in;
3201   inl = util::SafeLoad(in);
3202   inl = arrow::bit_util::FromLittleEndian(inl);
3203   *out |= (inl % (1U << 24)) << (27 - 24);
3204   out++;
3205   *out = (inl >> 24);
3206   ++in;
3207   inl = util::SafeLoad(in);
3208   inl = arrow::bit_util::FromLittleEndian(inl);
3209   *out |= (inl % (1U << 19)) << (27 - 19);
3210   out++;
3211   *out = (inl >> 19);
3212   ++in;
3213   inl = util::SafeLoad(in);
3214   inl = arrow::bit_util::FromLittleEndian(inl);
3215   *out |= (inl % (1U << 14)) << (27 - 14);
3216   out++;
3217   *out = (inl >> 14);
3218   ++in;
3219   inl = util::SafeLoad(in);
3220   inl = arrow::bit_util::FromLittleEndian(inl);
3221   *out |= (inl % (1U << 9)) << (27 - 9);
3222   out++;
3223   *out = (inl >> 9);
3224   ++in;
3225   inl = util::SafeLoad(in);
3226   inl = arrow::bit_util::FromLittleEndian(inl);
3227   *out |= (inl % (1U << 4)) << (27 - 4);
3228   out++;
3229   *out = (inl >> 4) % (1U << 27);
3230   out++;
3231   *out = (inl >> 31);
3232   ++in;
3233   inl = util::SafeLoad(in);
3234   inl = arrow::bit_util::FromLittleEndian(inl);
3235   *out |= (inl % (1U << 26)) << (27 - 26);
3236   out++;
3237   *out = (inl >> 26);
3238   ++in;
3239   inl = util::SafeLoad(in);
3240   inl = arrow::bit_util::FromLittleEndian(inl);
3241   *out |= (inl % (1U << 21)) << (27 - 21);
3242   out++;
3243   *out = (inl >> 21);
3244   ++in;
3245   inl = util::SafeLoad(in);
3246   inl = arrow::bit_util::FromLittleEndian(inl);
3247   *out |= (inl % (1U << 16)) << (27 - 16);
3248   out++;
3249   *out = (inl >> 16);
3250   ++in;
3251   inl = util::SafeLoad(in);
3252   inl = arrow::bit_util::FromLittleEndian(inl);
3253   *out |= (inl % (1U << 11)) << (27 - 11);
3254   out++;
3255   *out = (inl >> 11);
3256   ++in;
3257   inl = util::SafeLoad(in);
3258   inl = arrow::bit_util::FromLittleEndian(inl);
3259   *out |= (inl % (1U << 6)) << (27 - 6);
3260   out++;
3261   *out = (inl >> 6);
3262   ++in;
3263   inl = util::SafeLoad(in);
3264   inl = arrow::bit_util::FromLittleEndian(inl);
3265   *out |= (inl % (1U << 1)) << (27 - 1);
3266   out++;
3267   *out = (inl >> 1) % (1U << 27);
3268   out++;
3269   *out = (inl >> 28);
3270   ++in;
3271   inl = util::SafeLoad(in);
3272   inl = arrow::bit_util::FromLittleEndian(inl);
3273   *out |= (inl % (1U << 23)) << (27 - 23);
3274   out++;
3275   *out = (inl >> 23);
3276   ++in;
3277   inl = util::SafeLoad(in);
3278   inl = arrow::bit_util::FromLittleEndian(inl);
3279   *out |= (inl % (1U << 18)) << (27 - 18);
3280   out++;
3281   *out = (inl >> 18);
3282   ++in;
3283   inl = util::SafeLoad(in);
3284   inl = arrow::bit_util::FromLittleEndian(inl);
3285   *out |= (inl % (1U << 13)) << (27 - 13);
3286   out++;
3287   *out = (inl >> 13);
3288   ++in;
3289   inl = util::SafeLoad(in);
3290   inl = arrow::bit_util::FromLittleEndian(inl);
3291   *out |= (inl % (1U << 8)) << (27 - 8);
3292   out++;
3293   *out = (inl >> 8);
3294   ++in;
3295   inl = util::SafeLoad(in);
3296   inl = arrow::bit_util::FromLittleEndian(inl);
3297   *out |= (inl % (1U << 3)) << (27 - 3);
3298   out++;
3299   *out = (inl >> 3) % (1U << 27);
3300   out++;
3301   *out = (inl >> 30);
3302   ++in;
3303   inl = util::SafeLoad(in);
3304   inl = arrow::bit_util::FromLittleEndian(inl);
3305   *out |= (inl % (1U << 25)) << (27 - 25);
3306   out++;
3307   *out = (inl >> 25);
3308   ++in;
3309   inl = util::SafeLoad(in);
3310   inl = arrow::bit_util::FromLittleEndian(inl);
3311   *out |= (inl % (1U << 20)) << (27 - 20);
3312   out++;
3313   *out = (inl >> 20);
3314   ++in;
3315   inl = util::SafeLoad(in);
3316   inl = arrow::bit_util::FromLittleEndian(inl);
3317   *out |= (inl % (1U << 15)) << (27 - 15);
3318   out++;
3319   *out = (inl >> 15);
3320   ++in;
3321   inl = util::SafeLoad(in);
3322   inl = arrow::bit_util::FromLittleEndian(inl);
3323   *out |= (inl % (1U << 10)) << (27 - 10);
3324   out++;
3325   *out = (inl >> 10);
3326   ++in;
3327   inl = util::SafeLoad(in);
3328   inl = arrow::bit_util::FromLittleEndian(inl);
3329   *out |= (inl % (1U << 5)) << (27 - 5);
3330   out++;
3331   *out = (inl >> 5);
3332   ++in;
3333   out++;
3334 
3335   return in;
3336 }
3337 
3338 inline const uint32_t* unpack28_32(const uint32_t* in, uint32_t* out) {
3339   uint32_t inl = util::SafeLoad(in);
3340   inl = arrow::bit_util::FromLittleEndian(inl);
3341   *out = (inl >> 0) % (1U << 28);
3342   out++;
3343   *out = (inl >> 28);
3344   ++in;
3345   inl = util::SafeLoad(in);
3346   inl = arrow::bit_util::FromLittleEndian(inl);
3347   *out |= (inl % (1U << 24)) << (28 - 24);
3348   out++;
3349   *out = (inl >> 24);
3350   ++in;
3351   inl = util::SafeLoad(in);
3352   inl = arrow::bit_util::FromLittleEndian(inl);
3353   *out |= (inl % (1U << 20)) << (28 - 20);
3354   out++;
3355   *out = (inl >> 20);
3356   ++in;
3357   inl = util::SafeLoad(in);
3358   inl = arrow::bit_util::FromLittleEndian(inl);
3359   *out |= (inl % (1U << 16)) << (28 - 16);
3360   out++;
3361   *out = (inl >> 16);
3362   ++in;
3363   inl = util::SafeLoad(in);
3364   inl = arrow::bit_util::FromLittleEndian(inl);
3365   *out |= (inl % (1U << 12)) << (28 - 12);
3366   out++;
3367   *out = (inl >> 12);
3368   ++in;
3369   inl = util::SafeLoad(in);
3370   inl = arrow::bit_util::FromLittleEndian(inl);
3371   *out |= (inl % (1U << 8)) << (28 - 8);
3372   out++;
3373   *out = (inl >> 8);
3374   ++in;
3375   inl = util::SafeLoad(in);
3376   inl = arrow::bit_util::FromLittleEndian(inl);
3377   *out |= (inl % (1U << 4)) << (28 - 4);
3378   out++;
3379   *out = (inl >> 4);
3380   ++in;
3381   inl = util::SafeLoad(in);
3382   inl = arrow::bit_util::FromLittleEndian(inl);
3383   out++;
3384   *out = (inl >> 0) % (1U << 28);
3385   out++;
3386   *out = (inl >> 28);
3387   ++in;
3388   inl = util::SafeLoad(in);
3389   inl = arrow::bit_util::FromLittleEndian(inl);
3390   *out |= (inl % (1U << 24)) << (28 - 24);
3391   out++;
3392   *out = (inl >> 24);
3393   ++in;
3394   inl = util::SafeLoad(in);
3395   inl = arrow::bit_util::FromLittleEndian(inl);
3396   *out |= (inl % (1U << 20)) << (28 - 20);
3397   out++;
3398   *out = (inl >> 20);
3399   ++in;
3400   inl = util::SafeLoad(in);
3401   inl = arrow::bit_util::FromLittleEndian(inl);
3402   *out |= (inl % (1U << 16)) << (28 - 16);
3403   out++;
3404   *out = (inl >> 16);
3405   ++in;
3406   inl = util::SafeLoad(in);
3407   inl = arrow::bit_util::FromLittleEndian(inl);
3408   *out |= (inl % (1U << 12)) << (28 - 12);
3409   out++;
3410   *out = (inl >> 12);
3411   ++in;
3412   inl = util::SafeLoad(in);
3413   inl = arrow::bit_util::FromLittleEndian(inl);
3414   *out |= (inl % (1U << 8)) << (28 - 8);
3415   out++;
3416   *out = (inl >> 8);
3417   ++in;
3418   inl = util::SafeLoad(in);
3419   inl = arrow::bit_util::FromLittleEndian(inl);
3420   *out |= (inl % (1U << 4)) << (28 - 4);
3421   out++;
3422   *out = (inl >> 4);
3423   ++in;
3424   inl = util::SafeLoad(in);
3425   inl = arrow::bit_util::FromLittleEndian(inl);
3426   out++;
3427   *out = (inl >> 0) % (1U << 28);
3428   out++;
3429   *out = (inl >> 28);
3430   ++in;
3431   inl = util::SafeLoad(in);
3432   inl = arrow::bit_util::FromLittleEndian(inl);
3433   *out |= (inl % (1U << 24)) << (28 - 24);
3434   out++;
3435   *out = (inl >> 24);
3436   ++in;
3437   inl = util::SafeLoad(in);
3438   inl = arrow::bit_util::FromLittleEndian(inl);
3439   *out |= (inl % (1U << 20)) << (28 - 20);
3440   out++;
3441   *out = (inl >> 20);
3442   ++in;
3443   inl = util::SafeLoad(in);
3444   inl = arrow::bit_util::FromLittleEndian(inl);
3445   *out |= (inl % (1U << 16)) << (28 - 16);
3446   out++;
3447   *out = (inl >> 16);
3448   ++in;
3449   inl = util::SafeLoad(in);
3450   inl = arrow::bit_util::FromLittleEndian(inl);
3451   *out |= (inl % (1U << 12)) << (28 - 12);
3452   out++;
3453   *out = (inl >> 12);
3454   ++in;
3455   inl = util::SafeLoad(in);
3456   inl = arrow::bit_util::FromLittleEndian(inl);
3457   *out |= (inl % (1U << 8)) << (28 - 8);
3458   out++;
3459   *out = (inl >> 8);
3460   ++in;
3461   inl = util::SafeLoad(in);
3462   inl = arrow::bit_util::FromLittleEndian(inl);
3463   *out |= (inl % (1U << 4)) << (28 - 4);
3464   out++;
3465   *out = (inl >> 4);
3466   ++in;
3467   inl = util::SafeLoad(in);
3468   inl = arrow::bit_util::FromLittleEndian(inl);
3469   out++;
3470   *out = (inl >> 0) % (1U << 28);
3471   out++;
3472   *out = (inl >> 28);
3473   ++in;
3474   inl = util::SafeLoad(in);
3475   inl = arrow::bit_util::FromLittleEndian(inl);
3476   *out |= (inl % (1U << 24)) << (28 - 24);
3477   out++;
3478   *out = (inl >> 24);
3479   ++in;
3480   inl = util::SafeLoad(in);
3481   inl = arrow::bit_util::FromLittleEndian(inl);
3482   *out |= (inl % (1U << 20)) << (28 - 20);
3483   out++;
3484   *out = (inl >> 20);
3485   ++in;
3486   inl = util::SafeLoad(in);
3487   inl = arrow::bit_util::FromLittleEndian(inl);
3488   *out |= (inl % (1U << 16)) << (28 - 16);
3489   out++;
3490   *out = (inl >> 16);
3491   ++in;
3492   inl = util::SafeLoad(in);
3493   inl = arrow::bit_util::FromLittleEndian(inl);
3494   *out |= (inl % (1U << 12)) << (28 - 12);
3495   out++;
3496   *out = (inl >> 12);
3497   ++in;
3498   inl = util::SafeLoad(in);
3499   inl = arrow::bit_util::FromLittleEndian(inl);
3500   *out |= (inl % (1U << 8)) << (28 - 8);
3501   out++;
3502   *out = (inl >> 8);
3503   ++in;
3504   inl = util::SafeLoad(in);
3505   inl = arrow::bit_util::FromLittleEndian(inl);
3506   *out |= (inl % (1U << 4)) << (28 - 4);
3507   out++;
3508   *out = (inl >> 4);
3509   ++in;
3510   out++;
3511 
3512   return in;
3513 }
3514 
3515 inline const uint32_t* unpack29_32(const uint32_t* in, uint32_t* out) {
3516   uint32_t inl = util::SafeLoad(in);
3517   inl = arrow::bit_util::FromLittleEndian(inl);
3518   *out = (inl >> 0) % (1U << 29);
3519   out++;
3520   *out = (inl >> 29);
3521   ++in;
3522   inl = util::SafeLoad(in);
3523   inl = arrow::bit_util::FromLittleEndian(inl);
3524   *out |= (inl % (1U << 26)) << (29 - 26);
3525   out++;
3526   *out = (inl >> 26);
3527   ++in;
3528   inl = util::SafeLoad(in);
3529   inl = arrow::bit_util::FromLittleEndian(inl);
3530   *out |= (inl % (1U << 23)) << (29 - 23);
3531   out++;
3532   *out = (inl >> 23);
3533   ++in;
3534   inl = util::SafeLoad(in);
3535   inl = arrow::bit_util::FromLittleEndian(inl);
3536   *out |= (inl % (1U << 20)) << (29 - 20);
3537   out++;
3538   *out = (inl >> 20);
3539   ++in;
3540   inl = util::SafeLoad(in);
3541   inl = arrow::bit_util::FromLittleEndian(inl);
3542   *out |= (inl % (1U << 17)) << (29 - 17);
3543   out++;
3544   *out = (inl >> 17);
3545   ++in;
3546   inl = util::SafeLoad(in);
3547   inl = arrow::bit_util::FromLittleEndian(inl);
3548   *out |= (inl % (1U << 14)) << (29 - 14);
3549   out++;
3550   *out = (inl >> 14);
3551   ++in;
3552   inl = util::SafeLoad(in);
3553   inl = arrow::bit_util::FromLittleEndian(inl);
3554   *out |= (inl % (1U << 11)) << (29 - 11);
3555   out++;
3556   *out = (inl >> 11);
3557   ++in;
3558   inl = util::SafeLoad(in);
3559   inl = arrow::bit_util::FromLittleEndian(inl);
3560   *out |= (inl % (1U << 8)) << (29 - 8);
3561   out++;
3562   *out = (inl >> 8);
3563   ++in;
3564   inl = util::SafeLoad(in);
3565   inl = arrow::bit_util::FromLittleEndian(inl);
3566   *out |= (inl % (1U << 5)) << (29 - 5);
3567   out++;
3568   *out = (inl >> 5);
3569   ++in;
3570   inl = util::SafeLoad(in);
3571   inl = arrow::bit_util::FromLittleEndian(inl);
3572   *out |= (inl % (1U << 2)) << (29 - 2);
3573   out++;
3574   *out = (inl >> 2) % (1U << 29);
3575   out++;
3576   *out = (inl >> 31);
3577   ++in;
3578   inl = util::SafeLoad(in);
3579   inl = arrow::bit_util::FromLittleEndian(inl);
3580   *out |= (inl % (1U << 28)) << (29 - 28);
3581   out++;
3582   *out = (inl >> 28);
3583   ++in;
3584   inl = util::SafeLoad(in);
3585   inl = arrow::bit_util::FromLittleEndian(inl);
3586   *out |= (inl % (1U << 25)) << (29 - 25);
3587   out++;
3588   *out = (inl >> 25);
3589   ++in;
3590   inl = util::SafeLoad(in);
3591   inl = arrow::bit_util::FromLittleEndian(inl);
3592   *out |= (inl % (1U << 22)) << (29 - 22);
3593   out++;
3594   *out = (inl >> 22);
3595   ++in;
3596   inl = util::SafeLoad(in);
3597   inl = arrow::bit_util::FromLittleEndian(inl);
3598   *out |= (inl % (1U << 19)) << (29 - 19);
3599   out++;
3600   *out = (inl >> 19);
3601   ++in;
3602   inl = util::SafeLoad(in);
3603   inl = arrow::bit_util::FromLittleEndian(inl);
3604   *out |= (inl % (1U << 16)) << (29 - 16);
3605   out++;
3606   *out = (inl >> 16);
3607   ++in;
3608   inl = util::SafeLoad(in);
3609   inl = arrow::bit_util::FromLittleEndian(inl);
3610   *out |= (inl % (1U << 13)) << (29 - 13);
3611   out++;
3612   *out = (inl >> 13);
3613   ++in;
3614   inl = util::SafeLoad(in);
3615   inl = arrow::bit_util::FromLittleEndian(inl);
3616   *out |= (inl % (1U << 10)) << (29 - 10);
3617   out++;
3618   *out = (inl >> 10);
3619   ++in;
3620   inl = util::SafeLoad(in);
3621   inl = arrow::bit_util::FromLittleEndian(inl);
3622   *out |= (inl % (1U << 7)) << (29 - 7);
3623   out++;
3624   *out = (inl >> 7);
3625   ++in;
3626   inl = util::SafeLoad(in);
3627   inl = arrow::bit_util::FromLittleEndian(inl);
3628   *out |= (inl % (1U << 4)) << (29 - 4);
3629   out++;
3630   *out = (inl >> 4);
3631   ++in;
3632   inl = util::SafeLoad(in);
3633   inl = arrow::bit_util::FromLittleEndian(inl);
3634   *out |= (inl % (1U << 1)) << (29 - 1);
3635   out++;
3636   *out = (inl >> 1) % (1U << 29);
3637   out++;
3638   *out = (inl >> 30);
3639   ++in;
3640   inl = util::SafeLoad(in);
3641   inl = arrow::bit_util::FromLittleEndian(inl);
3642   *out |= (inl % (1U << 27)) << (29 - 27);
3643   out++;
3644   *out = (inl >> 27);
3645   ++in;
3646   inl = util::SafeLoad(in);
3647   inl = arrow::bit_util::FromLittleEndian(inl);
3648   *out |= (inl % (1U << 24)) << (29 - 24);
3649   out++;
3650   *out = (inl >> 24);
3651   ++in;
3652   inl = util::SafeLoad(in);
3653   inl = arrow::bit_util::FromLittleEndian(inl);
3654   *out |= (inl % (1U << 21)) << (29 - 21);
3655   out++;
3656   *out = (inl >> 21);
3657   ++in;
3658   inl = util::SafeLoad(in);
3659   inl = arrow::bit_util::FromLittleEndian(inl);
3660   *out |= (inl % (1U << 18)) << (29 - 18);
3661   out++;
3662   *out = (inl >> 18);
3663   ++in;
3664   inl = util::SafeLoad(in);
3665   inl = arrow::bit_util::FromLittleEndian(inl);
3666   *out |= (inl % (1U << 15)) << (29 - 15);
3667   out++;
3668   *out = (inl >> 15);
3669   ++in;
3670   inl = util::SafeLoad(in);
3671   inl = arrow::bit_util::FromLittleEndian(inl);
3672   *out |= (inl % (1U << 12)) << (29 - 12);
3673   out++;
3674   *out = (inl >> 12);
3675   ++in;
3676   inl = util::SafeLoad(in);
3677   inl = arrow::bit_util::FromLittleEndian(inl);
3678   *out |= (inl % (1U << 9)) << (29 - 9);
3679   out++;
3680   *out = (inl >> 9);
3681   ++in;
3682   inl = util::SafeLoad(in);
3683   inl = arrow::bit_util::FromLittleEndian(inl);
3684   *out |= (inl % (1U << 6)) << (29 - 6);
3685   out++;
3686   *out = (inl >> 6);
3687   ++in;
3688   inl = util::SafeLoad(in);
3689   inl = arrow::bit_util::FromLittleEndian(inl);
3690   *out |= (inl % (1U << 3)) << (29 - 3);
3691   out++;
3692   *out = (inl >> 3);
3693   ++in;
3694   out++;
3695 
3696   return in;
3697 }
3698 
3699 inline const uint32_t* unpack30_32(const uint32_t* in, uint32_t* out) {
3700   uint32_t inl = util::SafeLoad(in);
3701   inl = arrow::bit_util::FromLittleEndian(inl);
3702   *out = (inl >> 0) % (1U << 30);
3703   out++;
3704   *out = (inl >> 30);
3705   ++in;
3706   inl = util::SafeLoad(in);
3707   inl = arrow::bit_util::FromLittleEndian(inl);
3708   *out |= (inl % (1U << 28)) << (30 - 28);
3709   out++;
3710   *out = (inl >> 28);
3711   ++in;
3712   inl = util::SafeLoad(in);
3713   inl = arrow::bit_util::FromLittleEndian(inl);
3714   *out |= (inl % (1U << 26)) << (30 - 26);
3715   out++;
3716   *out = (inl >> 26);
3717   ++in;
3718   inl = util::SafeLoad(in);
3719   inl = arrow::bit_util::FromLittleEndian(inl);
3720   *out |= (inl % (1U << 24)) << (30 - 24);
3721   out++;
3722   *out = (inl >> 24);
3723   ++in;
3724   inl = util::SafeLoad(in);
3725   inl = arrow::bit_util::FromLittleEndian(inl);
3726   *out |= (inl % (1U << 22)) << (30 - 22);
3727   out++;
3728   *out = (inl >> 22);
3729   ++in;
3730   inl = util::SafeLoad(in);
3731   inl = arrow::bit_util::FromLittleEndian(inl);
3732   *out |= (inl % (1U << 20)) << (30 - 20);
3733   out++;
3734   *out = (inl >> 20);
3735   ++in;
3736   inl = util::SafeLoad(in);
3737   inl = arrow::bit_util::FromLittleEndian(inl);
3738   *out |= (inl % (1U << 18)) << (30 - 18);
3739   out++;
3740   *out = (inl >> 18);
3741   ++in;
3742   inl = util::SafeLoad(in);
3743   inl = arrow::bit_util::FromLittleEndian(inl);
3744   *out |= (inl % (1U << 16)) << (30 - 16);
3745   out++;
3746   *out = (inl >> 16);
3747   ++in;
3748   inl = util::SafeLoad(in);
3749   inl = arrow::bit_util::FromLittleEndian(inl);
3750   *out |= (inl % (1U << 14)) << (30 - 14);
3751   out++;
3752   *out = (inl >> 14);
3753   ++in;
3754   inl = util::SafeLoad(in);
3755   inl = arrow::bit_util::FromLittleEndian(inl);
3756   *out |= (inl % (1U << 12)) << (30 - 12);
3757   out++;
3758   *out = (inl >> 12);
3759   ++in;
3760   inl = util::SafeLoad(in);
3761   inl = arrow::bit_util::FromLittleEndian(inl);
3762   *out |= (inl % (1U << 10)) << (30 - 10);
3763   out++;
3764   *out = (inl >> 10);
3765   ++in;
3766   inl = util::SafeLoad(in);
3767   inl = arrow::bit_util::FromLittleEndian(inl);
3768   *out |= (inl % (1U << 8)) << (30 - 8);
3769   out++;
3770   *out = (inl >> 8);
3771   ++in;
3772   inl = util::SafeLoad(in);
3773   inl = arrow::bit_util::FromLittleEndian(inl);
3774   *out |= (inl % (1U << 6)) << (30 - 6);
3775   out++;
3776   *out = (inl >> 6);
3777   ++in;
3778   inl = util::SafeLoad(in);
3779   inl = arrow::bit_util::FromLittleEndian(inl);
3780   *out |= (inl % (1U << 4)) << (30 - 4);
3781   out++;
3782   *out = (inl >> 4);
3783   ++in;
3784   inl = util::SafeLoad(in);
3785   inl = arrow::bit_util::FromLittleEndian(inl);
3786   *out |= (inl % (1U << 2)) << (30 - 2);
3787   out++;
3788   *out = (inl >> 2);
3789   ++in;
3790   inl = util::SafeLoad(in);
3791   inl = arrow::bit_util::FromLittleEndian(inl);
3792   out++;
3793   *out = (inl >> 0) % (1U << 30);
3794   out++;
3795   *out = (inl >> 30);
3796   ++in;
3797   inl = util::SafeLoad(in);
3798   inl = arrow::bit_util::FromLittleEndian(inl);
3799   *out |= (inl % (1U << 28)) << (30 - 28);
3800   out++;
3801   *out = (inl >> 28);
3802   ++in;
3803   inl = util::SafeLoad(in);
3804   inl = arrow::bit_util::FromLittleEndian(inl);
3805   *out |= (inl % (1U << 26)) << (30 - 26);
3806   out++;
3807   *out = (inl >> 26);
3808   ++in;
3809   inl = util::SafeLoad(in);
3810   inl = arrow::bit_util::FromLittleEndian(inl);
3811   *out |= (inl % (1U << 24)) << (30 - 24);
3812   out++;
3813   *out = (inl >> 24);
3814   ++in;
3815   inl = util::SafeLoad(in);
3816   inl = arrow::bit_util::FromLittleEndian(inl);
3817   *out |= (inl % (1U << 22)) << (30 - 22);
3818   out++;
3819   *out = (inl >> 22);
3820   ++in;
3821   inl = util::SafeLoad(in);
3822   inl = arrow::bit_util::FromLittleEndian(inl);
3823   *out |= (inl % (1U << 20)) << (30 - 20);
3824   out++;
3825   *out = (inl >> 20);
3826   ++in;
3827   inl = util::SafeLoad(in);
3828   inl = arrow::bit_util::FromLittleEndian(inl);
3829   *out |= (inl % (1U << 18)) << (30 - 18);
3830   out++;
3831   *out = (inl >> 18);
3832   ++in;
3833   inl = util::SafeLoad(in);
3834   inl = arrow::bit_util::FromLittleEndian(inl);
3835   *out |= (inl % (1U << 16)) << (30 - 16);
3836   out++;
3837   *out = (inl >> 16);
3838   ++in;
3839   inl = util::SafeLoad(in);
3840   inl = arrow::bit_util::FromLittleEndian(inl);
3841   *out |= (inl % (1U << 14)) << (30 - 14);
3842   out++;
3843   *out = (inl >> 14);
3844   ++in;
3845   inl = util::SafeLoad(in);
3846   inl = arrow::bit_util::FromLittleEndian(inl);
3847   *out |= (inl % (1U << 12)) << (30 - 12);
3848   out++;
3849   *out = (inl >> 12);
3850   ++in;
3851   inl = util::SafeLoad(in);
3852   inl = arrow::bit_util::FromLittleEndian(inl);
3853   *out |= (inl % (1U << 10)) << (30 - 10);
3854   out++;
3855   *out = (inl >> 10);
3856   ++in;
3857   inl = util::SafeLoad(in);
3858   inl = arrow::bit_util::FromLittleEndian(inl);
3859   *out |= (inl % (1U << 8)) << (30 - 8);
3860   out++;
3861   *out = (inl >> 8);
3862   ++in;
3863   inl = util::SafeLoad(in);
3864   inl = arrow::bit_util::FromLittleEndian(inl);
3865   *out |= (inl % (1U << 6)) << (30 - 6);
3866   out++;
3867   *out = (inl >> 6);
3868   ++in;
3869   inl = util::SafeLoad(in);
3870   inl = arrow::bit_util::FromLittleEndian(inl);
3871   *out |= (inl % (1U << 4)) << (30 - 4);
3872   out++;
3873   *out = (inl >> 4);
3874   ++in;
3875   inl = util::SafeLoad(in);
3876   inl = arrow::bit_util::FromLittleEndian(inl);
3877   *out |= (inl % (1U << 2)) << (30 - 2);
3878   out++;
3879   *out = (inl >> 2);
3880   ++in;
3881   out++;
3882 
3883   return in;
3884 }
3885 
3886 inline const uint32_t* unpack31_32(const uint32_t* in, uint32_t* out) {
3887   uint32_t inl = util::SafeLoad(in);
3888   inl = arrow::bit_util::FromLittleEndian(inl);
3889   *out = (inl >> 0) % (1U << 31);
3890   out++;
3891   *out = (inl >> 31);
3892   ++in;
3893   inl = util::SafeLoad(in);
3894   inl = arrow::bit_util::FromLittleEndian(inl);
3895   *out |= (inl % (1U << 30)) << (31 - 30);
3896   out++;
3897   *out = (inl >> 30);
3898   ++in;
3899   inl = util::SafeLoad(in);
3900   inl = arrow::bit_util::FromLittleEndian(inl);
3901   *out |= (inl % (1U << 29)) << (31 - 29);
3902   out++;
3903   *out = (inl >> 29);
3904   ++in;
3905   inl = util::SafeLoad(in);
3906   inl = arrow::bit_util::FromLittleEndian(inl);
3907   *out |= (inl % (1U << 28)) << (31 - 28);
3908   out++;
3909   *out = (inl >> 28);
3910   ++in;
3911   inl = util::SafeLoad(in);
3912   inl = arrow::bit_util::FromLittleEndian(inl);
3913   *out |= (inl % (1U << 27)) << (31 - 27);
3914   out++;
3915   *out = (inl >> 27);
3916   ++in;
3917   inl = util::SafeLoad(in);
3918   inl = arrow::bit_util::FromLittleEndian(inl);
3919   *out |= (inl % (1U << 26)) << (31 - 26);
3920   out++;
3921   *out = (inl >> 26);
3922   ++in;
3923   inl = util::SafeLoad(in);
3924   inl = arrow::bit_util::FromLittleEndian(inl);
3925   *out |= (inl % (1U << 25)) << (31 - 25);
3926   out++;
3927   *out = (inl >> 25);
3928   ++in;
3929   inl = util::SafeLoad(in);
3930   inl = arrow::bit_util::FromLittleEndian(inl);
3931   *out |= (inl % (1U << 24)) << (31 - 24);
3932   out++;
3933   *out = (inl >> 24);
3934   ++in;
3935   inl = util::SafeLoad(in);
3936   inl = arrow::bit_util::FromLittleEndian(inl);
3937   *out |= (inl % (1U << 23)) << (31 - 23);
3938   out++;
3939   *out = (inl >> 23);
3940   ++in;
3941   inl = util::SafeLoad(in);
3942   inl = arrow::bit_util::FromLittleEndian(inl);
3943   *out |= (inl % (1U << 22)) << (31 - 22);
3944   out++;
3945   *out = (inl >> 22);
3946   ++in;
3947   inl = util::SafeLoad(in);
3948   inl = arrow::bit_util::FromLittleEndian(inl);
3949   *out |= (inl % (1U << 21)) << (31 - 21);
3950   out++;
3951   *out = (inl >> 21);
3952   ++in;
3953   inl = util::SafeLoad(in);
3954   inl = arrow::bit_util::FromLittleEndian(inl);
3955   *out |= (inl % (1U << 20)) << (31 - 20);
3956   out++;
3957   *out = (inl >> 20);
3958   ++in;
3959   inl = util::SafeLoad(in);
3960   inl = arrow::bit_util::FromLittleEndian(inl);
3961   *out |= (inl % (1U << 19)) << (31 - 19);
3962   out++;
3963   *out = (inl >> 19);
3964   ++in;
3965   inl = util::SafeLoad(in);
3966   inl = arrow::bit_util::FromLittleEndian(inl);
3967   *out |= (inl % (1U << 18)) << (31 - 18);
3968   out++;
3969   *out = (inl >> 18);
3970   ++in;
3971   inl = util::SafeLoad(in);
3972   inl = arrow::bit_util::FromLittleEndian(inl);
3973   *out |= (inl % (1U << 17)) << (31 - 17);
3974   out++;
3975   *out = (inl >> 17);
3976   ++in;
3977   inl = util::SafeLoad(in);
3978   inl = arrow::bit_util::FromLittleEndian(inl);
3979   *out |= (inl % (1U << 16)) << (31 - 16);
3980   out++;
3981   *out = (inl >> 16);
3982   ++in;
3983   inl = util::SafeLoad(in);
3984   inl = arrow::bit_util::FromLittleEndian(inl);
3985   *out |= (inl % (1U << 15)) << (31 - 15);
3986   out++;
3987   *out = (inl >> 15);
3988   ++in;
3989   inl = util::SafeLoad(in);
3990   inl = arrow::bit_util::FromLittleEndian(inl);
3991   *out |= (inl % (1U << 14)) << (31 - 14);
3992   out++;
3993   *out = (inl >> 14);
3994   ++in;
3995   inl = util::SafeLoad(in);
3996   inl = arrow::bit_util::FromLittleEndian(inl);
3997   *out |= (inl % (1U << 13)) << (31 - 13);
3998   out++;
3999   *out = (inl >> 13);
4000   ++in;
4001   inl = util::SafeLoad(in);
4002   inl = arrow::bit_util::FromLittleEndian(inl);
4003   *out |= (inl % (1U << 12)) << (31 - 12);
4004   out++;
4005   *out = (inl >> 12);
4006   ++in;
4007   inl = util::SafeLoad(in);
4008   inl = arrow::bit_util::FromLittleEndian(inl);
4009   *out |= (inl % (1U << 11)) << (31 - 11);
4010   out++;
4011   *out = (inl >> 11);
4012   ++in;
4013   inl = util::SafeLoad(in);
4014   inl = arrow::bit_util::FromLittleEndian(inl);
4015   *out |= (inl % (1U << 10)) << (31 - 10);
4016   out++;
4017   *out = (inl >> 10);
4018   ++in;
4019   inl = util::SafeLoad(in);
4020   inl = arrow::bit_util::FromLittleEndian(inl);
4021   *out |= (inl % (1U << 9)) << (31 - 9);
4022   out++;
4023   *out = (inl >> 9);
4024   ++in;
4025   inl = util::SafeLoad(in);
4026   inl = arrow::bit_util::FromLittleEndian(inl);
4027   *out |= (inl % (1U << 8)) << (31 - 8);
4028   out++;
4029   *out = (inl >> 8);
4030   ++in;
4031   inl = util::SafeLoad(in);
4032   inl = arrow::bit_util::FromLittleEndian(inl);
4033   *out |= (inl % (1U << 7)) << (31 - 7);
4034   out++;
4035   *out = (inl >> 7);
4036   ++in;
4037   inl = util::SafeLoad(in);
4038   inl = arrow::bit_util::FromLittleEndian(inl);
4039   *out |= (inl % (1U << 6)) << (31 - 6);
4040   out++;
4041   *out = (inl >> 6);
4042   ++in;
4043   inl = util::SafeLoad(in);
4044   inl = arrow::bit_util::FromLittleEndian(inl);
4045   *out |= (inl % (1U << 5)) << (31 - 5);
4046   out++;
4047   *out = (inl >> 5);
4048   ++in;
4049   inl = util::SafeLoad(in);
4050   inl = arrow::bit_util::FromLittleEndian(inl);
4051   *out |= (inl % (1U << 4)) << (31 - 4);
4052   out++;
4053   *out = (inl >> 4);
4054   ++in;
4055   inl = util::SafeLoad(in);
4056   inl = arrow::bit_util::FromLittleEndian(inl);
4057   *out |= (inl % (1U << 3)) << (31 - 3);
4058   out++;
4059   *out = (inl >> 3);
4060   ++in;
4061   inl = util::SafeLoad(in);
4062   inl = arrow::bit_util::FromLittleEndian(inl);
4063   *out |= (inl % (1U << 2)) << (31 - 2);
4064   out++;
4065   *out = (inl >> 2);
4066   ++in;
4067   inl = util::SafeLoad(in);
4068   inl = arrow::bit_util::FromLittleEndian(inl);
4069   *out |= (inl % (1U << 1)) << (31 - 1);
4070   out++;
4071   *out = (inl >> 1);
4072   ++in;
4073   out++;
4074 
4075   return in;
4076 }
4077 
4078 inline const uint32_t* unpack32_32(const uint32_t* in, uint32_t* out) {
4079   uint32_t inl = util::SafeLoad(in);
4080   inl = arrow::bit_util::FromLittleEndian(inl);
4081   *out = (inl >> 0);
4082   ++in;
4083   inl = util::SafeLoad(in);
4084   inl = arrow::bit_util::FromLittleEndian(inl);
4085   out++;
4086   *out = (inl >> 0);
4087   ++in;
4088   inl = util::SafeLoad(in);
4089   inl = arrow::bit_util::FromLittleEndian(inl);
4090   out++;
4091   *out = (inl >> 0);
4092   ++in;
4093   inl = util::SafeLoad(in);
4094   inl = arrow::bit_util::FromLittleEndian(inl);
4095   out++;
4096   *out = (inl >> 0);
4097   ++in;
4098   inl = util::SafeLoad(in);
4099   inl = arrow::bit_util::FromLittleEndian(inl);
4100   out++;
4101   *out = (inl >> 0);
4102   ++in;
4103   inl = util::SafeLoad(in);
4104   inl = arrow::bit_util::FromLittleEndian(inl);
4105   out++;
4106   *out = (inl >> 0);
4107   ++in;
4108   inl = util::SafeLoad(in);
4109   inl = arrow::bit_util::FromLittleEndian(inl);
4110   out++;
4111   *out = (inl >> 0);
4112   ++in;
4113   inl = util::SafeLoad(in);
4114   inl = arrow::bit_util::FromLittleEndian(inl);
4115   out++;
4116   *out = (inl >> 0);
4117   ++in;
4118   inl = util::SafeLoad(in);
4119   inl = arrow::bit_util::FromLittleEndian(inl);
4120   out++;
4121   *out = (inl >> 0);
4122   ++in;
4123   inl = util::SafeLoad(in);
4124   inl = arrow::bit_util::FromLittleEndian(inl);
4125   out++;
4126   *out = (inl >> 0);
4127   ++in;
4128   inl = util::SafeLoad(in);
4129   inl = arrow::bit_util::FromLittleEndian(inl);
4130   out++;
4131   *out = (inl >> 0);
4132   ++in;
4133   inl = util::SafeLoad(in);
4134   inl = arrow::bit_util::FromLittleEndian(inl);
4135   out++;
4136   *out = (inl >> 0);
4137   ++in;
4138   inl = util::SafeLoad(in);
4139   inl = arrow::bit_util::FromLittleEndian(inl);
4140   out++;
4141   *out = (inl >> 0);
4142   ++in;
4143   inl = util::SafeLoad(in);
4144   inl = arrow::bit_util::FromLittleEndian(inl);
4145   out++;
4146   *out = (inl >> 0);
4147   ++in;
4148   inl = util::SafeLoad(in);
4149   inl = arrow::bit_util::FromLittleEndian(inl);
4150   out++;
4151   *out = (inl >> 0);
4152   ++in;
4153   inl = util::SafeLoad(in);
4154   inl = arrow::bit_util::FromLittleEndian(inl);
4155   out++;
4156   *out = (inl >> 0);
4157   ++in;
4158   inl = util::SafeLoad(in);
4159   inl = arrow::bit_util::FromLittleEndian(inl);
4160   out++;
4161   *out = (inl >> 0);
4162   ++in;
4163   inl = util::SafeLoad(in);
4164   inl = arrow::bit_util::FromLittleEndian(inl);
4165   out++;
4166   *out = (inl >> 0);
4167   ++in;
4168   inl = util::SafeLoad(in);
4169   inl = arrow::bit_util::FromLittleEndian(inl);
4170   out++;
4171   *out = (inl >> 0);
4172   ++in;
4173   inl = util::SafeLoad(in);
4174   inl = arrow::bit_util::FromLittleEndian(inl);
4175   out++;
4176   *out = (inl >> 0);
4177   ++in;
4178   inl = util::SafeLoad(in);
4179   inl = arrow::bit_util::FromLittleEndian(inl);
4180   out++;
4181   *out = (inl >> 0);
4182   ++in;
4183   inl = util::SafeLoad(in);
4184   inl = arrow::bit_util::FromLittleEndian(inl);
4185   out++;
4186   *out = (inl >> 0);
4187   ++in;
4188   inl = util::SafeLoad(in);
4189   inl = arrow::bit_util::FromLittleEndian(inl);
4190   out++;
4191   *out = (inl >> 0);
4192   ++in;
4193   inl = util::SafeLoad(in);
4194   inl = arrow::bit_util::FromLittleEndian(inl);
4195   out++;
4196   *out = (inl >> 0);
4197   ++in;
4198   inl = util::SafeLoad(in);
4199   inl = arrow::bit_util::FromLittleEndian(inl);
4200   out++;
4201   *out = (inl >> 0);
4202   ++in;
4203   inl = util::SafeLoad(in);
4204   inl = arrow::bit_util::FromLittleEndian(inl);
4205   out++;
4206   *out = (inl >> 0);
4207   ++in;
4208   inl = util::SafeLoad(in);
4209   inl = arrow::bit_util::FromLittleEndian(inl);
4210   out++;
4211   *out = (inl >> 0);
4212   ++in;
4213   inl = util::SafeLoad(in);
4214   inl = arrow::bit_util::FromLittleEndian(inl);
4215   out++;
4216   *out = (inl >> 0);
4217   ++in;
4218   inl = util::SafeLoad(in);
4219   inl = arrow::bit_util::FromLittleEndian(inl);
4220   out++;
4221   *out = (inl >> 0);
4222   ++in;
4223   inl = util::SafeLoad(in);
4224   inl = arrow::bit_util::FromLittleEndian(inl);
4225   out++;
4226   *out = (inl >> 0);
4227   ++in;
4228   inl = util::SafeLoad(in);
4229   inl = arrow::bit_util::FromLittleEndian(inl);
4230   out++;
4231   *out = (inl >> 0);
4232   ++in;
4233   inl = util::SafeLoad(in);
4234   inl = arrow::bit_util::FromLittleEndian(inl);
4235   out++;
4236   *out = (inl >> 0);
4237   ++in;
4238   out++;
4239 
4240   return in;
4241 }
4242 
4243 inline const uint32_t* nullunpacker32(const uint32_t* in, uint32_t* out) {
4244   for (int k = 0; k < 32; ++k) {
4245     out[k] = 0;
4246   }
4247   return in;
4248 }
4249 
4250 }  // namespace internal
4251 }  // namespace arrow
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!