1 // Licensed to the Apache Software Foundation (ASF) under one
2 // or more contributor license agreements. See the NOTICE file
3 // distributed with this work for additional information
4 // regarding copyright ownership. The ASF licenses this file
5 // to you under the Apache License, Version 2.0 (the
6 // "License"); you may not use this file except in compliance
7 // with the License. You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing,
12 // software distributed under the License is distributed on an
13 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14 // KIND, either express or implied. See the License for the
15 // specific language governing permissions and limitations
16 // under the License.
17
18 // This file was modified from its original version for inclusion in parquet-cpp.
19 // Original source:
20 // https://github.com/lemire/FrameOfReference/blob/6ccaf9e97160f9a3b299e23a8ef739e711ef0c71/src/bpacking.cpp
21 // The original copyright notice follows.
22
23 // This code is released under the
24 // Apache License Version 2.0 http://www.apache.org/licenses/.
25 // (c) Daniel Lemire 2013
26
27 #pragma once
28
29 namespace arrow {
30 namespace internal {
31
unpack1_32(const uint32_t * in,uint32_t * out)32 inline const uint32_t* unpack1_32(const uint32_t* in, uint32_t* out) {
33 uint32_t inl = util::SafeLoad(in);
34 inl = arrow::BitUtil::FromLittleEndian(inl);
35 *out = (inl >> 0) & 1;
36 out++;
37 *out = (inl >> 1) & 1;
38 out++;
39 *out = (inl >> 2) & 1;
40 out++;
41 *out = (inl >> 3) & 1;
42 out++;
43 *out = (inl >> 4) & 1;
44 out++;
45 *out = (inl >> 5) & 1;
46 out++;
47 *out = (inl >> 6) & 1;
48 out++;
49 *out = (inl >> 7) & 1;
50 out++;
51 *out = (inl >> 8) & 1;
52 out++;
53 *out = (inl >> 9) & 1;
54 out++;
55 *out = (inl >> 10) & 1;
56 out++;
57 *out = (inl >> 11) & 1;
58 out++;
59 *out = (inl >> 12) & 1;
60 out++;
61 *out = (inl >> 13) & 1;
62 out++;
63 *out = (inl >> 14) & 1;
64 out++;
65 *out = (inl >> 15) & 1;
66 out++;
67 *out = (inl >> 16) & 1;
68 out++;
69 *out = (inl >> 17) & 1;
70 out++;
71 *out = (inl >> 18) & 1;
72 out++;
73 *out = (inl >> 19) & 1;
74 out++;
75 *out = (inl >> 20) & 1;
76 out++;
77 *out = (inl >> 21) & 1;
78 out++;
79 *out = (inl >> 22) & 1;
80 out++;
81 *out = (inl >> 23) & 1;
82 out++;
83 *out = (inl >> 24) & 1;
84 out++;
85 *out = (inl >> 25) & 1;
86 out++;
87 *out = (inl >> 26) & 1;
88 out++;
89 *out = (inl >> 27) & 1;
90 out++;
91 *out = (inl >> 28) & 1;
92 out++;
93 *out = (inl >> 29) & 1;
94 out++;
95 *out = (inl >> 30) & 1;
96 out++;
97 *out = (inl >> 31);
98 ++in;
99 out++;
100
101 return in;
102 }
103
unpack2_32(const uint32_t * in,uint32_t * out)104 inline const uint32_t* unpack2_32(const uint32_t* in, uint32_t* out) {
105 uint32_t inl = util::SafeLoad(in);
106 inl = arrow::BitUtil::FromLittleEndian(inl);
107 *out = (inl >> 0) % (1U << 2);
108 out++;
109 *out = (inl >> 2) % (1U << 2);
110 out++;
111 *out = (inl >> 4) % (1U << 2);
112 out++;
113 *out = (inl >> 6) % (1U << 2);
114 out++;
115 *out = (inl >> 8) % (1U << 2);
116 out++;
117 *out = (inl >> 10) % (1U << 2);
118 out++;
119 *out = (inl >> 12) % (1U << 2);
120 out++;
121 *out = (inl >> 14) % (1U << 2);
122 out++;
123 *out = (inl >> 16) % (1U << 2);
124 out++;
125 *out = (inl >> 18) % (1U << 2);
126 out++;
127 *out = (inl >> 20) % (1U << 2);
128 out++;
129 *out = (inl >> 22) % (1U << 2);
130 out++;
131 *out = (inl >> 24) % (1U << 2);
132 out++;
133 *out = (inl >> 26) % (1U << 2);
134 out++;
135 *out = (inl >> 28) % (1U << 2);
136 out++;
137 *out = (inl >> 30);
138 ++in;
139 inl = util::SafeLoad(in);
140 inl = arrow::BitUtil::FromLittleEndian(inl);
141 out++;
142 *out = (inl >> 0) % (1U << 2);
143 out++;
144 *out = (inl >> 2) % (1U << 2);
145 out++;
146 *out = (inl >> 4) % (1U << 2);
147 out++;
148 *out = (inl >> 6) % (1U << 2);
149 out++;
150 *out = (inl >> 8) % (1U << 2);
151 out++;
152 *out = (inl >> 10) % (1U << 2);
153 out++;
154 *out = (inl >> 12) % (1U << 2);
155 out++;
156 *out = (inl >> 14) % (1U << 2);
157 out++;
158 *out = (inl >> 16) % (1U << 2);
159 out++;
160 *out = (inl >> 18) % (1U << 2);
161 out++;
162 *out = (inl >> 20) % (1U << 2);
163 out++;
164 *out = (inl >> 22) % (1U << 2);
165 out++;
166 *out = (inl >> 24) % (1U << 2);
167 out++;
168 *out = (inl >> 26) % (1U << 2);
169 out++;
170 *out = (inl >> 28) % (1U << 2);
171 out++;
172 *out = (inl >> 30);
173 ++in;
174 out++;
175
176 return in;
177 }
178
unpack3_32(const uint32_t * in,uint32_t * out)179 inline const uint32_t* unpack3_32(const uint32_t* in, uint32_t* out) {
180 uint32_t inl = util::SafeLoad(in);
181 inl = arrow::BitUtil::FromLittleEndian(inl);
182 *out = (inl >> 0) % (1U << 3);
183 out++;
184 *out = (inl >> 3) % (1U << 3);
185 out++;
186 *out = (inl >> 6) % (1U << 3);
187 out++;
188 *out = (inl >> 9) % (1U << 3);
189 out++;
190 *out = (inl >> 12) % (1U << 3);
191 out++;
192 *out = (inl >> 15) % (1U << 3);
193 out++;
194 *out = (inl >> 18) % (1U << 3);
195 out++;
196 *out = (inl >> 21) % (1U << 3);
197 out++;
198 *out = (inl >> 24) % (1U << 3);
199 out++;
200 *out = (inl >> 27) % (1U << 3);
201 out++;
202 *out = (inl >> 30);
203 ++in;
204 inl = util::SafeLoad(in);
205 inl = arrow::BitUtil::FromLittleEndian(inl);
206 *out |= (inl % (1U << 1)) << (3 - 1);
207 out++;
208 *out = (inl >> 1) % (1U << 3);
209 out++;
210 *out = (inl >> 4) % (1U << 3);
211 out++;
212 *out = (inl >> 7) % (1U << 3);
213 out++;
214 *out = (inl >> 10) % (1U << 3);
215 out++;
216 *out = (inl >> 13) % (1U << 3);
217 out++;
218 *out = (inl >> 16) % (1U << 3);
219 out++;
220 *out = (inl >> 19) % (1U << 3);
221 out++;
222 *out = (inl >> 22) % (1U << 3);
223 out++;
224 *out = (inl >> 25) % (1U << 3);
225 out++;
226 *out = (inl >> 28) % (1U << 3);
227 out++;
228 *out = (inl >> 31);
229 ++in;
230 inl = util::SafeLoad(in);
231 inl = arrow::BitUtil::FromLittleEndian(inl);
232 *out |= (inl % (1U << 2)) << (3 - 2);
233 out++;
234 *out = (inl >> 2) % (1U << 3);
235 out++;
236 *out = (inl >> 5) % (1U << 3);
237 out++;
238 *out = (inl >> 8) % (1U << 3);
239 out++;
240 *out = (inl >> 11) % (1U << 3);
241 out++;
242 *out = (inl >> 14) % (1U << 3);
243 out++;
244 *out = (inl >> 17) % (1U << 3);
245 out++;
246 *out = (inl >> 20) % (1U << 3);
247 out++;
248 *out = (inl >> 23) % (1U << 3);
249 out++;
250 *out = (inl >> 26) % (1U << 3);
251 out++;
252 *out = (inl >> 29);
253 ++in;
254 out++;
255
256 return in;
257 }
258
unpack4_32(const uint32_t * in,uint32_t * out)259 inline const uint32_t* unpack4_32(const uint32_t* in, uint32_t* out) {
260 uint32_t inl = util::SafeLoad(in);
261 inl = arrow::BitUtil::FromLittleEndian(inl);
262 *out = (inl >> 0) % (1U << 4);
263 out++;
264 *out = (inl >> 4) % (1U << 4);
265 out++;
266 *out = (inl >> 8) % (1U << 4);
267 out++;
268 *out = (inl >> 12) % (1U << 4);
269 out++;
270 *out = (inl >> 16) % (1U << 4);
271 out++;
272 *out = (inl >> 20) % (1U << 4);
273 out++;
274 *out = (inl >> 24) % (1U << 4);
275 out++;
276 *out = (inl >> 28);
277 ++in;
278 inl = util::SafeLoad(in);
279 inl = arrow::BitUtil::FromLittleEndian(inl);
280 out++;
281 *out = (inl >> 0) % (1U << 4);
282 out++;
283 *out = (inl >> 4) % (1U << 4);
284 out++;
285 *out = (inl >> 8) % (1U << 4);
286 out++;
287 *out = (inl >> 12) % (1U << 4);
288 out++;
289 *out = (inl >> 16) % (1U << 4);
290 out++;
291 *out = (inl >> 20) % (1U << 4);
292 out++;
293 *out = (inl >> 24) % (1U << 4);
294 out++;
295 *out = (inl >> 28);
296 ++in;
297 inl = util::SafeLoad(in);
298 inl = arrow::BitUtil::FromLittleEndian(inl);
299 out++;
300 *out = (inl >> 0) % (1U << 4);
301 out++;
302 *out = (inl >> 4) % (1U << 4);
303 out++;
304 *out = (inl >> 8) % (1U << 4);
305 out++;
306 *out = (inl >> 12) % (1U << 4);
307 out++;
308 *out = (inl >> 16) % (1U << 4);
309 out++;
310 *out = (inl >> 20) % (1U << 4);
311 out++;
312 *out = (inl >> 24) % (1U << 4);
313 out++;
314 *out = (inl >> 28);
315 ++in;
316 inl = util::SafeLoad(in);
317 inl = arrow::BitUtil::FromLittleEndian(inl);
318 out++;
319 *out = (inl >> 0) % (1U << 4);
320 out++;
321 *out = (inl >> 4) % (1U << 4);
322 out++;
323 *out = (inl >> 8) % (1U << 4);
324 out++;
325 *out = (inl >> 12) % (1U << 4);
326 out++;
327 *out = (inl >> 16) % (1U << 4);
328 out++;
329 *out = (inl >> 20) % (1U << 4);
330 out++;
331 *out = (inl >> 24) % (1U << 4);
332 out++;
333 *out = (inl >> 28);
334 ++in;
335 out++;
336
337 return in;
338 }
339
unpack5_32(const uint32_t * in,uint32_t * out)340 inline const uint32_t* unpack5_32(const uint32_t* in, uint32_t* out) {
341 uint32_t inl = util::SafeLoad(in);
342 inl = arrow::BitUtil::FromLittleEndian(inl);
343 *out = (inl >> 0) % (1U << 5);
344 out++;
345 *out = (inl >> 5) % (1U << 5);
346 out++;
347 *out = (inl >> 10) % (1U << 5);
348 out++;
349 *out = (inl >> 15) % (1U << 5);
350 out++;
351 *out = (inl >> 20) % (1U << 5);
352 out++;
353 *out = (inl >> 25) % (1U << 5);
354 out++;
355 *out = (inl >> 30);
356 ++in;
357 inl = util::SafeLoad(in);
358 inl = arrow::BitUtil::FromLittleEndian(inl);
359 *out |= (inl % (1U << 3)) << (5 - 3);
360 out++;
361 *out = (inl >> 3) % (1U << 5);
362 out++;
363 *out = (inl >> 8) % (1U << 5);
364 out++;
365 *out = (inl >> 13) % (1U << 5);
366 out++;
367 *out = (inl >> 18) % (1U << 5);
368 out++;
369 *out = (inl >> 23) % (1U << 5);
370 out++;
371 *out = (inl >> 28);
372 ++in;
373 inl = util::SafeLoad(in);
374 inl = arrow::BitUtil::FromLittleEndian(inl);
375 *out |= (inl % (1U << 1)) << (5 - 1);
376 out++;
377 *out = (inl >> 1) % (1U << 5);
378 out++;
379 *out = (inl >> 6) % (1U << 5);
380 out++;
381 *out = (inl >> 11) % (1U << 5);
382 out++;
383 *out = (inl >> 16) % (1U << 5);
384 out++;
385 *out = (inl >> 21) % (1U << 5);
386 out++;
387 *out = (inl >> 26) % (1U << 5);
388 out++;
389 *out = (inl >> 31);
390 ++in;
391 inl = util::SafeLoad(in);
392 inl = arrow::BitUtil::FromLittleEndian(inl);
393 *out |= (inl % (1U << 4)) << (5 - 4);
394 out++;
395 *out = (inl >> 4) % (1U << 5);
396 out++;
397 *out = (inl >> 9) % (1U << 5);
398 out++;
399 *out = (inl >> 14) % (1U << 5);
400 out++;
401 *out = (inl >> 19) % (1U << 5);
402 out++;
403 *out = (inl >> 24) % (1U << 5);
404 out++;
405 *out = (inl >> 29);
406 ++in;
407 inl = util::SafeLoad(in);
408 inl = arrow::BitUtil::FromLittleEndian(inl);
409 *out |= (inl % (1U << 2)) << (5 - 2);
410 out++;
411 *out = (inl >> 2) % (1U << 5);
412 out++;
413 *out = (inl >> 7) % (1U << 5);
414 out++;
415 *out = (inl >> 12) % (1U << 5);
416 out++;
417 *out = (inl >> 17) % (1U << 5);
418 out++;
419 *out = (inl >> 22) % (1U << 5);
420 out++;
421 *out = (inl >> 27);
422 ++in;
423 out++;
424
425 return in;
426 }
427
unpack6_32(const uint32_t * in,uint32_t * out)428 inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
429 uint32_t inl = util::SafeLoad(in);
430 inl = arrow::BitUtil::FromLittleEndian(inl);
431 *out = (inl >> 0) % (1U << 6);
432 out++;
433 *out = (inl >> 6) % (1U << 6);
434 out++;
435 *out = (inl >> 12) % (1U << 6);
436 out++;
437 *out = (inl >> 18) % (1U << 6);
438 out++;
439 *out = (inl >> 24) % (1U << 6);
440 out++;
441 *out = (inl >> 30);
442 ++in;
443 inl = util::SafeLoad(in);
444 inl = arrow::BitUtil::FromLittleEndian(inl);
445 *out |= (inl % (1U << 4)) << (6 - 4);
446 out++;
447 *out = (inl >> 4) % (1U << 6);
448 out++;
449 *out = (inl >> 10) % (1U << 6);
450 out++;
451 *out = (inl >> 16) % (1U << 6);
452 out++;
453 *out = (inl >> 22) % (1U << 6);
454 out++;
455 *out = (inl >> 28);
456 ++in;
457 inl = util::SafeLoad(in);
458 inl = arrow::BitUtil::FromLittleEndian(inl);
459 *out |= (inl % (1U << 2)) << (6 - 2);
460 out++;
461 *out = (inl >> 2) % (1U << 6);
462 out++;
463 *out = (inl >> 8) % (1U << 6);
464 out++;
465 *out = (inl >> 14) % (1U << 6);
466 out++;
467 *out = (inl >> 20) % (1U << 6);
468 out++;
469 *out = (inl >> 26);
470 ++in;
471 inl = util::SafeLoad(in);
472 inl = arrow::BitUtil::FromLittleEndian(inl);
473 out++;
474 *out = (inl >> 0) % (1U << 6);
475 out++;
476 *out = (inl >> 6) % (1U << 6);
477 out++;
478 *out = (inl >> 12) % (1U << 6);
479 out++;
480 *out = (inl >> 18) % (1U << 6);
481 out++;
482 *out = (inl >> 24) % (1U << 6);
483 out++;
484 *out = (inl >> 30);
485 ++in;
486 inl = util::SafeLoad(in);
487 inl = arrow::BitUtil::FromLittleEndian(inl);
488 *out |= (inl % (1U << 4)) << (6 - 4);
489 out++;
490 *out = (inl >> 4) % (1U << 6);
491 out++;
492 *out = (inl >> 10) % (1U << 6);
493 out++;
494 *out = (inl >> 16) % (1U << 6);
495 out++;
496 *out = (inl >> 22) % (1U << 6);
497 out++;
498 *out = (inl >> 28);
499 ++in;
500 inl = util::SafeLoad(in);
501 inl = arrow::BitUtil::FromLittleEndian(inl);
502 *out |= (inl % (1U << 2)) << (6 - 2);
503 out++;
504 *out = (inl >> 2) % (1U << 6);
505 out++;
506 *out = (inl >> 8) % (1U << 6);
507 out++;
508 *out = (inl >> 14) % (1U << 6);
509 out++;
510 *out = (inl >> 20) % (1U << 6);
511 out++;
512 *out = (inl >> 26);
513 ++in;
514 out++;
515
516 return in;
517 }
518
unpack7_32(const uint32_t * in,uint32_t * out)519 inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
520 uint32_t inl = util::SafeLoad(in);
521 inl = arrow::BitUtil::FromLittleEndian(inl);
522 *out = (inl >> 0) % (1U << 7);
523 out++;
524 *out = (inl >> 7) % (1U << 7);
525 out++;
526 *out = (inl >> 14) % (1U << 7);
527 out++;
528 *out = (inl >> 21) % (1U << 7);
529 out++;
530 *out = (inl >> 28);
531 ++in;
532 inl = util::SafeLoad(in);
533 inl = arrow::BitUtil::FromLittleEndian(inl);
534 *out |= (inl % (1U << 3)) << (7 - 3);
535 out++;
536 *out = (inl >> 3) % (1U << 7);
537 out++;
538 *out = (inl >> 10) % (1U << 7);
539 out++;
540 *out = (inl >> 17) % (1U << 7);
541 out++;
542 *out = (inl >> 24) % (1U << 7);
543 out++;
544 *out = (inl >> 31);
545 ++in;
546 inl = util::SafeLoad(in);
547 inl = arrow::BitUtil::FromLittleEndian(inl);
548 *out |= (inl % (1U << 6)) << (7 - 6);
549 out++;
550 *out = (inl >> 6) % (1U << 7);
551 out++;
552 *out = (inl >> 13) % (1U << 7);
553 out++;
554 *out = (inl >> 20) % (1U << 7);
555 out++;
556 *out = (inl >> 27);
557 ++in;
558 inl = util::SafeLoad(in);
559 inl = arrow::BitUtil::FromLittleEndian(inl);
560 *out |= (inl % (1U << 2)) << (7 - 2);
561 out++;
562 *out = (inl >> 2) % (1U << 7);
563 out++;
564 *out = (inl >> 9) % (1U << 7);
565 out++;
566 *out = (inl >> 16) % (1U << 7);
567 out++;
568 *out = (inl >> 23) % (1U << 7);
569 out++;
570 *out = (inl >> 30);
571 ++in;
572 inl = util::SafeLoad(in);
573 inl = arrow::BitUtil::FromLittleEndian(inl);
574 *out |= (inl % (1U << 5)) << (7 - 5);
575 out++;
576 *out = (inl >> 5) % (1U << 7);
577 out++;
578 *out = (inl >> 12) % (1U << 7);
579 out++;
580 *out = (inl >> 19) % (1U << 7);
581 out++;
582 *out = (inl >> 26);
583 ++in;
584 inl = util::SafeLoad(in);
585 inl = arrow::BitUtil::FromLittleEndian(inl);
586 *out |= (inl % (1U << 1)) << (7 - 1);
587 out++;
588 *out = (inl >> 1) % (1U << 7);
589 out++;
590 *out = (inl >> 8) % (1U << 7);
591 out++;
592 *out = (inl >> 15) % (1U << 7);
593 out++;
594 *out = (inl >> 22) % (1U << 7);
595 out++;
596 *out = (inl >> 29);
597 ++in;
598 inl = util::SafeLoad(in);
599 inl = arrow::BitUtil::FromLittleEndian(inl);
600 *out |= (inl % (1U << 4)) << (7 - 4);
601 out++;
602 *out = (inl >> 4) % (1U << 7);
603 out++;
604 *out = (inl >> 11) % (1U << 7);
605 out++;
606 *out = (inl >> 18) % (1U << 7);
607 out++;
608 *out = (inl >> 25);
609 ++in;
610 out++;
611
612 return in;
613 }
614
unpack8_32(const uint32_t * in,uint32_t * out)615 inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
616 uint32_t inl = util::SafeLoad(in);
617 inl = arrow::BitUtil::FromLittleEndian(inl);
618 *out = (inl >> 0) % (1U << 8);
619 out++;
620 *out = (inl >> 8) % (1U << 8);
621 out++;
622 *out = (inl >> 16) % (1U << 8);
623 out++;
624 *out = (inl >> 24);
625 ++in;
626 inl = util::SafeLoad(in);
627 inl = arrow::BitUtil::FromLittleEndian(inl);
628 out++;
629 *out = (inl >> 0) % (1U << 8);
630 out++;
631 *out = (inl >> 8) % (1U << 8);
632 out++;
633 *out = (inl >> 16) % (1U << 8);
634 out++;
635 *out = (inl >> 24);
636 ++in;
637 inl = util::SafeLoad(in);
638 inl = arrow::BitUtil::FromLittleEndian(inl);
639 out++;
640 *out = (inl >> 0) % (1U << 8);
641 out++;
642 *out = (inl >> 8) % (1U << 8);
643 out++;
644 *out = (inl >> 16) % (1U << 8);
645 out++;
646 *out = (inl >> 24);
647 ++in;
648 inl = util::SafeLoad(in);
649 inl = arrow::BitUtil::FromLittleEndian(inl);
650 out++;
651 *out = (inl >> 0) % (1U << 8);
652 out++;
653 *out = (inl >> 8) % (1U << 8);
654 out++;
655 *out = (inl >> 16) % (1U << 8);
656 out++;
657 *out = (inl >> 24);
658 ++in;
659 inl = util::SafeLoad(in);
660 inl = arrow::BitUtil::FromLittleEndian(inl);
661 out++;
662 *out = (inl >> 0) % (1U << 8);
663 out++;
664 *out = (inl >> 8) % (1U << 8);
665 out++;
666 *out = (inl >> 16) % (1U << 8);
667 out++;
668 *out = (inl >> 24);
669 ++in;
670 inl = util::SafeLoad(in);
671 inl = arrow::BitUtil::FromLittleEndian(inl);
672 out++;
673 *out = (inl >> 0) % (1U << 8);
674 out++;
675 *out = (inl >> 8) % (1U << 8);
676 out++;
677 *out = (inl >> 16) % (1U << 8);
678 out++;
679 *out = (inl >> 24);
680 ++in;
681 inl = util::SafeLoad(in);
682 inl = arrow::BitUtil::FromLittleEndian(inl);
683 out++;
684 *out = (inl >> 0) % (1U << 8);
685 out++;
686 *out = (inl >> 8) % (1U << 8);
687 out++;
688 *out = (inl >> 16) % (1U << 8);
689 out++;
690 *out = (inl >> 24);
691 ++in;
692 inl = util::SafeLoad(in);
693 inl = arrow::BitUtil::FromLittleEndian(inl);
694 out++;
695 *out = (inl >> 0) % (1U << 8);
696 out++;
697 *out = (inl >> 8) % (1U << 8);
698 out++;
699 *out = (inl >> 16) % (1U << 8);
700 out++;
701 *out = (inl >> 24);
702 ++in;
703 out++;
704
705 return in;
706 }
707
unpack9_32(const uint32_t * in,uint32_t * out)708 inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
709 uint32_t inl = util::SafeLoad(in);
710 inl = arrow::BitUtil::FromLittleEndian(inl);
711 *out = (inl >> 0) % (1U << 9);
712 out++;
713 *out = (inl >> 9) % (1U << 9);
714 out++;
715 *out = (inl >> 18) % (1U << 9);
716 out++;
717 *out = (inl >> 27);
718 ++in;
719 inl = util::SafeLoad(in);
720 inl = arrow::BitUtil::FromLittleEndian(inl);
721 *out |= (inl % (1U << 4)) << (9 - 4);
722 out++;
723 *out = (inl >> 4) % (1U << 9);
724 out++;
725 *out = (inl >> 13) % (1U << 9);
726 out++;
727 *out = (inl >> 22) % (1U << 9);
728 out++;
729 *out = (inl >> 31);
730 ++in;
731 inl = util::SafeLoad(in);
732 inl = arrow::BitUtil::FromLittleEndian(inl);
733 *out |= (inl % (1U << 8)) << (9 - 8);
734 out++;
735 *out = (inl >> 8) % (1U << 9);
736 out++;
737 *out = (inl >> 17) % (1U << 9);
738 out++;
739 *out = (inl >> 26);
740 ++in;
741 inl = util::SafeLoad(in);
742 inl = arrow::BitUtil::FromLittleEndian(inl);
743 *out |= (inl % (1U << 3)) << (9 - 3);
744 out++;
745 *out = (inl >> 3) % (1U << 9);
746 out++;
747 *out = (inl >> 12) % (1U << 9);
748 out++;
749 *out = (inl >> 21) % (1U << 9);
750 out++;
751 *out = (inl >> 30);
752 ++in;
753 inl = util::SafeLoad(in);
754 inl = arrow::BitUtil::FromLittleEndian(inl);
755 *out |= (inl % (1U << 7)) << (9 - 7);
756 out++;
757 *out = (inl >> 7) % (1U << 9);
758 out++;
759 *out = (inl >> 16) % (1U << 9);
760 out++;
761 *out = (inl >> 25);
762 ++in;
763 inl = util::SafeLoad(in);
764 inl = arrow::BitUtil::FromLittleEndian(inl);
765 *out |= (inl % (1U << 2)) << (9 - 2);
766 out++;
767 *out = (inl >> 2) % (1U << 9);
768 out++;
769 *out = (inl >> 11) % (1U << 9);
770 out++;
771 *out = (inl >> 20) % (1U << 9);
772 out++;
773 *out = (inl >> 29);
774 ++in;
775 inl = util::SafeLoad(in);
776 inl = arrow::BitUtil::FromLittleEndian(inl);
777 *out |= (inl % (1U << 6)) << (9 - 6);
778 out++;
779 *out = (inl >> 6) % (1U << 9);
780 out++;
781 *out = (inl >> 15) % (1U << 9);
782 out++;
783 *out = (inl >> 24);
784 ++in;
785 inl = util::SafeLoad(in);
786 inl = arrow::BitUtil::FromLittleEndian(inl);
787 *out |= (inl % (1U << 1)) << (9 - 1);
788 out++;
789 *out = (inl >> 1) % (1U << 9);
790 out++;
791 *out = (inl >> 10) % (1U << 9);
792 out++;
793 *out = (inl >> 19) % (1U << 9);
794 out++;
795 *out = (inl >> 28);
796 ++in;
797 inl = util::SafeLoad(in);
798 inl = arrow::BitUtil::FromLittleEndian(inl);
799 *out |= (inl % (1U << 5)) << (9 - 5);
800 out++;
801 *out = (inl >> 5) % (1U << 9);
802 out++;
803 *out = (inl >> 14) % (1U << 9);
804 out++;
805 *out = (inl >> 23);
806 ++in;
807 out++;
808
809 return in;
810 }
811
unpack10_32(const uint32_t * in,uint32_t * out)812 inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
813 uint32_t inl = util::SafeLoad(in);
814 inl = arrow::BitUtil::FromLittleEndian(inl);
815 *out = (inl >> 0) % (1U << 10);
816 out++;
817 *out = (inl >> 10) % (1U << 10);
818 out++;
819 *out = (inl >> 20) % (1U << 10);
820 out++;
821 *out = (inl >> 30);
822 ++in;
823 inl = util::SafeLoad(in);
824 inl = arrow::BitUtil::FromLittleEndian(inl);
825 *out |= (inl % (1U << 8)) << (10 - 8);
826 out++;
827 *out = (inl >> 8) % (1U << 10);
828 out++;
829 *out = (inl >> 18) % (1U << 10);
830 out++;
831 *out = (inl >> 28);
832 ++in;
833 inl = util::SafeLoad(in);
834 inl = arrow::BitUtil::FromLittleEndian(inl);
835 *out |= (inl % (1U << 6)) << (10 - 6);
836 out++;
837 *out = (inl >> 6) % (1U << 10);
838 out++;
839 *out = (inl >> 16) % (1U << 10);
840 out++;
841 *out = (inl >> 26);
842 ++in;
843 inl = util::SafeLoad(in);
844 inl = arrow::BitUtil::FromLittleEndian(inl);
845 *out |= (inl % (1U << 4)) << (10 - 4);
846 out++;
847 *out = (inl >> 4) % (1U << 10);
848 out++;
849 *out = (inl >> 14) % (1U << 10);
850 out++;
851 *out = (inl >> 24);
852 ++in;
853 inl = util::SafeLoad(in);
854 inl = arrow::BitUtil::FromLittleEndian(inl);
855 *out |= (inl % (1U << 2)) << (10 - 2);
856 out++;
857 *out = (inl >> 2) % (1U << 10);
858 out++;
859 *out = (inl >> 12) % (1U << 10);
860 out++;
861 *out = (inl >> 22);
862 ++in;
863 inl = util::SafeLoad(in);
864 inl = arrow::BitUtil::FromLittleEndian(inl);
865 out++;
866 *out = (inl >> 0) % (1U << 10);
867 out++;
868 *out = (inl >> 10) % (1U << 10);
869 out++;
870 *out = (inl >> 20) % (1U << 10);
871 out++;
872 *out = (inl >> 30);
873 ++in;
874 inl = util::SafeLoad(in);
875 inl = arrow::BitUtil::FromLittleEndian(inl);
876 *out |= (inl % (1U << 8)) << (10 - 8);
877 out++;
878 *out = (inl >> 8) % (1U << 10);
879 out++;
880 *out = (inl >> 18) % (1U << 10);
881 out++;
882 *out = (inl >> 28);
883 ++in;
884 inl = util::SafeLoad(in);
885 inl = arrow::BitUtil::FromLittleEndian(inl);
886 *out |= (inl % (1U << 6)) << (10 - 6);
887 out++;
888 *out = (inl >> 6) % (1U << 10);
889 out++;
890 *out = (inl >> 16) % (1U << 10);
891 out++;
892 *out = (inl >> 26);
893 ++in;
894 inl = util::SafeLoad(in);
895 inl = arrow::BitUtil::FromLittleEndian(inl);
896 *out |= (inl % (1U << 4)) << (10 - 4);
897 out++;
898 *out = (inl >> 4) % (1U << 10);
899 out++;
900 *out = (inl >> 14) % (1U << 10);
901 out++;
902 *out = (inl >> 24);
903 ++in;
904 inl = util::SafeLoad(in);
905 inl = arrow::BitUtil::FromLittleEndian(inl);
906 *out |= (inl % (1U << 2)) << (10 - 2);
907 out++;
908 *out = (inl >> 2) % (1U << 10);
909 out++;
910 *out = (inl >> 12) % (1U << 10);
911 out++;
912 *out = (inl >> 22);
913 ++in;
914 out++;
915
916 return in;
917 }
918
unpack11_32(const uint32_t * in,uint32_t * out)919 inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
920 uint32_t inl = util::SafeLoad(in);
921 inl = arrow::BitUtil::FromLittleEndian(inl);
922 *out = (inl >> 0) % (1U << 11);
923 out++;
924 *out = (inl >> 11) % (1U << 11);
925 out++;
926 *out = (inl >> 22);
927 ++in;
928 inl = util::SafeLoad(in);
929 inl = arrow::BitUtil::FromLittleEndian(inl);
930 *out |= (inl % (1U << 1)) << (11 - 1);
931 out++;
932 *out = (inl >> 1) % (1U << 11);
933 out++;
934 *out = (inl >> 12) % (1U << 11);
935 out++;
936 *out = (inl >> 23);
937 ++in;
938 inl = util::SafeLoad(in);
939 inl = arrow::BitUtil::FromLittleEndian(inl);
940 *out |= (inl % (1U << 2)) << (11 - 2);
941 out++;
942 *out = (inl >> 2) % (1U << 11);
943 out++;
944 *out = (inl >> 13) % (1U << 11);
945 out++;
946 *out = (inl >> 24);
947 ++in;
948 inl = util::SafeLoad(in);
949 inl = arrow::BitUtil::FromLittleEndian(inl);
950 *out |= (inl % (1U << 3)) << (11 - 3);
951 out++;
952 *out = (inl >> 3) % (1U << 11);
953 out++;
954 *out = (inl >> 14) % (1U << 11);
955 out++;
956 *out = (inl >> 25);
957 ++in;
958 inl = util::SafeLoad(in);
959 inl = arrow::BitUtil::FromLittleEndian(inl);
960 *out |= (inl % (1U << 4)) << (11 - 4);
961 out++;
962 *out = (inl >> 4) % (1U << 11);
963 out++;
964 *out = (inl >> 15) % (1U << 11);
965 out++;
966 *out = (inl >> 26);
967 ++in;
968 inl = util::SafeLoad(in);
969 inl = arrow::BitUtil::FromLittleEndian(inl);
970 *out |= (inl % (1U << 5)) << (11 - 5);
971 out++;
972 *out = (inl >> 5) % (1U << 11);
973 out++;
974 *out = (inl >> 16) % (1U << 11);
975 out++;
976 *out = (inl >> 27);
977 ++in;
978 inl = util::SafeLoad(in);
979 inl = arrow::BitUtil::FromLittleEndian(inl);
980 *out |= (inl % (1U << 6)) << (11 - 6);
981 out++;
982 *out = (inl >> 6) % (1U << 11);
983 out++;
984 *out = (inl >> 17) % (1U << 11);
985 out++;
986 *out = (inl >> 28);
987 ++in;
988 inl = util::SafeLoad(in);
989 inl = arrow::BitUtil::FromLittleEndian(inl);
990 *out |= (inl % (1U << 7)) << (11 - 7);
991 out++;
992 *out = (inl >> 7) % (1U << 11);
993 out++;
994 *out = (inl >> 18) % (1U << 11);
995 out++;
996 *out = (inl >> 29);
997 ++in;
998 inl = util::SafeLoad(in);
999 inl = arrow::BitUtil::FromLittleEndian(inl);
1000 *out |= (inl % (1U << 8)) << (11 - 8);
1001 out++;
1002 *out = (inl >> 8) % (1U << 11);
1003 out++;
1004 *out = (inl >> 19) % (1U << 11);
1005 out++;
1006 *out = (inl >> 30);
1007 ++in;
1008 inl = util::SafeLoad(in);
1009 inl = arrow::BitUtil::FromLittleEndian(inl);
1010 *out |= (inl % (1U << 9)) << (11 - 9);
1011 out++;
1012 *out = (inl >> 9) % (1U << 11);
1013 out++;
1014 *out = (inl >> 20) % (1U << 11);
1015 out++;
1016 *out = (inl >> 31);
1017 ++in;
1018 inl = util::SafeLoad(in);
1019 inl = arrow::BitUtil::FromLittleEndian(inl);
1020 *out |= (inl % (1U << 10)) << (11 - 10);
1021 out++;
1022 *out = (inl >> 10) % (1U << 11);
1023 out++;
1024 *out = (inl >> 21);
1025 ++in;
1026 out++;
1027
1028 return in;
1029 }
1030
unpack12_32(const uint32_t * in,uint32_t * out)1031 inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
1032 uint32_t inl = util::SafeLoad(in);
1033 inl = arrow::BitUtil::FromLittleEndian(inl);
1034 *out = (inl >> 0) % (1U << 12);
1035 out++;
1036 *out = (inl >> 12) % (1U << 12);
1037 out++;
1038 *out = (inl >> 24);
1039 ++in;
1040 inl = util::SafeLoad(in);
1041 inl = arrow::BitUtil::FromLittleEndian(inl);
1042 *out |= (inl % (1U << 4)) << (12 - 4);
1043 out++;
1044 *out = (inl >> 4) % (1U << 12);
1045 out++;
1046 *out = (inl >> 16) % (1U << 12);
1047 out++;
1048 *out = (inl >> 28);
1049 ++in;
1050 inl = util::SafeLoad(in);
1051 inl = arrow::BitUtil::FromLittleEndian(inl);
1052 *out |= (inl % (1U << 8)) << (12 - 8);
1053 out++;
1054 *out = (inl >> 8) % (1U << 12);
1055 out++;
1056 *out = (inl >> 20);
1057 ++in;
1058 inl = util::SafeLoad(in);
1059 inl = arrow::BitUtil::FromLittleEndian(inl);
1060 out++;
1061 *out = (inl >> 0) % (1U << 12);
1062 out++;
1063 *out = (inl >> 12) % (1U << 12);
1064 out++;
1065 *out = (inl >> 24);
1066 ++in;
1067 inl = util::SafeLoad(in);
1068 inl = arrow::BitUtil::FromLittleEndian(inl);
1069 *out |= (inl % (1U << 4)) << (12 - 4);
1070 out++;
1071 *out = (inl >> 4) % (1U << 12);
1072 out++;
1073 *out = (inl >> 16) % (1U << 12);
1074 out++;
1075 *out = (inl >> 28);
1076 ++in;
1077 inl = util::SafeLoad(in);
1078 inl = arrow::BitUtil::FromLittleEndian(inl);
1079 *out |= (inl % (1U << 8)) << (12 - 8);
1080 out++;
1081 *out = (inl >> 8) % (1U << 12);
1082 out++;
1083 *out = (inl >> 20);
1084 ++in;
1085 inl = util::SafeLoad(in);
1086 inl = arrow::BitUtil::FromLittleEndian(inl);
1087 out++;
1088 *out = (inl >> 0) % (1U << 12);
1089 out++;
1090 *out = (inl >> 12) % (1U << 12);
1091 out++;
1092 *out = (inl >> 24);
1093 ++in;
1094 inl = util::SafeLoad(in);
1095 inl = arrow::BitUtil::FromLittleEndian(inl);
1096 *out |= (inl % (1U << 4)) << (12 - 4);
1097 out++;
1098 *out = (inl >> 4) % (1U << 12);
1099 out++;
1100 *out = (inl >> 16) % (1U << 12);
1101 out++;
1102 *out = (inl >> 28);
1103 ++in;
1104 inl = util::SafeLoad(in);
1105 inl = arrow::BitUtil::FromLittleEndian(inl);
1106 *out |= (inl % (1U << 8)) << (12 - 8);
1107 out++;
1108 *out = (inl >> 8) % (1U << 12);
1109 out++;
1110 *out = (inl >> 20);
1111 ++in;
1112 inl = util::SafeLoad(in);
1113 inl = arrow::BitUtil::FromLittleEndian(inl);
1114 out++;
1115 *out = (inl >> 0) % (1U << 12);
1116 out++;
1117 *out = (inl >> 12) % (1U << 12);
1118 out++;
1119 *out = (inl >> 24);
1120 ++in;
1121 inl = util::SafeLoad(in);
1122 inl = arrow::BitUtil::FromLittleEndian(inl);
1123 *out |= (inl % (1U << 4)) << (12 - 4);
1124 out++;
1125 *out = (inl >> 4) % (1U << 12);
1126 out++;
1127 *out = (inl >> 16) % (1U << 12);
1128 out++;
1129 *out = (inl >> 28);
1130 ++in;
1131 inl = util::SafeLoad(in);
1132 inl = arrow::BitUtil::FromLittleEndian(inl);
1133 *out |= (inl % (1U << 8)) << (12 - 8);
1134 out++;
1135 *out = (inl >> 8) % (1U << 12);
1136 out++;
1137 *out = (inl >> 20);
1138 ++in;
1139 out++;
1140
1141 return in;
1142 }
1143
unpack13_32(const uint32_t * in,uint32_t * out)1144 inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
1145 uint32_t inl = util::SafeLoad(in);
1146 inl = arrow::BitUtil::FromLittleEndian(inl);
1147 *out = (inl >> 0) % (1U << 13);
1148 out++;
1149 *out = (inl >> 13) % (1U << 13);
1150 out++;
1151 *out = (inl >> 26);
1152 ++in;
1153 inl = util::SafeLoad(in);
1154 inl = arrow::BitUtil::FromLittleEndian(inl);
1155 *out |= (inl % (1U << 7)) << (13 - 7);
1156 out++;
1157 *out = (inl >> 7) % (1U << 13);
1158 out++;
1159 *out = (inl >> 20);
1160 ++in;
1161 inl = util::SafeLoad(in);
1162 inl = arrow::BitUtil::FromLittleEndian(inl);
1163 *out |= (inl % (1U << 1)) << (13 - 1);
1164 out++;
1165 *out = (inl >> 1) % (1U << 13);
1166 out++;
1167 *out = (inl >> 14) % (1U << 13);
1168 out++;
1169 *out = (inl >> 27);
1170 ++in;
1171 inl = util::SafeLoad(in);
1172 inl = arrow::BitUtil::FromLittleEndian(inl);
1173 *out |= (inl % (1U << 8)) << (13 - 8);
1174 out++;
1175 *out = (inl >> 8) % (1U << 13);
1176 out++;
1177 *out = (inl >> 21);
1178 ++in;
1179 inl = util::SafeLoad(in);
1180 inl = arrow::BitUtil::FromLittleEndian(inl);
1181 *out |= (inl % (1U << 2)) << (13 - 2);
1182 out++;
1183 *out = (inl >> 2) % (1U << 13);
1184 out++;
1185 *out = (inl >> 15) % (1U << 13);
1186 out++;
1187 *out = (inl >> 28);
1188 ++in;
1189 inl = util::SafeLoad(in);
1190 inl = arrow::BitUtil::FromLittleEndian(inl);
1191 *out |= (inl % (1U << 9)) << (13 - 9);
1192 out++;
1193 *out = (inl >> 9) % (1U << 13);
1194 out++;
1195 *out = (inl >> 22);
1196 ++in;
1197 inl = util::SafeLoad(in);
1198 inl = arrow::BitUtil::FromLittleEndian(inl);
1199 *out |= (inl % (1U << 3)) << (13 - 3);
1200 out++;
1201 *out = (inl >> 3) % (1U << 13);
1202 out++;
1203 *out = (inl >> 16) % (1U << 13);
1204 out++;
1205 *out = (inl >> 29);
1206 ++in;
1207 inl = util::SafeLoad(in);
1208 inl = arrow::BitUtil::FromLittleEndian(inl);
1209 *out |= (inl % (1U << 10)) << (13 - 10);
1210 out++;
1211 *out = (inl >> 10) % (1U << 13);
1212 out++;
1213 *out = (inl >> 23);
1214 ++in;
1215 inl = util::SafeLoad(in);
1216 inl = arrow::BitUtil::FromLittleEndian(inl);
1217 *out |= (inl % (1U << 4)) << (13 - 4);
1218 out++;
1219 *out = (inl >> 4) % (1U << 13);
1220 out++;
1221 *out = (inl >> 17) % (1U << 13);
1222 out++;
1223 *out = (inl >> 30);
1224 ++in;
1225 inl = util::SafeLoad(in);
1226 inl = arrow::BitUtil::FromLittleEndian(inl);
1227 *out |= (inl % (1U << 11)) << (13 - 11);
1228 out++;
1229 *out = (inl >> 11) % (1U << 13);
1230 out++;
1231 *out = (inl >> 24);
1232 ++in;
1233 inl = util::SafeLoad(in);
1234 inl = arrow::BitUtil::FromLittleEndian(inl);
1235 *out |= (inl % (1U << 5)) << (13 - 5);
1236 out++;
1237 *out = (inl >> 5) % (1U << 13);
1238 out++;
1239 *out = (inl >> 18) % (1U << 13);
1240 out++;
1241 *out = (inl >> 31);
1242 ++in;
1243 inl = util::SafeLoad(in);
1244 inl = arrow::BitUtil::FromLittleEndian(inl);
1245 *out |= (inl % (1U << 12)) << (13 - 12);
1246 out++;
1247 *out = (inl >> 12) % (1U << 13);
1248 out++;
1249 *out = (inl >> 25);
1250 ++in;
1251 inl = util::SafeLoad(in);
1252 inl = arrow::BitUtil::FromLittleEndian(inl);
1253 *out |= (inl % (1U << 6)) << (13 - 6);
1254 out++;
1255 *out = (inl >> 6) % (1U << 13);
1256 out++;
1257 *out = (inl >> 19);
1258 ++in;
1259 out++;
1260
1261 return in;
1262 }
1263
unpack14_32(const uint32_t * in,uint32_t * out)1264 inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
1265 uint32_t inl = util::SafeLoad(in);
1266 inl = arrow::BitUtil::FromLittleEndian(inl);
1267 *out = (inl >> 0) % (1U << 14);
1268 out++;
1269 *out = (inl >> 14) % (1U << 14);
1270 out++;
1271 *out = (inl >> 28);
1272 ++in;
1273 inl = util::SafeLoad(in);
1274 inl = arrow::BitUtil::FromLittleEndian(inl);
1275 *out |= (inl % (1U << 10)) << (14 - 10);
1276 out++;
1277 *out = (inl >> 10) % (1U << 14);
1278 out++;
1279 *out = (inl >> 24);
1280 ++in;
1281 inl = util::SafeLoad(in);
1282 inl = arrow::BitUtil::FromLittleEndian(inl);
1283 *out |= (inl % (1U << 6)) << (14 - 6);
1284 out++;
1285 *out = (inl >> 6) % (1U << 14);
1286 out++;
1287 *out = (inl >> 20);
1288 ++in;
1289 inl = util::SafeLoad(in);
1290 inl = arrow::BitUtil::FromLittleEndian(inl);
1291 *out |= (inl % (1U << 2)) << (14 - 2);
1292 out++;
1293 *out = (inl >> 2) % (1U << 14);
1294 out++;
1295 *out = (inl >> 16) % (1U << 14);
1296 out++;
1297 *out = (inl >> 30);
1298 ++in;
1299 inl = util::SafeLoad(in);
1300 inl = arrow::BitUtil::FromLittleEndian(inl);
1301 *out |= (inl % (1U << 12)) << (14 - 12);
1302 out++;
1303 *out = (inl >> 12) % (1U << 14);
1304 out++;
1305 *out = (inl >> 26);
1306 ++in;
1307 inl = util::SafeLoad(in);
1308 inl = arrow::BitUtil::FromLittleEndian(inl);
1309 *out |= (inl % (1U << 8)) << (14 - 8);
1310 out++;
1311 *out = (inl >> 8) % (1U << 14);
1312 out++;
1313 *out = (inl >> 22);
1314 ++in;
1315 inl = util::SafeLoad(in);
1316 inl = arrow::BitUtil::FromLittleEndian(inl);
1317 *out |= (inl % (1U << 4)) << (14 - 4);
1318 out++;
1319 *out = (inl >> 4) % (1U << 14);
1320 out++;
1321 *out = (inl >> 18);
1322 ++in;
1323 inl = util::SafeLoad(in);
1324 inl = arrow::BitUtil::FromLittleEndian(inl);
1325 out++;
1326 *out = (inl >> 0) % (1U << 14);
1327 out++;
1328 *out = (inl >> 14) % (1U << 14);
1329 out++;
1330 *out = (inl >> 28);
1331 ++in;
1332 inl = util::SafeLoad(in);
1333 inl = arrow::BitUtil::FromLittleEndian(inl);
1334 *out |= (inl % (1U << 10)) << (14 - 10);
1335 out++;
1336 *out = (inl >> 10) % (1U << 14);
1337 out++;
1338 *out = (inl >> 24);
1339 ++in;
1340 inl = util::SafeLoad(in);
1341 inl = arrow::BitUtil::FromLittleEndian(inl);
1342 *out |= (inl % (1U << 6)) << (14 - 6);
1343 out++;
1344 *out = (inl >> 6) % (1U << 14);
1345 out++;
1346 *out = (inl >> 20);
1347 ++in;
1348 inl = util::SafeLoad(in);
1349 inl = arrow::BitUtil::FromLittleEndian(inl);
1350 *out |= (inl % (1U << 2)) << (14 - 2);
1351 out++;
1352 *out = (inl >> 2) % (1U << 14);
1353 out++;
1354 *out = (inl >> 16) % (1U << 14);
1355 out++;
1356 *out = (inl >> 30);
1357 ++in;
1358 inl = util::SafeLoad(in);
1359 inl = arrow::BitUtil::FromLittleEndian(inl);
1360 *out |= (inl % (1U << 12)) << (14 - 12);
1361 out++;
1362 *out = (inl >> 12) % (1U << 14);
1363 out++;
1364 *out = (inl >> 26);
1365 ++in;
1366 inl = util::SafeLoad(in);
1367 inl = arrow::BitUtil::FromLittleEndian(inl);
1368 *out |= (inl % (1U << 8)) << (14 - 8);
1369 out++;
1370 *out = (inl >> 8) % (1U << 14);
1371 out++;
1372 *out = (inl >> 22);
1373 ++in;
1374 inl = util::SafeLoad(in);
1375 inl = arrow::BitUtil::FromLittleEndian(inl);
1376 *out |= (inl % (1U << 4)) << (14 - 4);
1377 out++;
1378 *out = (inl >> 4) % (1U << 14);
1379 out++;
1380 *out = (inl >> 18);
1381 ++in;
1382 out++;
1383
1384 return in;
1385 }
1386
unpack15_32(const uint32_t * in,uint32_t * out)1387 inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
1388 uint32_t inl = util::SafeLoad(in);
1389 inl = arrow::BitUtil::FromLittleEndian(inl);
1390 *out = (inl >> 0) % (1U << 15);
1391 out++;
1392 *out = (inl >> 15) % (1U << 15);
1393 out++;
1394 *out = (inl >> 30);
1395 ++in;
1396 inl = util::SafeLoad(in);
1397 inl = arrow::BitUtil::FromLittleEndian(inl);
1398 *out |= (inl % (1U << 13)) << (15 - 13);
1399 out++;
1400 *out = (inl >> 13) % (1U << 15);
1401 out++;
1402 *out = (inl >> 28);
1403 ++in;
1404 inl = util::SafeLoad(in);
1405 inl = arrow::BitUtil::FromLittleEndian(inl);
1406 *out |= (inl % (1U << 11)) << (15 - 11);
1407 out++;
1408 *out = (inl >> 11) % (1U << 15);
1409 out++;
1410 *out = (inl >> 26);
1411 ++in;
1412 inl = util::SafeLoad(in);
1413 inl = arrow::BitUtil::FromLittleEndian(inl);
1414 *out |= (inl % (1U << 9)) << (15 - 9);
1415 out++;
1416 *out = (inl >> 9) % (1U << 15);
1417 out++;
1418 *out = (inl >> 24);
1419 ++in;
1420 inl = util::SafeLoad(in);
1421 inl = arrow::BitUtil::FromLittleEndian(inl);
1422 *out |= (inl % (1U << 7)) << (15 - 7);
1423 out++;
1424 *out = (inl >> 7) % (1U << 15);
1425 out++;
1426 *out = (inl >> 22);
1427 ++in;
1428 inl = util::SafeLoad(in);
1429 inl = arrow::BitUtil::FromLittleEndian(inl);
1430 *out |= (inl % (1U << 5)) << (15 - 5);
1431 out++;
1432 *out = (inl >> 5) % (1U << 15);
1433 out++;
1434 *out = (inl >> 20);
1435 ++in;
1436 inl = util::SafeLoad(in);
1437 inl = arrow::BitUtil::FromLittleEndian(inl);
1438 *out |= (inl % (1U << 3)) << (15 - 3);
1439 out++;
1440 *out = (inl >> 3) % (1U << 15);
1441 out++;
1442 *out = (inl >> 18);
1443 ++in;
1444 inl = util::SafeLoad(in);
1445 inl = arrow::BitUtil::FromLittleEndian(inl);
1446 *out |= (inl % (1U << 1)) << (15 - 1);
1447 out++;
1448 *out = (inl >> 1) % (1U << 15);
1449 out++;
1450 *out = (inl >> 16) % (1U << 15);
1451 out++;
1452 *out = (inl >> 31);
1453 ++in;
1454 inl = util::SafeLoad(in);
1455 inl = arrow::BitUtil::FromLittleEndian(inl);
1456 *out |= (inl % (1U << 14)) << (15 - 14);
1457 out++;
1458 *out = (inl >> 14) % (1U << 15);
1459 out++;
1460 *out = (inl >> 29);
1461 ++in;
1462 inl = util::SafeLoad(in);
1463 inl = arrow::BitUtil::FromLittleEndian(inl);
1464 *out |= (inl % (1U << 12)) << (15 - 12);
1465 out++;
1466 *out = (inl >> 12) % (1U << 15);
1467 out++;
1468 *out = (inl >> 27);
1469 ++in;
1470 inl = util::SafeLoad(in);
1471 inl = arrow::BitUtil::FromLittleEndian(inl);
1472 *out |= (inl % (1U << 10)) << (15 - 10);
1473 out++;
1474 *out = (inl >> 10) % (1U << 15);
1475 out++;
1476 *out = (inl >> 25);
1477 ++in;
1478 inl = util::SafeLoad(in);
1479 inl = arrow::BitUtil::FromLittleEndian(inl);
1480 *out |= (inl % (1U << 8)) << (15 - 8);
1481 out++;
1482 *out = (inl >> 8) % (1U << 15);
1483 out++;
1484 *out = (inl >> 23);
1485 ++in;
1486 inl = util::SafeLoad(in);
1487 inl = arrow::BitUtil::FromLittleEndian(inl);
1488 *out |= (inl % (1U << 6)) << (15 - 6);
1489 out++;
1490 *out = (inl >> 6) % (1U << 15);
1491 out++;
1492 *out = (inl >> 21);
1493 ++in;
1494 inl = util::SafeLoad(in);
1495 inl = arrow::BitUtil::FromLittleEndian(inl);
1496 *out |= (inl % (1U << 4)) << (15 - 4);
1497 out++;
1498 *out = (inl >> 4) % (1U << 15);
1499 out++;
1500 *out = (inl >> 19);
1501 ++in;
1502 inl = util::SafeLoad(in);
1503 inl = arrow::BitUtil::FromLittleEndian(inl);
1504 *out |= (inl % (1U << 2)) << (15 - 2);
1505 out++;
1506 *out = (inl >> 2) % (1U << 15);
1507 out++;
1508 *out = (inl >> 17);
1509 ++in;
1510 out++;
1511
1512 return in;
1513 }
1514
unpack16_32(const uint32_t * in,uint32_t * out)1515 inline const uint32_t* unpack16_32(const uint32_t* in, uint32_t* out) {
1516 uint32_t inl = util::SafeLoad(in);
1517 inl = arrow::BitUtil::FromLittleEndian(inl);
1518 *out = (inl >> 0) % (1U << 16);
1519 out++;
1520 *out = (inl >> 16);
1521 ++in;
1522 inl = util::SafeLoad(in);
1523 inl = arrow::BitUtil::FromLittleEndian(inl);
1524 out++;
1525 *out = (inl >> 0) % (1U << 16);
1526 out++;
1527 *out = (inl >> 16);
1528 ++in;
1529 inl = util::SafeLoad(in);
1530 inl = arrow::BitUtil::FromLittleEndian(inl);
1531 out++;
1532 *out = (inl >> 0) % (1U << 16);
1533 out++;
1534 *out = (inl >> 16);
1535 ++in;
1536 inl = util::SafeLoad(in);
1537 inl = arrow::BitUtil::FromLittleEndian(inl);
1538 out++;
1539 *out = (inl >> 0) % (1U << 16);
1540 out++;
1541 *out = (inl >> 16);
1542 ++in;
1543 inl = util::SafeLoad(in);
1544 inl = arrow::BitUtil::FromLittleEndian(inl);
1545 out++;
1546 *out = (inl >> 0) % (1U << 16);
1547 out++;
1548 *out = (inl >> 16);
1549 ++in;
1550 inl = util::SafeLoad(in);
1551 inl = arrow::BitUtil::FromLittleEndian(inl);
1552 out++;
1553 *out = (inl >> 0) % (1U << 16);
1554 out++;
1555 *out = (inl >> 16);
1556 ++in;
1557 inl = util::SafeLoad(in);
1558 inl = arrow::BitUtil::FromLittleEndian(inl);
1559 out++;
1560 *out = (inl >> 0) % (1U << 16);
1561 out++;
1562 *out = (inl >> 16);
1563 ++in;
1564 inl = util::SafeLoad(in);
1565 inl = arrow::BitUtil::FromLittleEndian(inl);
1566 out++;
1567 *out = (inl >> 0) % (1U << 16);
1568 out++;
1569 *out = (inl >> 16);
1570 ++in;
1571 inl = util::SafeLoad(in);
1572 inl = arrow::BitUtil::FromLittleEndian(inl);
1573 out++;
1574 *out = (inl >> 0) % (1U << 16);
1575 out++;
1576 *out = (inl >> 16);
1577 ++in;
1578 inl = util::SafeLoad(in);
1579 inl = arrow::BitUtil::FromLittleEndian(inl);
1580 out++;
1581 *out = (inl >> 0) % (1U << 16);
1582 out++;
1583 *out = (inl >> 16);
1584 ++in;
1585 inl = util::SafeLoad(in);
1586 inl = arrow::BitUtil::FromLittleEndian(inl);
1587 out++;
1588 *out = (inl >> 0) % (1U << 16);
1589 out++;
1590 *out = (inl >> 16);
1591 ++in;
1592 inl = util::SafeLoad(in);
1593 inl = arrow::BitUtil::FromLittleEndian(inl);
1594 out++;
1595 *out = (inl >> 0) % (1U << 16);
1596 out++;
1597 *out = (inl >> 16);
1598 ++in;
1599 inl = util::SafeLoad(in);
1600 inl = arrow::BitUtil::FromLittleEndian(inl);
1601 out++;
1602 *out = (inl >> 0) % (1U << 16);
1603 out++;
1604 *out = (inl >> 16);
1605 ++in;
1606 inl = util::SafeLoad(in);
1607 inl = arrow::BitUtil::FromLittleEndian(inl);
1608 out++;
1609 *out = (inl >> 0) % (1U << 16);
1610 out++;
1611 *out = (inl >> 16);
1612 ++in;
1613 inl = util::SafeLoad(in);
1614 inl = arrow::BitUtil::FromLittleEndian(inl);
1615 out++;
1616 *out = (inl >> 0) % (1U << 16);
1617 out++;
1618 *out = (inl >> 16);
1619 ++in;
1620 inl = util::SafeLoad(in);
1621 inl = arrow::BitUtil::FromLittleEndian(inl);
1622 out++;
1623 *out = (inl >> 0) % (1U << 16);
1624 out++;
1625 *out = (inl >> 16);
1626 ++in;
1627 out++;
1628
1629 return in;
1630 }
1631
unpack17_32(const uint32_t * in,uint32_t * out)1632 inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
1633 uint32_t inl = util::SafeLoad(in);
1634 inl = arrow::BitUtil::FromLittleEndian(inl);
1635 *out = (inl >> 0) % (1U << 17);
1636 out++;
1637 *out = (inl >> 17);
1638 ++in;
1639 inl = util::SafeLoad(in);
1640 inl = arrow::BitUtil::FromLittleEndian(inl);
1641 *out |= (inl % (1U << 2)) << (17 - 2);
1642 out++;
1643 *out = (inl >> 2) % (1U << 17);
1644 out++;
1645 *out = (inl >> 19);
1646 ++in;
1647 inl = util::SafeLoad(in);
1648 inl = arrow::BitUtil::FromLittleEndian(inl);
1649 *out |= (inl % (1U << 4)) << (17 - 4);
1650 out++;
1651 *out = (inl >> 4) % (1U << 17);
1652 out++;
1653 *out = (inl >> 21);
1654 ++in;
1655 inl = util::SafeLoad(in);
1656 inl = arrow::BitUtil::FromLittleEndian(inl);
1657 *out |= (inl % (1U << 6)) << (17 - 6);
1658 out++;
1659 *out = (inl >> 6) % (1U << 17);
1660 out++;
1661 *out = (inl >> 23);
1662 ++in;
1663 inl = util::SafeLoad(in);
1664 inl = arrow::BitUtil::FromLittleEndian(inl);
1665 *out |= (inl % (1U << 8)) << (17 - 8);
1666 out++;
1667 *out = (inl >> 8) % (1U << 17);
1668 out++;
1669 *out = (inl >> 25);
1670 ++in;
1671 inl = util::SafeLoad(in);
1672 inl = arrow::BitUtil::FromLittleEndian(inl);
1673 *out |= (inl % (1U << 10)) << (17 - 10);
1674 out++;
1675 *out = (inl >> 10) % (1U << 17);
1676 out++;
1677 *out = (inl >> 27);
1678 ++in;
1679 inl = util::SafeLoad(in);
1680 inl = arrow::BitUtil::FromLittleEndian(inl);
1681 *out |= (inl % (1U << 12)) << (17 - 12);
1682 out++;
1683 *out = (inl >> 12) % (1U << 17);
1684 out++;
1685 *out = (inl >> 29);
1686 ++in;
1687 inl = util::SafeLoad(in);
1688 inl = arrow::BitUtil::FromLittleEndian(inl);
1689 *out |= (inl % (1U << 14)) << (17 - 14);
1690 out++;
1691 *out = (inl >> 14) % (1U << 17);
1692 out++;
1693 *out = (inl >> 31);
1694 ++in;
1695 inl = util::SafeLoad(in);
1696 inl = arrow::BitUtil::FromLittleEndian(inl);
1697 *out |= (inl % (1U << 16)) << (17 - 16);
1698 out++;
1699 *out = (inl >> 16);
1700 ++in;
1701 inl = util::SafeLoad(in);
1702 inl = arrow::BitUtil::FromLittleEndian(inl);
1703 *out |= (inl % (1U << 1)) << (17 - 1);
1704 out++;
1705 *out = (inl >> 1) % (1U << 17);
1706 out++;
1707 *out = (inl >> 18);
1708 ++in;
1709 inl = util::SafeLoad(in);
1710 inl = arrow::BitUtil::FromLittleEndian(inl);
1711 *out |= (inl % (1U << 3)) << (17 - 3);
1712 out++;
1713 *out = (inl >> 3) % (1U << 17);
1714 out++;
1715 *out = (inl >> 20);
1716 ++in;
1717 inl = util::SafeLoad(in);
1718 inl = arrow::BitUtil::FromLittleEndian(inl);
1719 *out |= (inl % (1U << 5)) << (17 - 5);
1720 out++;
1721 *out = (inl >> 5) % (1U << 17);
1722 out++;
1723 *out = (inl >> 22);
1724 ++in;
1725 inl = util::SafeLoad(in);
1726 inl = arrow::BitUtil::FromLittleEndian(inl);
1727 *out |= (inl % (1U << 7)) << (17 - 7);
1728 out++;
1729 *out = (inl >> 7) % (1U << 17);
1730 out++;
1731 *out = (inl >> 24);
1732 ++in;
1733 inl = util::SafeLoad(in);
1734 inl = arrow::BitUtil::FromLittleEndian(inl);
1735 *out |= (inl % (1U << 9)) << (17 - 9);
1736 out++;
1737 *out = (inl >> 9) % (1U << 17);
1738 out++;
1739 *out = (inl >> 26);
1740 ++in;
1741 inl = util::SafeLoad(in);
1742 inl = arrow::BitUtil::FromLittleEndian(inl);
1743 *out |= (inl % (1U << 11)) << (17 - 11);
1744 out++;
1745 *out = (inl >> 11) % (1U << 17);
1746 out++;
1747 *out = (inl >> 28);
1748 ++in;
1749 inl = util::SafeLoad(in);
1750 inl = arrow::BitUtil::FromLittleEndian(inl);
1751 *out |= (inl % (1U << 13)) << (17 - 13);
1752 out++;
1753 *out = (inl >> 13) % (1U << 17);
1754 out++;
1755 *out = (inl >> 30);
1756 ++in;
1757 inl = util::SafeLoad(in);
1758 inl = arrow::BitUtil::FromLittleEndian(inl);
1759 *out |= (inl % (1U << 15)) << (17 - 15);
1760 out++;
1761 *out = (inl >> 15);
1762 ++in;
1763 out++;
1764
1765 return in;
1766 }
1767
unpack18_32(const uint32_t * in,uint32_t * out)1768 inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
1769 uint32_t inl = util::SafeLoad(in);
1770 inl = arrow::BitUtil::FromLittleEndian(inl);
1771 *out = (inl >> 0) % (1U << 18);
1772 out++;
1773 *out = (inl >> 18);
1774 ++in;
1775 inl = util::SafeLoad(in);
1776 inl = arrow::BitUtil::FromLittleEndian(inl);
1777 *out |= (inl % (1U << 4)) << (18 - 4);
1778 out++;
1779 *out = (inl >> 4) % (1U << 18);
1780 out++;
1781 *out = (inl >> 22);
1782 ++in;
1783 inl = util::SafeLoad(in);
1784 inl = arrow::BitUtil::FromLittleEndian(inl);
1785 *out |= (inl % (1U << 8)) << (18 - 8);
1786 out++;
1787 *out = (inl >> 8) % (1U << 18);
1788 out++;
1789 *out = (inl >> 26);
1790 ++in;
1791 inl = util::SafeLoad(in);
1792 inl = arrow::BitUtil::FromLittleEndian(inl);
1793 *out |= (inl % (1U << 12)) << (18 - 12);
1794 out++;
1795 *out = (inl >> 12) % (1U << 18);
1796 out++;
1797 *out = (inl >> 30);
1798 ++in;
1799 inl = util::SafeLoad(in);
1800 inl = arrow::BitUtil::FromLittleEndian(inl);
1801 *out |= (inl % (1U << 16)) << (18 - 16);
1802 out++;
1803 *out = (inl >> 16);
1804 ++in;
1805 inl = util::SafeLoad(in);
1806 inl = arrow::BitUtil::FromLittleEndian(inl);
1807 *out |= (inl % (1U << 2)) << (18 - 2);
1808 out++;
1809 *out = (inl >> 2) % (1U << 18);
1810 out++;
1811 *out = (inl >> 20);
1812 ++in;
1813 inl = util::SafeLoad(in);
1814 inl = arrow::BitUtil::FromLittleEndian(inl);
1815 *out |= (inl % (1U << 6)) << (18 - 6);
1816 out++;
1817 *out = (inl >> 6) % (1U << 18);
1818 out++;
1819 *out = (inl >> 24);
1820 ++in;
1821 inl = util::SafeLoad(in);
1822 inl = arrow::BitUtil::FromLittleEndian(inl);
1823 *out |= (inl % (1U << 10)) << (18 - 10);
1824 out++;
1825 *out = (inl >> 10) % (1U << 18);
1826 out++;
1827 *out = (inl >> 28);
1828 ++in;
1829 inl = util::SafeLoad(in);
1830 inl = arrow::BitUtil::FromLittleEndian(inl);
1831 *out |= (inl % (1U << 14)) << (18 - 14);
1832 out++;
1833 *out = (inl >> 14);
1834 ++in;
1835 inl = util::SafeLoad(in);
1836 inl = arrow::BitUtil::FromLittleEndian(inl);
1837 out++;
1838 *out = (inl >> 0) % (1U << 18);
1839 out++;
1840 *out = (inl >> 18);
1841 ++in;
1842 inl = util::SafeLoad(in);
1843 inl = arrow::BitUtil::FromLittleEndian(inl);
1844 *out |= (inl % (1U << 4)) << (18 - 4);
1845 out++;
1846 *out = (inl >> 4) % (1U << 18);
1847 out++;
1848 *out = (inl >> 22);
1849 ++in;
1850 inl = util::SafeLoad(in);
1851 inl = arrow::BitUtil::FromLittleEndian(inl);
1852 *out |= (inl % (1U << 8)) << (18 - 8);
1853 out++;
1854 *out = (inl >> 8) % (1U << 18);
1855 out++;
1856 *out = (inl >> 26);
1857 ++in;
1858 inl = util::SafeLoad(in);
1859 inl = arrow::BitUtil::FromLittleEndian(inl);
1860 *out |= (inl % (1U << 12)) << (18 - 12);
1861 out++;
1862 *out = (inl >> 12) % (1U << 18);
1863 out++;
1864 *out = (inl >> 30);
1865 ++in;
1866 inl = util::SafeLoad(in);
1867 inl = arrow::BitUtil::FromLittleEndian(inl);
1868 *out |= (inl % (1U << 16)) << (18 - 16);
1869 out++;
1870 *out = (inl >> 16);
1871 ++in;
1872 inl = util::SafeLoad(in);
1873 inl = arrow::BitUtil::FromLittleEndian(inl);
1874 *out |= (inl % (1U << 2)) << (18 - 2);
1875 out++;
1876 *out = (inl >> 2) % (1U << 18);
1877 out++;
1878 *out = (inl >> 20);
1879 ++in;
1880 inl = util::SafeLoad(in);
1881 inl = arrow::BitUtil::FromLittleEndian(inl);
1882 *out |= (inl % (1U << 6)) << (18 - 6);
1883 out++;
1884 *out = (inl >> 6) % (1U << 18);
1885 out++;
1886 *out = (inl >> 24);
1887 ++in;
1888 inl = util::SafeLoad(in);
1889 inl = arrow::BitUtil::FromLittleEndian(inl);
1890 *out |= (inl % (1U << 10)) << (18 - 10);
1891 out++;
1892 *out = (inl >> 10) % (1U << 18);
1893 out++;
1894 *out = (inl >> 28);
1895 ++in;
1896 inl = util::SafeLoad(in);
1897 inl = arrow::BitUtil::FromLittleEndian(inl);
1898 *out |= (inl % (1U << 14)) << (18 - 14);
1899 out++;
1900 *out = (inl >> 14);
1901 ++in;
1902 out++;
1903
1904 return in;
1905 }
1906
unpack19_32(const uint32_t * in,uint32_t * out)1907 inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
1908 uint32_t inl = util::SafeLoad(in);
1909 inl = arrow::BitUtil::FromLittleEndian(inl);
1910 *out = (inl >> 0) % (1U << 19);
1911 out++;
1912 *out = (inl >> 19);
1913 ++in;
1914 inl = util::SafeLoad(in);
1915 inl = arrow::BitUtil::FromLittleEndian(inl);
1916 *out |= (inl % (1U << 6)) << (19 - 6);
1917 out++;
1918 *out = (inl >> 6) % (1U << 19);
1919 out++;
1920 *out = (inl >> 25);
1921 ++in;
1922 inl = util::SafeLoad(in);
1923 inl = arrow::BitUtil::FromLittleEndian(inl);
1924 *out |= (inl % (1U << 12)) << (19 - 12);
1925 out++;
1926 *out = (inl >> 12) % (1U << 19);
1927 out++;
1928 *out = (inl >> 31);
1929 ++in;
1930 inl = util::SafeLoad(in);
1931 inl = arrow::BitUtil::FromLittleEndian(inl);
1932 *out |= (inl % (1U << 18)) << (19 - 18);
1933 out++;
1934 *out = (inl >> 18);
1935 ++in;
1936 inl = util::SafeLoad(in);
1937 inl = arrow::BitUtil::FromLittleEndian(inl);
1938 *out |= (inl % (1U << 5)) << (19 - 5);
1939 out++;
1940 *out = (inl >> 5) % (1U << 19);
1941 out++;
1942 *out = (inl >> 24);
1943 ++in;
1944 inl = util::SafeLoad(in);
1945 inl = arrow::BitUtil::FromLittleEndian(inl);
1946 *out |= (inl % (1U << 11)) << (19 - 11);
1947 out++;
1948 *out = (inl >> 11) % (1U << 19);
1949 out++;
1950 *out = (inl >> 30);
1951 ++in;
1952 inl = util::SafeLoad(in);
1953 inl = arrow::BitUtil::FromLittleEndian(inl);
1954 *out |= (inl % (1U << 17)) << (19 - 17);
1955 out++;
1956 *out = (inl >> 17);
1957 ++in;
1958 inl = util::SafeLoad(in);
1959 inl = arrow::BitUtil::FromLittleEndian(inl);
1960 *out |= (inl % (1U << 4)) << (19 - 4);
1961 out++;
1962 *out = (inl >> 4) % (1U << 19);
1963 out++;
1964 *out = (inl >> 23);
1965 ++in;
1966 inl = util::SafeLoad(in);
1967 inl = arrow::BitUtil::FromLittleEndian(inl);
1968 *out |= (inl % (1U << 10)) << (19 - 10);
1969 out++;
1970 *out = (inl >> 10) % (1U << 19);
1971 out++;
1972 *out = (inl >> 29);
1973 ++in;
1974 inl = util::SafeLoad(in);
1975 inl = arrow::BitUtil::FromLittleEndian(inl);
1976 *out |= (inl % (1U << 16)) << (19 - 16);
1977 out++;
1978 *out = (inl >> 16);
1979 ++in;
1980 inl = util::SafeLoad(in);
1981 inl = arrow::BitUtil::FromLittleEndian(inl);
1982 *out |= (inl % (1U << 3)) << (19 - 3);
1983 out++;
1984 *out = (inl >> 3) % (1U << 19);
1985 out++;
1986 *out = (inl >> 22);
1987 ++in;
1988 inl = util::SafeLoad(in);
1989 inl = arrow::BitUtil::FromLittleEndian(inl);
1990 *out |= (inl % (1U << 9)) << (19 - 9);
1991 out++;
1992 *out = (inl >> 9) % (1U << 19);
1993 out++;
1994 *out = (inl >> 28);
1995 ++in;
1996 inl = util::SafeLoad(in);
1997 inl = arrow::BitUtil::FromLittleEndian(inl);
1998 *out |= (inl % (1U << 15)) << (19 - 15);
1999 out++;
2000 *out = (inl >> 15);
2001 ++in;
2002 inl = util::SafeLoad(in);
2003 inl = arrow::BitUtil::FromLittleEndian(inl);
2004 *out |= (inl % (1U << 2)) << (19 - 2);
2005 out++;
2006 *out = (inl >> 2) % (1U << 19);
2007 out++;
2008 *out = (inl >> 21);
2009 ++in;
2010 inl = util::SafeLoad(in);
2011 inl = arrow::BitUtil::FromLittleEndian(inl);
2012 *out |= (inl % (1U << 8)) << (19 - 8);
2013 out++;
2014 *out = (inl >> 8) % (1U << 19);
2015 out++;
2016 *out = (inl >> 27);
2017 ++in;
2018 inl = util::SafeLoad(in);
2019 inl = arrow::BitUtil::FromLittleEndian(inl);
2020 *out |= (inl % (1U << 14)) << (19 - 14);
2021 out++;
2022 *out = (inl >> 14);
2023 ++in;
2024 inl = util::SafeLoad(in);
2025 inl = arrow::BitUtil::FromLittleEndian(inl);
2026 *out |= (inl % (1U << 1)) << (19 - 1);
2027 out++;
2028 *out = (inl >> 1) % (1U << 19);
2029 out++;
2030 *out = (inl >> 20);
2031 ++in;
2032 inl = util::SafeLoad(in);
2033 inl = arrow::BitUtil::FromLittleEndian(inl);
2034 *out |= (inl % (1U << 7)) << (19 - 7);
2035 out++;
2036 *out = (inl >> 7) % (1U << 19);
2037 out++;
2038 *out = (inl >> 26);
2039 ++in;
2040 inl = util::SafeLoad(in);
2041 inl = arrow::BitUtil::FromLittleEndian(inl);
2042 *out |= (inl % (1U << 13)) << (19 - 13);
2043 out++;
2044 *out = (inl >> 13);
2045 ++in;
2046 out++;
2047
2048 return in;
2049 }
2050
unpack20_32(const uint32_t * in,uint32_t * out)2051 inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
2052 uint32_t inl = util::SafeLoad(in);
2053 inl = arrow::BitUtil::FromLittleEndian(inl);
2054 *out = (inl >> 0) % (1U << 20);
2055 out++;
2056 *out = (inl >> 20);
2057 ++in;
2058 inl = util::SafeLoad(in);
2059 inl = arrow::BitUtil::FromLittleEndian(inl);
2060 *out |= (inl % (1U << 8)) << (20 - 8);
2061 out++;
2062 *out = (inl >> 8) % (1U << 20);
2063 out++;
2064 *out = (inl >> 28);
2065 ++in;
2066 inl = util::SafeLoad(in);
2067 inl = arrow::BitUtil::FromLittleEndian(inl);
2068 *out |= (inl % (1U << 16)) << (20 - 16);
2069 out++;
2070 *out = (inl >> 16);
2071 ++in;
2072 inl = util::SafeLoad(in);
2073 inl = arrow::BitUtil::FromLittleEndian(inl);
2074 *out |= (inl % (1U << 4)) << (20 - 4);
2075 out++;
2076 *out = (inl >> 4) % (1U << 20);
2077 out++;
2078 *out = (inl >> 24);
2079 ++in;
2080 inl = util::SafeLoad(in);
2081 inl = arrow::BitUtil::FromLittleEndian(inl);
2082 *out |= (inl % (1U << 12)) << (20 - 12);
2083 out++;
2084 *out = (inl >> 12);
2085 ++in;
2086 inl = util::SafeLoad(in);
2087 inl = arrow::BitUtil::FromLittleEndian(inl);
2088 out++;
2089 *out = (inl >> 0) % (1U << 20);
2090 out++;
2091 *out = (inl >> 20);
2092 ++in;
2093 inl = util::SafeLoad(in);
2094 inl = arrow::BitUtil::FromLittleEndian(inl);
2095 *out |= (inl % (1U << 8)) << (20 - 8);
2096 out++;
2097 *out = (inl >> 8) % (1U << 20);
2098 out++;
2099 *out = (inl >> 28);
2100 ++in;
2101 inl = util::SafeLoad(in);
2102 inl = arrow::BitUtil::FromLittleEndian(inl);
2103 *out |= (inl % (1U << 16)) << (20 - 16);
2104 out++;
2105 *out = (inl >> 16);
2106 ++in;
2107 inl = util::SafeLoad(in);
2108 inl = arrow::BitUtil::FromLittleEndian(inl);
2109 *out |= (inl % (1U << 4)) << (20 - 4);
2110 out++;
2111 *out = (inl >> 4) % (1U << 20);
2112 out++;
2113 *out = (inl >> 24);
2114 ++in;
2115 inl = util::SafeLoad(in);
2116 inl = arrow::BitUtil::FromLittleEndian(inl);
2117 *out |= (inl % (1U << 12)) << (20 - 12);
2118 out++;
2119 *out = (inl >> 12);
2120 ++in;
2121 inl = util::SafeLoad(in);
2122 inl = arrow::BitUtil::FromLittleEndian(inl);
2123 out++;
2124 *out = (inl >> 0) % (1U << 20);
2125 out++;
2126 *out = (inl >> 20);
2127 ++in;
2128 inl = util::SafeLoad(in);
2129 inl = arrow::BitUtil::FromLittleEndian(inl);
2130 *out |= (inl % (1U << 8)) << (20 - 8);
2131 out++;
2132 *out = (inl >> 8) % (1U << 20);
2133 out++;
2134 *out = (inl >> 28);
2135 ++in;
2136 inl = util::SafeLoad(in);
2137 inl = arrow::BitUtil::FromLittleEndian(inl);
2138 *out |= (inl % (1U << 16)) << (20 - 16);
2139 out++;
2140 *out = (inl >> 16);
2141 ++in;
2142 inl = util::SafeLoad(in);
2143 inl = arrow::BitUtil::FromLittleEndian(inl);
2144 *out |= (inl % (1U << 4)) << (20 - 4);
2145 out++;
2146 *out = (inl >> 4) % (1U << 20);
2147 out++;
2148 *out = (inl >> 24);
2149 ++in;
2150 inl = util::SafeLoad(in);
2151 inl = arrow::BitUtil::FromLittleEndian(inl);
2152 *out |= (inl % (1U << 12)) << (20 - 12);
2153 out++;
2154 *out = (inl >> 12);
2155 ++in;
2156 inl = util::SafeLoad(in);
2157 inl = arrow::BitUtil::FromLittleEndian(inl);
2158 out++;
2159 *out = (inl >> 0) % (1U << 20);
2160 out++;
2161 *out = (inl >> 20);
2162 ++in;
2163 inl = util::SafeLoad(in);
2164 inl = arrow::BitUtil::FromLittleEndian(inl);
2165 *out |= (inl % (1U << 8)) << (20 - 8);
2166 out++;
2167 *out = (inl >> 8) % (1U << 20);
2168 out++;
2169 *out = (inl >> 28);
2170 ++in;
2171 inl = util::SafeLoad(in);
2172 inl = arrow::BitUtil::FromLittleEndian(inl);
2173 *out |= (inl % (1U << 16)) << (20 - 16);
2174 out++;
2175 *out = (inl >> 16);
2176 ++in;
2177 inl = util::SafeLoad(in);
2178 inl = arrow::BitUtil::FromLittleEndian(inl);
2179 *out |= (inl % (1U << 4)) << (20 - 4);
2180 out++;
2181 *out = (inl >> 4) % (1U << 20);
2182 out++;
2183 *out = (inl >> 24);
2184 ++in;
2185 inl = util::SafeLoad(in);
2186 inl = arrow::BitUtil::FromLittleEndian(inl);
2187 *out |= (inl % (1U << 12)) << (20 - 12);
2188 out++;
2189 *out = (inl >> 12);
2190 ++in;
2191 out++;
2192
2193 return in;
2194 }
2195
unpack21_32(const uint32_t * in,uint32_t * out)2196 inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
2197 uint32_t inl = util::SafeLoad(in);
2198 inl = arrow::BitUtil::FromLittleEndian(inl);
2199 *out = (inl >> 0) % (1U << 21);
2200 out++;
2201 *out = (inl >> 21);
2202 ++in;
2203 inl = util::SafeLoad(in);
2204 inl = arrow::BitUtil::FromLittleEndian(inl);
2205 *out |= (inl % (1U << 10)) << (21 - 10);
2206 out++;
2207 *out = (inl >> 10) % (1U << 21);
2208 out++;
2209 *out = (inl >> 31);
2210 ++in;
2211 inl = util::SafeLoad(in);
2212 inl = arrow::BitUtil::FromLittleEndian(inl);
2213 *out |= (inl % (1U << 20)) << (21 - 20);
2214 out++;
2215 *out = (inl >> 20);
2216 ++in;
2217 inl = util::SafeLoad(in);
2218 inl = arrow::BitUtil::FromLittleEndian(inl);
2219 *out |= (inl % (1U << 9)) << (21 - 9);
2220 out++;
2221 *out = (inl >> 9) % (1U << 21);
2222 out++;
2223 *out = (inl >> 30);
2224 ++in;
2225 inl = util::SafeLoad(in);
2226 inl = arrow::BitUtil::FromLittleEndian(inl);
2227 *out |= (inl % (1U << 19)) << (21 - 19);
2228 out++;
2229 *out = (inl >> 19);
2230 ++in;
2231 inl = util::SafeLoad(in);
2232 inl = arrow::BitUtil::FromLittleEndian(inl);
2233 *out |= (inl % (1U << 8)) << (21 - 8);
2234 out++;
2235 *out = (inl >> 8) % (1U << 21);
2236 out++;
2237 *out = (inl >> 29);
2238 ++in;
2239 inl = util::SafeLoad(in);
2240 inl = arrow::BitUtil::FromLittleEndian(inl);
2241 *out |= (inl % (1U << 18)) << (21 - 18);
2242 out++;
2243 *out = (inl >> 18);
2244 ++in;
2245 inl = util::SafeLoad(in);
2246 inl = arrow::BitUtil::FromLittleEndian(inl);
2247 *out |= (inl % (1U << 7)) << (21 - 7);
2248 out++;
2249 *out = (inl >> 7) % (1U << 21);
2250 out++;
2251 *out = (inl >> 28);
2252 ++in;
2253 inl = util::SafeLoad(in);
2254 inl = arrow::BitUtil::FromLittleEndian(inl);
2255 *out |= (inl % (1U << 17)) << (21 - 17);
2256 out++;
2257 *out = (inl >> 17);
2258 ++in;
2259 inl = util::SafeLoad(in);
2260 inl = arrow::BitUtil::FromLittleEndian(inl);
2261 *out |= (inl % (1U << 6)) << (21 - 6);
2262 out++;
2263 *out = (inl >> 6) % (1U << 21);
2264 out++;
2265 *out = (inl >> 27);
2266 ++in;
2267 inl = util::SafeLoad(in);
2268 inl = arrow::BitUtil::FromLittleEndian(inl);
2269 *out |= (inl % (1U << 16)) << (21 - 16);
2270 out++;
2271 *out = (inl >> 16);
2272 ++in;
2273 inl = util::SafeLoad(in);
2274 inl = arrow::BitUtil::FromLittleEndian(inl);
2275 *out |= (inl % (1U << 5)) << (21 - 5);
2276 out++;
2277 *out = (inl >> 5) % (1U << 21);
2278 out++;
2279 *out = (inl >> 26);
2280 ++in;
2281 inl = util::SafeLoad(in);
2282 inl = arrow::BitUtil::FromLittleEndian(inl);
2283 *out |= (inl % (1U << 15)) << (21 - 15);
2284 out++;
2285 *out = (inl >> 15);
2286 ++in;
2287 inl = util::SafeLoad(in);
2288 inl = arrow::BitUtil::FromLittleEndian(inl);
2289 *out |= (inl % (1U << 4)) << (21 - 4);
2290 out++;
2291 *out = (inl >> 4) % (1U << 21);
2292 out++;
2293 *out = (inl >> 25);
2294 ++in;
2295 inl = util::SafeLoad(in);
2296 inl = arrow::BitUtil::FromLittleEndian(inl);
2297 *out |= (inl % (1U << 14)) << (21 - 14);
2298 out++;
2299 *out = (inl >> 14);
2300 ++in;
2301 inl = util::SafeLoad(in);
2302 inl = arrow::BitUtil::FromLittleEndian(inl);
2303 *out |= (inl % (1U << 3)) << (21 - 3);
2304 out++;
2305 *out = (inl >> 3) % (1U << 21);
2306 out++;
2307 *out = (inl >> 24);
2308 ++in;
2309 inl = util::SafeLoad(in);
2310 inl = arrow::BitUtil::FromLittleEndian(inl);
2311 *out |= (inl % (1U << 13)) << (21 - 13);
2312 out++;
2313 *out = (inl >> 13);
2314 ++in;
2315 inl = util::SafeLoad(in);
2316 inl = arrow::BitUtil::FromLittleEndian(inl);
2317 *out |= (inl % (1U << 2)) << (21 - 2);
2318 out++;
2319 *out = (inl >> 2) % (1U << 21);
2320 out++;
2321 *out = (inl >> 23);
2322 ++in;
2323 inl = util::SafeLoad(in);
2324 inl = arrow::BitUtil::FromLittleEndian(inl);
2325 *out |= (inl % (1U << 12)) << (21 - 12);
2326 out++;
2327 *out = (inl >> 12);
2328 ++in;
2329 inl = util::SafeLoad(in);
2330 inl = arrow::BitUtil::FromLittleEndian(inl);
2331 *out |= (inl % (1U << 1)) << (21 - 1);
2332 out++;
2333 *out = (inl >> 1) % (1U << 21);
2334 out++;
2335 *out = (inl >> 22);
2336 ++in;
2337 inl = util::SafeLoad(in);
2338 inl = arrow::BitUtil::FromLittleEndian(inl);
2339 *out |= (inl % (1U << 11)) << (21 - 11);
2340 out++;
2341 *out = (inl >> 11);
2342 ++in;
2343 out++;
2344
2345 return in;
2346 }
2347
unpack22_32(const uint32_t * in,uint32_t * out)2348 inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
2349 uint32_t inl = util::SafeLoad(in);
2350 inl = arrow::BitUtil::FromLittleEndian(inl);
2351 *out = (inl >> 0) % (1U << 22);
2352 out++;
2353 *out = (inl >> 22);
2354 ++in;
2355 inl = util::SafeLoad(in);
2356 inl = arrow::BitUtil::FromLittleEndian(inl);
2357 *out |= (inl % (1U << 12)) << (22 - 12);
2358 out++;
2359 *out = (inl >> 12);
2360 ++in;
2361 inl = util::SafeLoad(in);
2362 inl = arrow::BitUtil::FromLittleEndian(inl);
2363 *out |= (inl % (1U << 2)) << (22 - 2);
2364 out++;
2365 *out = (inl >> 2) % (1U << 22);
2366 out++;
2367 *out = (inl >> 24);
2368 ++in;
2369 inl = util::SafeLoad(in);
2370 inl = arrow::BitUtil::FromLittleEndian(inl);
2371 *out |= (inl % (1U << 14)) << (22 - 14);
2372 out++;
2373 *out = (inl >> 14);
2374 ++in;
2375 inl = util::SafeLoad(in);
2376 inl = arrow::BitUtil::FromLittleEndian(inl);
2377 *out |= (inl % (1U << 4)) << (22 - 4);
2378 out++;
2379 *out = (inl >> 4) % (1U << 22);
2380 out++;
2381 *out = (inl >> 26);
2382 ++in;
2383 inl = util::SafeLoad(in);
2384 inl = arrow::BitUtil::FromLittleEndian(inl);
2385 *out |= (inl % (1U << 16)) << (22 - 16);
2386 out++;
2387 *out = (inl >> 16);
2388 ++in;
2389 inl = util::SafeLoad(in);
2390 inl = arrow::BitUtil::FromLittleEndian(inl);
2391 *out |= (inl % (1U << 6)) << (22 - 6);
2392 out++;
2393 *out = (inl >> 6) % (1U << 22);
2394 out++;
2395 *out = (inl >> 28);
2396 ++in;
2397 inl = util::SafeLoad(in);
2398 inl = arrow::BitUtil::FromLittleEndian(inl);
2399 *out |= (inl % (1U << 18)) << (22 - 18);
2400 out++;
2401 *out = (inl >> 18);
2402 ++in;
2403 inl = util::SafeLoad(in);
2404 inl = arrow::BitUtil::FromLittleEndian(inl);
2405 *out |= (inl % (1U << 8)) << (22 - 8);
2406 out++;
2407 *out = (inl >> 8) % (1U << 22);
2408 out++;
2409 *out = (inl >> 30);
2410 ++in;
2411 inl = util::SafeLoad(in);
2412 inl = arrow::BitUtil::FromLittleEndian(inl);
2413 *out |= (inl % (1U << 20)) << (22 - 20);
2414 out++;
2415 *out = (inl >> 20);
2416 ++in;
2417 inl = util::SafeLoad(in);
2418 inl = arrow::BitUtil::FromLittleEndian(inl);
2419 *out |= (inl % (1U << 10)) << (22 - 10);
2420 out++;
2421 *out = (inl >> 10);
2422 ++in;
2423 inl = util::SafeLoad(in);
2424 inl = arrow::BitUtil::FromLittleEndian(inl);
2425 out++;
2426 *out = (inl >> 0) % (1U << 22);
2427 out++;
2428 *out = (inl >> 22);
2429 ++in;
2430 inl = util::SafeLoad(in);
2431 inl = arrow::BitUtil::FromLittleEndian(inl);
2432 *out |= (inl % (1U << 12)) << (22 - 12);
2433 out++;
2434 *out = (inl >> 12);
2435 ++in;
2436 inl = util::SafeLoad(in);
2437 inl = arrow::BitUtil::FromLittleEndian(inl);
2438 *out |= (inl % (1U << 2)) << (22 - 2);
2439 out++;
2440 *out = (inl >> 2) % (1U << 22);
2441 out++;
2442 *out = (inl >> 24);
2443 ++in;
2444 inl = util::SafeLoad(in);
2445 inl = arrow::BitUtil::FromLittleEndian(inl);
2446 *out |= (inl % (1U << 14)) << (22 - 14);
2447 out++;
2448 *out = (inl >> 14);
2449 ++in;
2450 inl = util::SafeLoad(in);
2451 inl = arrow::BitUtil::FromLittleEndian(inl);
2452 *out |= (inl % (1U << 4)) << (22 - 4);
2453 out++;
2454 *out = (inl >> 4) % (1U << 22);
2455 out++;
2456 *out = (inl >> 26);
2457 ++in;
2458 inl = util::SafeLoad(in);
2459 inl = arrow::BitUtil::FromLittleEndian(inl);
2460 *out |= (inl % (1U << 16)) << (22 - 16);
2461 out++;
2462 *out = (inl >> 16);
2463 ++in;
2464 inl = util::SafeLoad(in);
2465 inl = arrow::BitUtil::FromLittleEndian(inl);
2466 *out |= (inl % (1U << 6)) << (22 - 6);
2467 out++;
2468 *out = (inl >> 6) % (1U << 22);
2469 out++;
2470 *out = (inl >> 28);
2471 ++in;
2472 inl = util::SafeLoad(in);
2473 inl = arrow::BitUtil::FromLittleEndian(inl);
2474 *out |= (inl % (1U << 18)) << (22 - 18);
2475 out++;
2476 *out = (inl >> 18);
2477 ++in;
2478 inl = util::SafeLoad(in);
2479 inl = arrow::BitUtil::FromLittleEndian(inl);
2480 *out |= (inl % (1U << 8)) << (22 - 8);
2481 out++;
2482 *out = (inl >> 8) % (1U << 22);
2483 out++;
2484 *out = (inl >> 30);
2485 ++in;
2486 inl = util::SafeLoad(in);
2487 inl = arrow::BitUtil::FromLittleEndian(inl);
2488 *out |= (inl % (1U << 20)) << (22 - 20);
2489 out++;
2490 *out = (inl >> 20);
2491 ++in;
2492 inl = util::SafeLoad(in);
2493 inl = arrow::BitUtil::FromLittleEndian(inl);
2494 *out |= (inl % (1U << 10)) << (22 - 10);
2495 out++;
2496 *out = (inl >> 10);
2497 ++in;
2498 out++;
2499
2500 return in;
2501 }
2502
unpack23_32(const uint32_t * in,uint32_t * out)2503 inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
2504 uint32_t inl = util::SafeLoad(in);
2505 inl = arrow::BitUtil::FromLittleEndian(inl);
2506 *out = (inl >> 0) % (1U << 23);
2507 out++;
2508 *out = (inl >> 23);
2509 ++in;
2510 inl = util::SafeLoad(in);
2511 inl = arrow::BitUtil::FromLittleEndian(inl);
2512 *out |= (inl % (1U << 14)) << (23 - 14);
2513 out++;
2514 *out = (inl >> 14);
2515 ++in;
2516 inl = util::SafeLoad(in);
2517 inl = arrow::BitUtil::FromLittleEndian(inl);
2518 *out |= (inl % (1U << 5)) << (23 - 5);
2519 out++;
2520 *out = (inl >> 5) % (1U << 23);
2521 out++;
2522 *out = (inl >> 28);
2523 ++in;
2524 inl = util::SafeLoad(in);
2525 inl = arrow::BitUtil::FromLittleEndian(inl);
2526 *out |= (inl % (1U << 19)) << (23 - 19);
2527 out++;
2528 *out = (inl >> 19);
2529 ++in;
2530 inl = util::SafeLoad(in);
2531 inl = arrow::BitUtil::FromLittleEndian(inl);
2532 *out |= (inl % (1U << 10)) << (23 - 10);
2533 out++;
2534 *out = (inl >> 10);
2535 ++in;
2536 inl = util::SafeLoad(in);
2537 inl = arrow::BitUtil::FromLittleEndian(inl);
2538 *out |= (inl % (1U << 1)) << (23 - 1);
2539 out++;
2540 *out = (inl >> 1) % (1U << 23);
2541 out++;
2542 *out = (inl >> 24);
2543 ++in;
2544 inl = util::SafeLoad(in);
2545 inl = arrow::BitUtil::FromLittleEndian(inl);
2546 *out |= (inl % (1U << 15)) << (23 - 15);
2547 out++;
2548 *out = (inl >> 15);
2549 ++in;
2550 inl = util::SafeLoad(in);
2551 inl = arrow::BitUtil::FromLittleEndian(inl);
2552 *out |= (inl % (1U << 6)) << (23 - 6);
2553 out++;
2554 *out = (inl >> 6) % (1U << 23);
2555 out++;
2556 *out = (inl >> 29);
2557 ++in;
2558 inl = util::SafeLoad(in);
2559 inl = arrow::BitUtil::FromLittleEndian(inl);
2560 *out |= (inl % (1U << 20)) << (23 - 20);
2561 out++;
2562 *out = (inl >> 20);
2563 ++in;
2564 inl = util::SafeLoad(in);
2565 inl = arrow::BitUtil::FromLittleEndian(inl);
2566 *out |= (inl % (1U << 11)) << (23 - 11);
2567 out++;
2568 *out = (inl >> 11);
2569 ++in;
2570 inl = util::SafeLoad(in);
2571 inl = arrow::BitUtil::FromLittleEndian(inl);
2572 *out |= (inl % (1U << 2)) << (23 - 2);
2573 out++;
2574 *out = (inl >> 2) % (1U << 23);
2575 out++;
2576 *out = (inl >> 25);
2577 ++in;
2578 inl = util::SafeLoad(in);
2579 inl = arrow::BitUtil::FromLittleEndian(inl);
2580 *out |= (inl % (1U << 16)) << (23 - 16);
2581 out++;
2582 *out = (inl >> 16);
2583 ++in;
2584 inl = util::SafeLoad(in);
2585 inl = arrow::BitUtil::FromLittleEndian(inl);
2586 *out |= (inl % (1U << 7)) << (23 - 7);
2587 out++;
2588 *out = (inl >> 7) % (1U << 23);
2589 out++;
2590 *out = (inl >> 30);
2591 ++in;
2592 inl = util::SafeLoad(in);
2593 inl = arrow::BitUtil::FromLittleEndian(inl);
2594 *out |= (inl % (1U << 21)) << (23 - 21);
2595 out++;
2596 *out = (inl >> 21);
2597 ++in;
2598 inl = util::SafeLoad(in);
2599 inl = arrow::BitUtil::FromLittleEndian(inl);
2600 *out |= (inl % (1U << 12)) << (23 - 12);
2601 out++;
2602 *out = (inl >> 12);
2603 ++in;
2604 inl = util::SafeLoad(in);
2605 inl = arrow::BitUtil::FromLittleEndian(inl);
2606 *out |= (inl % (1U << 3)) << (23 - 3);
2607 out++;
2608 *out = (inl >> 3) % (1U << 23);
2609 out++;
2610 *out = (inl >> 26);
2611 ++in;
2612 inl = util::SafeLoad(in);
2613 inl = arrow::BitUtil::FromLittleEndian(inl);
2614 *out |= (inl % (1U << 17)) << (23 - 17);
2615 out++;
2616 *out = (inl >> 17);
2617 ++in;
2618 inl = util::SafeLoad(in);
2619 inl = arrow::BitUtil::FromLittleEndian(inl);
2620 *out |= (inl % (1U << 8)) << (23 - 8);
2621 out++;
2622 *out = (inl >> 8) % (1U << 23);
2623 out++;
2624 *out = (inl >> 31);
2625 ++in;
2626 inl = util::SafeLoad(in);
2627 inl = arrow::BitUtil::FromLittleEndian(inl);
2628 *out |= (inl % (1U << 22)) << (23 - 22);
2629 out++;
2630 *out = (inl >> 22);
2631 ++in;
2632 inl = util::SafeLoad(in);
2633 inl = arrow::BitUtil::FromLittleEndian(inl);
2634 *out |= (inl % (1U << 13)) << (23 - 13);
2635 out++;
2636 *out = (inl >> 13);
2637 ++in;
2638 inl = util::SafeLoad(in);
2639 inl = arrow::BitUtil::FromLittleEndian(inl);
2640 *out |= (inl % (1U << 4)) << (23 - 4);
2641 out++;
2642 *out = (inl >> 4) % (1U << 23);
2643 out++;
2644 *out = (inl >> 27);
2645 ++in;
2646 inl = util::SafeLoad(in);
2647 inl = arrow::BitUtil::FromLittleEndian(inl);
2648 *out |= (inl % (1U << 18)) << (23 - 18);
2649 out++;
2650 *out = (inl >> 18);
2651 ++in;
2652 inl = util::SafeLoad(in);
2653 inl = arrow::BitUtil::FromLittleEndian(inl);
2654 *out |= (inl % (1U << 9)) << (23 - 9);
2655 out++;
2656 *out = (inl >> 9);
2657 ++in;
2658 out++;
2659
2660 return in;
2661 }
2662
unpack24_32(const uint32_t * in,uint32_t * out)2663 inline const uint32_t* unpack24_32(const uint32_t* in, uint32_t* out) {
2664 uint32_t inl = util::SafeLoad(in);
2665 inl = arrow::BitUtil::FromLittleEndian(inl);
2666 *out = (inl >> 0) % (1U << 24);
2667 out++;
2668 *out = (inl >> 24);
2669 ++in;
2670 inl = util::SafeLoad(in);
2671 inl = arrow::BitUtil::FromLittleEndian(inl);
2672 *out |= (inl % (1U << 16)) << (24 - 16);
2673 out++;
2674 *out = (inl >> 16);
2675 ++in;
2676 inl = util::SafeLoad(in);
2677 inl = arrow::BitUtil::FromLittleEndian(inl);
2678 *out |= (inl % (1U << 8)) << (24 - 8);
2679 out++;
2680 *out = (inl >> 8);
2681 ++in;
2682 inl = util::SafeLoad(in);
2683 inl = arrow::BitUtil::FromLittleEndian(inl);
2684 out++;
2685 *out = (inl >> 0) % (1U << 24);
2686 out++;
2687 *out = (inl >> 24);
2688 ++in;
2689 inl = util::SafeLoad(in);
2690 inl = arrow::BitUtil::FromLittleEndian(inl);
2691 *out |= (inl % (1U << 16)) << (24 - 16);
2692 out++;
2693 *out = (inl >> 16);
2694 ++in;
2695 inl = util::SafeLoad(in);
2696 inl = arrow::BitUtil::FromLittleEndian(inl);
2697 *out |= (inl % (1U << 8)) << (24 - 8);
2698 out++;
2699 *out = (inl >> 8);
2700 ++in;
2701 inl = util::SafeLoad(in);
2702 inl = arrow::BitUtil::FromLittleEndian(inl);
2703 out++;
2704 *out = (inl >> 0) % (1U << 24);
2705 out++;
2706 *out = (inl >> 24);
2707 ++in;
2708 inl = util::SafeLoad(in);
2709 inl = arrow::BitUtil::FromLittleEndian(inl);
2710 *out |= (inl % (1U << 16)) << (24 - 16);
2711 out++;
2712 *out = (inl >> 16);
2713 ++in;
2714 inl = util::SafeLoad(in);
2715 inl = arrow::BitUtil::FromLittleEndian(inl);
2716 *out |= (inl % (1U << 8)) << (24 - 8);
2717 out++;
2718 *out = (inl >> 8);
2719 ++in;
2720 inl = util::SafeLoad(in);
2721 inl = arrow::BitUtil::FromLittleEndian(inl);
2722 out++;
2723 *out = (inl >> 0) % (1U << 24);
2724 out++;
2725 *out = (inl >> 24);
2726 ++in;
2727 inl = util::SafeLoad(in);
2728 inl = arrow::BitUtil::FromLittleEndian(inl);
2729 *out |= (inl % (1U << 16)) << (24 - 16);
2730 out++;
2731 *out = (inl >> 16);
2732 ++in;
2733 inl = util::SafeLoad(in);
2734 inl = arrow::BitUtil::FromLittleEndian(inl);
2735 *out |= (inl % (1U << 8)) << (24 - 8);
2736 out++;
2737 *out = (inl >> 8);
2738 ++in;
2739 inl = util::SafeLoad(in);
2740 inl = arrow::BitUtil::FromLittleEndian(inl);
2741 out++;
2742 *out = (inl >> 0) % (1U << 24);
2743 out++;
2744 *out = (inl >> 24);
2745 ++in;
2746 inl = util::SafeLoad(in);
2747 inl = arrow::BitUtil::FromLittleEndian(inl);
2748 *out |= (inl % (1U << 16)) << (24 - 16);
2749 out++;
2750 *out = (inl >> 16);
2751 ++in;
2752 inl = util::SafeLoad(in);
2753 inl = arrow::BitUtil::FromLittleEndian(inl);
2754 *out |= (inl % (1U << 8)) << (24 - 8);
2755 out++;
2756 *out = (inl >> 8);
2757 ++in;
2758 inl = util::SafeLoad(in);
2759 inl = arrow::BitUtil::FromLittleEndian(inl);
2760 out++;
2761 *out = (inl >> 0) % (1U << 24);
2762 out++;
2763 *out = (inl >> 24);
2764 ++in;
2765 inl = util::SafeLoad(in);
2766 inl = arrow::BitUtil::FromLittleEndian(inl);
2767 *out |= (inl % (1U << 16)) << (24 - 16);
2768 out++;
2769 *out = (inl >> 16);
2770 ++in;
2771 inl = util::SafeLoad(in);
2772 inl = arrow::BitUtil::FromLittleEndian(inl);
2773 *out |= (inl % (1U << 8)) << (24 - 8);
2774 out++;
2775 *out = (inl >> 8);
2776 ++in;
2777 inl = util::SafeLoad(in);
2778 inl = arrow::BitUtil::FromLittleEndian(inl);
2779 out++;
2780 *out = (inl >> 0) % (1U << 24);
2781 out++;
2782 *out = (inl >> 24);
2783 ++in;
2784 inl = util::SafeLoad(in);
2785 inl = arrow::BitUtil::FromLittleEndian(inl);
2786 *out |= (inl % (1U << 16)) << (24 - 16);
2787 out++;
2788 *out = (inl >> 16);
2789 ++in;
2790 inl = util::SafeLoad(in);
2791 inl = arrow::BitUtil::FromLittleEndian(inl);
2792 *out |= (inl % (1U << 8)) << (24 - 8);
2793 out++;
2794 *out = (inl >> 8);
2795 ++in;
2796 inl = util::SafeLoad(in);
2797 inl = arrow::BitUtil::FromLittleEndian(inl);
2798 out++;
2799 *out = (inl >> 0) % (1U << 24);
2800 out++;
2801 *out = (inl >> 24);
2802 ++in;
2803 inl = util::SafeLoad(in);
2804 inl = arrow::BitUtil::FromLittleEndian(inl);
2805 *out |= (inl % (1U << 16)) << (24 - 16);
2806 out++;
2807 *out = (inl >> 16);
2808 ++in;
2809 inl = util::SafeLoad(in);
2810 inl = arrow::BitUtil::FromLittleEndian(inl);
2811 *out |= (inl % (1U << 8)) << (24 - 8);
2812 out++;
2813 *out = (inl >> 8);
2814 ++in;
2815 out++;
2816
2817 return in;
2818 }
2819
unpack25_32(const uint32_t * in,uint32_t * out)2820 inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
2821 uint32_t inl = util::SafeLoad(in);
2822 inl = arrow::BitUtil::FromLittleEndian(inl);
2823 *out = (inl >> 0) % (1U << 25);
2824 out++;
2825 *out = (inl >> 25);
2826 ++in;
2827 inl = util::SafeLoad(in);
2828 inl = arrow::BitUtil::FromLittleEndian(inl);
2829 *out |= (inl % (1U << 18)) << (25 - 18);
2830 out++;
2831 *out = (inl >> 18);
2832 ++in;
2833 inl = util::SafeLoad(in);
2834 inl = arrow::BitUtil::FromLittleEndian(inl);
2835 *out |= (inl % (1U << 11)) << (25 - 11);
2836 out++;
2837 *out = (inl >> 11);
2838 ++in;
2839 inl = util::SafeLoad(in);
2840 inl = arrow::BitUtil::FromLittleEndian(inl);
2841 *out |= (inl % (1U << 4)) << (25 - 4);
2842 out++;
2843 *out = (inl >> 4) % (1U << 25);
2844 out++;
2845 *out = (inl >> 29);
2846 ++in;
2847 inl = util::SafeLoad(in);
2848 inl = arrow::BitUtil::FromLittleEndian(inl);
2849 *out |= (inl % (1U << 22)) << (25 - 22);
2850 out++;
2851 *out = (inl >> 22);
2852 ++in;
2853 inl = util::SafeLoad(in);
2854 inl = arrow::BitUtil::FromLittleEndian(inl);
2855 *out |= (inl % (1U << 15)) << (25 - 15);
2856 out++;
2857 *out = (inl >> 15);
2858 ++in;
2859 inl = util::SafeLoad(in);
2860 inl = arrow::BitUtil::FromLittleEndian(inl);
2861 *out |= (inl % (1U << 8)) << (25 - 8);
2862 out++;
2863 *out = (inl >> 8);
2864 ++in;
2865 inl = util::SafeLoad(in);
2866 inl = arrow::BitUtil::FromLittleEndian(inl);
2867 *out |= (inl % (1U << 1)) << (25 - 1);
2868 out++;
2869 *out = (inl >> 1) % (1U << 25);
2870 out++;
2871 *out = (inl >> 26);
2872 ++in;
2873 inl = util::SafeLoad(in);
2874 inl = arrow::BitUtil::FromLittleEndian(inl);
2875 *out |= (inl % (1U << 19)) << (25 - 19);
2876 out++;
2877 *out = (inl >> 19);
2878 ++in;
2879 inl = util::SafeLoad(in);
2880 inl = arrow::BitUtil::FromLittleEndian(inl);
2881 *out |= (inl % (1U << 12)) << (25 - 12);
2882 out++;
2883 *out = (inl >> 12);
2884 ++in;
2885 inl = util::SafeLoad(in);
2886 inl = arrow::BitUtil::FromLittleEndian(inl);
2887 *out |= (inl % (1U << 5)) << (25 - 5);
2888 out++;
2889 *out = (inl >> 5) % (1U << 25);
2890 out++;
2891 *out = (inl >> 30);
2892 ++in;
2893 inl = util::SafeLoad(in);
2894 inl = arrow::BitUtil::FromLittleEndian(inl);
2895 *out |= (inl % (1U << 23)) << (25 - 23);
2896 out++;
2897 *out = (inl >> 23);
2898 ++in;
2899 inl = util::SafeLoad(in);
2900 inl = arrow::BitUtil::FromLittleEndian(inl);
2901 *out |= (inl % (1U << 16)) << (25 - 16);
2902 out++;
2903 *out = (inl >> 16);
2904 ++in;
2905 inl = util::SafeLoad(in);
2906 inl = arrow::BitUtil::FromLittleEndian(inl);
2907 *out |= (inl % (1U << 9)) << (25 - 9);
2908 out++;
2909 *out = (inl >> 9);
2910 ++in;
2911 inl = util::SafeLoad(in);
2912 inl = arrow::BitUtil::FromLittleEndian(inl);
2913 *out |= (inl % (1U << 2)) << (25 - 2);
2914 out++;
2915 *out = (inl >> 2) % (1U << 25);
2916 out++;
2917 *out = (inl >> 27);
2918 ++in;
2919 inl = util::SafeLoad(in);
2920 inl = arrow::BitUtil::FromLittleEndian(inl);
2921 *out |= (inl % (1U << 20)) << (25 - 20);
2922 out++;
2923 *out = (inl >> 20);
2924 ++in;
2925 inl = util::SafeLoad(in);
2926 inl = arrow::BitUtil::FromLittleEndian(inl);
2927 *out |= (inl % (1U << 13)) << (25 - 13);
2928 out++;
2929 *out = (inl >> 13);
2930 ++in;
2931 inl = util::SafeLoad(in);
2932 inl = arrow::BitUtil::FromLittleEndian(inl);
2933 *out |= (inl % (1U << 6)) << (25 - 6);
2934 out++;
2935 *out = (inl >> 6) % (1U << 25);
2936 out++;
2937 *out = (inl >> 31);
2938 ++in;
2939 inl = util::SafeLoad(in);
2940 inl = arrow::BitUtil::FromLittleEndian(inl);
2941 *out |= (inl % (1U << 24)) << (25 - 24);
2942 out++;
2943 *out = (inl >> 24);
2944 ++in;
2945 inl = util::SafeLoad(in);
2946 inl = arrow::BitUtil::FromLittleEndian(inl);
2947 *out |= (inl % (1U << 17)) << (25 - 17);
2948 out++;
2949 *out = (inl >> 17);
2950 ++in;
2951 inl = util::SafeLoad(in);
2952 inl = arrow::BitUtil::FromLittleEndian(inl);
2953 *out |= (inl % (1U << 10)) << (25 - 10);
2954 out++;
2955 *out = (inl >> 10);
2956 ++in;
2957 inl = util::SafeLoad(in);
2958 inl = arrow::BitUtil::FromLittleEndian(inl);
2959 *out |= (inl % (1U << 3)) << (25 - 3);
2960 out++;
2961 *out = (inl >> 3) % (1U << 25);
2962 out++;
2963 *out = (inl >> 28);
2964 ++in;
2965 inl = util::SafeLoad(in);
2966 inl = arrow::BitUtil::FromLittleEndian(inl);
2967 *out |= (inl % (1U << 21)) << (25 - 21);
2968 out++;
2969 *out = (inl >> 21);
2970 ++in;
2971 inl = util::SafeLoad(in);
2972 inl = arrow::BitUtil::FromLittleEndian(inl);
2973 *out |= (inl % (1U << 14)) << (25 - 14);
2974 out++;
2975 *out = (inl >> 14);
2976 ++in;
2977 inl = util::SafeLoad(in);
2978 inl = arrow::BitUtil::FromLittleEndian(inl);
2979 *out |= (inl % (1U << 7)) << (25 - 7);
2980 out++;
2981 *out = (inl >> 7);
2982 ++in;
2983 out++;
2984
2985 return in;
2986 }
2987
unpack26_32(const uint32_t * in,uint32_t * out)2988 inline const uint32_t* unpack26_32(const uint32_t* in, uint32_t* out) {
2989 uint32_t inl = util::SafeLoad(in);
2990 inl = arrow::BitUtil::FromLittleEndian(inl);
2991 *out = (inl >> 0) % (1U << 26);
2992 out++;
2993 *out = (inl >> 26);
2994 ++in;
2995 inl = util::SafeLoad(in);
2996 inl = arrow::BitUtil::FromLittleEndian(inl);
2997 *out |= (inl % (1U << 20)) << (26 - 20);
2998 out++;
2999 *out = (inl >> 20);
3000 ++in;
3001 inl = util::SafeLoad(in);
3002 inl = arrow::BitUtil::FromLittleEndian(inl);
3003 *out |= (inl % (1U << 14)) << (26 - 14);
3004 out++;
3005 *out = (inl >> 14);
3006 ++in;
3007 inl = util::SafeLoad(in);
3008 inl = arrow::BitUtil::FromLittleEndian(inl);
3009 *out |= (inl % (1U << 8)) << (26 - 8);
3010 out++;
3011 *out = (inl >> 8);
3012 ++in;
3013 inl = util::SafeLoad(in);
3014 inl = arrow::BitUtil::FromLittleEndian(inl);
3015 *out |= (inl % (1U << 2)) << (26 - 2);
3016 out++;
3017 *out = (inl >> 2) % (1U << 26);
3018 out++;
3019 *out = (inl >> 28);
3020 ++in;
3021 inl = util::SafeLoad(in);
3022 inl = arrow::BitUtil::FromLittleEndian(inl);
3023 *out |= (inl % (1U << 22)) << (26 - 22);
3024 out++;
3025 *out = (inl >> 22);
3026 ++in;
3027 inl = util::SafeLoad(in);
3028 inl = arrow::BitUtil::FromLittleEndian(inl);
3029 *out |= (inl % (1U << 16)) << (26 - 16);
3030 out++;
3031 *out = (inl >> 16);
3032 ++in;
3033 inl = util::SafeLoad(in);
3034 inl = arrow::BitUtil::FromLittleEndian(inl);
3035 *out |= (inl % (1U << 10)) << (26 - 10);
3036 out++;
3037 *out = (inl >> 10);
3038 ++in;
3039 inl = util::SafeLoad(in);
3040 inl = arrow::BitUtil::FromLittleEndian(inl);
3041 *out |= (inl % (1U << 4)) << (26 - 4);
3042 out++;
3043 *out = (inl >> 4) % (1U << 26);
3044 out++;
3045 *out = (inl >> 30);
3046 ++in;
3047 inl = util::SafeLoad(in);
3048 inl = arrow::BitUtil::FromLittleEndian(inl);
3049 *out |= (inl % (1U << 24)) << (26 - 24);
3050 out++;
3051 *out = (inl >> 24);
3052 ++in;
3053 inl = util::SafeLoad(in);
3054 inl = arrow::BitUtil::FromLittleEndian(inl);
3055 *out |= (inl % (1U << 18)) << (26 - 18);
3056 out++;
3057 *out = (inl >> 18);
3058 ++in;
3059 inl = util::SafeLoad(in);
3060 inl = arrow::BitUtil::FromLittleEndian(inl);
3061 *out |= (inl % (1U << 12)) << (26 - 12);
3062 out++;
3063 *out = (inl >> 12);
3064 ++in;
3065 inl = util::SafeLoad(in);
3066 inl = arrow::BitUtil::FromLittleEndian(inl);
3067 *out |= (inl % (1U << 6)) << (26 - 6);
3068 out++;
3069 *out = (inl >> 6);
3070 ++in;
3071 inl = util::SafeLoad(in);
3072 inl = arrow::BitUtil::FromLittleEndian(inl);
3073 out++;
3074 *out = (inl >> 0) % (1U << 26);
3075 out++;
3076 *out = (inl >> 26);
3077 ++in;
3078 inl = util::SafeLoad(in);
3079 inl = arrow::BitUtil::FromLittleEndian(inl);
3080 *out |= (inl % (1U << 20)) << (26 - 20);
3081 out++;
3082 *out = (inl >> 20);
3083 ++in;
3084 inl = util::SafeLoad(in);
3085 inl = arrow::BitUtil::FromLittleEndian(inl);
3086 *out |= (inl % (1U << 14)) << (26 - 14);
3087 out++;
3088 *out = (inl >> 14);
3089 ++in;
3090 inl = util::SafeLoad(in);
3091 inl = arrow::BitUtil::FromLittleEndian(inl);
3092 *out |= (inl % (1U << 8)) << (26 - 8);
3093 out++;
3094 *out = (inl >> 8);
3095 ++in;
3096 inl = util::SafeLoad(in);
3097 inl = arrow::BitUtil::FromLittleEndian(inl);
3098 *out |= (inl % (1U << 2)) << (26 - 2);
3099 out++;
3100 *out = (inl >> 2) % (1U << 26);
3101 out++;
3102 *out = (inl >> 28);
3103 ++in;
3104 inl = util::SafeLoad(in);
3105 inl = arrow::BitUtil::FromLittleEndian(inl);
3106 *out |= (inl % (1U << 22)) << (26 - 22);
3107 out++;
3108 *out = (inl >> 22);
3109 ++in;
3110 inl = util::SafeLoad(in);
3111 inl = arrow::BitUtil::FromLittleEndian(inl);
3112 *out |= (inl % (1U << 16)) << (26 - 16);
3113 out++;
3114 *out = (inl >> 16);
3115 ++in;
3116 inl = util::SafeLoad(in);
3117 inl = arrow::BitUtil::FromLittleEndian(inl);
3118 *out |= (inl % (1U << 10)) << (26 - 10);
3119 out++;
3120 *out = (inl >> 10);
3121 ++in;
3122 inl = util::SafeLoad(in);
3123 inl = arrow::BitUtil::FromLittleEndian(inl);
3124 *out |= (inl % (1U << 4)) << (26 - 4);
3125 out++;
3126 *out = (inl >> 4) % (1U << 26);
3127 out++;
3128 *out = (inl >> 30);
3129 ++in;
3130 inl = util::SafeLoad(in);
3131 inl = arrow::BitUtil::FromLittleEndian(inl);
3132 *out |= (inl % (1U << 24)) << (26 - 24);
3133 out++;
3134 *out = (inl >> 24);
3135 ++in;
3136 inl = util::SafeLoad(in);
3137 inl = arrow::BitUtil::FromLittleEndian(inl);
3138 *out |= (inl % (1U << 18)) << (26 - 18);
3139 out++;
3140 *out = (inl >> 18);
3141 ++in;
3142 inl = util::SafeLoad(in);
3143 inl = arrow::BitUtil::FromLittleEndian(inl);
3144 *out |= (inl % (1U << 12)) << (26 - 12);
3145 out++;
3146 *out = (inl >> 12);
3147 ++in;
3148 inl = util::SafeLoad(in);
3149 inl = arrow::BitUtil::FromLittleEndian(inl);
3150 *out |= (inl % (1U << 6)) << (26 - 6);
3151 out++;
3152 *out = (inl >> 6);
3153 ++in;
3154 out++;
3155
3156 return in;
3157 }
3158
unpack27_32(const uint32_t * in,uint32_t * out)3159 inline const uint32_t* unpack27_32(const uint32_t* in, uint32_t* out) {
3160 uint32_t inl = util::SafeLoad(in);
3161 inl = arrow::BitUtil::FromLittleEndian(inl);
3162 *out = (inl >> 0) % (1U << 27);
3163 out++;
3164 *out = (inl >> 27);
3165 ++in;
3166 inl = util::SafeLoad(in);
3167 inl = arrow::BitUtil::FromLittleEndian(inl);
3168 *out |= (inl % (1U << 22)) << (27 - 22);
3169 out++;
3170 *out = (inl >> 22);
3171 ++in;
3172 inl = util::SafeLoad(in);
3173 inl = arrow::BitUtil::FromLittleEndian(inl);
3174 *out |= (inl % (1U << 17)) << (27 - 17);
3175 out++;
3176 *out = (inl >> 17);
3177 ++in;
3178 inl = util::SafeLoad(in);
3179 inl = arrow::BitUtil::FromLittleEndian(inl);
3180 *out |= (inl % (1U << 12)) << (27 - 12);
3181 out++;
3182 *out = (inl >> 12);
3183 ++in;
3184 inl = util::SafeLoad(in);
3185 inl = arrow::BitUtil::FromLittleEndian(inl);
3186 *out |= (inl % (1U << 7)) << (27 - 7);
3187 out++;
3188 *out = (inl >> 7);
3189 ++in;
3190 inl = util::SafeLoad(in);
3191 inl = arrow::BitUtil::FromLittleEndian(inl);
3192 *out |= (inl % (1U << 2)) << (27 - 2);
3193 out++;
3194 *out = (inl >> 2) % (1U << 27);
3195 out++;
3196 *out = (inl >> 29);
3197 ++in;
3198 inl = util::SafeLoad(in);
3199 inl = arrow::BitUtil::FromLittleEndian(inl);
3200 *out |= (inl % (1U << 24)) << (27 - 24);
3201 out++;
3202 *out = (inl >> 24);
3203 ++in;
3204 inl = util::SafeLoad(in);
3205 inl = arrow::BitUtil::FromLittleEndian(inl);
3206 *out |= (inl % (1U << 19)) << (27 - 19);
3207 out++;
3208 *out = (inl >> 19);
3209 ++in;
3210 inl = util::SafeLoad(in);
3211 inl = arrow::BitUtil::FromLittleEndian(inl);
3212 *out |= (inl % (1U << 14)) << (27 - 14);
3213 out++;
3214 *out = (inl >> 14);
3215 ++in;
3216 inl = util::SafeLoad(in);
3217 inl = arrow::BitUtil::FromLittleEndian(inl);
3218 *out |= (inl % (1U << 9)) << (27 - 9);
3219 out++;
3220 *out = (inl >> 9);
3221 ++in;
3222 inl = util::SafeLoad(in);
3223 inl = arrow::BitUtil::FromLittleEndian(inl);
3224 *out |= (inl % (1U << 4)) << (27 - 4);
3225 out++;
3226 *out = (inl >> 4) % (1U << 27);
3227 out++;
3228 *out = (inl >> 31);
3229 ++in;
3230 inl = util::SafeLoad(in);
3231 inl = arrow::BitUtil::FromLittleEndian(inl);
3232 *out |= (inl % (1U << 26)) << (27 - 26);
3233 out++;
3234 *out = (inl >> 26);
3235 ++in;
3236 inl = util::SafeLoad(in);
3237 inl = arrow::BitUtil::FromLittleEndian(inl);
3238 *out |= (inl % (1U << 21)) << (27 - 21);
3239 out++;
3240 *out = (inl >> 21);
3241 ++in;
3242 inl = util::SafeLoad(in);
3243 inl = arrow::BitUtil::FromLittleEndian(inl);
3244 *out |= (inl % (1U << 16)) << (27 - 16);
3245 out++;
3246 *out = (inl >> 16);
3247 ++in;
3248 inl = util::SafeLoad(in);
3249 inl = arrow::BitUtil::FromLittleEndian(inl);
3250 *out |= (inl % (1U << 11)) << (27 - 11);
3251 out++;
3252 *out = (inl >> 11);
3253 ++in;
3254 inl = util::SafeLoad(in);
3255 inl = arrow::BitUtil::FromLittleEndian(inl);
3256 *out |= (inl % (1U << 6)) << (27 - 6);
3257 out++;
3258 *out = (inl >> 6);
3259 ++in;
3260 inl = util::SafeLoad(in);
3261 inl = arrow::BitUtil::FromLittleEndian(inl);
3262 *out |= (inl % (1U << 1)) << (27 - 1);
3263 out++;
3264 *out = (inl >> 1) % (1U << 27);
3265 out++;
3266 *out = (inl >> 28);
3267 ++in;
3268 inl = util::SafeLoad(in);
3269 inl = arrow::BitUtil::FromLittleEndian(inl);
3270 *out |= (inl % (1U << 23)) << (27 - 23);
3271 out++;
3272 *out = (inl >> 23);
3273 ++in;
3274 inl = util::SafeLoad(in);
3275 inl = arrow::BitUtil::FromLittleEndian(inl);
3276 *out |= (inl % (1U << 18)) << (27 - 18);
3277 out++;
3278 *out = (inl >> 18);
3279 ++in;
3280 inl = util::SafeLoad(in);
3281 inl = arrow::BitUtil::FromLittleEndian(inl);
3282 *out |= (inl % (1U << 13)) << (27 - 13);
3283 out++;
3284 *out = (inl >> 13);
3285 ++in;
3286 inl = util::SafeLoad(in);
3287 inl = arrow::BitUtil::FromLittleEndian(inl);
3288 *out |= (inl % (1U << 8)) << (27 - 8);
3289 out++;
3290 *out = (inl >> 8);
3291 ++in;
3292 inl = util::SafeLoad(in);
3293 inl = arrow::BitUtil::FromLittleEndian(inl);
3294 *out |= (inl % (1U << 3)) << (27 - 3);
3295 out++;
3296 *out = (inl >> 3) % (1U << 27);
3297 out++;
3298 *out = (inl >> 30);
3299 ++in;
3300 inl = util::SafeLoad(in);
3301 inl = arrow::BitUtil::FromLittleEndian(inl);
3302 *out |= (inl % (1U << 25)) << (27 - 25);
3303 out++;
3304 *out = (inl >> 25);
3305 ++in;
3306 inl = util::SafeLoad(in);
3307 inl = arrow::BitUtil::FromLittleEndian(inl);
3308 *out |= (inl % (1U << 20)) << (27 - 20);
3309 out++;
3310 *out = (inl >> 20);
3311 ++in;
3312 inl = util::SafeLoad(in);
3313 inl = arrow::BitUtil::FromLittleEndian(inl);
3314 *out |= (inl % (1U << 15)) << (27 - 15);
3315 out++;
3316 *out = (inl >> 15);
3317 ++in;
3318 inl = util::SafeLoad(in);
3319 inl = arrow::BitUtil::FromLittleEndian(inl);
3320 *out |= (inl % (1U << 10)) << (27 - 10);
3321 out++;
3322 *out = (inl >> 10);
3323 ++in;
3324 inl = util::SafeLoad(in);
3325 inl = arrow::BitUtil::FromLittleEndian(inl);
3326 *out |= (inl % (1U << 5)) << (27 - 5);
3327 out++;
3328 *out = (inl >> 5);
3329 ++in;
3330 out++;
3331
3332 return in;
3333 }
3334
unpack28_32(const uint32_t * in,uint32_t * out)3335 inline const uint32_t* unpack28_32(const uint32_t* in, uint32_t* out) {
3336 uint32_t inl = util::SafeLoad(in);
3337 inl = arrow::BitUtil::FromLittleEndian(inl);
3338 *out = (inl >> 0) % (1U << 28);
3339 out++;
3340 *out = (inl >> 28);
3341 ++in;
3342 inl = util::SafeLoad(in);
3343 inl = arrow::BitUtil::FromLittleEndian(inl);
3344 *out |= (inl % (1U << 24)) << (28 - 24);
3345 out++;
3346 *out = (inl >> 24);
3347 ++in;
3348 inl = util::SafeLoad(in);
3349 inl = arrow::BitUtil::FromLittleEndian(inl);
3350 *out |= (inl % (1U << 20)) << (28 - 20);
3351 out++;
3352 *out = (inl >> 20);
3353 ++in;
3354 inl = util::SafeLoad(in);
3355 inl = arrow::BitUtil::FromLittleEndian(inl);
3356 *out |= (inl % (1U << 16)) << (28 - 16);
3357 out++;
3358 *out = (inl >> 16);
3359 ++in;
3360 inl = util::SafeLoad(in);
3361 inl = arrow::BitUtil::FromLittleEndian(inl);
3362 *out |= (inl % (1U << 12)) << (28 - 12);
3363 out++;
3364 *out = (inl >> 12);
3365 ++in;
3366 inl = util::SafeLoad(in);
3367 inl = arrow::BitUtil::FromLittleEndian(inl);
3368 *out |= (inl % (1U << 8)) << (28 - 8);
3369 out++;
3370 *out = (inl >> 8);
3371 ++in;
3372 inl = util::SafeLoad(in);
3373 inl = arrow::BitUtil::FromLittleEndian(inl);
3374 *out |= (inl % (1U << 4)) << (28 - 4);
3375 out++;
3376 *out = (inl >> 4);
3377 ++in;
3378 inl = util::SafeLoad(in);
3379 inl = arrow::BitUtil::FromLittleEndian(inl);
3380 out++;
3381 *out = (inl >> 0) % (1U << 28);
3382 out++;
3383 *out = (inl >> 28);
3384 ++in;
3385 inl = util::SafeLoad(in);
3386 inl = arrow::BitUtil::FromLittleEndian(inl);
3387 *out |= (inl % (1U << 24)) << (28 - 24);
3388 out++;
3389 *out = (inl >> 24);
3390 ++in;
3391 inl = util::SafeLoad(in);
3392 inl = arrow::BitUtil::FromLittleEndian(inl);
3393 *out |= (inl % (1U << 20)) << (28 - 20);
3394 out++;
3395 *out = (inl >> 20);
3396 ++in;
3397 inl = util::SafeLoad(in);
3398 inl = arrow::BitUtil::FromLittleEndian(inl);
3399 *out |= (inl % (1U << 16)) << (28 - 16);
3400 out++;
3401 *out = (inl >> 16);
3402 ++in;
3403 inl = util::SafeLoad(in);
3404 inl = arrow::BitUtil::FromLittleEndian(inl);
3405 *out |= (inl % (1U << 12)) << (28 - 12);
3406 out++;
3407 *out = (inl >> 12);
3408 ++in;
3409 inl = util::SafeLoad(in);
3410 inl = arrow::BitUtil::FromLittleEndian(inl);
3411 *out |= (inl % (1U << 8)) << (28 - 8);
3412 out++;
3413 *out = (inl >> 8);
3414 ++in;
3415 inl = util::SafeLoad(in);
3416 inl = arrow::BitUtil::FromLittleEndian(inl);
3417 *out |= (inl % (1U << 4)) << (28 - 4);
3418 out++;
3419 *out = (inl >> 4);
3420 ++in;
3421 inl = util::SafeLoad(in);
3422 inl = arrow::BitUtil::FromLittleEndian(inl);
3423 out++;
3424 *out = (inl >> 0) % (1U << 28);
3425 out++;
3426 *out = (inl >> 28);
3427 ++in;
3428 inl = util::SafeLoad(in);
3429 inl = arrow::BitUtil::FromLittleEndian(inl);
3430 *out |= (inl % (1U << 24)) << (28 - 24);
3431 out++;
3432 *out = (inl >> 24);
3433 ++in;
3434 inl = util::SafeLoad(in);
3435 inl = arrow::BitUtil::FromLittleEndian(inl);
3436 *out |= (inl % (1U << 20)) << (28 - 20);
3437 out++;
3438 *out = (inl >> 20);
3439 ++in;
3440 inl = util::SafeLoad(in);
3441 inl = arrow::BitUtil::FromLittleEndian(inl);
3442 *out |= (inl % (1U << 16)) << (28 - 16);
3443 out++;
3444 *out = (inl >> 16);
3445 ++in;
3446 inl = util::SafeLoad(in);
3447 inl = arrow::BitUtil::FromLittleEndian(inl);
3448 *out |= (inl % (1U << 12)) << (28 - 12);
3449 out++;
3450 *out = (inl >> 12);
3451 ++in;
3452 inl = util::SafeLoad(in);
3453 inl = arrow::BitUtil::FromLittleEndian(inl);
3454 *out |= (inl % (1U << 8)) << (28 - 8);
3455 out++;
3456 *out = (inl >> 8);
3457 ++in;
3458 inl = util::SafeLoad(in);
3459 inl = arrow::BitUtil::FromLittleEndian(inl);
3460 *out |= (inl % (1U << 4)) << (28 - 4);
3461 out++;
3462 *out = (inl >> 4);
3463 ++in;
3464 inl = util::SafeLoad(in);
3465 inl = arrow::BitUtil::FromLittleEndian(inl);
3466 out++;
3467 *out = (inl >> 0) % (1U << 28);
3468 out++;
3469 *out = (inl >> 28);
3470 ++in;
3471 inl = util::SafeLoad(in);
3472 inl = arrow::BitUtil::FromLittleEndian(inl);
3473 *out |= (inl % (1U << 24)) << (28 - 24);
3474 out++;
3475 *out = (inl >> 24);
3476 ++in;
3477 inl = util::SafeLoad(in);
3478 inl = arrow::BitUtil::FromLittleEndian(inl);
3479 *out |= (inl % (1U << 20)) << (28 - 20);
3480 out++;
3481 *out = (inl >> 20);
3482 ++in;
3483 inl = util::SafeLoad(in);
3484 inl = arrow::BitUtil::FromLittleEndian(inl);
3485 *out |= (inl % (1U << 16)) << (28 - 16);
3486 out++;
3487 *out = (inl >> 16);
3488 ++in;
3489 inl = util::SafeLoad(in);
3490 inl = arrow::BitUtil::FromLittleEndian(inl);
3491 *out |= (inl % (1U << 12)) << (28 - 12);
3492 out++;
3493 *out = (inl >> 12);
3494 ++in;
3495 inl = util::SafeLoad(in);
3496 inl = arrow::BitUtil::FromLittleEndian(inl);
3497 *out |= (inl % (1U << 8)) << (28 - 8);
3498 out++;
3499 *out = (inl >> 8);
3500 ++in;
3501 inl = util::SafeLoad(in);
3502 inl = arrow::BitUtil::FromLittleEndian(inl);
3503 *out |= (inl % (1U << 4)) << (28 - 4);
3504 out++;
3505 *out = (inl >> 4);
3506 ++in;
3507 out++;
3508
3509 return in;
3510 }
3511
unpack29_32(const uint32_t * in,uint32_t * out)3512 inline const uint32_t* unpack29_32(const uint32_t* in, uint32_t* out) {
3513 uint32_t inl = util::SafeLoad(in);
3514 inl = arrow::BitUtil::FromLittleEndian(inl);
3515 *out = (inl >> 0) % (1U << 29);
3516 out++;
3517 *out = (inl >> 29);
3518 ++in;
3519 inl = util::SafeLoad(in);
3520 inl = arrow::BitUtil::FromLittleEndian(inl);
3521 *out |= (inl % (1U << 26)) << (29 - 26);
3522 out++;
3523 *out = (inl >> 26);
3524 ++in;
3525 inl = util::SafeLoad(in);
3526 inl = arrow::BitUtil::FromLittleEndian(inl);
3527 *out |= (inl % (1U << 23)) << (29 - 23);
3528 out++;
3529 *out = (inl >> 23);
3530 ++in;
3531 inl = util::SafeLoad(in);
3532 inl = arrow::BitUtil::FromLittleEndian(inl);
3533 *out |= (inl % (1U << 20)) << (29 - 20);
3534 out++;
3535 *out = (inl >> 20);
3536 ++in;
3537 inl = util::SafeLoad(in);
3538 inl = arrow::BitUtil::FromLittleEndian(inl);
3539 *out |= (inl % (1U << 17)) << (29 - 17);
3540 out++;
3541 *out = (inl >> 17);
3542 ++in;
3543 inl = util::SafeLoad(in);
3544 inl = arrow::BitUtil::FromLittleEndian(inl);
3545 *out |= (inl % (1U << 14)) << (29 - 14);
3546 out++;
3547 *out = (inl >> 14);
3548 ++in;
3549 inl = util::SafeLoad(in);
3550 inl = arrow::BitUtil::FromLittleEndian(inl);
3551 *out |= (inl % (1U << 11)) << (29 - 11);
3552 out++;
3553 *out = (inl >> 11);
3554 ++in;
3555 inl = util::SafeLoad(in);
3556 inl = arrow::BitUtil::FromLittleEndian(inl);
3557 *out |= (inl % (1U << 8)) << (29 - 8);
3558 out++;
3559 *out = (inl >> 8);
3560 ++in;
3561 inl = util::SafeLoad(in);
3562 inl = arrow::BitUtil::FromLittleEndian(inl);
3563 *out |= (inl % (1U << 5)) << (29 - 5);
3564 out++;
3565 *out = (inl >> 5);
3566 ++in;
3567 inl = util::SafeLoad(in);
3568 inl = arrow::BitUtil::FromLittleEndian(inl);
3569 *out |= (inl % (1U << 2)) << (29 - 2);
3570 out++;
3571 *out = (inl >> 2) % (1U << 29);
3572 out++;
3573 *out = (inl >> 31);
3574 ++in;
3575 inl = util::SafeLoad(in);
3576 inl = arrow::BitUtil::FromLittleEndian(inl);
3577 *out |= (inl % (1U << 28)) << (29 - 28);
3578 out++;
3579 *out = (inl >> 28);
3580 ++in;
3581 inl = util::SafeLoad(in);
3582 inl = arrow::BitUtil::FromLittleEndian(inl);
3583 *out |= (inl % (1U << 25)) << (29 - 25);
3584 out++;
3585 *out = (inl >> 25);
3586 ++in;
3587 inl = util::SafeLoad(in);
3588 inl = arrow::BitUtil::FromLittleEndian(inl);
3589 *out |= (inl % (1U << 22)) << (29 - 22);
3590 out++;
3591 *out = (inl >> 22);
3592 ++in;
3593 inl = util::SafeLoad(in);
3594 inl = arrow::BitUtil::FromLittleEndian(inl);
3595 *out |= (inl % (1U << 19)) << (29 - 19);
3596 out++;
3597 *out = (inl >> 19);
3598 ++in;
3599 inl = util::SafeLoad(in);
3600 inl = arrow::BitUtil::FromLittleEndian(inl);
3601 *out |= (inl % (1U << 16)) << (29 - 16);
3602 out++;
3603 *out = (inl >> 16);
3604 ++in;
3605 inl = util::SafeLoad(in);
3606 inl = arrow::BitUtil::FromLittleEndian(inl);
3607 *out |= (inl % (1U << 13)) << (29 - 13);
3608 out++;
3609 *out = (inl >> 13);
3610 ++in;
3611 inl = util::SafeLoad(in);
3612 inl = arrow::BitUtil::FromLittleEndian(inl);
3613 *out |= (inl % (1U << 10)) << (29 - 10);
3614 out++;
3615 *out = (inl >> 10);
3616 ++in;
3617 inl = util::SafeLoad(in);
3618 inl = arrow::BitUtil::FromLittleEndian(inl);
3619 *out |= (inl % (1U << 7)) << (29 - 7);
3620 out++;
3621 *out = (inl >> 7);
3622 ++in;
3623 inl = util::SafeLoad(in);
3624 inl = arrow::BitUtil::FromLittleEndian(inl);
3625 *out |= (inl % (1U << 4)) << (29 - 4);
3626 out++;
3627 *out = (inl >> 4);
3628 ++in;
3629 inl = util::SafeLoad(in);
3630 inl = arrow::BitUtil::FromLittleEndian(inl);
3631 *out |= (inl % (1U << 1)) << (29 - 1);
3632 out++;
3633 *out = (inl >> 1) % (1U << 29);
3634 out++;
3635 *out = (inl >> 30);
3636 ++in;
3637 inl = util::SafeLoad(in);
3638 inl = arrow::BitUtil::FromLittleEndian(inl);
3639 *out |= (inl % (1U << 27)) << (29 - 27);
3640 out++;
3641 *out = (inl >> 27);
3642 ++in;
3643 inl = util::SafeLoad(in);
3644 inl = arrow::BitUtil::FromLittleEndian(inl);
3645 *out |= (inl % (1U << 24)) << (29 - 24);
3646 out++;
3647 *out = (inl >> 24);
3648 ++in;
3649 inl = util::SafeLoad(in);
3650 inl = arrow::BitUtil::FromLittleEndian(inl);
3651 *out |= (inl % (1U << 21)) << (29 - 21);
3652 out++;
3653 *out = (inl >> 21);
3654 ++in;
3655 inl = util::SafeLoad(in);
3656 inl = arrow::BitUtil::FromLittleEndian(inl);
3657 *out |= (inl % (1U << 18)) << (29 - 18);
3658 out++;
3659 *out = (inl >> 18);
3660 ++in;
3661 inl = util::SafeLoad(in);
3662 inl = arrow::BitUtil::FromLittleEndian(inl);
3663 *out |= (inl % (1U << 15)) << (29 - 15);
3664 out++;
3665 *out = (inl >> 15);
3666 ++in;
3667 inl = util::SafeLoad(in);
3668 inl = arrow::BitUtil::FromLittleEndian(inl);
3669 *out |= (inl % (1U << 12)) << (29 - 12);
3670 out++;
3671 *out = (inl >> 12);
3672 ++in;
3673 inl = util::SafeLoad(in);
3674 inl = arrow::BitUtil::FromLittleEndian(inl);
3675 *out |= (inl % (1U << 9)) << (29 - 9);
3676 out++;
3677 *out = (inl >> 9);
3678 ++in;
3679 inl = util::SafeLoad(in);
3680 inl = arrow::BitUtil::FromLittleEndian(inl);
3681 *out |= (inl % (1U << 6)) << (29 - 6);
3682 out++;
3683 *out = (inl >> 6);
3684 ++in;
3685 inl = util::SafeLoad(in);
3686 inl = arrow::BitUtil::FromLittleEndian(inl);
3687 *out |= (inl % (1U << 3)) << (29 - 3);
3688 out++;
3689 *out = (inl >> 3);
3690 ++in;
3691 out++;
3692
3693 return in;
3694 }
3695
unpack30_32(const uint32_t * in,uint32_t * out)3696 inline const uint32_t* unpack30_32(const uint32_t* in, uint32_t* out) {
3697 uint32_t inl = util::SafeLoad(in);
3698 inl = arrow::BitUtil::FromLittleEndian(inl);
3699 *out = (inl >> 0) % (1U << 30);
3700 out++;
3701 *out = (inl >> 30);
3702 ++in;
3703 inl = util::SafeLoad(in);
3704 inl = arrow::BitUtil::FromLittleEndian(inl);
3705 *out |= (inl % (1U << 28)) << (30 - 28);
3706 out++;
3707 *out = (inl >> 28);
3708 ++in;
3709 inl = util::SafeLoad(in);
3710 inl = arrow::BitUtil::FromLittleEndian(inl);
3711 *out |= (inl % (1U << 26)) << (30 - 26);
3712 out++;
3713 *out = (inl >> 26);
3714 ++in;
3715 inl = util::SafeLoad(in);
3716 inl = arrow::BitUtil::FromLittleEndian(inl);
3717 *out |= (inl % (1U << 24)) << (30 - 24);
3718 out++;
3719 *out = (inl >> 24);
3720 ++in;
3721 inl = util::SafeLoad(in);
3722 inl = arrow::BitUtil::FromLittleEndian(inl);
3723 *out |= (inl % (1U << 22)) << (30 - 22);
3724 out++;
3725 *out = (inl >> 22);
3726 ++in;
3727 inl = util::SafeLoad(in);
3728 inl = arrow::BitUtil::FromLittleEndian(inl);
3729 *out |= (inl % (1U << 20)) << (30 - 20);
3730 out++;
3731 *out = (inl >> 20);
3732 ++in;
3733 inl = util::SafeLoad(in);
3734 inl = arrow::BitUtil::FromLittleEndian(inl);
3735 *out |= (inl % (1U << 18)) << (30 - 18);
3736 out++;
3737 *out = (inl >> 18);
3738 ++in;
3739 inl = util::SafeLoad(in);
3740 inl = arrow::BitUtil::FromLittleEndian(inl);
3741 *out |= (inl % (1U << 16)) << (30 - 16);
3742 out++;
3743 *out = (inl >> 16);
3744 ++in;
3745 inl = util::SafeLoad(in);
3746 inl = arrow::BitUtil::FromLittleEndian(inl);
3747 *out |= (inl % (1U << 14)) << (30 - 14);
3748 out++;
3749 *out = (inl >> 14);
3750 ++in;
3751 inl = util::SafeLoad(in);
3752 inl = arrow::BitUtil::FromLittleEndian(inl);
3753 *out |= (inl % (1U << 12)) << (30 - 12);
3754 out++;
3755 *out = (inl >> 12);
3756 ++in;
3757 inl = util::SafeLoad(in);
3758 inl = arrow::BitUtil::FromLittleEndian(inl);
3759 *out |= (inl % (1U << 10)) << (30 - 10);
3760 out++;
3761 *out = (inl >> 10);
3762 ++in;
3763 inl = util::SafeLoad(in);
3764 inl = arrow::BitUtil::FromLittleEndian(inl);
3765 *out |= (inl % (1U << 8)) << (30 - 8);
3766 out++;
3767 *out = (inl >> 8);
3768 ++in;
3769 inl = util::SafeLoad(in);
3770 inl = arrow::BitUtil::FromLittleEndian(inl);
3771 *out |= (inl % (1U << 6)) << (30 - 6);
3772 out++;
3773 *out = (inl >> 6);
3774 ++in;
3775 inl = util::SafeLoad(in);
3776 inl = arrow::BitUtil::FromLittleEndian(inl);
3777 *out |= (inl % (1U << 4)) << (30 - 4);
3778 out++;
3779 *out = (inl >> 4);
3780 ++in;
3781 inl = util::SafeLoad(in);
3782 inl = arrow::BitUtil::FromLittleEndian(inl);
3783 *out |= (inl % (1U << 2)) << (30 - 2);
3784 out++;
3785 *out = (inl >> 2);
3786 ++in;
3787 inl = util::SafeLoad(in);
3788 inl = arrow::BitUtil::FromLittleEndian(inl);
3789 out++;
3790 *out = (inl >> 0) % (1U << 30);
3791 out++;
3792 *out = (inl >> 30);
3793 ++in;
3794 inl = util::SafeLoad(in);
3795 inl = arrow::BitUtil::FromLittleEndian(inl);
3796 *out |= (inl % (1U << 28)) << (30 - 28);
3797 out++;
3798 *out = (inl >> 28);
3799 ++in;
3800 inl = util::SafeLoad(in);
3801 inl = arrow::BitUtil::FromLittleEndian(inl);
3802 *out |= (inl % (1U << 26)) << (30 - 26);
3803 out++;
3804 *out = (inl >> 26);
3805 ++in;
3806 inl = util::SafeLoad(in);
3807 inl = arrow::BitUtil::FromLittleEndian(inl);
3808 *out |= (inl % (1U << 24)) << (30 - 24);
3809 out++;
3810 *out = (inl >> 24);
3811 ++in;
3812 inl = util::SafeLoad(in);
3813 inl = arrow::BitUtil::FromLittleEndian(inl);
3814 *out |= (inl % (1U << 22)) << (30 - 22);
3815 out++;
3816 *out = (inl >> 22);
3817 ++in;
3818 inl = util::SafeLoad(in);
3819 inl = arrow::BitUtil::FromLittleEndian(inl);
3820 *out |= (inl % (1U << 20)) << (30 - 20);
3821 out++;
3822 *out = (inl >> 20);
3823 ++in;
3824 inl = util::SafeLoad(in);
3825 inl = arrow::BitUtil::FromLittleEndian(inl);
3826 *out |= (inl % (1U << 18)) << (30 - 18);
3827 out++;
3828 *out = (inl >> 18);
3829 ++in;
3830 inl = util::SafeLoad(in);
3831 inl = arrow::BitUtil::FromLittleEndian(inl);
3832 *out |= (inl % (1U << 16)) << (30 - 16);
3833 out++;
3834 *out = (inl >> 16);
3835 ++in;
3836 inl = util::SafeLoad(in);
3837 inl = arrow::BitUtil::FromLittleEndian(inl);
3838 *out |= (inl % (1U << 14)) << (30 - 14);
3839 out++;
3840 *out = (inl >> 14);
3841 ++in;
3842 inl = util::SafeLoad(in);
3843 inl = arrow::BitUtil::FromLittleEndian(inl);
3844 *out |= (inl % (1U << 12)) << (30 - 12);
3845 out++;
3846 *out = (inl >> 12);
3847 ++in;
3848 inl = util::SafeLoad(in);
3849 inl = arrow::BitUtil::FromLittleEndian(inl);
3850 *out |= (inl % (1U << 10)) << (30 - 10);
3851 out++;
3852 *out = (inl >> 10);
3853 ++in;
3854 inl = util::SafeLoad(in);
3855 inl = arrow::BitUtil::FromLittleEndian(inl);
3856 *out |= (inl % (1U << 8)) << (30 - 8);
3857 out++;
3858 *out = (inl >> 8);
3859 ++in;
3860 inl = util::SafeLoad(in);
3861 inl = arrow::BitUtil::FromLittleEndian(inl);
3862 *out |= (inl % (1U << 6)) << (30 - 6);
3863 out++;
3864 *out = (inl >> 6);
3865 ++in;
3866 inl = util::SafeLoad(in);
3867 inl = arrow::BitUtil::FromLittleEndian(inl);
3868 *out |= (inl % (1U << 4)) << (30 - 4);
3869 out++;
3870 *out = (inl >> 4);
3871 ++in;
3872 inl = util::SafeLoad(in);
3873 inl = arrow::BitUtil::FromLittleEndian(inl);
3874 *out |= (inl % (1U << 2)) << (30 - 2);
3875 out++;
3876 *out = (inl >> 2);
3877 ++in;
3878 out++;
3879
3880 return in;
3881 }
3882
unpack31_32(const uint32_t * in,uint32_t * out)3883 inline const uint32_t* unpack31_32(const uint32_t* in, uint32_t* out) {
3884 uint32_t inl = util::SafeLoad(in);
3885 inl = arrow::BitUtil::FromLittleEndian(inl);
3886 *out = (inl >> 0) % (1U << 31);
3887 out++;
3888 *out = (inl >> 31);
3889 ++in;
3890 inl = util::SafeLoad(in);
3891 inl = arrow::BitUtil::FromLittleEndian(inl);
3892 *out |= (inl % (1U << 30)) << (31 - 30);
3893 out++;
3894 *out = (inl >> 30);
3895 ++in;
3896 inl = util::SafeLoad(in);
3897 inl = arrow::BitUtil::FromLittleEndian(inl);
3898 *out |= (inl % (1U << 29)) << (31 - 29);
3899 out++;
3900 *out = (inl >> 29);
3901 ++in;
3902 inl = util::SafeLoad(in);
3903 inl = arrow::BitUtil::FromLittleEndian(inl);
3904 *out |= (inl % (1U << 28)) << (31 - 28);
3905 out++;
3906 *out = (inl >> 28);
3907 ++in;
3908 inl = util::SafeLoad(in);
3909 inl = arrow::BitUtil::FromLittleEndian(inl);
3910 *out |= (inl % (1U << 27)) << (31 - 27);
3911 out++;
3912 *out = (inl >> 27);
3913 ++in;
3914 inl = util::SafeLoad(in);
3915 inl = arrow::BitUtil::FromLittleEndian(inl);
3916 *out |= (inl % (1U << 26)) << (31 - 26);
3917 out++;
3918 *out = (inl >> 26);
3919 ++in;
3920 inl = util::SafeLoad(in);
3921 inl = arrow::BitUtil::FromLittleEndian(inl);
3922 *out |= (inl % (1U << 25)) << (31 - 25);
3923 out++;
3924 *out = (inl >> 25);
3925 ++in;
3926 inl = util::SafeLoad(in);
3927 inl = arrow::BitUtil::FromLittleEndian(inl);
3928 *out |= (inl % (1U << 24)) << (31 - 24);
3929 out++;
3930 *out = (inl >> 24);
3931 ++in;
3932 inl = util::SafeLoad(in);
3933 inl = arrow::BitUtil::FromLittleEndian(inl);
3934 *out |= (inl % (1U << 23)) << (31 - 23);
3935 out++;
3936 *out = (inl >> 23);
3937 ++in;
3938 inl = util::SafeLoad(in);
3939 inl = arrow::BitUtil::FromLittleEndian(inl);
3940 *out |= (inl % (1U << 22)) << (31 - 22);
3941 out++;
3942 *out = (inl >> 22);
3943 ++in;
3944 inl = util::SafeLoad(in);
3945 inl = arrow::BitUtil::FromLittleEndian(inl);
3946 *out |= (inl % (1U << 21)) << (31 - 21);
3947 out++;
3948 *out = (inl >> 21);
3949 ++in;
3950 inl = util::SafeLoad(in);
3951 inl = arrow::BitUtil::FromLittleEndian(inl);
3952 *out |= (inl % (1U << 20)) << (31 - 20);
3953 out++;
3954 *out = (inl >> 20);
3955 ++in;
3956 inl = util::SafeLoad(in);
3957 inl = arrow::BitUtil::FromLittleEndian(inl);
3958 *out |= (inl % (1U << 19)) << (31 - 19);
3959 out++;
3960 *out = (inl >> 19);
3961 ++in;
3962 inl = util::SafeLoad(in);
3963 inl = arrow::BitUtil::FromLittleEndian(inl);
3964 *out |= (inl % (1U << 18)) << (31 - 18);
3965 out++;
3966 *out = (inl >> 18);
3967 ++in;
3968 inl = util::SafeLoad(in);
3969 inl = arrow::BitUtil::FromLittleEndian(inl);
3970 *out |= (inl % (1U << 17)) << (31 - 17);
3971 out++;
3972 *out = (inl >> 17);
3973 ++in;
3974 inl = util::SafeLoad(in);
3975 inl = arrow::BitUtil::FromLittleEndian(inl);
3976 *out |= (inl % (1U << 16)) << (31 - 16);
3977 out++;
3978 *out = (inl >> 16);
3979 ++in;
3980 inl = util::SafeLoad(in);
3981 inl = arrow::BitUtil::FromLittleEndian(inl);
3982 *out |= (inl % (1U << 15)) << (31 - 15);
3983 out++;
3984 *out = (inl >> 15);
3985 ++in;
3986 inl = util::SafeLoad(in);
3987 inl = arrow::BitUtil::FromLittleEndian(inl);
3988 *out |= (inl % (1U << 14)) << (31 - 14);
3989 out++;
3990 *out = (inl >> 14);
3991 ++in;
3992 inl = util::SafeLoad(in);
3993 inl = arrow::BitUtil::FromLittleEndian(inl);
3994 *out |= (inl % (1U << 13)) << (31 - 13);
3995 out++;
3996 *out = (inl >> 13);
3997 ++in;
3998 inl = util::SafeLoad(in);
3999 inl = arrow::BitUtil::FromLittleEndian(inl);
4000 *out |= (inl % (1U << 12)) << (31 - 12);
4001 out++;
4002 *out = (inl >> 12);
4003 ++in;
4004 inl = util::SafeLoad(in);
4005 inl = arrow::BitUtil::FromLittleEndian(inl);
4006 *out |= (inl % (1U << 11)) << (31 - 11);
4007 out++;
4008 *out = (inl >> 11);
4009 ++in;
4010 inl = util::SafeLoad(in);
4011 inl = arrow::BitUtil::FromLittleEndian(inl);
4012 *out |= (inl % (1U << 10)) << (31 - 10);
4013 out++;
4014 *out = (inl >> 10);
4015 ++in;
4016 inl = util::SafeLoad(in);
4017 inl = arrow::BitUtil::FromLittleEndian(inl);
4018 *out |= (inl % (1U << 9)) << (31 - 9);
4019 out++;
4020 *out = (inl >> 9);
4021 ++in;
4022 inl = util::SafeLoad(in);
4023 inl = arrow::BitUtil::FromLittleEndian(inl);
4024 *out |= (inl % (1U << 8)) << (31 - 8);
4025 out++;
4026 *out = (inl >> 8);
4027 ++in;
4028 inl = util::SafeLoad(in);
4029 inl = arrow::BitUtil::FromLittleEndian(inl);
4030 *out |= (inl % (1U << 7)) << (31 - 7);
4031 out++;
4032 *out = (inl >> 7);
4033 ++in;
4034 inl = util::SafeLoad(in);
4035 inl = arrow::BitUtil::FromLittleEndian(inl);
4036 *out |= (inl % (1U << 6)) << (31 - 6);
4037 out++;
4038 *out = (inl >> 6);
4039 ++in;
4040 inl = util::SafeLoad(in);
4041 inl = arrow::BitUtil::FromLittleEndian(inl);
4042 *out |= (inl % (1U << 5)) << (31 - 5);
4043 out++;
4044 *out = (inl >> 5);
4045 ++in;
4046 inl = util::SafeLoad(in);
4047 inl = arrow::BitUtil::FromLittleEndian(inl);
4048 *out |= (inl % (1U << 4)) << (31 - 4);
4049 out++;
4050 *out = (inl >> 4);
4051 ++in;
4052 inl = util::SafeLoad(in);
4053 inl = arrow::BitUtil::FromLittleEndian(inl);
4054 *out |= (inl % (1U << 3)) << (31 - 3);
4055 out++;
4056 *out = (inl >> 3);
4057 ++in;
4058 inl = util::SafeLoad(in);
4059 inl = arrow::BitUtil::FromLittleEndian(inl);
4060 *out |= (inl % (1U << 2)) << (31 - 2);
4061 out++;
4062 *out = (inl >> 2);
4063 ++in;
4064 inl = util::SafeLoad(in);
4065 inl = arrow::BitUtil::FromLittleEndian(inl);
4066 *out |= (inl % (1U << 1)) << (31 - 1);
4067 out++;
4068 *out = (inl >> 1);
4069 ++in;
4070 out++;
4071
4072 return in;
4073 }
4074
unpack32_32(const uint32_t * in,uint32_t * out)4075 inline const uint32_t* unpack32_32(const uint32_t* in, uint32_t* out) {
4076 uint32_t inl = util::SafeLoad(in);
4077 inl = arrow::BitUtil::FromLittleEndian(inl);
4078 *out = (inl >> 0);
4079 ++in;
4080 inl = util::SafeLoad(in);
4081 inl = arrow::BitUtil::FromLittleEndian(inl);
4082 out++;
4083 *out = (inl >> 0);
4084 ++in;
4085 inl = util::SafeLoad(in);
4086 inl = arrow::BitUtil::FromLittleEndian(inl);
4087 out++;
4088 *out = (inl >> 0);
4089 ++in;
4090 inl = util::SafeLoad(in);
4091 inl = arrow::BitUtil::FromLittleEndian(inl);
4092 out++;
4093 *out = (inl >> 0);
4094 ++in;
4095 inl = util::SafeLoad(in);
4096 inl = arrow::BitUtil::FromLittleEndian(inl);
4097 out++;
4098 *out = (inl >> 0);
4099 ++in;
4100 inl = util::SafeLoad(in);
4101 inl = arrow::BitUtil::FromLittleEndian(inl);
4102 out++;
4103 *out = (inl >> 0);
4104 ++in;
4105 inl = util::SafeLoad(in);
4106 inl = arrow::BitUtil::FromLittleEndian(inl);
4107 out++;
4108 *out = (inl >> 0);
4109 ++in;
4110 inl = util::SafeLoad(in);
4111 inl = arrow::BitUtil::FromLittleEndian(inl);
4112 out++;
4113 *out = (inl >> 0);
4114 ++in;
4115 inl = util::SafeLoad(in);
4116 inl = arrow::BitUtil::FromLittleEndian(inl);
4117 out++;
4118 *out = (inl >> 0);
4119 ++in;
4120 inl = util::SafeLoad(in);
4121 inl = arrow::BitUtil::FromLittleEndian(inl);
4122 out++;
4123 *out = (inl >> 0);
4124 ++in;
4125 inl = util::SafeLoad(in);
4126 inl = arrow::BitUtil::FromLittleEndian(inl);
4127 out++;
4128 *out = (inl >> 0);
4129 ++in;
4130 inl = util::SafeLoad(in);
4131 inl = arrow::BitUtil::FromLittleEndian(inl);
4132 out++;
4133 *out = (inl >> 0);
4134 ++in;
4135 inl = util::SafeLoad(in);
4136 inl = arrow::BitUtil::FromLittleEndian(inl);
4137 out++;
4138 *out = (inl >> 0);
4139 ++in;
4140 inl = util::SafeLoad(in);
4141 inl = arrow::BitUtil::FromLittleEndian(inl);
4142 out++;
4143 *out = (inl >> 0);
4144 ++in;
4145 inl = util::SafeLoad(in);
4146 inl = arrow::BitUtil::FromLittleEndian(inl);
4147 out++;
4148 *out = (inl >> 0);
4149 ++in;
4150 inl = util::SafeLoad(in);
4151 inl = arrow::BitUtil::FromLittleEndian(inl);
4152 out++;
4153 *out = (inl >> 0);
4154 ++in;
4155 inl = util::SafeLoad(in);
4156 inl = arrow::BitUtil::FromLittleEndian(inl);
4157 out++;
4158 *out = (inl >> 0);
4159 ++in;
4160 inl = util::SafeLoad(in);
4161 inl = arrow::BitUtil::FromLittleEndian(inl);
4162 out++;
4163 *out = (inl >> 0);
4164 ++in;
4165 inl = util::SafeLoad(in);
4166 inl = arrow::BitUtil::FromLittleEndian(inl);
4167 out++;
4168 *out = (inl >> 0);
4169 ++in;
4170 inl = util::SafeLoad(in);
4171 inl = arrow::BitUtil::FromLittleEndian(inl);
4172 out++;
4173 *out = (inl >> 0);
4174 ++in;
4175 inl = util::SafeLoad(in);
4176 inl = arrow::BitUtil::FromLittleEndian(inl);
4177 out++;
4178 *out = (inl >> 0);
4179 ++in;
4180 inl = util::SafeLoad(in);
4181 inl = arrow::BitUtil::FromLittleEndian(inl);
4182 out++;
4183 *out = (inl >> 0);
4184 ++in;
4185 inl = util::SafeLoad(in);
4186 inl = arrow::BitUtil::FromLittleEndian(inl);
4187 out++;
4188 *out = (inl >> 0);
4189 ++in;
4190 inl = util::SafeLoad(in);
4191 inl = arrow::BitUtil::FromLittleEndian(inl);
4192 out++;
4193 *out = (inl >> 0);
4194 ++in;
4195 inl = util::SafeLoad(in);
4196 inl = arrow::BitUtil::FromLittleEndian(inl);
4197 out++;
4198 *out = (inl >> 0);
4199 ++in;
4200 inl = util::SafeLoad(in);
4201 inl = arrow::BitUtil::FromLittleEndian(inl);
4202 out++;
4203 *out = (inl >> 0);
4204 ++in;
4205 inl = util::SafeLoad(in);
4206 inl = arrow::BitUtil::FromLittleEndian(inl);
4207 out++;
4208 *out = (inl >> 0);
4209 ++in;
4210 inl = util::SafeLoad(in);
4211 inl = arrow::BitUtil::FromLittleEndian(inl);
4212 out++;
4213 *out = (inl >> 0);
4214 ++in;
4215 inl = util::SafeLoad(in);
4216 inl = arrow::BitUtil::FromLittleEndian(inl);
4217 out++;
4218 *out = (inl >> 0);
4219 ++in;
4220 inl = util::SafeLoad(in);
4221 inl = arrow::BitUtil::FromLittleEndian(inl);
4222 out++;
4223 *out = (inl >> 0);
4224 ++in;
4225 inl = util::SafeLoad(in);
4226 inl = arrow::BitUtil::FromLittleEndian(inl);
4227 out++;
4228 *out = (inl >> 0);
4229 ++in;
4230 inl = util::SafeLoad(in);
4231 inl = arrow::BitUtil::FromLittleEndian(inl);
4232 out++;
4233 *out = (inl >> 0);
4234 ++in;
4235 out++;
4236
4237 return in;
4238 }
4239
nullunpacker32(const uint32_t * in,uint32_t * out)4240 inline const uint32_t* nullunpacker32(const uint32_t* in, uint32_t* out) {
4241 for (int k = 0; k < 32; ++k) {
4242 out[k] = 0;
4243 }
4244 return in;
4245 }
4246
4247 } // namespace internal
4248 } // namespace arrow
4249