1 static char rcsid[] = "$Id: bitpack64-incr.c 212659 2018-01-20 00:58:14Z twu $";
2 #ifdef HAVE_CONFIG_H
3 #include <config.h>
4 #endif
5
6 #include "bitpack64-incr.h"
7 #include "bitpack64-access.h"
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include "mem.h"
12
13 #ifdef WORDS_BIGENDIAN
14 #include "bigendian.h"
15 #define CONVERT(x) Bigendian_convert_uint(x)
16 #else
17 #define CONVERT(x) x
18 #endif
19
20
21 #define CHECK 1
22
23
24 #ifdef DEBUG
25 #define debug(x) x
26 #else
27 #define debug(x)
28 #endif
29
30
31 #define BLOCKSIZE 64
32
33 /* Vertical access is slightly more efficient than horizontal */
34 /* Choice needs to match that in bitpack64-access */
35
36 #ifdef HORIZONTAL
37 #define WORD_INCR 1 /* 1 for horizontal; 4 for vertical */
38 #else
39 #define WORD_INCR 4
40 #endif
41
42
43 #define BIT0 0x1;
44 #define BIT2 0x4;
45 #define BIT4 0x10;
46 #define BIT6 0x40;
47 #define BIT8 0x100;
48 #define BIT10 0x400;
49 #define BIT12 0x1000;
50 #define BIT14 0x4000;
51 #define BIT16 0x10000;
52 #define BIT18 0x40000;
53 #define BIT20 0x100000;
54 #define BIT22 0x400000;
55 #define BIT24 0x1000000;
56 #define BIT26 0x4000000;
57 #define BIT28 0x10000000;
58 #define BIT30 0x40000000;
59
60
61
62 static UINT4
incr_00(UINT4 * in)63 incr_00 (UINT4 *in) {
64 abort();
65 return 0U;
66 }
67
68
69
70 static UINT4
incr_02_00(UINT4 * in)71 incr_02_00 (UINT4 *in) {
72 UINT4 prev = ( CONVERT(*in) >> 0 ) % (1U << 2 ) ;
73 *in += BIT0;
74 return prev;
75 }
76
77 static UINT4
incr_02_01(UINT4 * in)78 incr_02_01 (UINT4 *in) {
79 UINT4 prev = ( CONVERT(*in) >> 2 ) % (1U << 2 ) ;
80 *in += BIT2;
81 return prev;
82 }
83
84 static UINT4
incr_02_02(UINT4 * in)85 incr_02_02 (UINT4 *in) {
86 UINT4 prev = ( CONVERT(*in) >> 4 ) % (1U << 2 ) ;
87 *in += BIT4;
88 return prev;
89 }
90
91 static UINT4
incr_02_03(UINT4 * in)92 incr_02_03 (UINT4 *in) {
93 UINT4 prev = ( CONVERT(*in) >> 6 ) % (1U << 2 ) ;
94 *in += BIT6;
95 return prev;
96 }
97
98 static UINT4
incr_02_04(UINT4 * in)99 incr_02_04 (UINT4 *in) {
100 UINT4 prev = ( CONVERT(*in) >> 8 ) % (1U << 2 ) ;
101 *in += BIT8;
102 return prev;
103 }
104
105 static UINT4
incr_02_05(UINT4 * in)106 incr_02_05 (UINT4 *in) {
107 UINT4 prev = ( CONVERT(*in) >> 10 ) % (1U << 2 ) ;
108 *in += BIT10;
109 return prev;
110 }
111
112 static UINT4
incr_02_06(UINT4 * in)113 incr_02_06 (UINT4 *in) {
114 UINT4 prev = ( CONVERT(*in) >> 12 ) % (1U << 2 ) ;
115 *in += BIT12;
116 return prev;
117 }
118
119 static UINT4
incr_02_07(UINT4 * in)120 incr_02_07 (UINT4 *in) {
121 UINT4 prev = ( CONVERT(*in) >> 14 ) % (1U << 2 ) ;
122 *in += BIT14;
123 return prev;
124 }
125
126 static UINT4
incr_02_08(UINT4 * in)127 incr_02_08 (UINT4 *in) {
128 UINT4 prev = ( CONVERT(*in) >> 16 ) % (1U << 2 ) ;
129 *in += BIT16;
130 return prev;
131 }
132
133 static UINT4
incr_02_09(UINT4 * in)134 incr_02_09 (UINT4 *in) {
135 UINT4 prev = ( CONVERT(*in) >> 18 ) % (1U << 2 ) ;
136 *in += BIT18;
137 return prev;
138 }
139
140 static UINT4
incr_02_10(UINT4 * in)141 incr_02_10 (UINT4 *in) {
142 UINT4 prev = ( CONVERT(*in) >> 20 ) % (1U << 2 ) ;
143 *in += BIT20;
144 return prev;
145 }
146
147 static UINT4
incr_02_11(UINT4 * in)148 incr_02_11 (UINT4 *in) {
149 UINT4 prev = ( CONVERT(*in) >> 22 ) % (1U << 2 ) ;
150 *in += BIT22;
151 return prev;
152 }
153
154 static UINT4
incr_02_12(UINT4 * in)155 incr_02_12 (UINT4 *in) {
156 UINT4 prev = ( CONVERT(*in) >> 24 ) % (1U << 2 ) ;
157 *in += BIT24;
158 return prev;
159 }
160
161 static UINT4
incr_02_13(UINT4 * in)162 incr_02_13 (UINT4 *in) {
163 UINT4 prev = ( CONVERT(*in) >> 26 ) % (1U << 2 ) ;
164 *in += BIT26;
165 return prev;
166 }
167
168 static UINT4
incr_02_14(UINT4 * in)169 incr_02_14 (UINT4 *in) {
170 UINT4 prev = ( CONVERT(*in) >> 28 ) % (1U << 2 ) ;
171 *in += BIT28;
172 return prev;
173 }
174
175 static UINT4
incr_02_15(UINT4 * in)176 incr_02_15 (UINT4 *in) {
177 UINT4 prev = ( CONVERT(*in) >> 30 ) % (1U << 2 ) ;
178 *in += BIT30;
179 return prev;
180 }
181
182
183
184 static UINT4
incr_04_00(UINT4 * in)185 incr_04_00 (UINT4 *in) {
186 UINT4 prev = ( CONVERT(*in) >> 0 ) % (1U << 4 ) ;
187 *in += BIT0;
188 return prev;
189 }
190
191 static UINT4
incr_04_01(UINT4 * in)192 incr_04_01 (UINT4 *in) {
193 UINT4 prev = ( CONVERT(*in) >> 4 ) % (1U << 4 ) ;
194 *in += BIT4;
195 return prev;
196 }
197
198 static UINT4
incr_04_02(UINT4 * in)199 incr_04_02 (UINT4 *in) {
200 UINT4 prev = ( CONVERT(*in) >> 8 ) % (1U << 4 ) ;
201 *in += BIT8;
202 return prev;
203 }
204
205 static UINT4
incr_04_03(UINT4 * in)206 incr_04_03 (UINT4 *in) {
207 UINT4 prev = ( CONVERT(*in) >> 12 ) % (1U << 4 ) ;
208 *in += BIT12;
209 return prev;
210 }
211
212 static UINT4
incr_04_04(UINT4 * in)213 incr_04_04 (UINT4 *in) {
214 UINT4 prev = ( CONVERT(*in) >> 16 ) % (1U << 4 ) ;
215 *in += BIT16;
216 return prev;
217 }
218
219 static UINT4
incr_04_05(UINT4 * in)220 incr_04_05 (UINT4 *in) {
221 UINT4 prev = ( CONVERT(*in) >> 20 ) % (1U << 4 ) ;
222 *in += BIT20;
223 return prev;
224 }
225
226 static UINT4
incr_04_06(UINT4 * in)227 incr_04_06 (UINT4 *in) {
228 UINT4 prev = ( CONVERT(*in) >> 24 ) % (1U << 4 ) ;
229 *in += BIT24;
230 return prev;
231 }
232
233 static UINT4
incr_04_07(UINT4 * in)234 incr_04_07 (UINT4 *in) {
235 UINT4 prev = ( CONVERT(*in) >> 28 ) % (1U << 4 ) ;
236 *in += BIT28;
237 return prev;
238 }
239
240 static UINT4
incr_04_08(UINT4 * in)241 incr_04_08 (UINT4 *in) {
242 UINT4 prev;
243
244 in += 1 * WORD_INCR;
245 prev = ( CONVERT(*in) >> 0 ) % (1U << 4 ) ;
246 *in += BIT0;
247 return prev;
248 }
249
250 static UINT4
incr_04_09(UINT4 * in)251 incr_04_09 (UINT4 *in) {
252 UINT4 prev;
253
254 in += 1 * WORD_INCR;
255 prev = ( CONVERT(*in) >> 4 ) % (1U << 4 ) ;
256 *in += BIT4;
257 return prev;
258 }
259
260 static UINT4
incr_04_10(UINT4 * in)261 incr_04_10 (UINT4 *in) {
262 UINT4 prev;
263
264 in += 1 * WORD_INCR;
265 prev = ( CONVERT(*in) >> 8 ) % (1U << 4 ) ;
266 *in += BIT8;
267 return prev;
268 }
269
270 static UINT4
incr_04_11(UINT4 * in)271 incr_04_11 (UINT4 *in) {
272 UINT4 prev;
273
274 in += 1 * WORD_INCR;
275 prev = ( CONVERT(*in) >> 12 ) % (1U << 4 ) ;
276 *in += BIT12;
277 return prev;
278 }
279
280 static UINT4
incr_04_12(UINT4 * in)281 incr_04_12 (UINT4 *in) {
282 UINT4 prev;
283
284 in += 1 * WORD_INCR;
285 prev = ( CONVERT(*in) >> 16 ) % (1U << 4 ) ;
286 *in += BIT16;
287 return prev;
288 }
289
290 static UINT4
incr_04_13(UINT4 * in)291 incr_04_13 (UINT4 *in) {
292 UINT4 prev;
293
294 in += 1 * WORD_INCR;
295 prev = ( CONVERT(*in) >> 20 ) % (1U << 4 ) ;
296 *in += BIT20;
297 return prev;
298 }
299
300 static UINT4
incr_04_14(UINT4 * in)301 incr_04_14 (UINT4 *in) {
302 UINT4 prev;
303
304 in += 1 * WORD_INCR;
305 prev = ( CONVERT(*in) >> 24 ) % (1U << 4 ) ;
306 *in += BIT24;
307 return prev;
308 }
309
310 static UINT4
incr_04_15(UINT4 * in)311 incr_04_15 (UINT4 *in) {
312 UINT4 prev;
313
314 in += 1 * WORD_INCR;
315 prev = ( CONVERT(*in) >> 28 ) % (1U << 4 ) ;
316 *in += BIT28;
317 return prev;
318 }
319
320
321 static UINT4
incr_06_00(UINT4 * in)322 incr_06_00 (UINT4 *in) {
323 UINT4 prev;
324
325 prev = ( CONVERT(*in) >> 0 ) % (1U << 6 ) ;
326 *in += BIT0;
327 return prev;
328 }
329
330 static UINT4
incr_06_01(UINT4 * in)331 incr_06_01 (UINT4 *in) {
332 UINT4 prev;
333
334 prev = ( CONVERT(*in) >> 6 ) % (1U << 6 ) ;
335 *in += BIT6;
336 return prev;
337 }
338
339 static UINT4
incr_06_02(UINT4 * in)340 incr_06_02 (UINT4 *in) {
341 UINT4 prev;
342
343 prev = ( CONVERT(*in) >> 12 ) % (1U << 6 ) ;
344 *in += BIT12;
345 return prev;
346 }
347
348 static UINT4
incr_06_03(UINT4 * in)349 incr_06_03 (UINT4 *in) {
350 UINT4 prev;
351
352 prev = ( CONVERT(*in) >> 18 ) % (1U << 6 ) ;
353 *in += BIT18;
354 return prev;
355 }
356
357 static UINT4
incr_06_04(UINT4 * in)358 incr_06_04 (UINT4 *in) {
359 UINT4 prev;
360
361 prev = ( CONVERT(*in) >> 24 ) % (1U << 6 ) ;
362 *in += BIT24;
363 return prev;
364 }
365
366 static UINT4
incr_06_05(UINT4 * in)367 incr_06_05 (UINT4 *in) {
368 UINT4 prev, carry;
369
370 prev = ( CONVERT(*in) >> 30 ) % (1U << 6 ) ;
371 carry = ( (prev + 1) >> (6 - 4) );
372 *in += BIT30;
373
374 in += 1 * WORD_INCR;
375 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 6 - 4 );
376 *in += carry;
377
378 return prev;
379 }
380
381 static UINT4
incr_06_06(UINT4 * in)382 incr_06_06 (UINT4 *in) {
383 UINT4 prev;
384
385 in += 1 * WORD_INCR;
386 prev = ( CONVERT(*in) >> 4 ) % (1U << 6 ) ;
387 *in += BIT4;
388 return prev;
389 }
390
391 static UINT4
incr_06_07(UINT4 * in)392 incr_06_07 (UINT4 *in) {
393 UINT4 prev;
394
395 in += 1 * WORD_INCR;
396 prev = ( CONVERT(*in) >> 10 ) % (1U << 6 ) ;
397 *in += BIT10;
398 return prev;
399 }
400
401 static UINT4
incr_06_08(UINT4 * in)402 incr_06_08 (UINT4 *in) {
403 UINT4 prev;
404
405 in += 1 * WORD_INCR;
406 prev = ( CONVERT(*in) >> 16 ) % (1U << 6 ) ;
407 *in += BIT16;
408 return prev;
409 }
410
411 static UINT4
incr_06_09(UINT4 * in)412 incr_06_09 (UINT4 *in) {
413 UINT4 prev;
414
415 in += 1 * WORD_INCR;
416 prev = ( CONVERT(*in) >> 22 ) % (1U << 6 ) ;
417 *in += BIT22;
418 return prev;
419 }
420
421 static UINT4
incr_06_10(UINT4 * in)422 incr_06_10 (UINT4 *in) {
423 UINT4 prev, carry;
424
425 in += 1 * WORD_INCR;
426 prev = ( CONVERT(*in) >> 28 ) % (1U << 6 ) ;
427 carry = ( (prev + 1) >> (6 - 2) );
428 *in += BIT28;
429
430 in += 1 * WORD_INCR;
431 prev |= (CONVERT(*in) % (1U<< 2 ))<<( 6 - 2 );
432 *in += carry;
433
434 return prev;
435 }
436
437 static UINT4
incr_06_11(UINT4 * in)438 incr_06_11 (UINT4 *in) {
439 UINT4 prev;
440
441 in += 2 * WORD_INCR;
442 prev = ( CONVERT(*in) >> 2 ) % (1U << 6 ) ;
443 *in += BIT2;
444 return prev;
445 }
446
447 static UINT4
incr_06_12(UINT4 * in)448 incr_06_12 (UINT4 *in) {
449 UINT4 prev;
450
451 in += 2 * WORD_INCR;
452 prev = ( CONVERT(*in) >> 8 ) % (1U << 6 ) ;
453 *in += BIT8;
454 return prev;
455 }
456
457 static UINT4
incr_06_13(UINT4 * in)458 incr_06_13 (UINT4 *in) {
459 UINT4 prev;
460
461 in += 2 * WORD_INCR;
462 prev = ( CONVERT(*in) >> 14 ) % (1U << 6 ) ;
463 *in += BIT14;
464 return prev;
465 }
466
467 static UINT4
incr_06_14(UINT4 * in)468 incr_06_14 (UINT4 *in) {
469 UINT4 prev;
470
471 in += 2 * WORD_INCR;
472 prev = ( CONVERT(*in) >> 20 ) % (1U << 6 ) ;
473 *in += BIT20;
474 return prev;
475 }
476
477 static UINT4
incr_06_15(UINT4 * in)478 incr_06_15 (UINT4 *in) {
479 UINT4 prev;
480
481 in += 2 * WORD_INCR;
482 prev = ( CONVERT(*in) >> 26 ) % (1U << 6 ) ;
483 *in += BIT26;
484 return prev;
485 }
486
487
488 static UINT4
incr_08_00(UINT4 * in)489 incr_08_00 (UINT4 *in) {
490 UINT4 prev;
491
492 prev = ( CONVERT(*in) >> 0 ) % (1U << 8 ) ;
493 *in += BIT0;
494 return prev;
495 }
496
497 static UINT4
incr_08_01(UINT4 * in)498 incr_08_01 (UINT4 *in) {
499 UINT4 prev;
500
501 prev = ( CONVERT(*in) >> 8 ) % (1U << 8 ) ;
502 *in += BIT8;
503 return prev;
504 }
505
506 static UINT4
incr_08_02(UINT4 * in)507 incr_08_02 (UINT4 *in) {
508 UINT4 prev;
509
510 prev = ( CONVERT(*in) >> 16 ) % (1U << 8 ) ;
511 *in += BIT16;
512 return prev;
513 }
514
515 static UINT4
incr_08_03(UINT4 * in)516 incr_08_03 (UINT4 *in) {
517 UINT4 prev;
518
519 prev = ( CONVERT(*in) >> 24 ) % (1U << 8 ) ;
520 *in += BIT24;
521 return prev;
522 }
523
524 static UINT4
incr_08_04(UINT4 * in)525 incr_08_04 (UINT4 *in) {
526 UINT4 prev;
527
528 in += 1 * WORD_INCR;
529 prev = ( CONVERT(*in) >> 0 ) % (1U << 8 ) ;
530 *in += BIT0;
531 return prev;
532 }
533
534 static UINT4
incr_08_05(UINT4 * in)535 incr_08_05 (UINT4 *in) {
536 UINT4 prev;
537
538 in += 1 * WORD_INCR;
539 prev = ( CONVERT(*in) >> 8 ) % (1U << 8 ) ;
540 *in += BIT8;
541 return prev;
542 }
543
544 static UINT4
incr_08_06(UINT4 * in)545 incr_08_06 (UINT4 *in) {
546 UINT4 prev;
547
548 in += 1 * WORD_INCR;
549 prev = ( CONVERT(*in) >> 16 ) % (1U << 8 ) ;
550 *in += BIT16;
551 return prev;
552 }
553
554 static UINT4
incr_08_07(UINT4 * in)555 incr_08_07 (UINT4 *in) {
556 UINT4 prev;
557
558 in += 1 * WORD_INCR;
559 prev = ( CONVERT(*in) >> 24 ) % (1U << 8 ) ;
560 *in += BIT24;
561 return prev;
562 }
563
564 static UINT4
incr_08_08(UINT4 * in)565 incr_08_08 (UINT4 *in) {
566 UINT4 prev;
567
568 in += 2 * WORD_INCR;
569 prev = ( CONVERT(*in) >> 0 ) % (1U << 8 ) ;
570 *in += BIT0;
571 return prev;
572 }
573
574 static UINT4
incr_08_09(UINT4 * in)575 incr_08_09 (UINT4 *in) {
576 UINT4 prev;
577
578 in += 2 * WORD_INCR;
579 prev = ( CONVERT(*in) >> 8 ) % (1U << 8 ) ;
580 *in += BIT8;
581 return prev;
582 }
583
584 static UINT4
incr_08_10(UINT4 * in)585 incr_08_10 (UINT4 *in) {
586 UINT4 prev;
587
588 in += 2 * WORD_INCR;
589 prev = ( CONVERT(*in) >> 16 ) % (1U << 8 ) ;
590 *in += BIT16;
591 return prev;
592 }
593
594 static UINT4
incr_08_11(UINT4 * in)595 incr_08_11 (UINT4 *in) {
596 UINT4 prev;
597
598 in += 2 * WORD_INCR;
599 prev = ( CONVERT(*in) >> 24 ) % (1U << 8 ) ;
600 *in += BIT24;
601 return prev;
602 }
603
604 static UINT4
incr_08_12(UINT4 * in)605 incr_08_12 (UINT4 *in) {
606 UINT4 prev;
607
608 in += 3 * WORD_INCR;
609 prev = ( CONVERT(*in) >> 0 ) % (1U << 8 ) ;
610 *in += BIT0;
611 return prev;
612 }
613
614 static UINT4
incr_08_13(UINT4 * in)615 incr_08_13 (UINT4 *in) {
616 UINT4 prev;
617
618 in += 3 * WORD_INCR;
619 prev = ( CONVERT(*in) >> 8 ) % (1U << 8 ) ;
620 *in += BIT8;
621 return prev;
622 }
623
624 static UINT4
incr_08_14(UINT4 * in)625 incr_08_14 (UINT4 *in) {
626 UINT4 prev;
627
628 in += 3 * WORD_INCR;
629 prev = ( CONVERT(*in) >> 16 ) % (1U << 8 ) ;
630 *in += BIT16;
631 return prev;
632 }
633
634 static UINT4
incr_08_15(UINT4 * in)635 incr_08_15 (UINT4 *in) {
636 UINT4 prev;
637
638 in += 3 * WORD_INCR;
639 prev = ( CONVERT(*in) >> 24 ) % (1U << 8 ) ;
640 *in += BIT24;
641 return prev;
642 }
643
644
645
646 static UINT4
incr_10_00(UINT4 * in)647 incr_10_00 (UINT4 *in) {
648 UINT4 prev;
649
650 prev = ( CONVERT(*in) >> 0 ) % (1U << 10 ) ;
651 *in += BIT0;
652 return prev;
653 }
654
655 static UINT4
incr_10_01(UINT4 * in)656 incr_10_01 (UINT4 *in) {
657 UINT4 prev;
658
659 prev = ( CONVERT(*in) >> 10 ) % (1U << 10 ) ;
660 *in += BIT10;
661 return prev;
662 }
663
664 static UINT4
incr_10_02(UINT4 * in)665 incr_10_02 (UINT4 *in) {
666 UINT4 prev;
667
668 prev = ( CONVERT(*in) >> 20 ) % (1U << 10 ) ;
669 *in += BIT20;
670 return prev;
671 }
672
673 static UINT4
incr_10_03(UINT4 * in)674 incr_10_03 (UINT4 *in) {
675 UINT4 prev, carry;
676
677 prev = ( CONVERT(*in) >> 30 ) % (1U << 10 ) ;
678 carry = ( (prev + 1) >> (10 - 8) );
679 *in += BIT30;
680
681 in += 1 * WORD_INCR;
682 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 10 - 8 );
683 *in += carry;
684
685 return prev;
686 }
687
688 static UINT4
incr_10_04(UINT4 * in)689 incr_10_04 (UINT4 *in) {
690 UINT4 prev;
691
692 in += 1 * WORD_INCR;
693 prev = ( CONVERT(*in) >> 8 ) % (1U << 10 ) ;
694 *in += BIT8;
695 return prev;
696 }
697
698 static UINT4
incr_10_05(UINT4 * in)699 incr_10_05 (UINT4 *in) {
700 UINT4 prev;
701
702 in += 1 * WORD_INCR;
703 prev = ( CONVERT(*in) >> 18 ) % (1U << 10 ) ;
704 *in += BIT18;
705 return prev;
706 }
707
708 static UINT4
incr_10_06(UINT4 * in)709 incr_10_06 (UINT4 *in) {
710 UINT4 prev, carry;
711
712 in += 1 * WORD_INCR;
713 prev = ( CONVERT(*in) >> 28 ) % (1U << 10 ) ;
714 carry = ( (prev + 1) >> (10 - 6) );
715 *in += BIT28;
716
717 in += 1 * WORD_INCR;
718 prev |= (CONVERT(*in) % (1U<< 6 ))<<( 10 - 6 );
719 *in += carry;
720
721 return prev;
722 }
723
724 static UINT4
incr_10_07(UINT4 * in)725 incr_10_07 (UINT4 *in) {
726 UINT4 prev;
727
728 in += 2 * WORD_INCR;
729 prev = ( CONVERT(*in) >> 6 ) % (1U << 10 ) ;
730 *in += BIT6;
731 return prev;
732 }
733
734 static UINT4
incr_10_08(UINT4 * in)735 incr_10_08 (UINT4 *in) {
736 UINT4 prev;
737
738 in += 2 * WORD_INCR;
739 prev = ( CONVERT(*in) >> 16 ) % (1U << 10 ) ;
740 *in += BIT16;
741 return prev;
742 }
743
744 static UINT4
incr_10_09(UINT4 * in)745 incr_10_09 (UINT4 *in) {
746 UINT4 prev, carry;
747
748 in += 2 * WORD_INCR;
749 prev = ( CONVERT(*in) >> 26 ) % (1U << 10 ) ;
750 carry = ( (prev + 1) >> (10 - 4) );
751 *in += BIT26;
752
753 in += 1 * WORD_INCR;
754 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 10 - 4 );
755 *in += carry;
756
757 return prev;
758 }
759
760 static UINT4
incr_10_10(UINT4 * in)761 incr_10_10 (UINT4 *in) {
762 UINT4 prev;
763
764 in += 3 * WORD_INCR;
765 prev = ( CONVERT(*in) >> 4 ) % (1U << 10 ) ;
766 *in += BIT4;
767 return prev;
768 }
769
770 static UINT4
incr_10_11(UINT4 * in)771 incr_10_11 (UINT4 *in) {
772 UINT4 prev;
773
774 in += 3 * WORD_INCR;
775 prev = ( CONVERT(*in) >> 14 ) % (1U << 10 ) ;
776 *in += BIT14;
777 return prev;
778 }
779
780 static UINT4
incr_10_12(UINT4 * in)781 incr_10_12 (UINT4 *in) {
782 UINT4 prev, carry;
783
784 in += 3 * WORD_INCR;
785 prev = ( CONVERT(*in) >> 24 ) % (1U << 10 ) ;
786 carry = ( (prev + 1) >> (10 - 2) );
787 *in += BIT24;
788
789 in += 1 * WORD_INCR;
790 prev |= (CONVERT(*in) % (1U<< 2 ))<<( 10 - 2 );
791 *in += carry;
792
793 return prev;
794 }
795
796 static UINT4
incr_10_13(UINT4 * in)797 incr_10_13 (UINT4 *in) {
798 UINT4 prev;
799
800 in += 4 * WORD_INCR;
801 prev = ( CONVERT(*in) >> 2 ) % (1U << 10 ) ;
802 *in += BIT2;
803 return prev;
804 }
805
806 static UINT4
incr_10_14(UINT4 * in)807 incr_10_14 (UINT4 *in) {
808 UINT4 prev;
809
810 in += 4 * WORD_INCR;
811 prev = ( CONVERT(*in) >> 12 ) % (1U << 10 ) ;
812 *in += BIT12;
813 return prev;
814 }
815
816 static UINT4
incr_10_15(UINT4 * in)817 incr_10_15 (UINT4 *in) {
818 UINT4 prev;
819
820 in += 4 * WORD_INCR;
821 prev = ( CONVERT(*in) >> 22 ) % (1U << 10 ) ;
822 *in += BIT22;
823 return prev;
824 }
825
826
827
828 static UINT4
incr_12_00(UINT4 * in)829 incr_12_00 (UINT4 *in) {
830 UINT4 prev;
831
832 prev = ( CONVERT(*in) >> 0 ) % (1U << 12 ) ;
833 *in += BIT0;
834 return prev;
835 }
836
837 static UINT4
incr_12_01(UINT4 * in)838 incr_12_01 (UINT4 *in) {
839 UINT4 prev;
840
841 prev = ( CONVERT(*in) >> 12 ) % (1U << 12 ) ;
842 *in += BIT12;
843 return prev;
844 }
845
846 static UINT4
incr_12_02(UINT4 * in)847 incr_12_02 (UINT4 *in) {
848 UINT4 prev, carry;
849
850 prev = ( CONVERT(*in) >> 24 ) % (1U << 12 ) ;
851 carry = ( (prev + 1) >> (12 - 4) );
852 *in += BIT24;
853
854 in += 1 * WORD_INCR;
855 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 12 - 4 );
856 *in += carry;
857
858 return prev;
859 }
860
861 static UINT4
incr_12_03(UINT4 * in)862 incr_12_03 (UINT4 *in) {
863 UINT4 prev;
864
865 in += 1 * WORD_INCR;
866 prev = ( CONVERT(*in) >> 4 ) % (1U << 12 ) ;
867 *in += BIT4;
868 return prev;
869 }
870
871 static UINT4
incr_12_04(UINT4 * in)872 incr_12_04 (UINT4 *in) {
873 UINT4 prev;
874
875 in += 1 * WORD_INCR;
876 prev = ( CONVERT(*in) >> 16 ) % (1U << 12 ) ;
877 *in += BIT16;
878 return prev;
879 }
880
881 static UINT4
incr_12_05(UINT4 * in)882 incr_12_05 (UINT4 *in) {
883 UINT4 prev, carry;
884
885 in += 1 * WORD_INCR;
886 prev = ( CONVERT(*in) >> 28 ) % (1U << 12 ) ;
887 carry = ( (prev + 1) >> (12 - 8));
888 *in += BIT28;
889
890 in += 1 * WORD_INCR;
891 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 12 - 8 );
892 *in += carry;
893
894 return prev;
895 }
896
897 static UINT4
incr_12_06(UINT4 * in)898 incr_12_06 (UINT4 *in) {
899 UINT4 prev;
900
901 in += 2 * WORD_INCR;
902 prev = ( CONVERT(*in) >> 8 ) % (1U << 12 ) ;
903 *in += BIT8;
904 return prev;
905 }
906
907 static UINT4
incr_12_07(UINT4 * in)908 incr_12_07 (UINT4 *in) {
909 UINT4 prev;
910
911 in += 2 * WORD_INCR;
912 prev = ( CONVERT(*in) >> 20 ) % (1U << 12 ) ;
913 *in += BIT20;
914 return prev;
915 }
916
917 static UINT4
incr_12_08(UINT4 * in)918 incr_12_08 (UINT4 *in) {
919 UINT4 prev;
920
921 in += 3 * WORD_INCR;
922 prev = ( CONVERT(*in) >> 0 ) % (1U << 12 ) ;
923 *in += BIT0;
924 return prev;
925 }
926
927 static UINT4
incr_12_09(UINT4 * in)928 incr_12_09 (UINT4 *in) {
929 UINT4 prev;
930
931 in += 3 * WORD_INCR;
932 prev = ( CONVERT(*in) >> 12 ) % (1U << 12 ) ;
933 *in += BIT12;
934 return prev;
935 }
936
937 static UINT4
incr_12_10(UINT4 * in)938 incr_12_10 (UINT4 *in) {
939 UINT4 prev, carry;
940
941 in += 3 * WORD_INCR;
942 prev = ( CONVERT(*in) >> 24 ) % (1U << 12 ) ;
943 carry = ( (prev + 1) >> (12 - 4) );
944 *in += BIT24;
945
946 in += 1 * WORD_INCR;
947 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 12 - 4 );
948 *in += carry;
949
950 return prev;
951 }
952
953 static UINT4
incr_12_11(UINT4 * in)954 incr_12_11 (UINT4 *in) {
955 UINT4 prev;
956
957 in += 4 * WORD_INCR;
958 prev = ( CONVERT(*in) >> 4 ) % (1U << 12 ) ;
959 *in += BIT4;
960 return prev;
961 }
962
963 static UINT4
incr_12_12(UINT4 * in)964 incr_12_12 (UINT4 *in) {
965 UINT4 prev;
966
967 in += 4 * WORD_INCR;
968 prev = ( CONVERT(*in) >> 16 ) % (1U << 12 ) ;
969 *in += BIT16;
970 return prev;
971 }
972
973 static UINT4
incr_12_13(UINT4 * in)974 incr_12_13 (UINT4 *in) {
975 UINT4 prev, carry;
976
977 in += 4 * WORD_INCR;
978 prev = ( CONVERT(*in) >> 28 ) % (1U << 12 ) ;
979 carry = ( (prev + 1) >> (12 - 8));
980 *in += BIT28;
981
982 in += 1 * WORD_INCR;
983 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 12 - 8 );
984 *in += carry;
985
986 return prev;
987 }
988
989 static UINT4
incr_12_14(UINT4 * in)990 incr_12_14 (UINT4 *in) {
991 UINT4 prev;
992
993 in += 5 * WORD_INCR;
994 prev = ( CONVERT(*in) >> 8 ) % (1U << 12 ) ;
995 *in += BIT8;
996 return prev;
997 }
998
999 static UINT4
incr_12_15(UINT4 * in)1000 incr_12_15 (UINT4 *in) {
1001 UINT4 prev;
1002
1003 in += 5 * WORD_INCR;
1004 prev = ( CONVERT(*in) >> 20 ) % (1U << 12 ) ;
1005 *in += BIT20;
1006 return prev;
1007 }
1008
1009
1010 static UINT4
incr_14_00(UINT4 * in)1011 incr_14_00 (UINT4 *in) {
1012 UINT4 prev;
1013
1014 prev = ( CONVERT(*in) >> 0 ) % (1U << 14 ) ;
1015 *in += BIT0;
1016 return prev;
1017 }
1018
1019 static UINT4
incr_14_01(UINT4 * in)1020 incr_14_01 (UINT4 *in) {
1021 UINT4 prev;
1022
1023 prev = ( CONVERT(*in) >> 14 ) % (1U << 14 ) ;
1024 *in += BIT14;
1025 return prev;
1026 }
1027
1028 static UINT4
incr_14_02(UINT4 * in)1029 incr_14_02 (UINT4 *in) {
1030 UINT4 prev, carry;
1031
1032 prev = ( CONVERT(*in) >> 28 ) % (1U << 14 ) ;
1033 carry = ( (prev + 1) >> (14 - 10) );
1034 *in += BIT28;
1035
1036 in += 1 * WORD_INCR;
1037 prev |= (CONVERT(*in) % (1U<< 10 ))<<( 14 - 10 );
1038 *in += carry;
1039
1040 return prev;
1041 }
1042
1043 static UINT4
incr_14_03(UINT4 * in)1044 incr_14_03 (UINT4 *in) {
1045 UINT4 prev;
1046
1047 in += 1 * WORD_INCR;
1048 prev = ( CONVERT(*in) >> 10 ) % (1U << 14 ) ;
1049 *in += BIT10;
1050 return prev;
1051 }
1052
1053 static UINT4
incr_14_04(UINT4 * in)1054 incr_14_04 (UINT4 *in) {
1055 UINT4 prev, carry;
1056
1057 in += 1 * WORD_INCR;
1058 prev = ( CONVERT(*in) >> 24 ) % (1U << 14 ) ;
1059 carry = ( (prev + 1) >> (14 - 6) );
1060 *in += BIT24;
1061
1062 in += 1 * WORD_INCR;
1063 prev |= (CONVERT(*in) % (1U<< 6 ))<<( 14 - 6 );
1064 *in += carry;
1065
1066 return prev;
1067 }
1068
1069 static UINT4
incr_14_05(UINT4 * in)1070 incr_14_05 (UINT4 *in) {
1071 UINT4 prev;
1072
1073 in += 2 * WORD_INCR;
1074 prev = ( CONVERT(*in) >> 6 ) % (1U << 14 ) ;
1075 *in += BIT6;
1076 return prev;
1077 }
1078
1079 static UINT4
incr_14_06(UINT4 * in)1080 incr_14_06 (UINT4 *in) {
1081 UINT4 prev, carry;
1082
1083 in += 2 * WORD_INCR;
1084 prev = ( CONVERT(*in) >> 20 ) % (1U << 14 ) ;
1085 carry = ( (prev + 1) >> (14 - 2) );
1086 *in += BIT20;
1087
1088 in += 1 * WORD_INCR;
1089 prev |= (CONVERT(*in) % (1U<< 2 ))<<( 14 - 2 );
1090 *in += carry;
1091
1092 return prev;
1093 }
1094
1095 static UINT4
incr_14_07(UINT4 * in)1096 incr_14_07 (UINT4 *in) {
1097 UINT4 prev;
1098
1099 in += 3 * WORD_INCR;
1100 prev = ( CONVERT(*in) >> 2 ) % (1U << 14 ) ;
1101 *in += BIT2;
1102 return prev;
1103 }
1104
1105 static UINT4
incr_14_08(UINT4 * in)1106 incr_14_08 (UINT4 *in) {
1107 UINT4 prev;
1108
1109 in += 3 * WORD_INCR;
1110 prev = ( CONVERT(*in) >> 16 ) % (1U << 14 ) ;
1111 *in += BIT16;
1112 return prev;
1113 }
1114
1115 static UINT4
incr_14_09(UINT4 * in)1116 incr_14_09 (UINT4 *in) {
1117 UINT4 prev, carry;
1118
1119 in += 3 * WORD_INCR;
1120 prev = ( CONVERT(*in) >> 30 ) % (1U << 14 ) ;
1121 carry = ( (prev + 1) >> (14 - 12) );
1122 *in += BIT30;
1123
1124 in += 1 * WORD_INCR;
1125 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 14 - 12 );
1126 *in += carry;
1127
1128 return prev;
1129 }
1130
1131 static UINT4
incr_14_10(UINT4 * in)1132 incr_14_10 (UINT4 *in) {
1133 UINT4 prev;
1134
1135 in += 4 * WORD_INCR;
1136 prev = ( CONVERT(*in) >> 12 ) % (1U << 14 ) ;
1137 *in += BIT12;
1138 return prev;
1139 }
1140
1141 static UINT4
incr_14_11(UINT4 * in)1142 incr_14_11 (UINT4 *in) {
1143 UINT4 prev, carry;
1144
1145 in += 4 * WORD_INCR;
1146 prev = ( CONVERT(*in) >> 26 ) % (1U << 14 ) ;
1147 carry = ( (prev + 1) >> (14 - 8) );
1148 *in += BIT26;
1149
1150 in += 1 * WORD_INCR;
1151 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 14 - 8 );
1152 *in += carry;
1153
1154 return prev;
1155 }
1156
1157 static UINT4
incr_14_12(UINT4 * in)1158 incr_14_12 (UINT4 *in) {
1159 UINT4 prev;
1160
1161 in += 5 * WORD_INCR;
1162 prev = ( CONVERT(*in) >> 8 ) % (1U << 14 ) ;
1163 *in += BIT8;
1164 return prev;
1165 }
1166
1167 static UINT4
incr_14_13(UINT4 * in)1168 incr_14_13 (UINT4 *in) {
1169 UINT4 prev, carry;
1170
1171 in += 5 * WORD_INCR;
1172 prev = ( CONVERT(*in) >> 22 ) % (1U << 14 ) ;
1173 carry = ( (prev + 1) >> (14 - 4) );
1174 *in += BIT22;
1175
1176 in += 1 * WORD_INCR;
1177 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 14 - 4 );
1178 *in += carry;
1179
1180 return prev;
1181 }
1182
1183 static UINT4
incr_14_14(UINT4 * in)1184 incr_14_14 (UINT4 *in) {
1185 UINT4 prev;
1186
1187 in += 6 * WORD_INCR;
1188 prev = ( CONVERT(*in) >> 4 ) % (1U << 14 ) ;
1189 *in += BIT4;
1190 return prev;
1191 }
1192
1193 static UINT4
incr_14_15(UINT4 * in)1194 incr_14_15 (UINT4 *in) {
1195 UINT4 prev;
1196
1197 in += 6 * WORD_INCR;
1198 prev = ( CONVERT(*in) >> 18 ) % (1U << 14 ) ;
1199 *in += BIT18;
1200 return prev;
1201 }
1202
1203
1204 static UINT4
incr_16_00(UINT4 * in)1205 incr_16_00 (UINT4 *in) {
1206 UINT4 prev;
1207
1208 prev = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
1209 *in += BIT0;
1210 return prev;
1211 }
1212
1213 static UINT4
incr_16_01(UINT4 * in)1214 incr_16_01 (UINT4 *in) {
1215 UINT4 prev;
1216
1217 prev = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
1218 *in += BIT16;
1219 return prev;
1220 }
1221
1222 static UINT4
incr_16_02(UINT4 * in)1223 incr_16_02 (UINT4 *in) {
1224 UINT4 prev;
1225
1226 in += 1 * WORD_INCR;
1227 prev = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
1228 *in += BIT0;
1229 return prev;
1230 }
1231
1232 static UINT4
incr_16_03(UINT4 * in)1233 incr_16_03 (UINT4 *in) {
1234 UINT4 prev;
1235
1236 in += 1 * WORD_INCR;
1237 prev = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
1238 *in += BIT16;
1239 return prev;
1240 }
1241
1242 static UINT4
incr_16_04(UINT4 * in)1243 incr_16_04 (UINT4 *in) {
1244 UINT4 prev;
1245
1246 in += 2 * WORD_INCR;
1247 prev = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
1248 *in += BIT0;
1249 return prev;
1250 }
1251
1252 static UINT4
incr_16_05(UINT4 * in)1253 incr_16_05 (UINT4 *in) {
1254 UINT4 prev;
1255
1256 in += 2 * WORD_INCR;
1257 prev = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
1258 *in += BIT16;
1259 return prev;
1260 }
1261
1262 static UINT4
incr_16_06(UINT4 * in)1263 incr_16_06 (UINT4 *in) {
1264 UINT4 prev;
1265
1266 in += 3 * WORD_INCR;
1267 prev = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
1268 *in += BIT0;
1269 return prev;
1270 }
1271
1272 static UINT4
incr_16_07(UINT4 * in)1273 incr_16_07 (UINT4 *in) {
1274 UINT4 prev;
1275
1276 in += 3 * WORD_INCR;
1277 prev = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
1278 *in += BIT16;
1279 return prev;
1280 }
1281
1282 static UINT4
incr_16_08(UINT4 * in)1283 incr_16_08 (UINT4 *in) {
1284 UINT4 prev;
1285
1286 in += 4 * WORD_INCR;
1287 prev = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
1288 *in += BIT0;
1289 return prev;
1290 }
1291
1292 static UINT4
incr_16_09(UINT4 * in)1293 incr_16_09 (UINT4 *in) {
1294 UINT4 prev;
1295
1296 in += 4 * WORD_INCR;
1297 prev = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
1298 *in += BIT16;
1299 return prev;
1300 }
1301
1302 static UINT4
incr_16_10(UINT4 * in)1303 incr_16_10 (UINT4 *in) {
1304 UINT4 prev;
1305
1306 in += 5 * WORD_INCR;
1307 prev = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
1308 *in += BIT0;
1309 return prev;
1310 }
1311
1312 static UINT4
incr_16_11(UINT4 * in)1313 incr_16_11 (UINT4 *in) {
1314 UINT4 prev;
1315
1316 in += 5 * WORD_INCR;
1317 prev = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
1318 *in += BIT16;
1319 return prev;
1320 }
1321
1322 static UINT4
incr_16_12(UINT4 * in)1323 incr_16_12 (UINT4 *in) {
1324 UINT4 prev;
1325
1326 in += 6 * WORD_INCR;
1327 prev = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
1328 *in += BIT0;
1329 return prev;
1330 }
1331
1332 static UINT4
incr_16_13(UINT4 * in)1333 incr_16_13 (UINT4 *in) {
1334 UINT4 prev;
1335
1336 in += 6 * WORD_INCR;
1337 prev = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
1338 *in += BIT16;
1339 return prev;
1340 }
1341
1342 static UINT4
incr_16_14(UINT4 * in)1343 incr_16_14 (UINT4 *in) {
1344 UINT4 prev;
1345
1346 in += 7 * WORD_INCR;
1347 prev = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
1348 *in += BIT0;
1349 return prev;
1350 }
1351
1352 static UINT4
incr_16_15(UINT4 * in)1353 incr_16_15 (UINT4 *in) {
1354 UINT4 prev;
1355
1356 in += 7 * WORD_INCR;
1357 prev = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
1358 *in += BIT16;
1359 return prev;
1360 }
1361
1362
1363 static UINT4
incr_18_00(UINT4 * in)1364 incr_18_00 (UINT4 *in) {
1365 UINT4 prev;
1366
1367 prev = ( CONVERT(*in) >> 0 ) % (1U << 18 ) ;
1368 *in += BIT0;
1369 return prev;
1370 }
1371
1372 static UINT4
incr_18_01(UINT4 * in)1373 incr_18_01 (UINT4 *in) {
1374 UINT4 prev, carry;
1375
1376 prev = ( CONVERT(*in) >> 18 ) % (1U << 18 ) ;
1377 carry = ( (prev + 1) >> (18 - 4) );
1378 *in += BIT18;
1379
1380 in += 1 * WORD_INCR;
1381 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 18 - 4 );
1382 *in += carry;
1383
1384 return prev;
1385 }
1386
1387 static UINT4
incr_18_02(UINT4 * in)1388 incr_18_02 (UINT4 *in) {
1389 UINT4 prev;
1390
1391 in += 1 * WORD_INCR;
1392 prev = ( CONVERT(*in) >> 4 ) % (1U << 18 ) ;
1393 *in += BIT4;
1394 return prev;
1395 }
1396
1397 static UINT4
incr_18_03(UINT4 * in)1398 incr_18_03 (UINT4 *in) {
1399 UINT4 prev, carry;
1400
1401 in += 1 * WORD_INCR;
1402 prev = ( CONVERT(*in) >> 22 ) % (1U << 18 ) ;
1403 carry = ( (prev + 1) >> (18 - 8) );
1404 *in += BIT22;
1405
1406 in += 1 * WORD_INCR;
1407 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 18 - 8 );
1408 *in += carry;
1409
1410 return prev;
1411 }
1412
1413 static UINT4
incr_18_04(UINT4 * in)1414 incr_18_04 (UINT4 *in) {
1415 UINT4 prev;
1416
1417 in += 2 * WORD_INCR;
1418 prev = ( CONVERT(*in) >> 8 ) % (1U << 18 ) ;
1419 *in += BIT8;
1420 return prev;
1421 }
1422
1423 static UINT4
incr_18_05(UINT4 * in)1424 incr_18_05 (UINT4 *in) {
1425 UINT4 prev, carry;
1426
1427 in += 2 * WORD_INCR;
1428 prev = ( CONVERT(*in) >> 26 ) % (1U << 18 ) ;
1429 carry = ( (prev + 1) >> (18 - 12) );
1430 *in += BIT26;
1431
1432 in += 1 * WORD_INCR;
1433 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 18 - 12 );
1434 *in += carry;
1435
1436 return prev;
1437 }
1438
1439 static UINT4
incr_18_06(UINT4 * in)1440 incr_18_06 (UINT4 *in) {
1441 UINT4 prev;
1442
1443 in += 3 * WORD_INCR;
1444 prev = ( CONVERT(*in) >> 12 ) % (1U << 18 ) ;
1445 *in += BIT12;
1446 return prev;
1447 }
1448
1449 static UINT4
incr_18_07(UINT4 * in)1450 incr_18_07 (UINT4 *in) {
1451 UINT4 prev, carry;
1452
1453 in += 3 * WORD_INCR;
1454 prev = ( CONVERT(*in) >> 30 ) % (1U << 18 ) ;
1455 carry = ( (prev + 1) >> (18 - 16) );
1456 *in += BIT30;
1457
1458 in += 1 * WORD_INCR;
1459 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 18 - 16 );
1460 *in += carry;
1461
1462 return prev;
1463 }
1464
1465 static UINT4
incr_18_08(UINT4 * in)1466 incr_18_08 (UINT4 *in) {
1467 UINT4 prev, carry;
1468
1469 in += 4 * WORD_INCR;
1470 prev = ( CONVERT(*in) >> 16 ) % (1U << 18 ) ;
1471 carry = ( (prev + 1) >> (18 - 2) );
1472 *in += BIT16;
1473
1474 in += 1 * WORD_INCR;
1475 prev |= (CONVERT(*in) % (1U<< 2 ))<<( 18 - 2 );
1476 *in += carry;
1477
1478 return prev;
1479 }
1480
1481 static UINT4
incr_18_09(UINT4 * in)1482 incr_18_09 (UINT4 *in) {
1483 UINT4 prev;
1484
1485 in += 5 * WORD_INCR;
1486 prev = ( CONVERT(*in) >> 2 ) % (1U << 18 ) ;
1487 *in += BIT2;
1488 return prev;
1489 }
1490
1491 static UINT4
incr_18_10(UINT4 * in)1492 incr_18_10 (UINT4 *in) {
1493 UINT4 prev, carry;
1494
1495 in += 5 * WORD_INCR;
1496 prev = ( CONVERT(*in) >> 20 ) % (1U << 18 ) ;
1497 carry = ( (prev + 1) >> (18 - 6) );
1498 *in += BIT20;
1499
1500 in += 1 * WORD_INCR;
1501 prev |= (CONVERT(*in) % (1U<< 6 ))<<( 18 - 6 );
1502 *in += carry;
1503
1504 return prev;
1505 }
1506
1507 static UINT4
incr_18_11(UINT4 * in)1508 incr_18_11 (UINT4 *in) {
1509 UINT4 prev;
1510
1511 in += 6 * WORD_INCR;
1512 prev = ( CONVERT(*in) >> 6 ) % (1U << 18 ) ;
1513 *in += BIT6;
1514 return prev;
1515 }
1516
1517 static UINT4
incr_18_12(UINT4 * in)1518 incr_18_12 (UINT4 *in) {
1519 UINT4 prev, carry;
1520
1521 in += 6 * WORD_INCR;
1522 prev = ( CONVERT(*in) >> 24 ) % (1U << 18 ) ;
1523 carry = ( (prev + 1) >> (18 - 10) );
1524 *in += BIT24;
1525
1526 in += 1 * WORD_INCR;
1527 prev |= (CONVERT(*in) % (1U<< 10 ))<<( 18 - 10 );
1528 *in += carry;
1529
1530 return prev;
1531 }
1532
1533 static UINT4
incr_18_13(UINT4 * in)1534 incr_18_13 (UINT4 *in) {
1535 UINT4 prev;
1536
1537 in += 7 * WORD_INCR;
1538 prev = ( CONVERT(*in) >> 10 ) % (1U << 18 ) ;
1539 *in += BIT10;
1540 return prev;
1541 }
1542
1543 static UINT4
incr_18_14(UINT4 * in)1544 incr_18_14 (UINT4 *in) {
1545 UINT4 prev, carry;
1546
1547 in += 7 * WORD_INCR;
1548 prev = ( CONVERT(*in) >> 28 ) % (1U << 18 ) ;
1549 carry = ( (prev + 1) >> (18 - 14) );
1550 *in += BIT28;
1551
1552 in += 1 * WORD_INCR;
1553 prev |= (CONVERT(*in) % (1U<< 14 ))<<( 18 - 14 );
1554 *in += carry;
1555
1556 return prev;
1557 }
1558
1559 static UINT4
incr_18_15(UINT4 * in)1560 incr_18_15 (UINT4 *in) {
1561 UINT4 prev;
1562
1563 in += 8 * WORD_INCR;
1564 prev = ( CONVERT(*in) >> 14 ) % (1U << 18 ) ;
1565 *in += BIT14;
1566 return prev;
1567 }
1568
1569
1570 static UINT4
incr_20_00(UINT4 * in)1571 incr_20_00 (UINT4 *in) {
1572 UINT4 prev;
1573
1574 prev = ( CONVERT(*in) >> 0 ) % (1U << 20 ) ;
1575 *in += BIT0;
1576 return prev;
1577 }
1578
1579 static UINT4
incr_20_01(UINT4 * in)1580 incr_20_01 (UINT4 *in) {
1581 UINT4 prev, carry;
1582
1583 prev = ( CONVERT(*in) >> 20 ) % (1U << 20 ) ;
1584 carry = ( (prev + 1) >> (20 - 8) );
1585 *in += BIT20;
1586
1587 in += 1 * WORD_INCR;
1588 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 20 - 8 );
1589 *in += carry;
1590
1591 return prev;
1592 }
1593
1594 static UINT4
incr_20_02(UINT4 * in)1595 incr_20_02 (UINT4 *in) {
1596 UINT4 prev;
1597
1598 in += 1 * WORD_INCR;
1599 prev = ( CONVERT(*in) >> 8 ) % (1U << 20 ) ;
1600 *in += BIT8;
1601 return prev;
1602 }
1603
1604 static UINT4
incr_20_03(UINT4 * in)1605 incr_20_03 (UINT4 *in) {
1606 UINT4 prev, carry;
1607
1608 in += 1 * WORD_INCR;
1609 prev = ( CONVERT(*in) >> 28 ) % (1U << 20 ) ;
1610 carry = ( (prev + 1) >> (20 - 16) );
1611 *in += BIT28;
1612
1613 in += 1 * WORD_INCR;
1614 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 20 - 16 );
1615 *in += carry;
1616
1617 return prev;
1618 }
1619
1620 static UINT4
incr_20_04(UINT4 * in)1621 incr_20_04 (UINT4 *in) {
1622 UINT4 prev, carry;
1623
1624 in += 2 * WORD_INCR;
1625 prev = ( CONVERT(*in) >> 16 ) % (1U << 20 ) ;
1626 carry = ( (prev + 1) >> (20 - 4) );
1627 *in += BIT16;
1628
1629 in += 1 * WORD_INCR;
1630 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 20 - 4 );
1631 *in += carry;
1632
1633 return prev;
1634 }
1635
1636 static UINT4
incr_20_05(UINT4 * in)1637 incr_20_05 (UINT4 *in) {
1638 UINT4 prev;
1639
1640 in += 3 * WORD_INCR;
1641 prev = ( CONVERT(*in) >> 4 ) % (1U << 20 ) ;
1642 *in += BIT4;
1643 return prev;
1644 }
1645
1646 static UINT4
incr_20_06(UINT4 * in)1647 incr_20_06 (UINT4 *in) {
1648 UINT4 prev, carry;
1649
1650 in += 3 * WORD_INCR;
1651 prev = ( CONVERT(*in) >> 24 ) % (1U << 20 ) ;
1652 carry = ( (prev + 1) >> (20 - 12) );
1653 *in += BIT24;
1654
1655 in += 1 * WORD_INCR;
1656 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 20 - 12 );
1657 *in += carry;
1658
1659 return prev;
1660 }
1661
1662 static UINT4
incr_20_07(UINT4 * in)1663 incr_20_07 (UINT4 *in) {
1664 UINT4 prev;
1665
1666 in += 4 * WORD_INCR;
1667 prev = ( CONVERT(*in) >> 12 ) % (1U << 20 ) ;
1668 *in += BIT12;
1669 return prev;
1670 }
1671
1672 static UINT4
incr_20_08(UINT4 * in)1673 incr_20_08 (UINT4 *in) {
1674 UINT4 prev;
1675
1676 in += 5 * WORD_INCR;
1677 prev = ( CONVERT(*in) >> 0 ) % (1U << 20 ) ;
1678 *in += BIT0;
1679 return prev;
1680 }
1681
1682 static UINT4
incr_20_09(UINT4 * in)1683 incr_20_09 (UINT4 *in) {
1684 UINT4 prev, carry;
1685
1686 in += 5 * WORD_INCR;
1687 prev = ( CONVERT(*in) >> 20 ) % (1U << 20 ) ;
1688 carry = ( (prev + 1) >> (20 - 8) );
1689 *in += BIT20;
1690
1691 in += 1 * WORD_INCR;
1692 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 20 - 8 );
1693 *in += carry;
1694
1695 return prev;
1696 }
1697
1698 static UINT4
incr_20_10(UINT4 * in)1699 incr_20_10 (UINT4 *in) {
1700 UINT4 prev;
1701
1702 in += 6 * WORD_INCR;
1703 prev = ( CONVERT(*in) >> 8 ) % (1U << 20 ) ;
1704 *in += BIT8;
1705 return prev;
1706 }
1707
1708 static UINT4
incr_20_11(UINT4 * in)1709 incr_20_11 (UINT4 *in) {
1710 UINT4 prev, carry;
1711
1712 in += 6 * WORD_INCR;
1713 prev = ( CONVERT(*in) >> 28 ) % (1U << 20 ) ;
1714 carry = ( (prev + 1) >> (20 - 16) );
1715 *in += BIT28;
1716
1717 in += 1 * WORD_INCR;
1718 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 20 - 16 );
1719 *in += carry;
1720
1721 return prev;
1722 }
1723
1724 static UINT4
incr_20_12(UINT4 * in)1725 incr_20_12 (UINT4 *in) {
1726 UINT4 prev, carry;
1727
1728 in += 7 * WORD_INCR;
1729 prev = ( CONVERT(*in) >> 16 ) % (1U << 20 ) ;
1730 carry = ( (prev + 1) >> (20 - 4) );
1731 *in += BIT16;
1732
1733 in += 1 * WORD_INCR;
1734 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 20 - 4 );
1735 *in += carry;
1736
1737 return prev;
1738 }
1739
1740 static UINT4
incr_20_13(UINT4 * in)1741 incr_20_13 (UINT4 *in) {
1742 UINT4 prev;
1743
1744 in += 8 * WORD_INCR;
1745 prev = ( CONVERT(*in) >> 4 ) % (1U << 20 ) ;
1746 *in += BIT4;
1747 return prev;
1748 }
1749
1750 static UINT4
incr_20_14(UINT4 * in)1751 incr_20_14 (UINT4 *in) {
1752 UINT4 prev, carry;
1753
1754 in += 8 * WORD_INCR;
1755 prev = ( CONVERT(*in) >> 24 ) % (1U << 20 ) ;
1756 carry = ( (prev + 1) >> (20 - 12) );
1757 *in += BIT24;
1758
1759 in += 1 * WORD_INCR;
1760 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 20 - 12 );
1761 *in += carry;
1762
1763 return prev;
1764 }
1765
1766 static UINT4
incr_20_15(UINT4 * in)1767 incr_20_15 (UINT4 *in) {
1768 UINT4 prev;
1769
1770 in += 9 * WORD_INCR;
1771 prev = ( CONVERT(*in) >> 12 ) % (1U << 20 ) ;
1772 *in += BIT12;
1773 return prev;
1774 }
1775
1776
1777 static UINT4
incr_22_00(UINT4 * in)1778 incr_22_00 (UINT4 *in) {
1779 UINT4 prev;
1780
1781 prev = ( CONVERT(*in) >> 0 ) % (1U << 22 ) ;
1782 *in += BIT0;
1783 return prev;
1784 }
1785
1786 static UINT4
incr_22_01(UINT4 * in)1787 incr_22_01 (UINT4 *in) {
1788 UINT4 prev, carry;
1789
1790 prev = ( CONVERT(*in) >> 22 ) % (1U << 22 ) ;
1791 carry = ( (prev + 1) >> (22 - 12) );
1792 *in += BIT22;
1793
1794 in += 1 * WORD_INCR;
1795 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 22 - 12 );
1796 *in += carry;
1797
1798 return prev;
1799 }
1800
1801 static UINT4
incr_22_02(UINT4 * in)1802 incr_22_02 (UINT4 *in) {
1803 UINT4 prev, carry;
1804
1805 in += 1 * WORD_INCR;
1806 prev = ( CONVERT(*in) >> 12 ) % (1U << 22 ) ;
1807 carry = ( (prev + 1) >> (22 - 2) );
1808 *in += BIT12;
1809
1810 in += 1 * WORD_INCR;
1811 prev |= (CONVERT(*in) % (1U<< 2 ))<<( 22 - 2 );
1812 *in += carry;
1813
1814 return prev;
1815 }
1816
1817 static UINT4
incr_22_03(UINT4 * in)1818 incr_22_03 (UINT4 *in) {
1819 UINT4 prev;
1820
1821 in += 2 * WORD_INCR;
1822 prev = ( CONVERT(*in) >> 2 ) % (1U << 22 ) ;
1823 *in += BIT2;
1824 return prev;
1825 }
1826
1827 static UINT4
incr_22_04(UINT4 * in)1828 incr_22_04 (UINT4 *in) {
1829 UINT4 prev, carry;
1830
1831 in += 2 * WORD_INCR;
1832 prev = ( CONVERT(*in) >> 24 ) % (1U << 22 ) ;
1833 carry = ( (prev + 1) >> (22 - 14) );
1834 *in += BIT24;
1835
1836 in += 1 * WORD_INCR;
1837 prev |= (CONVERT(*in) % (1U<< 14 ))<<( 22 - 14 );
1838 *in += carry;
1839
1840 return prev;
1841 }
1842
1843 static UINT4
incr_22_05(UINT4 * in)1844 incr_22_05 (UINT4 *in) {
1845 UINT4 prev, carry;
1846
1847 in += 3 * WORD_INCR;
1848 prev = ( CONVERT(*in) >> 14 ) % (1U << 22 ) ;
1849 carry = ( (prev + 1) >> (22 - 4) );
1850 *in += BIT14;
1851
1852 in += 1 * WORD_INCR;
1853 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 22 - 4 );
1854 *in += carry;
1855
1856 return prev;
1857 }
1858
1859 static UINT4
incr_22_06(UINT4 * in)1860 incr_22_06 (UINT4 *in) {
1861 UINT4 prev;
1862
1863 in += 4 * WORD_INCR;
1864 prev = ( CONVERT(*in) >> 4 ) % (1U << 22 ) ;
1865 *in += BIT4;
1866 return prev;
1867 }
1868
1869 static UINT4
incr_22_07(UINT4 * in)1870 incr_22_07 (UINT4 *in) {
1871 UINT4 prev, carry;
1872
1873 in += 4 * WORD_INCR;
1874 prev = ( CONVERT(*in) >> 26 ) % (1U << 22 ) ;
1875 carry = ( (prev + 1) >> (22 - 16) );
1876 *in += BIT26;
1877
1878 in += 1 * WORD_INCR;
1879 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 22 - 16 );
1880 *in += carry;
1881
1882 return prev;
1883 }
1884
1885 static UINT4
incr_22_08(UINT4 * in)1886 incr_22_08 (UINT4 *in) {
1887 UINT4 prev, carry;
1888
1889 in += 5 * WORD_INCR;
1890 prev = ( CONVERT(*in) >> 16 ) % (1U << 22 ) ;
1891 carry = ( (prev + 1) >> (22 - 6) );
1892 *in += BIT16;
1893
1894 in += 1 * WORD_INCR;
1895 prev |= (CONVERT(*in) % (1U<< 6 ))<<( 22 - 6 );
1896 *in += carry;
1897
1898 return prev;
1899 }
1900
1901 static UINT4
incr_22_09(UINT4 * in)1902 incr_22_09 (UINT4 *in) {
1903 UINT4 prev;
1904
1905 in += 6 * WORD_INCR;
1906 prev = ( CONVERT(*in) >> 6 ) % (1U << 22 ) ;
1907 *in += BIT6;
1908 return prev;
1909 }
1910
1911 static UINT4
incr_22_10(UINT4 * in)1912 incr_22_10 (UINT4 *in) {
1913 UINT4 prev, carry;
1914
1915 in += 6 * WORD_INCR;
1916 prev = ( CONVERT(*in) >> 28 ) % (1U << 22 ) ;
1917 carry = ( (prev + 1) >> (22 - 18) );
1918 *in += BIT28;
1919
1920 in += 1 * WORD_INCR;
1921 prev |= (CONVERT(*in) % (1U<< 18 ))<<( 22 - 18 );
1922 *in += carry;
1923
1924 return prev;
1925 }
1926
1927 static UINT4
incr_22_11(UINT4 * in)1928 incr_22_11 (UINT4 *in) {
1929 UINT4 prev, carry;
1930
1931 in += 7 * WORD_INCR;
1932 prev = ( CONVERT(*in) >> 18 ) % (1U << 22 ) ;
1933 carry = ( (prev + 1) >> (22 - 8) );
1934 *in += BIT18;
1935
1936 in += 1 * WORD_INCR;
1937 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 22 - 8 );
1938 *in += carry;
1939
1940 return prev;
1941 }
1942
1943 static UINT4
incr_22_12(UINT4 * in)1944 incr_22_12 (UINT4 *in) {
1945 UINT4 prev;
1946
1947 in += 8 * WORD_INCR;
1948 prev = ( CONVERT(*in) >> 8 ) % (1U << 22 ) ;
1949 *in += BIT8;
1950 return prev;
1951 }
1952
1953 static UINT4
incr_22_13(UINT4 * in)1954 incr_22_13 (UINT4 *in) {
1955 UINT4 prev, carry;
1956
1957 in += 8 * WORD_INCR;
1958 prev = ( CONVERT(*in) >> 30 ) % (1U << 22 ) ;
1959 carry = ( (prev + 1) >> (22 - 20) );
1960 *in += BIT30;
1961
1962 in += 1 * WORD_INCR;
1963 prev |= (CONVERT(*in) % (1U<< 20 ))<<( 22 - 20 );
1964 *in += carry;
1965
1966 return prev;
1967 }
1968
1969 static UINT4
incr_22_14(UINT4 * in)1970 incr_22_14 (UINT4 *in) {
1971 UINT4 prev, carry;
1972
1973 in += 9 * WORD_INCR;
1974 prev = ( CONVERT(*in) >> 20 ) % (1U << 22 ) ;
1975 carry = ( (prev + 1) >> (22 - 10) );
1976 *in += BIT20;
1977
1978 in += 1 * WORD_INCR;
1979 prev |= (CONVERT(*in) % (1U<< 10 ))<<( 22 - 10 );
1980 *in += carry;
1981
1982 return prev;
1983 }
1984
1985 static UINT4
incr_22_15(UINT4 * in)1986 incr_22_15 (UINT4 *in) {
1987 UINT4 prev;
1988
1989 in += 10 * WORD_INCR;
1990 prev = ( CONVERT(*in) >> 10 ) % (1U << 22 ) ;
1991 *in += BIT10;
1992 return prev;
1993 }
1994
1995
1996
1997 static UINT4
incr_24_00(UINT4 * in)1998 incr_24_00 (UINT4 *in) {
1999 UINT4 prev;
2000
2001 prev = ( CONVERT(*in) >> 0 ) % (1U << 24 ) ;
2002 *in += BIT0;
2003 return prev;
2004 }
2005
2006 static UINT4
incr_24_01(UINT4 * in)2007 incr_24_01 (UINT4 *in) {
2008 UINT4 prev, carry;
2009
2010 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
2011 carry = ( (prev + 1) >> (24 - 16) );
2012 *in += BIT24;
2013
2014 in += 1 * WORD_INCR;
2015 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 );
2016 *in += carry;
2017
2018 return prev;
2019 }
2020
2021 static UINT4
incr_24_02(UINT4 * in)2022 incr_24_02 (UINT4 *in) {
2023 UINT4 prev, carry;
2024
2025 in += 1 * WORD_INCR;
2026 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
2027 carry = ( (prev + 1) >> (24 - 8) );
2028 *in += BIT16;
2029
2030 in += 1 * WORD_INCR;
2031 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 );
2032 *in += carry;
2033
2034 return prev;
2035 }
2036
2037 static UINT4
incr_24_03(UINT4 * in)2038 incr_24_03 (UINT4 *in) {
2039 UINT4 prev;
2040
2041 in += 2 * WORD_INCR;
2042 prev = ( CONVERT(*in) >> 8 ) % (1U << 24 ) ;
2043 *in += BIT8;
2044 return prev;
2045 }
2046
2047 static UINT4
incr_24_04(UINT4 * in)2048 incr_24_04 (UINT4 *in) {
2049 UINT4 prev;
2050
2051 in += 3 * WORD_INCR;
2052 prev = ( CONVERT(*in) >> 0 ) % (1U << 24 ) ;
2053 *in += BIT0;
2054 return prev;
2055 }
2056
2057 static UINT4
incr_24_05(UINT4 * in)2058 incr_24_05 (UINT4 *in) {
2059 UINT4 prev, carry;
2060
2061 in += 3 * WORD_INCR;
2062 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
2063 carry = ( (prev + 1) >> (24 - 16) );
2064 *in += BIT24;
2065
2066 in += 1 * WORD_INCR;
2067 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 );
2068 *in += carry;
2069
2070 return prev;
2071 }
2072
2073 static UINT4
incr_24_06(UINT4 * in)2074 incr_24_06 (UINT4 *in) {
2075 UINT4 prev, carry;
2076
2077 in += 4 * WORD_INCR;
2078 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
2079 carry = ( (prev + 1) >> (24 - 8) );
2080 *in += BIT16;
2081
2082 in += 1 * WORD_INCR;
2083 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 );
2084 *in += carry;
2085
2086 return prev;
2087 }
2088
2089 static UINT4
incr_24_07(UINT4 * in)2090 incr_24_07 (UINT4 *in) {
2091 UINT4 prev;
2092
2093 in += 5 * WORD_INCR;
2094 prev = ( CONVERT(*in) >> 8 ) % (1U << 24 ) ;
2095 *in += BIT8;
2096 return prev;
2097 }
2098
2099 static UINT4
incr_24_08(UINT4 * in)2100 incr_24_08 (UINT4 *in) {
2101 UINT4 prev;
2102
2103 in += 6 * WORD_INCR;
2104 prev = ( CONVERT(*in) >> 0 ) % (1U << 24 ) ;
2105 *in += BIT0;
2106 return prev;
2107 }
2108
2109 static UINT4
incr_24_09(UINT4 * in)2110 incr_24_09 (UINT4 *in) {
2111 UINT4 prev, carry;
2112
2113 in += 6 * WORD_INCR;
2114 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
2115 carry = ( (prev + 1) >> (24 - 16) );
2116 *in += BIT24;
2117
2118 in += 1 * WORD_INCR;
2119 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 );
2120 *in += carry;
2121
2122 return prev;
2123 }
2124
2125 static UINT4
incr_24_10(UINT4 * in)2126 incr_24_10 (UINT4 *in) {
2127 UINT4 prev, carry;
2128
2129 in += 7 * WORD_INCR;
2130 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
2131 carry = ( (prev + 1) >> (24 - 8) );
2132 *in += BIT16;
2133
2134 in += 1 * WORD_INCR;
2135 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 );
2136 *in += carry;
2137
2138 return prev;
2139 }
2140
2141 static UINT4
incr_24_11(UINT4 * in)2142 incr_24_11 (UINT4 *in) {
2143 UINT4 prev;
2144
2145 in += 8 * WORD_INCR;
2146 prev = ( CONVERT(*in) >> 8 ) % (1U << 24 ) ;
2147 *in += BIT8;
2148 return prev;
2149 }
2150
2151 static UINT4
incr_24_12(UINT4 * in)2152 incr_24_12 (UINT4 *in) {
2153 UINT4 prev;
2154
2155 in += 9 * WORD_INCR;
2156 prev = ( CONVERT(*in) >> 0 ) % (1U << 24 ) ;
2157 *in += BIT0;
2158 return prev;
2159 }
2160
2161 static UINT4
incr_24_13(UINT4 * in)2162 incr_24_13 (UINT4 *in) {
2163 UINT4 prev, carry;
2164
2165 in += 9 * WORD_INCR;
2166 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
2167 carry = ( (prev + 1) >> (24 - 16) );
2168 *in += BIT24;
2169
2170 in += 1 * WORD_INCR;
2171 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 );
2172 *in += carry;
2173
2174 return prev;
2175 }
2176
2177 static UINT4
incr_24_14(UINT4 * in)2178 incr_24_14 (UINT4 *in) {
2179 UINT4 prev, carry;
2180
2181 in += 10 * WORD_INCR;
2182 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
2183 carry = ( (prev + 1) >> (24 - 8) );
2184 *in += BIT16;
2185
2186 in += 1 * WORD_INCR;
2187 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 );
2188 *in += carry;
2189
2190 return prev;
2191 }
2192
2193 static UINT4
incr_24_15(UINT4 * in)2194 incr_24_15 (UINT4 *in) {
2195 UINT4 prev;
2196
2197 in += 11 * WORD_INCR;
2198 prev = ( CONVERT(*in) >> 8 ) % (1U << 24 ) ;
2199 *in += BIT8;
2200 return prev;
2201 }
2202
2203
2204
2205 static UINT4
incr_26_00(UINT4 * in)2206 incr_26_00 (UINT4 *in) {
2207 UINT4 prev;
2208
2209 prev = ( CONVERT(*in) >> 0 ) % (1U << 26 ) ;
2210 *in += BIT0;
2211 return prev;
2212 }
2213
2214 static UINT4
incr_26_01(UINT4 * in)2215 incr_26_01 (UINT4 *in) {
2216 UINT4 prev, carry;
2217
2218 prev = ( CONVERT(*in) >> 26 ) % (1U << 26 ) ;
2219 carry = ( (prev + 1) >> (26 - 20) );
2220 *in += BIT26;
2221
2222 in += 1 * WORD_INCR;
2223 prev |= (CONVERT(*in) % (1U<< 20 ))<<( 26 - 20 );
2224 *in += carry;
2225
2226 return prev;
2227 }
2228
2229 static UINT4
incr_26_02(UINT4 * in)2230 incr_26_02 (UINT4 *in) {
2231 UINT4 prev, carry;
2232
2233 in += 1 * WORD_INCR;
2234 prev = ( CONVERT(*in) >> 20 ) % (1U << 26 ) ;
2235 carry = ( (prev + 1) >> (26 - 14) );
2236 *in += BIT20;
2237
2238 in += 1 * WORD_INCR;
2239 prev |= (CONVERT(*in) % (1U<< 14 ))<<( 26 - 14 );
2240 *in += carry;
2241
2242 return prev;
2243 }
2244
2245 static UINT4
incr_26_03(UINT4 * in)2246 incr_26_03 (UINT4 *in) {
2247 UINT4 prev, carry;
2248
2249 in += 2 * WORD_INCR;
2250 prev = ( CONVERT(*in) >> 14 ) % (1U << 26 ) ;
2251 carry = ( (prev + 1) >> (26 - 8) );
2252 *in += BIT14;
2253
2254 in += 1 * WORD_INCR;
2255 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 26 - 8 );
2256 *in += carry;
2257
2258 return prev;
2259 }
2260
2261 static UINT4
incr_26_04(UINT4 * in)2262 incr_26_04 (UINT4 *in) {
2263 UINT4 prev, carry;
2264
2265 in += 3 * WORD_INCR;
2266 prev = ( CONVERT(*in) >> 8 ) % (1U << 26 ) ;
2267 carry = ( (prev + 1) >> (26 - 2) );
2268 *in += BIT8;
2269
2270 in += 1 * WORD_INCR;
2271 prev |= (CONVERT(*in) % (1U<< 2 ))<<( 26 - 2 );
2272 *in += carry;
2273
2274 return prev;
2275 }
2276
2277 static UINT4
incr_26_05(UINT4 * in)2278 incr_26_05 (UINT4 *in) {
2279 UINT4 prev;
2280
2281 in += 4 * WORD_INCR;
2282 prev = ( CONVERT(*in) >> 2 ) % (1U << 26 ) ;
2283 *in += BIT2;
2284 return prev;
2285 }
2286
2287 static UINT4
incr_26_06(UINT4 * in)2288 incr_26_06 (UINT4 *in) {
2289 UINT4 prev, carry;
2290
2291 in += 4 * WORD_INCR;
2292 prev = ( CONVERT(*in) >> 28 ) % (1U << 26 ) ;
2293 carry = ( (prev + 1) >> (26 - 22) );
2294 *in += BIT28;
2295
2296 in += 1 * WORD_INCR;
2297 prev |= (CONVERT(*in) % (1U<< 22 ))<<( 26 - 22 );
2298 *in += carry;
2299
2300 return prev;
2301 }
2302
2303 static UINT4
incr_26_07(UINT4 * in)2304 incr_26_07 (UINT4 *in) {
2305 UINT4 prev, carry;
2306
2307 in += 5 * WORD_INCR;
2308 prev = ( CONVERT(*in) >> 22 ) % (1U << 26 ) ;
2309 carry = ( (prev + 1) >> (26 - 16) );
2310 *in += BIT22;
2311
2312 in += 1 * WORD_INCR;
2313 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 26 - 16 );
2314 *in += carry;
2315
2316 return prev;
2317 }
2318
2319 static UINT4
incr_26_08(UINT4 * in)2320 incr_26_08 (UINT4 *in) {
2321 UINT4 prev, carry;
2322
2323 in += 6 * WORD_INCR;
2324 prev = ( CONVERT(*in) >> 16 ) % (1U << 26 ) ;
2325 carry = ( (prev + 1) >> (26 - 10) );
2326 *in += BIT16;
2327
2328 in += 1 * WORD_INCR;
2329 prev |= (CONVERT(*in) % (1U<< 10 ))<<( 26 - 10 );
2330 *in += carry;
2331
2332 return prev;
2333 }
2334
2335 static UINT4
incr_26_09(UINT4 * in)2336 incr_26_09 (UINT4 *in) {
2337 UINT4 prev, carry;
2338
2339 in += 7 * WORD_INCR;
2340 prev = ( CONVERT(*in) >> 10 ) % (1U << 26 ) ;
2341 carry = ( (prev + 1) >> (26 - 4) );
2342 *in += BIT10;
2343
2344 in += 1 * WORD_INCR;
2345 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 26 - 4 );
2346 *in += carry;
2347
2348 return prev;
2349 }
2350
2351 static UINT4
incr_26_10(UINT4 * in)2352 incr_26_10 (UINT4 *in) {
2353 UINT4 prev;
2354
2355 in += 8 * WORD_INCR;
2356 prev = ( CONVERT(*in) >> 4 ) % (1U << 26 ) ;
2357 *in += BIT4;
2358 return prev;
2359 }
2360
2361 static UINT4
incr_26_11(UINT4 * in)2362 incr_26_11 (UINT4 *in) {
2363 UINT4 prev, carry;
2364
2365 in += 8 * WORD_INCR;
2366 prev = ( CONVERT(*in) >> 30 ) % (1U << 26 ) ;
2367 carry = ( (prev + 1) >> (26 - 24) );
2368 *in += BIT30;
2369
2370 in += 1 * WORD_INCR;
2371 prev |= (CONVERT(*in) % (1U<< 24 ))<<( 26 - 24 );
2372 *in += carry;
2373
2374 return prev;
2375 }
2376
2377 static UINT4
incr_26_12(UINT4 * in)2378 incr_26_12 (UINT4 *in) {
2379 UINT4 prev, carry;
2380
2381 in += 9 * WORD_INCR;
2382 prev = ( CONVERT(*in) >> 24 ) % (1U << 26 ) ;
2383 carry = ( (prev + 1) >> (26 - 18) );
2384 *in += BIT24;
2385
2386 in += 1 * WORD_INCR;
2387 prev |= (CONVERT(*in) % (1U<< 18 ))<<( 26 - 18 );
2388 *in += carry;
2389
2390 return prev;
2391 }
2392
2393 static UINT4
incr_26_13(UINT4 * in)2394 incr_26_13 (UINT4 *in) {
2395 UINT4 prev, carry;
2396
2397 in += 10 * WORD_INCR;
2398 prev = ( CONVERT(*in) >> 18 ) % (1U << 26 ) ;
2399 carry = ( (prev + 1) >> (26 - 12) );
2400 *in += BIT18;
2401
2402 in += 1 * WORD_INCR;
2403 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 26 - 12 );
2404 *in += carry;
2405
2406 return prev;
2407 }
2408
2409 static UINT4
incr_26_14(UINT4 * in)2410 incr_26_14 (UINT4 *in) {
2411 UINT4 prev, carry;
2412
2413 in += 11 * WORD_INCR;
2414 prev = ( CONVERT(*in) >> 12 ) % (1U << 26 ) ;
2415 carry = ( (prev + 1) >> (26 - 6) );
2416 *in += BIT12;
2417
2418 in += 1 * WORD_INCR;
2419 prev |= (CONVERT(*in) % (1U<< 6 ))<<( 26 - 6 );
2420 *in += carry;
2421
2422 return prev;
2423 }
2424
2425 static UINT4
incr_26_15(UINT4 * in)2426 incr_26_15 (UINT4 *in) {
2427 UINT4 prev;
2428
2429 in += 12 * WORD_INCR;
2430 prev = ( CONVERT(*in) >> 6 ) % (1U << 26 ) ;
2431 *in += BIT6;
2432 return prev;
2433 }
2434
2435
2436 static UINT4
incr_28_00(UINT4 * in)2437 incr_28_00 (UINT4 *in) {
2438 UINT4 prev;
2439
2440 prev = ( CONVERT(*in) >> 0 ) % (1U << 28 ) ;
2441 *in += BIT0;
2442 return prev;
2443 }
2444
2445 static UINT4
incr_28_01(UINT4 * in)2446 incr_28_01 (UINT4 *in) {
2447 UINT4 prev, carry;
2448
2449 prev = ( CONVERT(*in) >> 28 ) % (1U << 28 ) ;
2450 carry = ( (prev + 1) >> (28 - 24) );
2451 *in += BIT28;
2452
2453 in += 1 * WORD_INCR;
2454 prev |= (CONVERT(*in) % (1U<< 24 ))<<( 28 - 24 );
2455 *in += carry;
2456
2457 return prev;
2458 }
2459
2460 static UINT4
incr_28_02(UINT4 * in)2461 incr_28_02 (UINT4 *in) {
2462 UINT4 prev, carry;
2463
2464 in += 1 * WORD_INCR;
2465 prev = ( CONVERT(*in) >> 24 ) % (1U << 28 ) ;
2466 carry = ( (prev + 1) >> (28 - 20) );
2467 *in += BIT24;
2468
2469 in += 1 * WORD_INCR;
2470 prev |= (CONVERT(*in) % (1U<< 20 ))<<( 28 - 20 );
2471 *in += carry;
2472
2473 return prev;
2474 }
2475
2476 static UINT4
incr_28_03(UINT4 * in)2477 incr_28_03 (UINT4 *in) {
2478 UINT4 prev, carry;
2479
2480 in += 2 * WORD_INCR;
2481 prev = ( CONVERT(*in) >> 20 ) % (1U << 28 ) ;
2482 carry = ( (prev + 1) >> (28 - 16) );
2483 *in += BIT20;
2484
2485 in += 1 * WORD_INCR;
2486 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 28 - 16 );
2487 *in += carry;
2488
2489 return prev;
2490 }
2491
2492 static UINT4
incr_28_04(UINT4 * in)2493 incr_28_04 (UINT4 *in) {
2494 UINT4 prev, carry;
2495
2496 in += 3 * WORD_INCR;
2497 prev = ( CONVERT(*in) >> 16 ) % (1U << 28 ) ;
2498 carry = ( (prev + 1) >> (28 - 12) );
2499 *in += BIT16;
2500
2501 in += 1 * WORD_INCR;
2502 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 28 - 12 );
2503 *in += carry;
2504
2505 return prev;
2506 }
2507
2508 static UINT4
incr_28_05(UINT4 * in)2509 incr_28_05 (UINT4 *in) {
2510 UINT4 prev, carry;
2511
2512 in += 4 * WORD_INCR;
2513 prev = ( CONVERT(*in) >> 12 ) % (1U << 28 ) ;
2514 carry = ( (prev + 1) >> (28 - 8) );
2515 *in += BIT12;
2516
2517 in += 1 * WORD_INCR;
2518 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 28 - 8 );
2519 *in += carry;
2520
2521 return prev;
2522 }
2523
2524 static UINT4
incr_28_06(UINT4 * in)2525 incr_28_06 (UINT4 *in) {
2526 UINT4 prev, carry;
2527
2528 in += 5 * WORD_INCR;
2529 prev = ( CONVERT(*in) >> 8 ) % (1U << 28 ) ;
2530 carry = ( (prev + 1) >> (28 - 4) );
2531 *in += BIT8;
2532
2533 in += 1 * WORD_INCR;
2534 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 28 - 4 );
2535 *in += carry;
2536
2537 return prev;
2538 }
2539
2540 static UINT4
incr_28_07(UINT4 * in)2541 incr_28_07 (UINT4 *in) {
2542 UINT4 prev;
2543
2544 in += 6 * WORD_INCR;
2545 prev = ( CONVERT(*in) >> 4 ) % (1U << 28 ) ;
2546 *in += BIT4;
2547 return prev;
2548 }
2549
2550 static UINT4
incr_28_08(UINT4 * in)2551 incr_28_08 (UINT4 *in) {
2552 UINT4 prev;
2553
2554 in += 7 * WORD_INCR;
2555 prev = ( CONVERT(*in) >> 0 ) % (1U << 28 ) ;
2556 *in += BIT0;
2557 return prev;
2558 }
2559
2560 static UINT4
incr_28_09(UINT4 * in)2561 incr_28_09 (UINT4 *in) {
2562 UINT4 prev, carry;
2563
2564 in += 7 * WORD_INCR;
2565 prev = ( CONVERT(*in) >> 28 ) % (1U << 28 ) ;
2566 carry = ( (prev + 1) >> (28 - 24) );
2567 *in += BIT28;
2568
2569 in += 1 * WORD_INCR;
2570 prev |= (CONVERT(*in) % (1U<< 24 ))<<( 28 - 24 );
2571 *in += carry;
2572
2573 return prev;
2574 }
2575
2576 static UINT4
incr_28_10(UINT4 * in)2577 incr_28_10 (UINT4 *in) {
2578 UINT4 prev, carry;
2579
2580 in += 8 * WORD_INCR;
2581 prev = ( CONVERT(*in) >> 24 ) % (1U << 28 ) ;
2582 carry = ( (prev + 1) >> (28 - 20) );
2583 *in += BIT24;
2584
2585 in += 1 * WORD_INCR;
2586 prev |= (CONVERT(*in) % (1U<< 20 ))<<( 28 - 20 );
2587 *in += carry;
2588
2589 return prev;
2590 }
2591
2592 static UINT4
incr_28_11(UINT4 * in)2593 incr_28_11 (UINT4 *in) {
2594 UINT4 prev, carry;
2595
2596 in += 9 * WORD_INCR;
2597 prev = ( CONVERT(*in) >> 20 ) % (1U << 28 ) ;
2598 carry = ( (prev + 1) >> (28 - 16) );
2599 *in += BIT20;
2600
2601 in += 1 * WORD_INCR;
2602 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 28 - 16 );
2603 *in += carry;
2604
2605 return prev;
2606 }
2607
2608 static UINT4
incr_28_12(UINT4 * in)2609 incr_28_12 (UINT4 *in) {
2610 UINT4 prev, carry;
2611
2612 in += 10 * WORD_INCR;
2613 prev = ( CONVERT(*in) >> 16 ) % (1U << 28 ) ;
2614 carry = ( (prev + 1) >> (28 - 12) );
2615 *in += BIT16;
2616
2617 in += 1 * WORD_INCR;
2618 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 28 - 12 );
2619 *in += carry;
2620
2621 return prev;
2622 }
2623
2624 static UINT4
incr_28_13(UINT4 * in)2625 incr_28_13 (UINT4 *in) {
2626 UINT4 prev, carry;
2627
2628 in += 11 * WORD_INCR;
2629 prev = ( CONVERT(*in) >> 12 ) % (1U << 28 ) ;
2630 carry = ( (prev + 1) >> (28 - 8) );
2631 *in += BIT12;
2632
2633 in += 1 * WORD_INCR;
2634 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 28 - 8 );
2635 *in += carry;
2636
2637 return prev;
2638 }
2639
2640 static UINT4
incr_28_14(UINT4 * in)2641 incr_28_14 (UINT4 *in) {
2642 UINT4 prev, carry;
2643
2644 in += 12 * WORD_INCR;
2645 prev = ( CONVERT(*in) >> 8 ) % (1U << 28 ) ;
2646 carry = ( (prev + 1) >> (28 - 4) );
2647 *in += BIT8;
2648
2649 in += 1 * WORD_INCR;
2650 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 28 - 4 );
2651 *in += carry;
2652
2653 return prev;
2654 }
2655
2656 static UINT4
incr_28_15(UINT4 * in)2657 incr_28_15 (UINT4 *in) {
2658 UINT4 prev;
2659
2660 in += 13 * WORD_INCR;
2661 prev = ( CONVERT(*in) >> 4 ) % (1U << 28 ) ;
2662 *in += BIT4;
2663 return prev;
2664 }
2665
2666
2667 static UINT4
incr_30_00(UINT4 * in)2668 incr_30_00 (UINT4 *in) {
2669 UINT4 prev;
2670
2671 prev = ( CONVERT(*in) >> 0 ) % (1U << 30 ) ;
2672 *in += BIT0;
2673 return prev;
2674 }
2675
2676 static UINT4
incr_30_01(UINT4 * in)2677 incr_30_01 (UINT4 *in) {
2678 UINT4 prev, carry;
2679
2680 prev = ( CONVERT(*in) >> 30 ) % (1U << 30 ) ;
2681 carry = ( (prev + 1) >> (30 - 28) );
2682 *in += BIT30;
2683
2684 in += 1 * WORD_INCR;
2685 prev |= (CONVERT(*in) % (1U<< 28 ))<<( 30 - 28 );
2686 *in += carry;
2687
2688 return prev;
2689 }
2690
2691 static UINT4
incr_30_02(UINT4 * in)2692 incr_30_02 (UINT4 *in) {
2693 UINT4 prev, carry;
2694
2695 in += 1 * WORD_INCR;
2696 prev = ( CONVERT(*in) >> 28 ) % (1U << 30 ) ;
2697 carry = ( (prev + 1) >> (30 - 26) );
2698 *in += BIT28;
2699
2700 in += 1 * WORD_INCR;
2701 prev |= (CONVERT(*in) % (1U<< 26 ))<<( 30 - 26 );
2702 *in += carry;
2703
2704 return prev;
2705 }
2706
2707 static UINT4
incr_30_03(UINT4 * in)2708 incr_30_03 (UINT4 *in) {
2709 UINT4 prev, carry;
2710
2711 in += 2 * WORD_INCR;
2712 prev = ( CONVERT(*in) >> 26 ) % (1U << 30 ) ;
2713 carry = ( (prev + 1) >> (30 - 24) );
2714 *in += BIT26;
2715
2716 in += 1 * WORD_INCR;
2717 prev |= (CONVERT(*in) % (1U<< 24 ))<<( 30 - 24 );
2718 *in += carry;
2719
2720 return prev;
2721 }
2722
2723 static UINT4
incr_30_04(UINT4 * in)2724 incr_30_04 (UINT4 *in) {
2725 UINT4 prev, carry;
2726
2727 in += 3 * WORD_INCR;
2728 prev = ( CONVERT(*in) >> 24 ) % (1U << 30 ) ;
2729 carry = ( (prev + 1) >> (30 - 22) );
2730 *in += BIT24;
2731
2732 in += 1 * WORD_INCR;
2733 prev |= (CONVERT(*in) % (1U<< 22 ))<<( 30 - 22 );
2734 *in += carry;
2735
2736 return prev;
2737 }
2738
2739 static UINT4
incr_30_05(UINT4 * in)2740 incr_30_05 (UINT4 *in) {
2741 UINT4 prev, carry;
2742
2743 in += 4 * WORD_INCR;
2744 prev = ( CONVERT(*in) >> 22 ) % (1U << 30 ) ;
2745 carry = ( (prev + 1) >> (30 - 20) );
2746 *in += BIT22;
2747
2748 in += 1 * WORD_INCR;
2749 prev |= (CONVERT(*in) % (1U<< 20 ))<<( 30 - 20 );
2750 *in += carry;
2751
2752 return prev;
2753 }
2754
2755 static UINT4
incr_30_06(UINT4 * in)2756 incr_30_06 (UINT4 *in) {
2757 UINT4 prev, carry;
2758
2759 in += 5 * WORD_INCR;
2760 prev = ( CONVERT(*in) >> 20 ) % (1U << 30 ) ;
2761 carry = ( (prev + 1) >> (30 - 18));
2762 *in += BIT20;
2763
2764 in += 1 * WORD_INCR;
2765 prev |= (CONVERT(*in) % (1U<< 18 ))<<( 30 - 18 );
2766 *in += carry;
2767
2768 return prev;
2769 }
2770
2771 static UINT4
incr_30_07(UINT4 * in)2772 incr_30_07 (UINT4 *in) {
2773 UINT4 prev, carry;
2774
2775 in += 6 * WORD_INCR;
2776 prev = ( CONVERT(*in) >> 18 ) % (1U << 30 ) ;
2777 carry = ( (prev + 1) >> (30 - 16) );
2778 *in += BIT18;
2779
2780 in += 1 * WORD_INCR;
2781 prev |= (CONVERT(*in) % (1U<< 16 ))<<( 30 - 16 );
2782 *in += carry;
2783
2784 return prev;
2785 }
2786
2787 static UINT4
incr_30_08(UINT4 * in)2788 incr_30_08 (UINT4 *in) {
2789 UINT4 prev, carry;
2790
2791 in += 7 * WORD_INCR;
2792 prev = ( CONVERT(*in) >> 16 ) % (1U << 30 ) ;
2793 carry = ( (prev + 1) >> (30 - 14) );
2794 *in += BIT16;
2795
2796 in += 1 * WORD_INCR;
2797 prev |= (CONVERT(*in) % (1U<< 14 ))<<( 30 - 14 );
2798 *in += carry;
2799
2800 return prev;
2801 }
2802
2803 static UINT4
incr_30_09(UINT4 * in)2804 incr_30_09 (UINT4 *in) {
2805 UINT4 prev, carry;
2806
2807 in += 8 * WORD_INCR;
2808 prev = ( CONVERT(*in) >> 14 ) % (1U << 30 ) ;
2809 carry = ( (prev + 1) >> (30 - 12) );
2810 *in += BIT14;
2811
2812 in += 1 * WORD_INCR;
2813 prev |= (CONVERT(*in) % (1U<< 12 ))<<( 30 - 12 );
2814 *in += carry;
2815
2816 return prev;
2817 }
2818
2819 static UINT4
incr_30_10(UINT4 * in)2820 incr_30_10 (UINT4 *in) {
2821 UINT4 prev, carry;
2822
2823 in += 9 * WORD_INCR;
2824 prev = ( CONVERT(*in) >> 12 ) % (1U << 30 ) ;
2825 carry = ( (prev + 1) >> (30 - 10) );
2826 *in += BIT12;
2827
2828 in += 1 * WORD_INCR;
2829 prev |= (CONVERT(*in) % (1U<< 10 ))<<( 30 - 10 );
2830 *in += carry;
2831
2832 return prev;
2833 }
2834
2835 static UINT4
incr_30_11(UINT4 * in)2836 incr_30_11 (UINT4 *in) {
2837 UINT4 prev, carry;
2838
2839 in += 10 * WORD_INCR;
2840 prev = ( CONVERT(*in) >> 10 ) % (1U << 30 ) ;
2841 carry = ( (prev + 1) >> (30 - 8) );
2842 *in += BIT10;
2843
2844 in += 1 * WORD_INCR;
2845 prev |= (CONVERT(*in) % (1U<< 8 ))<<( 30 - 8 );
2846 *in += carry;
2847
2848 return prev;
2849 }
2850
2851 static UINT4
incr_30_12(UINT4 * in)2852 incr_30_12 (UINT4 *in) {
2853 UINT4 prev, carry;
2854
2855 in += 11 * WORD_INCR;
2856 prev = ( CONVERT(*in) >> 8 ) % (1U << 30 ) ;
2857 carry = ( (prev + 1) >> (30 - 6) );
2858 *in += BIT8;
2859
2860 in += 1 * WORD_INCR;
2861 prev |= (CONVERT(*in) % (1U<< 6 ))<<( 30 - 6 );
2862 *in += carry;
2863
2864 return prev;
2865 }
2866
2867 static UINT4
incr_30_13(UINT4 * in)2868 incr_30_13 (UINT4 *in) {
2869 UINT4 prev, carry;
2870
2871 in += 12 * WORD_INCR;
2872 prev = ( CONVERT(*in) >> 6 ) % (1U << 30 ) ;
2873 carry = ( (prev + 1) >> (30 - 4) );
2874 *in += BIT6;
2875
2876 in += 1 * WORD_INCR;
2877 prev |= (CONVERT(*in) % (1U<< 4 ))<<( 30 - 4 );
2878 *in += carry;
2879
2880 return prev;
2881 }
2882
2883 static UINT4
incr_30_14(UINT4 * in)2884 incr_30_14 (UINT4 *in) {
2885 UINT4 prev, carry;
2886
2887 in += 13 * WORD_INCR;
2888 prev = ( CONVERT(*in) >> 4 ) % (1U << 30 ) ;
2889 carry = ( (prev + 1) >> (30 - 2) );
2890 *in += BIT4;
2891
2892 in += 1 * WORD_INCR;
2893 prev |= (CONVERT(*in) % (1U<< 2 ))<<( 30 - 2 );
2894 *in += carry;
2895
2896 return prev;
2897 }
2898
2899 static UINT4
incr_30_15(UINT4 * in)2900 incr_30_15 (UINT4 *in) {
2901 UINT4 prev;
2902
2903 in += 14 * WORD_INCR;
2904 prev = ( CONVERT(*in) >> 2 ) % (1U << 30 ) ;
2905 *in += BIT2;
2906 return prev;
2907 }
2908
2909
2910 static UINT4
incr_32_00(UINT4 * in)2911 incr_32_00 (UINT4 *in) {
2912 UINT4 prev;
2913
2914 prev = CONVERT(*in);
2915 *in += 1;
2916 return prev;
2917 }
2918
2919 static UINT4
incr_32_01(UINT4 * in)2920 incr_32_01 (UINT4 *in) {
2921 UINT4 prev;
2922
2923 in += 1 * WORD_INCR;
2924 prev = CONVERT(*in);
2925 *in += 1;
2926 return prev;
2927 }
2928
2929 static UINT4
incr_32_02(UINT4 * in)2930 incr_32_02 (UINT4 *in) {
2931 UINT4 prev;
2932
2933 in += 2 * WORD_INCR;
2934 prev = CONVERT(*in);
2935 *in += 1;
2936 return prev;
2937 }
2938
2939 static UINT4
incr_32_03(UINT4 * in)2940 incr_32_03 (UINT4 *in) {
2941 UINT4 prev;
2942
2943 in += 3 * WORD_INCR;
2944 prev = CONVERT(*in);
2945 *in += 1;
2946 return prev;
2947 }
2948
2949 static UINT4
incr_32_04(UINT4 * in)2950 incr_32_04 (UINT4 *in) {
2951 UINT4 prev;
2952
2953 in += 4 * WORD_INCR;
2954 prev = CONVERT(*in);
2955 *in += 1;
2956 return prev;
2957 }
2958
2959 static UINT4
incr_32_05(UINT4 * in)2960 incr_32_05 (UINT4 *in) {
2961 UINT4 prev;
2962
2963 in += 5 * WORD_INCR;
2964 prev = CONVERT(*in);
2965 *in += 1;
2966 return prev;
2967 }
2968
2969 static UINT4
incr_32_06(UINT4 * in)2970 incr_32_06 (UINT4 *in) {
2971 UINT4 prev;
2972
2973 in += 6 * WORD_INCR;
2974 prev = CONVERT(*in);
2975 *in += 1;
2976 return prev;
2977 }
2978
2979
2980 static UINT4
incr_32_07(UINT4 * in)2981 incr_32_07 (UINT4 *in) {
2982 UINT4 prev;
2983
2984 in += 7 * WORD_INCR;
2985 prev = CONVERT(*in);
2986 *in += 1;
2987 return prev;
2988 }
2989
2990 static UINT4
incr_32_08(UINT4 * in)2991 incr_32_08 (UINT4 *in) {
2992 UINT4 prev;
2993
2994 in += 8 * WORD_INCR;
2995 prev = CONVERT(*in);
2996 *in += 1;
2997 return prev;
2998 }
2999
3000 static UINT4
incr_32_09(UINT4 * in)3001 incr_32_09 (UINT4 *in) {
3002 UINT4 prev;
3003
3004 in += 9 * WORD_INCR;
3005 prev = CONVERT(*in);
3006 *in += 1;
3007 return prev;
3008 }
3009
3010 static UINT4
incr_32_10(UINT4 * in)3011 incr_32_10 (UINT4 *in) {
3012 UINT4 prev;
3013
3014 in += 10 * WORD_INCR;
3015 prev = CONVERT(*in);
3016 *in += 1;
3017 return prev;
3018 }
3019
3020 static UINT4
incr_32_11(UINT4 * in)3021 incr_32_11 (UINT4 *in) {
3022 UINT4 prev;
3023
3024 in += 11 * WORD_INCR;
3025 prev = CONVERT(*in);
3026 *in += 1;
3027 return prev;
3028 }
3029
3030 static UINT4
incr_32_12(UINT4 * in)3031 incr_32_12 (UINT4 *in) {
3032 UINT4 prev;
3033
3034 in += 12 * WORD_INCR;
3035 prev = CONVERT(*in);
3036 *in += 1;
3037 return prev;
3038 }
3039
3040 static UINT4
incr_32_13(UINT4 * in)3041 incr_32_13 (UINT4 *in) {
3042 UINT4 prev;
3043
3044 in += 13 * WORD_INCR;
3045 prev = CONVERT(*in);
3046 *in += 1;
3047 return prev;
3048 }
3049
3050 static UINT4
incr_32_14(UINT4 * in)3051 incr_32_14 (UINT4 *in) {
3052 UINT4 prev;
3053
3054 in += 14 * WORD_INCR;
3055 prev = CONVERT(*in);
3056 *in += 1;
3057 return prev;
3058 }
3059
3060 static UINT4
incr_32_15(UINT4 * in)3061 incr_32_15 (UINT4 *in) {
3062 UINT4 prev;
3063
3064 in += 15 * WORD_INCR;
3065 prev = CONVERT(*in);
3066 *in += 1;
3067 return prev;
3068 }
3069
3070
3071
3072
3073 typedef UINT4 (*Incrementor_T) (UINT4 *);
3074
3075 static Incrementor_T incrementor_table[272] =
3076 {incr_00, incr_00, incr_00, incr_00,
3077 incr_00, incr_00, incr_00, incr_00,
3078 incr_00, incr_00, incr_00, incr_00,
3079 incr_00, incr_00, incr_00, incr_00,
3080
3081 incr_02_00, incr_02_01, incr_02_02, incr_02_03,
3082 incr_02_04, incr_02_05, incr_02_06, incr_02_07,
3083 incr_02_08, incr_02_09, incr_02_10, incr_02_11,
3084 incr_02_12, incr_02_13, incr_02_14, incr_02_15,
3085
3086 incr_04_00, incr_04_01, incr_04_02, incr_04_03,
3087 incr_04_04, incr_04_05, incr_04_06, incr_04_07,
3088 incr_04_08, incr_04_09, incr_04_10, incr_04_11,
3089 incr_04_12, incr_04_13, incr_04_14, incr_04_15,
3090
3091 incr_06_00, incr_06_01, incr_06_02, incr_06_03,
3092 incr_06_04, incr_06_05, incr_06_06, incr_06_07,
3093 incr_06_08, incr_06_09, incr_06_10, incr_06_11,
3094 incr_06_12, incr_06_13, incr_06_14, incr_06_15,
3095
3096 incr_08_00, incr_08_01, incr_08_02, incr_08_03,
3097 incr_08_04, incr_08_05, incr_08_06, incr_08_07,
3098 incr_08_08, incr_08_09, incr_08_10, incr_08_11,
3099 incr_08_12, incr_08_13, incr_08_14, incr_08_15,
3100
3101 incr_10_00, incr_10_01, incr_10_02, incr_10_03,
3102 incr_10_04, incr_10_05, incr_10_06, incr_10_07,
3103 incr_10_08, incr_10_09, incr_10_10, incr_10_11,
3104 incr_10_12, incr_10_13, incr_10_14, incr_10_15,
3105
3106 incr_12_00, incr_12_01, incr_12_02, incr_12_03,
3107 incr_12_04, incr_12_05, incr_12_06, incr_12_07,
3108 incr_12_08, incr_12_09, incr_12_10, incr_12_11,
3109 incr_12_12, incr_12_13, incr_12_14, incr_12_15,
3110
3111 incr_14_00, incr_14_01, incr_14_02, incr_14_03,
3112 incr_14_04, incr_14_05, incr_14_06, incr_14_07,
3113 incr_14_08, incr_14_09, incr_14_10, incr_14_11,
3114 incr_14_12, incr_14_13, incr_14_14, incr_14_15,
3115
3116 incr_16_00, incr_16_01, incr_16_02, incr_16_03,
3117 incr_16_04, incr_16_05, incr_16_06, incr_16_07,
3118 incr_16_08, incr_16_09, incr_16_10, incr_16_11,
3119 incr_16_12, incr_16_13, incr_16_14, incr_16_15,
3120
3121 incr_18_00, incr_18_01, incr_18_02, incr_18_03,
3122 incr_18_04, incr_18_05, incr_18_06, incr_18_07,
3123 incr_18_08, incr_18_09, incr_18_10, incr_18_11,
3124 incr_18_12, incr_18_13, incr_18_14, incr_18_15,
3125
3126 incr_20_00, incr_20_01, incr_20_02, incr_20_03,
3127 incr_20_04, incr_20_05, incr_20_06, incr_20_07,
3128 incr_20_08, incr_20_09, incr_20_10, incr_20_11,
3129 incr_20_12, incr_20_13, incr_20_14, incr_20_15,
3130
3131 incr_22_00, incr_22_01, incr_22_02, incr_22_03,
3132 incr_22_04, incr_22_05, incr_22_06, incr_22_07,
3133 incr_22_08, incr_22_09, incr_22_10, incr_22_11,
3134 incr_22_12, incr_22_13, incr_22_14, incr_22_15,
3135
3136 incr_24_00, incr_24_01, incr_24_02, incr_24_03,
3137 incr_24_04, incr_24_05, incr_24_06, incr_24_07,
3138 incr_24_08, incr_24_09, incr_24_10, incr_24_11,
3139 incr_24_12, incr_24_13, incr_24_14, incr_24_15,
3140
3141 incr_26_00, incr_26_01, incr_26_02, incr_26_03,
3142 incr_26_04, incr_26_05, incr_26_06, incr_26_07,
3143 incr_26_08, incr_26_09, incr_26_10, incr_26_11,
3144 incr_26_12, incr_26_13, incr_26_14, incr_26_15,
3145
3146 incr_28_00, incr_28_01, incr_28_02, incr_28_03,
3147 incr_28_04, incr_28_05, incr_28_06, incr_28_07,
3148 incr_28_08, incr_28_09, incr_28_10, incr_28_11,
3149 incr_28_12, incr_28_13, incr_28_14, incr_28_15,
3150
3151 incr_30_00, incr_30_01, incr_30_02, incr_30_03,
3152 incr_30_04, incr_30_05, incr_30_06, incr_30_07,
3153 incr_30_08, incr_30_09, incr_30_10, incr_30_11,
3154 incr_30_12, incr_30_13, incr_30_14, incr_30_15,
3155
3156 incr_32_00, incr_32_01, incr_32_02, incr_32_03,
3157 incr_32_04, incr_32_05, incr_32_06, incr_32_07,
3158 incr_32_08, incr_32_09, incr_32_10, incr_32_11,
3159 incr_32_12, incr_32_13, incr_32_14, incr_32_15,
3160 };
3161
3162
3163
3164 static void
add_00(UINT4 * in,UINT4 increment)3165 add_00 (UINT4 *in, UINT4 increment) {
3166 abort();
3167 return;
3168 }
3169
3170
3171
3172 static void
add_02_00(UINT4 * in,UINT4 increment)3173 add_02_00 (UINT4 *in, UINT4 increment) {
3174 *in += (increment << 0);
3175 return;
3176 }
3177
3178 static void
add_02_01(UINT4 * in,UINT4 increment)3179 add_02_01 (UINT4 *in, UINT4 increment) {
3180 *in += (increment << 2);
3181 return;
3182 }
3183
3184 static void
add_02_02(UINT4 * in,UINT4 increment)3185 add_02_02 (UINT4 *in, UINT4 increment) {
3186 *in += (increment << 4);
3187 return;
3188 }
3189
3190 static void
add_02_03(UINT4 * in,UINT4 increment)3191 add_02_03 (UINT4 *in, UINT4 increment) {
3192 *in += (increment << 6);
3193 return;
3194 }
3195
3196 static void
add_02_04(UINT4 * in,UINT4 increment)3197 add_02_04 (UINT4 *in, UINT4 increment) {
3198 *in += (increment << 8);
3199 return;
3200 }
3201
3202 static void
add_02_05(UINT4 * in,UINT4 increment)3203 add_02_05 (UINT4 *in, UINT4 increment) {
3204 *in += (increment << 10);
3205 return;
3206 }
3207
3208 static void
add_02_06(UINT4 * in,UINT4 increment)3209 add_02_06 (UINT4 *in, UINT4 increment) {
3210 *in += (increment << 12);
3211 return;
3212 }
3213
3214 static void
add_02_07(UINT4 * in,UINT4 increment)3215 add_02_07 (UINT4 *in, UINT4 increment) {
3216 *in += (increment << 14);
3217 return;
3218 }
3219
3220 static void
add_02_08(UINT4 * in,UINT4 increment)3221 add_02_08 (UINT4 *in, UINT4 increment) {
3222 *in += (increment << 16);
3223 return;
3224 }
3225
3226 static void
add_02_09(UINT4 * in,UINT4 increment)3227 add_02_09 (UINT4 *in, UINT4 increment) {
3228 *in += (increment << 18);
3229 return;
3230 }
3231
3232 static void
add_02_10(UINT4 * in,UINT4 increment)3233 add_02_10 (UINT4 *in, UINT4 increment) {
3234 *in += (increment << 20);
3235 return;
3236 }
3237
3238 static void
add_02_11(UINT4 * in,UINT4 increment)3239 add_02_11 (UINT4 *in, UINT4 increment) {
3240 *in += (increment << 22);
3241 return;
3242 }
3243
3244 static void
add_02_12(UINT4 * in,UINT4 increment)3245 add_02_12 (UINT4 *in, UINT4 increment) {
3246 *in += (increment << 24);
3247 return;
3248 }
3249
3250 static void
add_02_13(UINT4 * in,UINT4 increment)3251 add_02_13 (UINT4 *in, UINT4 increment) {
3252 *in += (increment << 26);
3253 return;
3254 }
3255
3256 static void
add_02_14(UINT4 * in,UINT4 increment)3257 add_02_14 (UINT4 *in, UINT4 increment) {
3258 *in += (increment << 28);
3259 return;
3260 }
3261
3262 static void
add_02_15(UINT4 * in,UINT4 increment)3263 add_02_15 (UINT4 *in, UINT4 increment) {
3264 *in += (increment << 30);
3265 return;
3266 }
3267
3268
3269 static void
add_04_00(UINT4 * in,UINT4 increment)3270 add_04_00 (UINT4 *in, UINT4 increment) {
3271 *in += (increment << 0);
3272 return;
3273 }
3274
3275 static void
add_04_01(UINT4 * in,UINT4 increment)3276 add_04_01 (UINT4 *in, UINT4 increment) {
3277 *in += (increment << 4);
3278 return;
3279 }
3280
3281 static void
add_04_02(UINT4 * in,UINT4 increment)3282 add_04_02 (UINT4 *in, UINT4 increment) {
3283 *in += (increment << 8);
3284 return;
3285 }
3286
3287 static void
add_04_03(UINT4 * in,UINT4 increment)3288 add_04_03 (UINT4 *in, UINT4 increment) {
3289 *in += (increment << 12);
3290 return;
3291 }
3292
3293 static void
add_04_04(UINT4 * in,UINT4 increment)3294 add_04_04 (UINT4 *in, UINT4 increment) {
3295 *in += (increment << 16);
3296 return;
3297 }
3298
3299 static void
add_04_05(UINT4 * in,UINT4 increment)3300 add_04_05 (UINT4 *in, UINT4 increment) {
3301 *in += (increment << 20);
3302 return;
3303 }
3304
3305 static void
add_04_06(UINT4 * in,UINT4 increment)3306 add_04_06 (UINT4 *in, UINT4 increment) {
3307 *in += (increment << 24);
3308 return;
3309 }
3310
3311 static void
add_04_07(UINT4 * in,UINT4 increment)3312 add_04_07 (UINT4 *in, UINT4 increment) {
3313 *in += (increment << 28);
3314 return;
3315 }
3316
3317 static void
add_04_08(UINT4 * in,UINT4 increment)3318 add_04_08 (UINT4 *in, UINT4 increment) {
3319 in += 1 * WORD_INCR;
3320 *in += (increment << 0);
3321 return;
3322 }
3323
3324 static void
add_04_09(UINT4 * in,UINT4 increment)3325 add_04_09 (UINT4 *in, UINT4 increment) {
3326 in += 1 * WORD_INCR;
3327 *in += (increment << 4);
3328 return;
3329 }
3330
3331 static void
add_04_10(UINT4 * in,UINT4 increment)3332 add_04_10 (UINT4 *in, UINT4 increment) {
3333 in += 1 * WORD_INCR;
3334 *in += (increment << 8);
3335 return;
3336 }
3337
3338 static void
add_04_11(UINT4 * in,UINT4 increment)3339 add_04_11 (UINT4 *in, UINT4 increment) {
3340 in += 1 * WORD_INCR;
3341 *in += (increment << 12);
3342 return;
3343 }
3344
3345 static void
add_04_12(UINT4 * in,UINT4 increment)3346 add_04_12 (UINT4 *in, UINT4 increment) {
3347 in += 1 * WORD_INCR;
3348 *in += (increment << 16);
3349 return;
3350 }
3351
3352 static void
add_04_13(UINT4 * in,UINT4 increment)3353 add_04_13 (UINT4 *in, UINT4 increment) {
3354 in += 1 * WORD_INCR;
3355 *in += (increment << 20);
3356 return;
3357 }
3358
3359 static void
add_04_14(UINT4 * in,UINT4 increment)3360 add_04_14 (UINT4 *in, UINT4 increment) {
3361 in += 1 * WORD_INCR;
3362 *in += (increment << 24);
3363 return;
3364 }
3365
3366 static void
add_04_15(UINT4 * in,UINT4 increment)3367 add_04_15 (UINT4 *in, UINT4 increment) {
3368 in += 1 * WORD_INCR;
3369 *in += (increment << 28);
3370 return;
3371 }
3372
3373
3374 static void
add_06_00(UINT4 * in,UINT4 increment)3375 add_06_00 (UINT4 *in, UINT4 increment) {
3376 *in += (increment << 0);
3377 return;
3378 }
3379
3380 static void
add_06_01(UINT4 * in,UINT4 increment)3381 add_06_01 (UINT4 *in, UINT4 increment) {
3382 *in += (increment << 6);
3383 return;
3384 }
3385
3386 static void
add_06_02(UINT4 * in,UINT4 increment)3387 add_06_02 (UINT4 *in, UINT4 increment) {
3388 *in += (increment << 12);
3389 return;
3390 }
3391
3392 static void
add_06_03(UINT4 * in,UINT4 increment)3393 add_06_03 (UINT4 *in, UINT4 increment) {
3394 *in += (increment << 18);
3395 return;
3396 }
3397
3398 static void
add_06_04(UINT4 * in,UINT4 increment)3399 add_06_04 (UINT4 *in, UINT4 increment) {
3400 *in += (increment << 24);
3401 return;
3402 }
3403
3404 static void
add_06_05(UINT4 * in,UINT4 increment)3405 add_06_05 (UINT4 *in, UINT4 increment) {
3406 UINT4 prev, carry;
3407
3408 prev = ( CONVERT(*in) >> 30 ) % (1U << 6 ) ;
3409 carry = ( (prev + increment) >> (6 - 4) );
3410 *in += (increment << 30);
3411
3412 in += 1 * WORD_INCR;
3413 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 6 - 4 ); */
3414 *in += carry;
3415
3416 return;
3417 }
3418
3419 static void
add_06_06(UINT4 * in,UINT4 increment)3420 add_06_06 (UINT4 *in, UINT4 increment) {
3421 in += 1 * WORD_INCR;
3422 *in += (increment << 4);
3423 return;
3424 }
3425
3426 static void
add_06_07(UINT4 * in,UINT4 increment)3427 add_06_07 (UINT4 *in, UINT4 increment) {
3428 in += 1 * WORD_INCR;
3429 *in += (increment << 10);
3430 return;
3431 }
3432
3433 static void
add_06_08(UINT4 * in,UINT4 increment)3434 add_06_08 (UINT4 *in, UINT4 increment) {
3435 in += 1 * WORD_INCR;
3436 *in += (increment << 16);
3437 return;
3438 }
3439
3440 static void
add_06_09(UINT4 * in,UINT4 increment)3441 add_06_09 (UINT4 *in, UINT4 increment) {
3442 in += 1 * WORD_INCR;
3443 *in += (increment << 22);
3444 return;
3445 }
3446
3447 static void
add_06_10(UINT4 * in,UINT4 increment)3448 add_06_10 (UINT4 *in, UINT4 increment) {
3449 UINT4 prev, carry;
3450
3451 in += 1 * WORD_INCR;
3452 prev = ( CONVERT(*in) >> 28 ) % (1U << 6 ) ;
3453 carry = ( (prev + increment) >> (6 - 2) );
3454 *in += (increment << 28);
3455
3456 in += 1 * WORD_INCR;
3457 /* prev |= (CONVERT(*in) % (1U<< 2 ))<<( 6 - 2 ); */
3458 *in += carry;
3459
3460 return;
3461 }
3462
3463 static void
add_06_11(UINT4 * in,UINT4 increment)3464 add_06_11 (UINT4 *in, UINT4 increment) {
3465 in += 2 * WORD_INCR;
3466 *in += (increment << 2);
3467 return;
3468 }
3469
3470 static void
add_06_12(UINT4 * in,UINT4 increment)3471 add_06_12 (UINT4 *in, UINT4 increment) {
3472 in += 2 * WORD_INCR;
3473 *in += (increment << 8);
3474 return;
3475 }
3476
3477 static void
add_06_13(UINT4 * in,UINT4 increment)3478 add_06_13 (UINT4 *in, UINT4 increment) {
3479 in += 2 * WORD_INCR;
3480 *in += (increment << 14);
3481 return;
3482 }
3483
3484 static void
add_06_14(UINT4 * in,UINT4 increment)3485 add_06_14 (UINT4 *in, UINT4 increment) {
3486 in += 2 * WORD_INCR;
3487 *in += (increment << 20);
3488 return;
3489 }
3490
3491 static void
add_06_15(UINT4 * in,UINT4 increment)3492 add_06_15 (UINT4 *in, UINT4 increment) {
3493 in += 2 * WORD_INCR;
3494 *in += (increment << 26);
3495 return;
3496 }
3497
3498
3499 static void
add_08_00(UINT4 * in,UINT4 increment)3500 add_08_00 (UINT4 *in, UINT4 increment) {
3501 *in += (increment << 0);
3502 return;
3503 }
3504
3505 static void
add_08_01(UINT4 * in,UINT4 increment)3506 add_08_01 (UINT4 *in, UINT4 increment) {
3507 *in += (increment << 8);
3508 return;
3509 }
3510
3511 static void
add_08_02(UINT4 * in,UINT4 increment)3512 add_08_02 (UINT4 *in, UINT4 increment) {
3513 *in += (increment << 16);
3514 return;
3515 }
3516
3517 static void
add_08_03(UINT4 * in,UINT4 increment)3518 add_08_03 (UINT4 *in, UINT4 increment) {
3519 *in += (increment << 24);
3520 return;
3521 }
3522
3523 static void
add_08_04(UINT4 * in,UINT4 increment)3524 add_08_04 (UINT4 *in, UINT4 increment) {
3525 in += 1 * WORD_INCR;
3526 *in += (increment << 0);
3527 return;
3528 }
3529
3530 static void
add_08_05(UINT4 * in,UINT4 increment)3531 add_08_05 (UINT4 *in, UINT4 increment) {
3532 in += 1 * WORD_INCR;
3533 *in += (increment << 8);
3534 return;
3535 }
3536
3537 static void
add_08_06(UINT4 * in,UINT4 increment)3538 add_08_06 (UINT4 *in, UINT4 increment) {
3539 in += 1 * WORD_INCR;
3540 *in += (increment << 16);
3541 return;
3542 }
3543
3544 static void
add_08_07(UINT4 * in,UINT4 increment)3545 add_08_07 (UINT4 *in, UINT4 increment) {
3546 in += 1 * WORD_INCR;
3547 *in += (increment << 24);
3548 return;
3549 }
3550
3551 static void
add_08_08(UINT4 * in,UINT4 increment)3552 add_08_08 (UINT4 *in, UINT4 increment) {
3553 in += 2 * WORD_INCR;
3554 *in += (increment << 0);
3555 return;
3556 }
3557
3558 static void
add_08_09(UINT4 * in,UINT4 increment)3559 add_08_09 (UINT4 *in, UINT4 increment) {
3560 in += 2 * WORD_INCR;
3561 *in += (increment << 8);
3562 return;
3563 }
3564
3565 static void
add_08_10(UINT4 * in,UINT4 increment)3566 add_08_10 (UINT4 *in, UINT4 increment) {
3567 in += 2 * WORD_INCR;
3568 *in += (increment << 16);
3569 return;
3570 }
3571
3572 static void
add_08_11(UINT4 * in,UINT4 increment)3573 add_08_11 (UINT4 *in, UINT4 increment) {
3574 in += 2 * WORD_INCR;
3575 *in += (increment << 24);
3576 return;
3577 }
3578
3579 static void
add_08_12(UINT4 * in,UINT4 increment)3580 add_08_12 (UINT4 *in, UINT4 increment) {
3581 in += 3 * WORD_INCR;
3582 *in += (increment << 0);
3583 return;
3584 }
3585
3586 static void
add_08_13(UINT4 * in,UINT4 increment)3587 add_08_13 (UINT4 *in, UINT4 increment) {
3588 in += 3 * WORD_INCR;
3589 *in += (increment << 8);
3590 return;
3591 }
3592
3593 static void
add_08_14(UINT4 * in,UINT4 increment)3594 add_08_14 (UINT4 *in, UINT4 increment) {
3595 in += 3 * WORD_INCR;
3596 *in += (increment << 16);
3597 return;
3598 }
3599
3600 static void
add_08_15(UINT4 * in,UINT4 increment)3601 add_08_15 (UINT4 *in, UINT4 increment) {
3602 in += 3 * WORD_INCR;
3603 *in += (increment << 24);
3604 return;
3605 }
3606
3607
3608
3609 static void
add_10_00(UINT4 * in,UINT4 increment)3610 add_10_00 (UINT4 *in, UINT4 increment) {
3611 *in += (increment << 0);
3612 return;
3613 }
3614
3615 static void
add_10_01(UINT4 * in,UINT4 increment)3616 add_10_01 (UINT4 *in, UINT4 increment) {
3617 *in += (increment << 10);
3618 return;
3619 }
3620
3621 static void
add_10_02(UINT4 * in,UINT4 increment)3622 add_10_02 (UINT4 *in, UINT4 increment) {
3623 *in += (increment << 20);
3624 return;
3625 }
3626
3627 static void
add_10_03(UINT4 * in,UINT4 increment)3628 add_10_03 (UINT4 *in, UINT4 increment) {
3629 UINT4 prev, carry;
3630
3631 prev = ( CONVERT(*in) >> 30 ) % (1U << 10 ) ;
3632 carry = ( (prev + increment) >> (10 - 8) );
3633 *in += (increment << 30);
3634
3635 in += 1 * WORD_INCR;
3636 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 10 - 8 ); */
3637 *in += carry;
3638
3639 return;
3640 }
3641
3642 static void
add_10_04(UINT4 * in,UINT4 increment)3643 add_10_04 (UINT4 *in, UINT4 increment) {
3644 in += 1 * WORD_INCR;
3645 *in += (increment << 8);
3646 return;
3647 }
3648
3649 static void
add_10_05(UINT4 * in,UINT4 increment)3650 add_10_05 (UINT4 *in, UINT4 increment) {
3651 in += 1 * WORD_INCR;
3652 *in += (increment << 18);
3653 return;
3654 }
3655
3656 static void
add_10_06(UINT4 * in,UINT4 increment)3657 add_10_06 (UINT4 *in, UINT4 increment) {
3658 UINT4 prev, carry;
3659
3660 in += 1 * WORD_INCR;
3661 prev = ( CONVERT(*in) >> 28 ) % (1U << 10 ) ;
3662 carry = ( (prev + increment) >> (10 - 6) );
3663 *in += (increment << 28);
3664
3665 in += 1 * WORD_INCR;
3666 /* prev |= (CONVERT(*in) % (1U<< 6 ))<<( 10 - 6 ); */
3667 *in += carry;
3668
3669 return;
3670 }
3671
3672 static void
add_10_07(UINT4 * in,UINT4 increment)3673 add_10_07 (UINT4 *in, UINT4 increment) {
3674 in += 2 * WORD_INCR;
3675 *in += (increment << 6);
3676 return;
3677 }
3678
3679 static void
add_10_08(UINT4 * in,UINT4 increment)3680 add_10_08 (UINT4 *in, UINT4 increment) {
3681 in += 2 * WORD_INCR;
3682 *in += (increment << 16);
3683 return;
3684 }
3685
3686 static void
add_10_09(UINT4 * in,UINT4 increment)3687 add_10_09 (UINT4 *in, UINT4 increment) {
3688 UINT4 prev, carry;
3689
3690 in += 2 * WORD_INCR;
3691 prev = ( CONVERT(*in) >> 26 ) % (1U << 10 ) ;
3692 carry = ( (prev + increment) >> (10 - 4) );
3693 *in += (increment << 26);
3694
3695 in += 1 * WORD_INCR;
3696 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 10 - 4 ); */
3697 *in += carry;
3698
3699 return;
3700 }
3701
3702 static void
add_10_10(UINT4 * in,UINT4 increment)3703 add_10_10 (UINT4 *in, UINT4 increment) {
3704 in += 3 * WORD_INCR;
3705 *in += (increment << 4);
3706 return;
3707 }
3708
3709 static void
add_10_11(UINT4 * in,UINT4 increment)3710 add_10_11 (UINT4 *in, UINT4 increment) {
3711 in += 3 * WORD_INCR;
3712 *in += (increment << 14);
3713 return;
3714 }
3715
3716 static void
add_10_12(UINT4 * in,UINT4 increment)3717 add_10_12 (UINT4 *in, UINT4 increment) {
3718 UINT4 prev, carry;
3719
3720 in += 3 * WORD_INCR;
3721 prev = ( CONVERT(*in) >> 24 ) % (1U << 10 ) ;
3722 carry = ( (prev + increment) >> (10 - 2) );
3723 *in += (increment << 24);
3724
3725 in += 1 * WORD_INCR;
3726 /* prev |= (CONVERT(*in) % (1U<< 2 ))<<( 10 - 2 ); */
3727 *in += carry;
3728
3729 return;
3730 }
3731
3732 static void
add_10_13(UINT4 * in,UINT4 increment)3733 add_10_13 (UINT4 *in, UINT4 increment) {
3734 in += 4 * WORD_INCR;
3735 *in += (increment << 2);
3736 return;
3737 }
3738
3739 static void
add_10_14(UINT4 * in,UINT4 increment)3740 add_10_14 (UINT4 *in, UINT4 increment) {
3741 in += 4 * WORD_INCR;
3742 *in += (increment << 12);
3743 return;
3744 }
3745
3746 static void
add_10_15(UINT4 * in,UINT4 increment)3747 add_10_15 (UINT4 *in, UINT4 increment) {
3748 in += 4 * WORD_INCR;
3749 *in += (increment << 22);
3750 return;
3751 }
3752
3753
3754
3755 static void
add_12_00(UINT4 * in,UINT4 increment)3756 add_12_00 (UINT4 *in, UINT4 increment) {
3757 *in += (increment << 0);
3758 return;
3759 }
3760
3761 static void
add_12_01(UINT4 * in,UINT4 increment)3762 add_12_01 (UINT4 *in, UINT4 increment) {
3763 *in += (increment << 12);
3764 return;
3765 }
3766
3767 static void
add_12_02(UINT4 * in,UINT4 increment)3768 add_12_02 (UINT4 *in, UINT4 increment) {
3769 UINT4 prev, carry;
3770
3771 prev = ( CONVERT(*in) >> 24 ) % (1U << 12 ) ;
3772 carry = ( (prev + increment) >> (12 - 4) );
3773 *in += (increment << 24);
3774
3775 in += 1 * WORD_INCR;
3776 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 12 - 4 ); */
3777 *in += carry;
3778
3779 return;
3780 }
3781
3782 static void
add_12_03(UINT4 * in,UINT4 increment)3783 add_12_03 (UINT4 *in, UINT4 increment) {
3784 in += 1 * WORD_INCR;
3785 *in += (increment << 4);
3786 return;
3787 }
3788
3789 static void
add_12_04(UINT4 * in,UINT4 increment)3790 add_12_04 (UINT4 *in, UINT4 increment) {
3791 in += 1 * WORD_INCR;
3792 *in += (increment << 16);
3793 return;
3794 }
3795
3796 static void
add_12_05(UINT4 * in,UINT4 increment)3797 add_12_05 (UINT4 *in, UINT4 increment) {
3798 UINT4 prev, carry;
3799
3800 in += 1 * WORD_INCR;
3801 prev = ( CONVERT(*in) >> 28 ) % (1U << 12 ) ;
3802 carry = ( (prev + increment) >> (12 - 8));
3803 *in += (increment << 28);
3804
3805 in += 1 * WORD_INCR;
3806 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 12 - 8 ); */
3807 *in += carry;
3808
3809 return;
3810 }
3811
3812 static void
add_12_06(UINT4 * in,UINT4 increment)3813 add_12_06 (UINT4 *in, UINT4 increment) {
3814 in += 2 * WORD_INCR;
3815 *in += (increment << 8);
3816 return;
3817 }
3818
3819 static void
add_12_07(UINT4 * in,UINT4 increment)3820 add_12_07 (UINT4 *in, UINT4 increment) {
3821 in += 2 * WORD_INCR;
3822 *in += (increment << 20);
3823 return;
3824 }
3825
3826 static void
add_12_08(UINT4 * in,UINT4 increment)3827 add_12_08 (UINT4 *in, UINT4 increment) {
3828 in += 3 * WORD_INCR;
3829 *in += (increment << 0);
3830 return;
3831 }
3832
3833 static void
add_12_09(UINT4 * in,UINT4 increment)3834 add_12_09 (UINT4 *in, UINT4 increment) {
3835 in += 3 * WORD_INCR;
3836 *in += (increment << 12);
3837 return;
3838 }
3839
3840 static void
add_12_10(UINT4 * in,UINT4 increment)3841 add_12_10 (UINT4 *in, UINT4 increment) {
3842 UINT4 prev, carry;
3843
3844 in += 3 * WORD_INCR;
3845 prev = ( CONVERT(*in) >> 24 ) % (1U << 12 ) ;
3846 carry = ( (prev + increment) >> (12 - 4) );
3847 *in += (increment << 24);
3848
3849 in += 1 * WORD_INCR;
3850 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 12 - 4 ); */
3851 *in += carry;
3852
3853 return;
3854 }
3855
3856 static void
add_12_11(UINT4 * in,UINT4 increment)3857 add_12_11 (UINT4 *in, UINT4 increment) {
3858 in += 4 * WORD_INCR;
3859 *in += (increment << 4);
3860 return;
3861 }
3862
3863 static void
add_12_12(UINT4 * in,UINT4 increment)3864 add_12_12 (UINT4 *in, UINT4 increment) {
3865 in += 4 * WORD_INCR;
3866 *in += (increment << 16);
3867 return;
3868 }
3869
3870 static void
add_12_13(UINT4 * in,UINT4 increment)3871 add_12_13 (UINT4 *in, UINT4 increment) {
3872 UINT4 prev, carry;
3873
3874 in += 4 * WORD_INCR;
3875 prev = ( CONVERT(*in) >> 28 ) % (1U << 12 ) ;
3876 carry = ( (prev + increment) >> (12 - 8));
3877 *in += (increment << 28);
3878
3879 in += 1 * WORD_INCR;
3880 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 12 - 8 ); */
3881 *in += carry;
3882
3883 return;
3884 }
3885
3886 static void
add_12_14(UINT4 * in,UINT4 increment)3887 add_12_14 (UINT4 *in, UINT4 increment) {
3888 in += 5 * WORD_INCR;
3889 *in += (increment << 8);
3890 return;
3891 }
3892
3893 static void
add_12_15(UINT4 * in,UINT4 increment)3894 add_12_15 (UINT4 *in, UINT4 increment) {
3895 in += 5 * WORD_INCR;
3896 *in += (increment << 20);
3897 return;
3898 }
3899
3900
3901 static void
add_14_00(UINT4 * in,UINT4 increment)3902 add_14_00 (UINT4 *in, UINT4 increment) {
3903 *in += (increment << 0);
3904 return;
3905 }
3906
3907 static void
add_14_01(UINT4 * in,UINT4 increment)3908 add_14_01 (UINT4 *in, UINT4 increment) {
3909 *in += (increment << 14);
3910 return;
3911 }
3912
3913 static void
add_14_02(UINT4 * in,UINT4 increment)3914 add_14_02 (UINT4 *in, UINT4 increment) {
3915 UINT4 prev, carry;
3916
3917 prev = ( CONVERT(*in) >> 28 ) % (1U << 14 ) ;
3918 carry = ( (prev + increment) >> (14 - 10) );
3919 *in += (increment << 28);
3920
3921 in += 1 * WORD_INCR;
3922 /* prev |= (CONVERT(*in) % (1U<< 10 ))<<( 14 - 10 ); */
3923 *in += carry;
3924
3925 return;
3926 }
3927
3928 static void
add_14_03(UINT4 * in,UINT4 increment)3929 add_14_03 (UINT4 *in, UINT4 increment) {
3930 in += 1 * WORD_INCR;
3931 *in += (increment << 10);
3932 return;
3933 }
3934
3935 static void
add_14_04(UINT4 * in,UINT4 increment)3936 add_14_04 (UINT4 *in, UINT4 increment) {
3937 UINT4 prev, carry;
3938
3939 in += 1 * WORD_INCR;
3940 prev = ( CONVERT(*in) >> 24 ) % (1U << 14 ) ;
3941 carry = ( (prev + increment) >> (14 - 6) );
3942 *in += (increment << 24);
3943
3944 in += 1 * WORD_INCR;
3945 /* prev |= (CONVERT(*in) % (1U<< 6 ))<<( 14 - 6 ); */
3946 *in += carry;
3947
3948 return;
3949 }
3950
3951 static void
add_14_05(UINT4 * in,UINT4 increment)3952 add_14_05 (UINT4 *in, UINT4 increment) {
3953 in += 2 * WORD_INCR;
3954 *in += (increment << 6);
3955 return;
3956 }
3957
3958 static void
add_14_06(UINT4 * in,UINT4 increment)3959 add_14_06 (UINT4 *in, UINT4 increment) {
3960 UINT4 prev, carry;
3961
3962 in += 2 * WORD_INCR;
3963 prev = ( CONVERT(*in) >> 20 ) % (1U << 14 ) ;
3964 carry = ( (prev + increment) >> (14 - 2) );
3965 *in += (increment << 20);
3966
3967 in += 1 * WORD_INCR;
3968 /* prev |= (CONVERT(*in) % (1U<< 2 ))<<( 14 - 2 ); */
3969 *in += carry;
3970
3971 return;
3972 }
3973
3974 static void
add_14_07(UINT4 * in,UINT4 increment)3975 add_14_07 (UINT4 *in, UINT4 increment) {
3976 in += 3 * WORD_INCR;
3977 *in += (increment << 2);
3978 return;
3979 }
3980
3981 static void
add_14_08(UINT4 * in,UINT4 increment)3982 add_14_08 (UINT4 *in, UINT4 increment) {
3983 in += 3 * WORD_INCR;
3984 *in += (increment << 16);
3985 return;
3986 }
3987
3988 static void
add_14_09(UINT4 * in,UINT4 increment)3989 add_14_09 (UINT4 *in, UINT4 increment) {
3990 UINT4 prev, carry;
3991
3992 in += 3 * WORD_INCR;
3993 prev = ( CONVERT(*in) >> 30 ) % (1U << 14 ) ;
3994 carry = ( (prev + increment) >> (14 - 12) );
3995 *in += (increment << 30);
3996
3997 in += 1 * WORD_INCR;
3998 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 14 - 12 ); */
3999 *in += carry;
4000
4001 return;
4002 }
4003
4004 static void
add_14_10(UINT4 * in,UINT4 increment)4005 add_14_10 (UINT4 *in, UINT4 increment) {
4006 in += 4 * WORD_INCR;
4007 *in += (increment << 12);
4008 return;
4009 }
4010
4011 static void
add_14_11(UINT4 * in,UINT4 increment)4012 add_14_11 (UINT4 *in, UINT4 increment) {
4013 UINT4 prev, carry;
4014
4015 in += 4 * WORD_INCR;
4016 prev = ( CONVERT(*in) >> 26 ) % (1U << 14 ) ;
4017 carry = ( (prev + increment) >> (14 - 8) );
4018 *in += (increment << 26);
4019
4020 in += 1 * WORD_INCR;
4021 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 14 - 8 ); */
4022 *in += carry;
4023
4024 return;
4025 }
4026
4027 static void
add_14_12(UINT4 * in,UINT4 increment)4028 add_14_12 (UINT4 *in, UINT4 increment) {
4029 in += 5 * WORD_INCR;
4030 *in += (increment << 8);
4031 return;
4032 }
4033
4034 static void
add_14_13(UINT4 * in,UINT4 increment)4035 add_14_13 (UINT4 *in, UINT4 increment) {
4036 UINT4 prev, carry;
4037
4038 in += 5 * WORD_INCR;
4039 prev = ( CONVERT(*in) >> 22 ) % (1U << 14 ) ;
4040 carry = ( (prev + increment) >> (14 - 4) );
4041 *in += (increment << 22);
4042
4043 in += 1 * WORD_INCR;
4044 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 14 - 4 ); */
4045 *in += carry;
4046
4047 return;
4048 }
4049
4050 static void
add_14_14(UINT4 * in,UINT4 increment)4051 add_14_14 (UINT4 *in, UINT4 increment) {
4052 in += 6 * WORD_INCR;
4053 *in += (increment << 4);
4054 return;
4055 }
4056
4057 static void
add_14_15(UINT4 * in,UINT4 increment)4058 add_14_15 (UINT4 *in, UINT4 increment) {
4059 in += 6 * WORD_INCR;
4060 *in += (increment << 18);
4061 return;
4062 }
4063
4064
4065 static void
add_16_00(UINT4 * in,UINT4 increment)4066 add_16_00 (UINT4 *in, UINT4 increment) {
4067 *in += (increment << 0);
4068 return;
4069 }
4070
4071 static void
add_16_01(UINT4 * in,UINT4 increment)4072 add_16_01 (UINT4 *in, UINT4 increment) {
4073 *in += (increment << 16);
4074 return;
4075 }
4076
4077 static void
add_16_02(UINT4 * in,UINT4 increment)4078 add_16_02 (UINT4 *in, UINT4 increment) {
4079 in += 1 * WORD_INCR;
4080 *in += (increment << 0);
4081 return;
4082 }
4083
4084 static void
add_16_03(UINT4 * in,UINT4 increment)4085 add_16_03 (UINT4 *in, UINT4 increment) {
4086 in += 1 * WORD_INCR;
4087 *in += (increment << 16);
4088 return;
4089 }
4090
4091 static void
add_16_04(UINT4 * in,UINT4 increment)4092 add_16_04 (UINT4 *in, UINT4 increment) {
4093 in += 2 * WORD_INCR;
4094 *in += (increment << 0);
4095 return;
4096 }
4097
4098 static void
add_16_05(UINT4 * in,UINT4 increment)4099 add_16_05 (UINT4 *in, UINT4 increment) {
4100 in += 2 * WORD_INCR;
4101 *in += (increment << 16);
4102 return;
4103 }
4104
4105 static void
add_16_06(UINT4 * in,UINT4 increment)4106 add_16_06 (UINT4 *in, UINT4 increment) {
4107 in += 3 * WORD_INCR;
4108 *in += (increment << 0);
4109 return;
4110 }
4111
4112 static void
add_16_07(UINT4 * in,UINT4 increment)4113 add_16_07 (UINT4 *in, UINT4 increment) {
4114 in += 3 * WORD_INCR;
4115 *in += (increment << 16);
4116 return;
4117 }
4118
4119 static void
add_16_08(UINT4 * in,UINT4 increment)4120 add_16_08 (UINT4 *in, UINT4 increment) {
4121 in += 4 * WORD_INCR;
4122 *in += (increment << 0);
4123 return;
4124 }
4125
4126 static void
add_16_09(UINT4 * in,UINT4 increment)4127 add_16_09 (UINT4 *in, UINT4 increment) {
4128 in += 4 * WORD_INCR;
4129 *in += (increment << 16);
4130 return;
4131 }
4132
4133 static void
add_16_10(UINT4 * in,UINT4 increment)4134 add_16_10 (UINT4 *in, UINT4 increment) {
4135 in += 5 * WORD_INCR;
4136 *in += (increment << 0);
4137 return;
4138 }
4139
4140 static void
add_16_11(UINT4 * in,UINT4 increment)4141 add_16_11 (UINT4 *in, UINT4 increment) {
4142 in += 5 * WORD_INCR;
4143 *in += (increment << 16);
4144 return;
4145 }
4146
4147 static void
add_16_12(UINT4 * in,UINT4 increment)4148 add_16_12 (UINT4 *in, UINT4 increment) {
4149 in += 6 * WORD_INCR;
4150 *in += (increment << 0);
4151 return;
4152 }
4153
4154 static void
add_16_13(UINT4 * in,UINT4 increment)4155 add_16_13 (UINT4 *in, UINT4 increment) {
4156 in += 6 * WORD_INCR;
4157 *in += (increment << 16);
4158 return;
4159 }
4160
4161 static void
add_16_14(UINT4 * in,UINT4 increment)4162 add_16_14 (UINT4 *in, UINT4 increment) {
4163 in += 7 * WORD_INCR;
4164 *in += (increment << 0);
4165 return;
4166 }
4167
4168 static void
add_16_15(UINT4 * in,UINT4 increment)4169 add_16_15 (UINT4 *in, UINT4 increment) {
4170 in += 7 * WORD_INCR;
4171 *in += (increment << 16);
4172 return;
4173 }
4174
4175
4176 static void
add_18_00(UINT4 * in,UINT4 increment)4177 add_18_00 (UINT4 *in, UINT4 increment) {
4178 *in += (increment << 0);
4179 return;
4180 }
4181
4182 static void
add_18_01(UINT4 * in,UINT4 increment)4183 add_18_01 (UINT4 *in, UINT4 increment) {
4184 UINT4 prev, carry;
4185
4186 prev = ( CONVERT(*in) >> 18 ) % (1U << 18 ) ;
4187 carry = ( (prev + increment) >> (18 - 4) );
4188 *in += (increment << 18);
4189
4190 in += 1 * WORD_INCR;
4191 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 18 - 4 ); */
4192 *in += carry;
4193
4194 return;
4195 }
4196
4197 static void
add_18_02(UINT4 * in,UINT4 increment)4198 add_18_02 (UINT4 *in, UINT4 increment) {
4199 in += 1 * WORD_INCR;
4200 *in += (increment << 4);
4201 return;
4202 }
4203
4204 static void
add_18_03(UINT4 * in,UINT4 increment)4205 add_18_03 (UINT4 *in, UINT4 increment) {
4206 UINT4 prev, carry;
4207
4208 in += 1 * WORD_INCR;
4209 prev = ( CONVERT(*in) >> 22 ) % (1U << 18 ) ;
4210 carry = ( (prev + increment) >> (18 - 8) );
4211 *in += (increment << 22);
4212
4213 in += 1 * WORD_INCR;
4214 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 18 - 8 ); */
4215 *in += carry;
4216
4217 return;
4218 }
4219
4220 static void
add_18_04(UINT4 * in,UINT4 increment)4221 add_18_04 (UINT4 *in, UINT4 increment) {
4222 in += 2 * WORD_INCR;
4223 *in += (increment << 8);
4224 return;
4225 }
4226
4227 static void
add_18_05(UINT4 * in,UINT4 increment)4228 add_18_05 (UINT4 *in, UINT4 increment) {
4229 UINT4 prev, carry;
4230
4231 in += 2 * WORD_INCR;
4232 prev = ( CONVERT(*in) >> 26 ) % (1U << 18 ) ;
4233 carry = ( (prev + increment) >> (18 - 12) );
4234 *in += (increment << 26);
4235
4236 in += 1 * WORD_INCR;
4237 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 18 - 12 ); */
4238 *in += carry;
4239
4240 return;
4241 }
4242
4243 static void
add_18_06(UINT4 * in,UINT4 increment)4244 add_18_06 (UINT4 *in, UINT4 increment) {
4245 in += 3 * WORD_INCR;
4246 *in += (increment << 12);
4247 return;
4248 }
4249
4250 static void
add_18_07(UINT4 * in,UINT4 increment)4251 add_18_07 (UINT4 *in, UINT4 increment) {
4252 UINT4 prev, carry;
4253
4254 in += 3 * WORD_INCR;
4255 prev = ( CONVERT(*in) >> 30 ) % (1U << 18 ) ;
4256 carry = ( (prev + increment) >> (18 - 16) );
4257 *in += (increment << 30);
4258
4259 in += 1 * WORD_INCR;
4260 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 18 - 16 ); */
4261 *in += carry;
4262
4263 return;
4264 }
4265
4266 static void
add_18_08(UINT4 * in,UINT4 increment)4267 add_18_08 (UINT4 *in, UINT4 increment) {
4268 UINT4 prev, carry;
4269
4270 in += 4 * WORD_INCR;
4271 prev = ( CONVERT(*in) >> 16 ) % (1U << 18 ) ;
4272 carry = ( (prev + increment) >> (18 - 2) );
4273 *in += (increment << 16);
4274
4275 in += 1 * WORD_INCR;
4276 /* prev |= (CONVERT(*in) % (1U<< 2 ))<<( 18 - 2 ); */
4277 *in += carry;
4278
4279 return;
4280 }
4281
4282 static void
add_18_09(UINT4 * in,UINT4 increment)4283 add_18_09 (UINT4 *in, UINT4 increment) {
4284 in += 5 * WORD_INCR;
4285 *in += (increment << 2);
4286 return;
4287 }
4288
4289 static void
add_18_10(UINT4 * in,UINT4 increment)4290 add_18_10 (UINT4 *in, UINT4 increment) {
4291 UINT4 prev, carry;
4292
4293 in += 5 * WORD_INCR;
4294 prev = ( CONVERT(*in) >> 20 ) % (1U << 18 ) ;
4295 carry = ( (prev + increment) >> (18 - 6) );
4296 *in += (increment << 20);
4297
4298 in += 1 * WORD_INCR;
4299 /* prev |= (CONVERT(*in) % (1U<< 6 ))<<( 18 - 6 ); */
4300 *in += carry;
4301
4302 return;
4303 }
4304
4305 static void
add_18_11(UINT4 * in,UINT4 increment)4306 add_18_11 (UINT4 *in, UINT4 increment) {
4307 in += 6 * WORD_INCR;
4308 *in += (increment << 6);
4309 return;
4310 }
4311
4312 static void
add_18_12(UINT4 * in,UINT4 increment)4313 add_18_12 (UINT4 *in, UINT4 increment) {
4314 UINT4 prev, carry;
4315
4316 in += 6 * WORD_INCR;
4317 prev = ( CONVERT(*in) >> 24 ) % (1U << 18 ) ;
4318 carry = ( (prev + increment) >> (18 - 10) );
4319 *in += (increment << 24);
4320
4321 in += 1 * WORD_INCR;
4322 /* prev |= (CONVERT(*in) % (1U<< 10 ))<<( 18 - 10 ); */
4323 *in += carry;
4324
4325 return;
4326 }
4327
4328 static void
add_18_13(UINT4 * in,UINT4 increment)4329 add_18_13 (UINT4 *in, UINT4 increment) {
4330 in += 7 * WORD_INCR;
4331 *in += (increment << 10);
4332 return;
4333 }
4334
4335 static void
add_18_14(UINT4 * in,UINT4 increment)4336 add_18_14 (UINT4 *in, UINT4 increment) {
4337 UINT4 prev, carry;
4338
4339 in += 7 * WORD_INCR;
4340 prev = ( CONVERT(*in) >> 28 ) % (1U << 18 ) ;
4341 carry = ( (prev + increment) >> (18 - 14) );
4342 *in += (increment << 28);
4343
4344 in += 1 * WORD_INCR;
4345 /* prev |= (CONVERT(*in) % (1U<< 14 ))<<( 18 - 14 ); */
4346 *in += carry;
4347
4348 return;
4349 }
4350
4351 static void
add_18_15(UINT4 * in,UINT4 increment)4352 add_18_15 (UINT4 *in, UINT4 increment) {
4353 in += 8 * WORD_INCR;
4354 *in += (increment << 14);
4355 return;
4356 }
4357
4358
4359 static void
add_20_00(UINT4 * in,UINT4 increment)4360 add_20_00 (UINT4 *in, UINT4 increment) {
4361 *in += (increment << 0);
4362 return;
4363 }
4364
4365 static void
add_20_01(UINT4 * in,UINT4 increment)4366 add_20_01 (UINT4 *in, UINT4 increment) {
4367 UINT4 prev, carry;
4368
4369 prev = ( CONVERT(*in) >> 20 ) % (1U << 20 ) ;
4370 carry = ( (prev + increment) >> (20 - 8) );
4371 *in += (increment << 20);
4372
4373 in += 1 * WORD_INCR;
4374 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 20 - 8 ); */
4375 *in += carry;
4376
4377 return;
4378 }
4379
4380 static void
add_20_02(UINT4 * in,UINT4 increment)4381 add_20_02 (UINT4 *in, UINT4 increment) {
4382 in += 1 * WORD_INCR;
4383 *in += (increment << 8);
4384 return;
4385 }
4386
4387 static void
add_20_03(UINT4 * in,UINT4 increment)4388 add_20_03 (UINT4 *in, UINT4 increment) {
4389 UINT4 prev, carry;
4390
4391 in += 1 * WORD_INCR;
4392 prev = ( CONVERT(*in) >> 28 ) % (1U << 20 ) ;
4393 carry = ( (prev + increment) >> (20 - 16) );
4394 *in += (increment << 28);
4395
4396 in += 1 * WORD_INCR;
4397 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 20 - 16 ); */
4398 *in += carry;
4399
4400 return;
4401 }
4402
4403 static void
add_20_04(UINT4 * in,UINT4 increment)4404 add_20_04 (UINT4 *in, UINT4 increment) {
4405 UINT4 prev, carry;
4406
4407 in += 2 * WORD_INCR;
4408 prev = ( CONVERT(*in) >> 16 ) % (1U << 20 ) ;
4409 carry = ( (prev + increment) >> (20 - 4) );
4410 *in += (increment << 16);
4411
4412 in += 1 * WORD_INCR;
4413 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 20 - 4 ); */
4414 *in += carry;
4415
4416 return;
4417 }
4418
4419 static void
add_20_05(UINT4 * in,UINT4 increment)4420 add_20_05 (UINT4 *in, UINT4 increment) {
4421 in += 3 * WORD_INCR;
4422 *in += (increment << 4);
4423 return;
4424 }
4425
4426 static void
add_20_06(UINT4 * in,UINT4 increment)4427 add_20_06 (UINT4 *in, UINT4 increment) {
4428 UINT4 prev, carry;
4429
4430 in += 3 * WORD_INCR;
4431 prev = ( CONVERT(*in) >> 24 ) % (1U << 20 ) ;
4432 carry = ( (prev + increment) >> (20 - 12) );
4433 *in += (increment << 24);
4434
4435 in += 1 * WORD_INCR;
4436 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 20 - 12 ); */
4437 *in += carry;
4438
4439 return;
4440 }
4441
4442 static void
add_20_07(UINT4 * in,UINT4 increment)4443 add_20_07 (UINT4 *in, UINT4 increment) {
4444 in += 4 * WORD_INCR;
4445 *in += (increment << 12);
4446 return;
4447 }
4448
4449 static void
add_20_08(UINT4 * in,UINT4 increment)4450 add_20_08 (UINT4 *in, UINT4 increment) {
4451 in += 5 * WORD_INCR;
4452 *in += (increment << 0);
4453 return;
4454 }
4455
4456 static void
add_20_09(UINT4 * in,UINT4 increment)4457 add_20_09 (UINT4 *in, UINT4 increment) {
4458 UINT4 prev, carry;
4459
4460 in += 5 * WORD_INCR;
4461 prev = ( CONVERT(*in) >> 20 ) % (1U << 20 ) ;
4462 carry = ( (prev + increment) >> (20 - 8) );
4463 *in += (increment << 20);
4464
4465 in += 1 * WORD_INCR;
4466 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 20 - 8 ); */
4467 *in += carry;
4468
4469 return;
4470 }
4471
4472 static void
add_20_10(UINT4 * in,UINT4 increment)4473 add_20_10 (UINT4 *in, UINT4 increment) {
4474 in += 6 * WORD_INCR;
4475 *in += (increment << 8);
4476 return;
4477 }
4478
4479 static void
add_20_11(UINT4 * in,UINT4 increment)4480 add_20_11 (UINT4 *in, UINT4 increment) {
4481 UINT4 prev, carry;
4482
4483 in += 6 * WORD_INCR;
4484 prev = ( CONVERT(*in) >> 28 ) % (1U << 20 ) ;
4485 carry = ( (prev + increment) >> (20 - 16) );
4486 *in += (increment << 28);
4487
4488 in += 1 * WORD_INCR;
4489 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 20 - 16 ); */
4490 *in += carry;
4491
4492 return;
4493 }
4494
4495 static void
add_20_12(UINT4 * in,UINT4 increment)4496 add_20_12 (UINT4 *in, UINT4 increment) {
4497 UINT4 prev, carry;
4498
4499 in += 7 * WORD_INCR;
4500 prev = ( CONVERT(*in) >> 16 ) % (1U << 20 ) ;
4501 carry = ( (prev + increment) >> (20 - 4) );
4502 *in += (increment << 16);
4503
4504 in += 1 * WORD_INCR;
4505 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 20 - 4 ); */
4506 *in += carry;
4507
4508 return;
4509 }
4510
4511 static void
add_20_13(UINT4 * in,UINT4 increment)4512 add_20_13 (UINT4 *in, UINT4 increment) {
4513 in += 8 * WORD_INCR;
4514 *in += (increment << 4);
4515 return;
4516 }
4517
4518 static void
add_20_14(UINT4 * in,UINT4 increment)4519 add_20_14 (UINT4 *in, UINT4 increment) {
4520 UINT4 prev, carry;
4521
4522 in += 8 * WORD_INCR;
4523 prev = ( CONVERT(*in) >> 24 ) % (1U << 20 ) ;
4524 carry = ( (prev + increment) >> (20 - 12) );
4525 *in += (increment << 24);
4526
4527 in += 1 * WORD_INCR;
4528 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 20 - 12 ); */
4529 *in += carry;
4530
4531 return;
4532 }
4533
4534 static void
add_20_15(UINT4 * in,UINT4 increment)4535 add_20_15 (UINT4 *in, UINT4 increment) {
4536 in += 9 * WORD_INCR;
4537 *in += (increment << 12);
4538 return;
4539 }
4540
4541
4542 static void
add_22_00(UINT4 * in,UINT4 increment)4543 add_22_00 (UINT4 *in, UINT4 increment) {
4544 *in += (increment << 0);
4545 return;
4546 }
4547
4548 static void
add_22_01(UINT4 * in,UINT4 increment)4549 add_22_01 (UINT4 *in, UINT4 increment) {
4550 UINT4 prev, carry;
4551
4552 prev = ( CONVERT(*in) >> 22 ) % (1U << 22 ) ;
4553 carry = ( (prev + increment) >> (22 - 12) );
4554 *in += (increment << 22);
4555
4556 in += 1 * WORD_INCR;
4557 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 22 - 12 ); */
4558 *in += carry;
4559
4560 return;
4561 }
4562
4563 static void
add_22_02(UINT4 * in,UINT4 increment)4564 add_22_02 (UINT4 *in, UINT4 increment) {
4565 UINT4 prev, carry;
4566
4567 in += 1 * WORD_INCR;
4568 prev = ( CONVERT(*in) >> 12 ) % (1U << 22 ) ;
4569 carry = ( (prev + increment) >> (22 - 2) );
4570 *in += (increment << 12);
4571
4572 in += 1 * WORD_INCR;
4573 /* prev |= (CONVERT(*in) % (1U<< 2 ))<<( 22 - 2 ); */
4574 *in += carry;
4575
4576 return;
4577 }
4578
4579 static void
add_22_03(UINT4 * in,UINT4 increment)4580 add_22_03 (UINT4 *in, UINT4 increment) {
4581 in += 2 * WORD_INCR;
4582 *in += (increment << 2);
4583 return;
4584 }
4585
4586 static void
add_22_04(UINT4 * in,UINT4 increment)4587 add_22_04 (UINT4 *in, UINT4 increment) {
4588 UINT4 prev, carry;
4589
4590 in += 2 * WORD_INCR;
4591 prev = ( CONVERT(*in) >> 24 ) % (1U << 22 ) ;
4592 carry = ( (prev + increment) >> (22 - 14) );
4593 *in += (increment << 24);
4594
4595 in += 1 * WORD_INCR;
4596 /* prev |= (CONVERT(*in) % (1U<< 14 ))<<( 22 - 14 ); */
4597 *in += carry;
4598
4599 return;
4600 }
4601
4602 static void
add_22_05(UINT4 * in,UINT4 increment)4603 add_22_05 (UINT4 *in, UINT4 increment) {
4604 UINT4 prev, carry;
4605
4606 in += 3 * WORD_INCR;
4607 prev = ( CONVERT(*in) >> 14 ) % (1U << 22 ) ;
4608 carry = ( (prev + increment) >> (22 - 4) );
4609 *in += (increment << 14);
4610
4611 in += 1 * WORD_INCR;
4612 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 22 - 4 ); */
4613 *in += carry;
4614
4615 return;
4616 }
4617
4618 static void
add_22_06(UINT4 * in,UINT4 increment)4619 add_22_06 (UINT4 *in, UINT4 increment) {
4620 in += 4 * WORD_INCR;
4621 *in += (increment << 4);
4622 return;
4623 }
4624
4625 static void
add_22_07(UINT4 * in,UINT4 increment)4626 add_22_07 (UINT4 *in, UINT4 increment) {
4627 UINT4 prev, carry;
4628
4629 in += 4 * WORD_INCR;
4630 prev = ( CONVERT(*in) >> 26 ) % (1U << 22 ) ;
4631 carry = ( (prev + increment) >> (22 - 16) );
4632 *in += (increment << 26);
4633
4634 in += 1 * WORD_INCR;
4635 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 22 - 16 ); */
4636 *in += carry;
4637
4638 return;
4639 }
4640
4641 static void
add_22_08(UINT4 * in,UINT4 increment)4642 add_22_08 (UINT4 *in, UINT4 increment) {
4643 UINT4 prev, carry;
4644
4645 in += 5 * WORD_INCR;
4646 prev = ( CONVERT(*in) >> 16 ) % (1U << 22 ) ;
4647 carry = ( (prev + increment) >> (22 - 6) );
4648 *in += (increment << 16);
4649
4650 in += 1 * WORD_INCR;
4651 /* prev |= (CONVERT(*in) % (1U<< 6 ))<<( 22 - 6 ); */
4652 *in += carry;
4653
4654 return;
4655 }
4656
4657 static void
add_22_09(UINT4 * in,UINT4 increment)4658 add_22_09 (UINT4 *in, UINT4 increment) {
4659 in += 6 * WORD_INCR;
4660 *in += (increment << 6);
4661 return;
4662 }
4663
4664 static void
add_22_10(UINT4 * in,UINT4 increment)4665 add_22_10 (UINT4 *in, UINT4 increment) {
4666 UINT4 prev, carry;
4667
4668 in += 6 * WORD_INCR;
4669 prev = ( CONVERT(*in) >> 28 ) % (1U << 22 ) ;
4670 carry = ( (prev + increment) >> (22 - 18) );
4671 *in += (increment << 28);
4672
4673 in += 1 * WORD_INCR;
4674 /* prev |= (CONVERT(*in) % (1U<< 18 ))<<( 22 - 18 ); */
4675 *in += carry;
4676
4677 return;
4678 }
4679
4680 static void
add_22_11(UINT4 * in,UINT4 increment)4681 add_22_11 (UINT4 *in, UINT4 increment) {
4682 UINT4 prev, carry;
4683
4684 in += 7 * WORD_INCR;
4685 prev = ( CONVERT(*in) >> 18 ) % (1U << 22 ) ;
4686 carry = ( (prev + increment) >> (22 - 8) );
4687 *in += (increment << 18);
4688
4689 in += 1 * WORD_INCR;
4690 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 22 - 8 ); */
4691 *in += carry;
4692
4693 return;
4694 }
4695
4696 static void
add_22_12(UINT4 * in,UINT4 increment)4697 add_22_12 (UINT4 *in, UINT4 increment) {
4698 in += 8 * WORD_INCR;
4699 *in += (increment << 8);
4700 return;
4701 }
4702
4703 static void
add_22_13(UINT4 * in,UINT4 increment)4704 add_22_13 (UINT4 *in, UINT4 increment) {
4705 UINT4 prev, carry;
4706
4707 in += 8 * WORD_INCR;
4708 prev = ( CONVERT(*in) >> 30 ) % (1U << 22 ) ;
4709 carry = ( (prev + increment) >> (22 - 20) );
4710 *in += (increment << 30);
4711
4712 in += 1 * WORD_INCR;
4713 /* prev |= (CONVERT(*in) % (1U<< 20 ))<<( 22 - 20 ); */
4714 *in += carry;
4715
4716 return;
4717 }
4718
4719 static void
add_22_14(UINT4 * in,UINT4 increment)4720 add_22_14 (UINT4 *in, UINT4 increment) {
4721 UINT4 prev, carry;
4722
4723 in += 9 * WORD_INCR;
4724 prev = ( CONVERT(*in) >> 20 ) % (1U << 22 ) ;
4725 carry = ( (prev + increment) >> (22 - 10) );
4726 *in += (increment << 20);
4727
4728 in += 1 * WORD_INCR;
4729 /* prev |= (CONVERT(*in) % (1U<< 10 ))<<( 22 - 10 ); */
4730 *in += carry;
4731
4732 return;
4733 }
4734
4735 static void
add_22_15(UINT4 * in,UINT4 increment)4736 add_22_15 (UINT4 *in, UINT4 increment) {
4737 in += 10 * WORD_INCR;
4738 *in += (increment << 10);
4739 return;
4740 }
4741
4742
4743
4744 static void
add_24_00(UINT4 * in,UINT4 increment)4745 add_24_00 (UINT4 *in, UINT4 increment) {
4746 *in += (increment << 0);
4747 return;
4748 }
4749
4750 static void
add_24_01(UINT4 * in,UINT4 increment)4751 add_24_01 (UINT4 *in, UINT4 increment) {
4752 UINT4 prev, carry;
4753
4754 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
4755 carry = ( (prev + increment) >> (24 - 16) );
4756 *in += (increment << 24);
4757
4758 in += 1 * WORD_INCR;
4759 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 ); */
4760 *in += carry;
4761
4762 return;
4763 }
4764
4765 static void
add_24_02(UINT4 * in,UINT4 increment)4766 add_24_02 (UINT4 *in, UINT4 increment) {
4767 UINT4 prev, carry;
4768
4769 in += 1 * WORD_INCR;
4770 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
4771 carry = ( (prev + increment) >> (24 - 8) );
4772 *in += (increment << 16);
4773
4774 in += 1 * WORD_INCR;
4775 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 ); */
4776 *in += carry;
4777
4778 return;
4779 }
4780
4781 static void
add_24_03(UINT4 * in,UINT4 increment)4782 add_24_03 (UINT4 *in, UINT4 increment) {
4783 in += 2 * WORD_INCR;
4784 *in += (increment << 8);
4785 return;
4786 }
4787
4788 static void
add_24_04(UINT4 * in,UINT4 increment)4789 add_24_04 (UINT4 *in, UINT4 increment) {
4790 in += 3 * WORD_INCR;
4791 *in += (increment << 0);
4792 return;
4793 }
4794
4795 static void
add_24_05(UINT4 * in,UINT4 increment)4796 add_24_05 (UINT4 *in, UINT4 increment) {
4797 UINT4 prev, carry;
4798
4799 in += 3 * WORD_INCR;
4800 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
4801 carry = ( (prev + increment) >> (24 - 16) );
4802 *in += (increment << 24);
4803
4804 in += 1 * WORD_INCR;
4805 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 ); */
4806 *in += carry;
4807
4808 return;
4809 }
4810
4811 static void
add_24_06(UINT4 * in,UINT4 increment)4812 add_24_06 (UINT4 *in, UINT4 increment) {
4813 UINT4 prev, carry;
4814
4815 in += 4 * WORD_INCR;
4816 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
4817 carry = ( (prev + increment) >> (24 - 8) );
4818 *in += (increment << 16);
4819
4820 in += 1 * WORD_INCR;
4821 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 ); */
4822 *in += carry;
4823
4824 return;
4825 }
4826
4827 static void
add_24_07(UINT4 * in,UINT4 increment)4828 add_24_07 (UINT4 *in, UINT4 increment) {
4829 in += 5 * WORD_INCR;
4830 *in += (increment << 8);
4831 return;
4832 }
4833
4834 static void
add_24_08(UINT4 * in,UINT4 increment)4835 add_24_08 (UINT4 *in, UINT4 increment) {
4836 in += 6 * WORD_INCR;
4837 *in += (increment << 0);
4838 return;
4839 }
4840
4841 static void
add_24_09(UINT4 * in,UINT4 increment)4842 add_24_09 (UINT4 *in, UINT4 increment) {
4843 UINT4 prev, carry;
4844
4845 in += 6 * WORD_INCR;
4846 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
4847 carry = ( (prev + increment) >> (24 - 16) );
4848 *in += (increment << 24);
4849
4850 in += 1 * WORD_INCR;
4851 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 ); */
4852 *in += carry;
4853
4854 return;
4855 }
4856
4857 static void
add_24_10(UINT4 * in,UINT4 increment)4858 add_24_10 (UINT4 *in, UINT4 increment) {
4859 UINT4 prev, carry;
4860
4861 in += 7 * WORD_INCR;
4862 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
4863 carry = ( (prev + increment) >> (24 - 8) );
4864 *in += (increment << 16);
4865
4866 in += 1 * WORD_INCR;
4867 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 ); */
4868 *in += carry;
4869
4870 return;
4871 }
4872
4873 static void
add_24_11(UINT4 * in,UINT4 increment)4874 add_24_11 (UINT4 *in, UINT4 increment) {
4875 in += 8 * WORD_INCR;
4876 *in += (increment << 8);
4877 return;
4878 }
4879
4880 static void
add_24_12(UINT4 * in,UINT4 increment)4881 add_24_12 (UINT4 *in, UINT4 increment) {
4882 in += 9 * WORD_INCR;
4883 *in += (increment << 0);
4884 return;
4885 }
4886
4887 static void
add_24_13(UINT4 * in,UINT4 increment)4888 add_24_13 (UINT4 *in, UINT4 increment) {
4889 UINT4 prev, carry;
4890
4891 in += 9 * WORD_INCR;
4892 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
4893 carry = ( (prev + increment) >> (24 - 16) );
4894 *in += (increment << 24);
4895
4896 in += 1 * WORD_INCR;
4897 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 ); */
4898 *in += carry;
4899
4900 return;
4901 }
4902
4903 static void
add_24_14(UINT4 * in,UINT4 increment)4904 add_24_14 (UINT4 *in, UINT4 increment) {
4905 UINT4 prev, carry;
4906
4907 in += 10 * WORD_INCR;
4908 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
4909 carry = ( (prev + increment) >> (24 - 8) );
4910 *in += (increment << 16);
4911
4912 in += 1 * WORD_INCR;
4913 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 ); */
4914 *in += carry;
4915
4916 return;
4917 }
4918
4919 static void
add_24_15(UINT4 * in,UINT4 increment)4920 add_24_15 (UINT4 *in, UINT4 increment) {
4921 in += 11 * WORD_INCR;
4922 *in += (increment << 8);
4923 return;
4924 }
4925
4926
4927
4928 static void
add_26_00(UINT4 * in,UINT4 increment)4929 add_26_00 (UINT4 *in, UINT4 increment) {
4930 *in += (increment << 0);
4931 return;
4932 }
4933
4934 static void
add_26_01(UINT4 * in,UINT4 increment)4935 add_26_01 (UINT4 *in, UINT4 increment) {
4936 UINT4 prev, carry;
4937
4938 prev = ( CONVERT(*in) >> 26 ) % (1U << 26 ) ;
4939 carry = ( (prev + increment) >> (26 - 20) );
4940 *in += (increment << 26);
4941
4942 in += 1 * WORD_INCR;
4943 /* prev |= (CONVERT(*in) % (1U<< 20 ))<<( 26 - 20 ); */
4944 *in += carry;
4945
4946 return;
4947 }
4948
4949 static void
add_26_02(UINT4 * in,UINT4 increment)4950 add_26_02 (UINT4 *in, UINT4 increment) {
4951 UINT4 prev, carry;
4952
4953 in += 1 * WORD_INCR;
4954 prev = ( CONVERT(*in) >> 20 ) % (1U << 26 ) ;
4955 carry = ( (prev + increment) >> (26 - 14) );
4956 *in += (increment << 20);
4957
4958 in += 1 * WORD_INCR;
4959 /* prev |= (CONVERT(*in) % (1U<< 14 ))<<( 26 - 14 ); */
4960 *in += carry;
4961
4962 return;
4963 }
4964
4965 static void
add_26_03(UINT4 * in,UINT4 increment)4966 add_26_03 (UINT4 *in, UINT4 increment) {
4967 UINT4 prev, carry;
4968
4969 in += 2 * WORD_INCR;
4970 prev = ( CONVERT(*in) >> 14 ) % (1U << 26 ) ;
4971 carry = ( (prev + increment) >> (26 - 8) );
4972 *in += (increment << 14);
4973
4974 in += 1 * WORD_INCR;
4975 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 26 - 8 ); */
4976 *in += carry;
4977
4978 return;
4979 }
4980
4981 static void
add_26_04(UINT4 * in,UINT4 increment)4982 add_26_04 (UINT4 *in, UINT4 increment) {
4983 UINT4 prev, carry;
4984
4985 in += 3 * WORD_INCR;
4986 prev = ( CONVERT(*in) >> 8 ) % (1U << 26 ) ;
4987 carry = ( (prev + increment) >> (26 - 2) );
4988 *in += (increment << 8);
4989
4990 in += 1 * WORD_INCR;
4991 /* prev |= (CONVERT(*in) % (1U<< 2 ))<<( 26 - 2 ); */
4992 *in += carry;
4993
4994 return;
4995 }
4996
4997 static void
add_26_05(UINT4 * in,UINT4 increment)4998 add_26_05 (UINT4 *in, UINT4 increment) {
4999 in += 4 * WORD_INCR;
5000 *in += (increment << 2);
5001 return;
5002 }
5003
5004 static void
add_26_06(UINT4 * in,UINT4 increment)5005 add_26_06 (UINT4 *in, UINT4 increment) {
5006 UINT4 prev, carry;
5007
5008 in += 4 * WORD_INCR;
5009 prev = ( CONVERT(*in) >> 28 ) % (1U << 26 ) ;
5010 carry = ( (prev + increment) >> (26 - 22) );
5011 *in += (increment << 28);
5012
5013 in += 1 * WORD_INCR;
5014 /* prev |= (CONVERT(*in) % (1U<< 22 ))<<( 26 - 22 ); */
5015 *in += carry;
5016
5017 return;
5018 }
5019
5020 static void
add_26_07(UINT4 * in,UINT4 increment)5021 add_26_07 (UINT4 *in, UINT4 increment) {
5022 UINT4 prev, carry;
5023
5024 in += 5 * WORD_INCR;
5025 prev = ( CONVERT(*in) >> 22 ) % (1U << 26 ) ;
5026 carry = ( (prev + increment) >> (26 - 16) );
5027 *in += (increment << 22);
5028
5029 in += 1 * WORD_INCR;
5030 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 26 - 16 ); */
5031 *in += carry;
5032
5033 return;
5034 }
5035
5036 static void
add_26_08(UINT4 * in,UINT4 increment)5037 add_26_08 (UINT4 *in, UINT4 increment) {
5038 UINT4 prev, carry;
5039
5040 in += 6 * WORD_INCR;
5041 prev = ( CONVERT(*in) >> 16 ) % (1U << 26 ) ;
5042 carry = ( (prev + increment) >> (26 - 10) );
5043 *in += (increment << 16);
5044
5045 in += 1 * WORD_INCR;
5046 /* prev |= (CONVERT(*in) % (1U<< 10 ))<<( 26 - 10 ); */
5047 *in += carry;
5048
5049 return;
5050 }
5051
5052 static void
add_26_09(UINT4 * in,UINT4 increment)5053 add_26_09 (UINT4 *in, UINT4 increment) {
5054 UINT4 prev, carry;
5055
5056 in += 7 * WORD_INCR;
5057 prev = ( CONVERT(*in) >> 10 ) % (1U << 26 ) ;
5058 carry = ( (prev + increment) >> (26 - 4) );
5059 *in += (increment << 10);
5060
5061 in += 1 * WORD_INCR;
5062 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 26 - 4 ); */
5063 *in += carry;
5064
5065 return;
5066 }
5067
5068 static void
add_26_10(UINT4 * in,UINT4 increment)5069 add_26_10 (UINT4 *in, UINT4 increment) {
5070 in += 8 * WORD_INCR;
5071 *in += (increment << 4);
5072 return;
5073 }
5074
5075 static void
add_26_11(UINT4 * in,UINT4 increment)5076 add_26_11 (UINT4 *in, UINT4 increment) {
5077 UINT4 prev, carry;
5078
5079 in += 8 * WORD_INCR;
5080 prev = ( CONVERT(*in) >> 30 ) % (1U << 26 ) ;
5081 carry = ( (prev + increment) >> (26 - 24) );
5082 *in += (increment << 30);
5083
5084 in += 1 * WORD_INCR;
5085 /* prev |= (CONVERT(*in) % (1U<< 24 ))<<( 26 - 24 ); */
5086 *in += carry;
5087
5088 return;
5089 }
5090
5091 static void
add_26_12(UINT4 * in,UINT4 increment)5092 add_26_12 (UINT4 *in, UINT4 increment) {
5093 UINT4 prev, carry;
5094
5095 in += 9 * WORD_INCR;
5096 prev = ( CONVERT(*in) >> 24 ) % (1U << 26 ) ;
5097 carry = ( (prev + increment) >> (26 - 18) );
5098 *in += (increment << 24);
5099
5100 in += 1 * WORD_INCR;
5101 /* prev |= (CONVERT(*in) % (1U<< 18 ))<<( 26 - 18 ); */
5102 *in += carry;
5103
5104 return;
5105 }
5106
5107 static void
add_26_13(UINT4 * in,UINT4 increment)5108 add_26_13 (UINT4 *in, UINT4 increment) {
5109 UINT4 prev, carry;
5110
5111 in += 10 * WORD_INCR;
5112 prev = ( CONVERT(*in) >> 18 ) % (1U << 26 ) ;
5113 carry = ( (prev + increment) >> (26 - 12) );
5114 *in += (increment << 18);
5115
5116 in += 1 * WORD_INCR;
5117 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 26 - 12 ); */
5118 *in += carry;
5119
5120 return;
5121 }
5122
5123 static void
add_26_14(UINT4 * in,UINT4 increment)5124 add_26_14 (UINT4 *in, UINT4 increment) {
5125 UINT4 prev, carry;
5126
5127 in += 11 * WORD_INCR;
5128 prev = ( CONVERT(*in) >> 12 ) % (1U << 26 ) ;
5129 carry = ( (prev + increment) >> (26 - 6) );
5130 *in += (increment << 12);
5131
5132 in += 1 * WORD_INCR;
5133 /* prev |= (CONVERT(*in) % (1U<< 6 ))<<( 26 - 6 ); */
5134 *in += carry;
5135
5136 return;
5137 }
5138
5139 static void
add_26_15(UINT4 * in,UINT4 increment)5140 add_26_15 (UINT4 *in, UINT4 increment) {
5141 in += 12 * WORD_INCR;
5142 *in += (increment << 6);
5143 return;
5144 }
5145
5146
5147 static void
add_28_00(UINT4 * in,UINT4 increment)5148 add_28_00 (UINT4 *in, UINT4 increment) {
5149 *in += (increment << 0);
5150 return;
5151 }
5152
5153 static void
add_28_01(UINT4 * in,UINT4 increment)5154 add_28_01 (UINT4 *in, UINT4 increment) {
5155 UINT4 prev, carry;
5156
5157 prev = ( CONVERT(*in) >> 28 ) % (1U << 28 ) ;
5158 carry = ( (prev + increment) >> (28 - 24) );
5159 *in += (increment << 28);
5160
5161 in += 1 * WORD_INCR;
5162 /* prev |= (CONVERT(*in) % (1U<< 24 ))<<( 28 - 24 ); */
5163 *in += carry;
5164
5165 return;
5166 }
5167
5168 static void
add_28_02(UINT4 * in,UINT4 increment)5169 add_28_02 (UINT4 *in, UINT4 increment) {
5170 UINT4 prev, carry;
5171
5172 in += 1 * WORD_INCR;
5173 prev = ( CONVERT(*in) >> 24 ) % (1U << 28 ) ;
5174 carry = ( (prev + increment) >> (28 - 20) );
5175 *in += (increment << 24);
5176
5177 in += 1 * WORD_INCR;
5178 /* prev |= (CONVERT(*in) % (1U<< 20 ))<<( 28 - 20 ); */
5179 *in += carry;
5180
5181 return;
5182 }
5183
5184 static void
add_28_03(UINT4 * in,UINT4 increment)5185 add_28_03 (UINT4 *in, UINT4 increment) {
5186 UINT4 prev, carry;
5187
5188 in += 2 * WORD_INCR;
5189 prev = ( CONVERT(*in) >> 20 ) % (1U << 28 ) ;
5190 carry = ( (prev + increment) >> (28 - 16) );
5191 *in += (increment << 20);
5192
5193 in += 1 * WORD_INCR;
5194 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 28 - 16 ); */
5195 *in += carry;
5196
5197 return;
5198 }
5199
5200 static void
add_28_04(UINT4 * in,UINT4 increment)5201 add_28_04 (UINT4 *in, UINT4 increment) {
5202 UINT4 prev, carry;
5203
5204 in += 3 * WORD_INCR;
5205 prev = ( CONVERT(*in) >> 16 ) % (1U << 28 ) ;
5206 carry = ( (prev + increment) >> (28 - 12) );
5207 *in += (increment << 16);
5208
5209 in += 1 * WORD_INCR;
5210 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 28 - 12 ); */
5211 *in += carry;
5212
5213 return;
5214 }
5215
5216 static void
add_28_05(UINT4 * in,UINT4 increment)5217 add_28_05 (UINT4 *in, UINT4 increment) {
5218 UINT4 prev, carry;
5219
5220 in += 4 * WORD_INCR;
5221 prev = ( CONVERT(*in) >> 12 ) % (1U << 28 ) ;
5222 carry = ( (prev + increment) >> (28 - 8) );
5223 *in += (increment << 12);
5224
5225 in += 1 * WORD_INCR;
5226 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 28 - 8 ); */
5227 *in += carry;
5228
5229 return;
5230 }
5231
5232 static void
add_28_06(UINT4 * in,UINT4 increment)5233 add_28_06 (UINT4 *in, UINT4 increment) {
5234 UINT4 prev, carry;
5235
5236 in += 5 * WORD_INCR;
5237 prev = ( CONVERT(*in) >> 8 ) % (1U << 28 ) ;
5238 carry = ( (prev + increment) >> (28 - 4) );
5239 *in += (increment << 8);
5240
5241 in += 1 * WORD_INCR;
5242 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 28 - 4 ); */
5243 *in += carry;
5244
5245 return;
5246 }
5247
5248 static void
add_28_07(UINT4 * in,UINT4 increment)5249 add_28_07 (UINT4 *in, UINT4 increment) {
5250 in += 6 * WORD_INCR;
5251 *in += (increment << 4);
5252 return;
5253 }
5254
5255 static void
add_28_08(UINT4 * in,UINT4 increment)5256 add_28_08 (UINT4 *in, UINT4 increment) {
5257 in += 7 * WORD_INCR;
5258 *in += (increment << 0);
5259 return;
5260 }
5261
5262 static void
add_28_09(UINT4 * in,UINT4 increment)5263 add_28_09 (UINT4 *in, UINT4 increment) {
5264 UINT4 prev, carry;
5265
5266 in += 7 * WORD_INCR;
5267 prev = ( CONVERT(*in) >> 28 ) % (1U << 28 ) ;
5268 carry = ( (prev + increment) >> (28 - 24) );
5269 *in += (increment << 28);
5270
5271 in += 1 * WORD_INCR;
5272 /* prev |= (CONVERT(*in) % (1U<< 24 ))<<( 28 - 24 ); */
5273 *in += carry;
5274
5275 return;
5276 }
5277
5278 static void
add_28_10(UINT4 * in,UINT4 increment)5279 add_28_10 (UINT4 *in, UINT4 increment) {
5280 UINT4 prev, carry;
5281
5282 in += 8 * WORD_INCR;
5283 prev = ( CONVERT(*in) >> 24 ) % (1U << 28 ) ;
5284 carry = ( (prev + increment) >> (28 - 20) );
5285 *in += (increment << 24);
5286
5287 in += 1 * WORD_INCR;
5288 /* prev |= (CONVERT(*in) % (1U<< 20 ))<<( 28 - 20 ); */
5289 *in += carry;
5290
5291 return;
5292 }
5293
5294 static void
add_28_11(UINT4 * in,UINT4 increment)5295 add_28_11 (UINT4 *in, UINT4 increment) {
5296 UINT4 prev, carry;
5297
5298 in += 9 * WORD_INCR;
5299 prev = ( CONVERT(*in) >> 20 ) % (1U << 28 ) ;
5300 carry = ( (prev + increment) >> (28 - 16) );
5301 *in += (increment << 20);
5302
5303 in += 1 * WORD_INCR;
5304 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 28 - 16 ); */
5305 *in += carry;
5306
5307 return;
5308 }
5309
5310 static void
add_28_12(UINT4 * in,UINT4 increment)5311 add_28_12 (UINT4 *in, UINT4 increment) {
5312 UINT4 prev, carry;
5313
5314 in += 10 * WORD_INCR;
5315 prev = ( CONVERT(*in) >> 16 ) % (1U << 28 ) ;
5316 carry = ( (prev + increment) >> (28 - 12) );
5317 *in += (increment << 16);
5318
5319 in += 1 * WORD_INCR;
5320 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 28 - 12 ); */
5321 *in += carry;
5322
5323 return;
5324 }
5325
5326 static void
add_28_13(UINT4 * in,UINT4 increment)5327 add_28_13 (UINT4 *in, UINT4 increment) {
5328 UINT4 prev, carry;
5329
5330 in += 11 * WORD_INCR;
5331 prev = ( CONVERT(*in) >> 12 ) % (1U << 28 ) ;
5332 carry = ( (prev + increment) >> (28 - 8) );
5333 *in += (increment << 12);
5334
5335 in += 1 * WORD_INCR;
5336 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 28 - 8 ); */
5337 *in += carry;
5338
5339 return;
5340 }
5341
5342 static void
add_28_14(UINT4 * in,UINT4 increment)5343 add_28_14 (UINT4 *in, UINT4 increment) {
5344 UINT4 prev, carry;
5345
5346 in += 12 * WORD_INCR;
5347 prev = ( CONVERT(*in) >> 8 ) % (1U << 28 ) ;
5348 carry = ( (prev + increment) >> (28 - 4) );
5349 *in += (increment << 8);
5350
5351 in += 1 * WORD_INCR;
5352 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 28 - 4 ); */
5353 *in += carry;
5354
5355 return;
5356 }
5357
5358 static void
add_28_15(UINT4 * in,UINT4 increment)5359 add_28_15 (UINT4 *in, UINT4 increment) {
5360 in += 13 * WORD_INCR;
5361 *in += (increment << 4);
5362 return;
5363 }
5364
5365
5366 static void
add_30_00(UINT4 * in,UINT4 increment)5367 add_30_00 (UINT4 *in, UINT4 increment) {
5368 *in += (increment << 0);
5369 return;
5370 }
5371
5372 static void
add_30_01(UINT4 * in,UINT4 increment)5373 add_30_01 (UINT4 *in, UINT4 increment) {
5374 UINT4 prev, carry;
5375
5376 prev = ( CONVERT(*in) >> 30 ) % (1U << 30 ) ;
5377 carry = ( (prev + increment) >> (30 - 28) );
5378 *in += (increment << 30);
5379
5380 in += 1 * WORD_INCR;
5381 /* prev |= (CONVERT(*in) % (1U<< 28 ))<<( 30 - 28 ); */
5382 *in += carry;
5383
5384 return;
5385 }
5386
5387 static void
add_30_02(UINT4 * in,UINT4 increment)5388 add_30_02 (UINT4 *in, UINT4 increment) {
5389 UINT4 prev, carry;
5390
5391 in += 1 * WORD_INCR;
5392 prev = ( CONVERT(*in) >> 28 ) % (1U << 30 ) ;
5393 carry = ( (prev + increment) >> (30 - 26) );
5394 *in += (increment << 28);
5395
5396 in += 1 * WORD_INCR;
5397 /* prev |= (CONVERT(*in) % (1U<< 26 ))<<( 30 - 26 ); */
5398 *in += carry;
5399
5400 return;
5401 }
5402
5403 static void
add_30_03(UINT4 * in,UINT4 increment)5404 add_30_03 (UINT4 *in, UINT4 increment) {
5405 UINT4 prev, carry;
5406
5407 in += 2 * WORD_INCR;
5408 prev = ( CONVERT(*in) >> 26 ) % (1U << 30 ) ;
5409 carry = ( (prev + increment) >> (30 - 24) );
5410 *in += (increment << 26);
5411
5412 in += 1 * WORD_INCR;
5413 /* prev |= (CONVERT(*in) % (1U<< 24 ))<<( 30 - 24 ); */
5414 *in += carry;
5415
5416 return;
5417 }
5418
5419 static void
add_30_04(UINT4 * in,UINT4 increment)5420 add_30_04 (UINT4 *in, UINT4 increment) {
5421 UINT4 prev, carry;
5422
5423 in += 3 * WORD_INCR;
5424 prev = ( CONVERT(*in) >> 24 ) % (1U << 30 ) ;
5425 carry = ( (prev + increment) >> (30 - 22) );
5426 *in += (increment << 24);
5427
5428 in += 1 * WORD_INCR;
5429 /* prev |= (CONVERT(*in) % (1U<< 22 ))<<( 30 - 22 ); */
5430 *in += carry;
5431
5432 return;
5433 }
5434
5435 static void
add_30_05(UINT4 * in,UINT4 increment)5436 add_30_05 (UINT4 *in, UINT4 increment) {
5437 UINT4 prev, carry;
5438
5439 in += 4 * WORD_INCR;
5440 prev = ( CONVERT(*in) >> 22 ) % (1U << 30 ) ;
5441 carry = ( (prev + increment) >> (30 - 20) );
5442 *in += (increment << 22);
5443
5444 in += 1 * WORD_INCR;
5445 /* prev |= (CONVERT(*in) % (1U<< 20 ))<<( 30 - 20 ); */
5446 *in += carry;
5447
5448 return;
5449 }
5450
5451 static void
add_30_06(UINT4 * in,UINT4 increment)5452 add_30_06 (UINT4 *in, UINT4 increment) {
5453 UINT4 prev, carry;
5454
5455 in += 5 * WORD_INCR;
5456 prev = ( CONVERT(*in) >> 20 ) % (1U << 30 ) ;
5457 carry = ( (prev + increment) >> (30 - 18));
5458 *in += (increment << 20);
5459
5460 in += 1 * WORD_INCR;
5461 /* prev |= (CONVERT(*in) % (1U<< 18 ))<<( 30 - 18 ); */
5462 *in += carry;
5463
5464 return;
5465 }
5466
5467 static void
add_30_07(UINT4 * in,UINT4 increment)5468 add_30_07 (UINT4 *in, UINT4 increment) {
5469 UINT4 prev, carry;
5470
5471 in += 6 * WORD_INCR;
5472 prev = ( CONVERT(*in) >> 18 ) % (1U << 30 ) ;
5473 carry = ( (prev + increment) >> (30 - 16) );
5474 *in += (increment << 18);
5475
5476 in += 1 * WORD_INCR;
5477 /* prev |= (CONVERT(*in) % (1U<< 16 ))<<( 30 - 16 ); */
5478 *in += carry;
5479
5480 return;
5481 }
5482
5483 static void
add_30_08(UINT4 * in,UINT4 increment)5484 add_30_08 (UINT4 *in, UINT4 increment) {
5485 UINT4 prev, carry;
5486
5487 in += 7 * WORD_INCR;
5488 prev = ( CONVERT(*in) >> 16 ) % (1U << 30 ) ;
5489 carry = ( (prev + increment) >> (30 - 14) );
5490 *in += (increment << 16);
5491
5492 in += 1 * WORD_INCR;
5493 /* prev |= (CONVERT(*in) % (1U<< 14 ))<<( 30 - 14 ); */
5494 *in += carry;
5495
5496 return;
5497 }
5498
5499 static void
add_30_09(UINT4 * in,UINT4 increment)5500 add_30_09 (UINT4 *in, UINT4 increment) {
5501 UINT4 prev, carry;
5502
5503 in += 8 * WORD_INCR;
5504 prev = ( CONVERT(*in) >> 14 ) % (1U << 30 ) ;
5505 carry = ( (prev + increment) >> (30 - 12) );
5506 *in += (increment << 14);
5507
5508 in += 1 * WORD_INCR;
5509 /* prev |= (CONVERT(*in) % (1U<< 12 ))<<( 30 - 12 ); */
5510 *in += carry;
5511
5512 return;
5513 }
5514
5515 static void
add_30_10(UINT4 * in,UINT4 increment)5516 add_30_10 (UINT4 *in, UINT4 increment) {
5517 UINT4 prev, carry;
5518
5519 in += 9 * WORD_INCR;
5520 prev = ( CONVERT(*in) >> 12 ) % (1U << 30 ) ;
5521 carry = ( (prev + increment) >> (30 - 10) );
5522 *in += (increment << 12);
5523
5524 in += 1 * WORD_INCR;
5525 /* prev |= (CONVERT(*in) % (1U<< 10 ))<<( 30 - 10 ); */
5526 *in += carry;
5527
5528 return;
5529 }
5530
5531 static void
add_30_11(UINT4 * in,UINT4 increment)5532 add_30_11 (UINT4 *in, UINT4 increment) {
5533 UINT4 prev, carry;
5534
5535 in += 10 * WORD_INCR;
5536 prev = ( CONVERT(*in) >> 10 ) % (1U << 30 ) ;
5537 carry = ( (prev + increment) >> (30 - 8) );
5538 *in += (increment << 10);
5539
5540 in += 1 * WORD_INCR;
5541 /* prev |= (CONVERT(*in) % (1U<< 8 ))<<( 30 - 8 ); */
5542 *in += carry;
5543
5544 return;
5545 }
5546
5547 static void
add_30_12(UINT4 * in,UINT4 increment)5548 add_30_12 (UINT4 *in, UINT4 increment) {
5549 UINT4 prev, carry;
5550
5551 in += 11 * WORD_INCR;
5552 prev = ( CONVERT(*in) >> 8 ) % (1U << 30 ) ;
5553 carry = ( (prev + increment) >> (30 - 6) );
5554 *in += (increment << 8);
5555
5556 in += 1 * WORD_INCR;
5557 /* prev |= (CONVERT(*in) % (1U<< 6 ))<<( 30 - 6 ); */
5558 *in += carry;
5559
5560 return;
5561 }
5562
5563 static void
add_30_13(UINT4 * in,UINT4 increment)5564 add_30_13 (UINT4 *in, UINT4 increment) {
5565 UINT4 prev, carry;
5566
5567 in += 12 * WORD_INCR;
5568 prev = ( CONVERT(*in) >> 6 ) % (1U << 30 ) ;
5569 carry = ( (prev + increment) >> (30 - 4) );
5570 *in += (increment << 6);
5571
5572 in += 1 * WORD_INCR;
5573 /* prev |= (CONVERT(*in) % (1U<< 4 ))<<( 30 - 4 ); */
5574 *in += carry;
5575
5576 return;
5577 }
5578
5579 static void
add_30_14(UINT4 * in,UINT4 increment)5580 add_30_14 (UINT4 *in, UINT4 increment) {
5581 UINT4 prev, carry;
5582
5583 in += 13 * WORD_INCR;
5584 prev = ( CONVERT(*in) >> 4 ) % (1U << 30 ) ;
5585 carry = ( (prev + increment) >> (30 - 2) );
5586 *in += (increment << 4);
5587
5588 in += 1 * WORD_INCR;
5589 /* prev |= (CONVERT(*in) % (1U<< 2 ))<<( 30 - 2 ); */
5590 *in += carry;
5591
5592 return;
5593 }
5594
5595 static void
add_30_15(UINT4 * in,UINT4 increment)5596 add_30_15 (UINT4 *in, UINT4 increment) {
5597 in += 14 * WORD_INCR;
5598 *in += (increment << 2);
5599 return;
5600 }
5601
5602
5603 static void
add_32_00(UINT4 * in,UINT4 increment)5604 add_32_00 (UINT4 *in, UINT4 increment) {
5605 *in += increment;
5606 return;
5607 }
5608
5609 static void
add_32_01(UINT4 * in,UINT4 increment)5610 add_32_01 (UINT4 *in, UINT4 increment) {
5611 in += 1 * WORD_INCR;
5612 *in += increment;
5613 return;
5614 }
5615
5616 static void
add_32_02(UINT4 * in,UINT4 increment)5617 add_32_02 (UINT4 *in, UINT4 increment) {
5618 in += 2 * WORD_INCR;
5619 *in += increment;
5620 return;
5621 }
5622
5623 static void
add_32_03(UINT4 * in,UINT4 increment)5624 add_32_03 (UINT4 *in, UINT4 increment) {
5625 in += 3 * WORD_INCR;
5626 *in += increment;
5627 return;
5628 }
5629
5630 static void
add_32_04(UINT4 * in,UINT4 increment)5631 add_32_04 (UINT4 *in, UINT4 increment) {
5632 in += 4 * WORD_INCR;
5633 *in += increment;
5634 return;
5635 }
5636
5637 static void
add_32_05(UINT4 * in,UINT4 increment)5638 add_32_05 (UINT4 *in, UINT4 increment) {
5639 in += 5 * WORD_INCR;
5640 *in += increment;
5641 return;
5642 }
5643
5644 static void
add_32_06(UINT4 * in,UINT4 increment)5645 add_32_06 (UINT4 *in, UINT4 increment) {
5646 in += 6 * WORD_INCR;
5647 *in += increment;
5648 return;
5649 }
5650
5651 static void
add_32_07(UINT4 * in,UINT4 increment)5652 add_32_07 (UINT4 *in, UINT4 increment) {
5653 in += 7 * WORD_INCR;
5654 *in += increment;
5655 return;
5656 }
5657
5658 static void
add_32_08(UINT4 * in,UINT4 increment)5659 add_32_08 (UINT4 *in, UINT4 increment) {
5660 in += 8 * WORD_INCR;
5661 *in += increment;
5662 return;
5663 }
5664
5665 static void
add_32_09(UINT4 * in,UINT4 increment)5666 add_32_09 (UINT4 *in, UINT4 increment) {
5667 in += 9 * WORD_INCR;
5668 *in += increment;
5669 return;
5670 }
5671
5672 static void
add_32_10(UINT4 * in,UINT4 increment)5673 add_32_10 (UINT4 *in, UINT4 increment) {
5674 in += 10 * WORD_INCR;
5675 *in += increment;
5676 return;
5677 }
5678
5679 static void
add_32_11(UINT4 * in,UINT4 increment)5680 add_32_11 (UINT4 *in, UINT4 increment) {
5681 in += 11 * WORD_INCR;
5682 *in += increment;
5683 return;
5684 }
5685
5686 static void
add_32_12(UINT4 * in,UINT4 increment)5687 add_32_12 (UINT4 *in, UINT4 increment) {
5688 in += 12 * WORD_INCR;
5689 *in += increment;
5690 return;
5691 }
5692
5693 static void
add_32_13(UINT4 * in,UINT4 increment)5694 add_32_13 (UINT4 *in, UINT4 increment) {
5695 in += 13 * WORD_INCR;
5696 *in += increment;
5697 return;
5698 }
5699
5700 static void
add_32_14(UINT4 * in,UINT4 increment)5701 add_32_14 (UINT4 *in, UINT4 increment) {
5702 in += 14 * WORD_INCR;
5703 *in += increment;
5704 return;
5705 }
5706
5707 static void
add_32_15(UINT4 * in,UINT4 increment)5708 add_32_15 (UINT4 *in, UINT4 increment) {
5709 in += 15 * WORD_INCR;
5710 *in += increment;
5711 return;
5712 }
5713
5714
5715 typedef void (*Adder_T) (UINT4 *, UINT4);
5716
5717 static Adder_T adder_table[272] =
5718 {add_00, add_00, add_00, add_00,
5719 add_00, add_00, add_00, add_00,
5720 add_00, add_00, add_00, add_00,
5721 add_00, add_00, add_00, add_00,
5722
5723 add_02_00, add_02_01, add_02_02, add_02_03,
5724 add_02_04, add_02_05, add_02_06, add_02_07,
5725 add_02_08, add_02_09, add_02_10, add_02_11,
5726 add_02_12, add_02_13, add_02_14, add_02_15,
5727
5728 add_04_00, add_04_01, add_04_02, add_04_03,
5729 add_04_04, add_04_05, add_04_06, add_04_07,
5730 add_04_08, add_04_09, add_04_10, add_04_11,
5731 add_04_12, add_04_13, add_04_14, add_04_15,
5732
5733 add_06_00, add_06_01, add_06_02, add_06_03,
5734 add_06_04, add_06_05, add_06_06, add_06_07,
5735 add_06_08, add_06_09, add_06_10, add_06_11,
5736 add_06_12, add_06_13, add_06_14, add_06_15,
5737
5738 add_08_00, add_08_01, add_08_02, add_08_03,
5739 add_08_04, add_08_05, add_08_06, add_08_07,
5740 add_08_08, add_08_09, add_08_10, add_08_11,
5741 add_08_12, add_08_13, add_08_14, add_08_15,
5742
5743 add_10_00, add_10_01, add_10_02, add_10_03,
5744 add_10_04, add_10_05, add_10_06, add_10_07,
5745 add_10_08, add_10_09, add_10_10, add_10_11,
5746 add_10_12, add_10_13, add_10_14, add_10_15,
5747
5748 add_12_00, add_12_01, add_12_02, add_12_03,
5749 add_12_04, add_12_05, add_12_06, add_12_07,
5750 add_12_08, add_12_09, add_12_10, add_12_11,
5751 add_12_12, add_12_13, add_12_14, add_12_15,
5752
5753 add_14_00, add_14_01, add_14_02, add_14_03,
5754 add_14_04, add_14_05, add_14_06, add_14_07,
5755 add_14_08, add_14_09, add_14_10, add_14_11,
5756 add_14_12, add_14_13, add_14_14, add_14_15,
5757
5758 add_16_00, add_16_01, add_16_02, add_16_03,
5759 add_16_04, add_16_05, add_16_06, add_16_07,
5760 add_16_08, add_16_09, add_16_10, add_16_11,
5761 add_16_12, add_16_13, add_16_14, add_16_15,
5762
5763 add_18_00, add_18_01, add_18_02, add_18_03,
5764 add_18_04, add_18_05, add_18_06, add_18_07,
5765 add_18_08, add_18_09, add_18_10, add_18_11,
5766 add_18_12, add_18_13, add_18_14, add_18_15,
5767
5768 add_20_00, add_20_01, add_20_02, add_20_03,
5769 add_20_04, add_20_05, add_20_06, add_20_07,
5770 add_20_08, add_20_09, add_20_10, add_20_11,
5771 add_20_12, add_20_13, add_20_14, add_20_15,
5772
5773 add_22_00, add_22_01, add_22_02, add_22_03,
5774 add_22_04, add_22_05, add_22_06, add_22_07,
5775 add_22_08, add_22_09, add_22_10, add_22_11,
5776 add_22_12, add_22_13, add_22_14, add_22_15,
5777
5778 add_24_00, add_24_01, add_24_02, add_24_03,
5779 add_24_04, add_24_05, add_24_06, add_24_07,
5780 add_24_08, add_24_09, add_24_10, add_24_11,
5781 add_24_12, add_24_13, add_24_14, add_24_15,
5782
5783 add_26_00, add_26_01, add_26_02, add_26_03,
5784 add_26_04, add_26_05, add_26_06, add_26_07,
5785 add_26_08, add_26_09, add_26_10, add_26_11,
5786 add_26_12, add_26_13, add_26_14, add_26_15,
5787
5788 add_28_00, add_28_01, add_28_02, add_28_03,
5789 add_28_04, add_28_05, add_28_06, add_28_07,
5790 add_28_08, add_28_09, add_28_10, add_28_11,
5791 add_28_12, add_28_13, add_28_14, add_28_15,
5792
5793 add_30_00, add_30_01, add_30_02, add_30_03,
5794 add_30_04, add_30_05, add_30_06, add_30_07,
5795 add_30_08, add_30_09, add_30_10, add_30_11,
5796 add_30_12, add_30_13, add_30_14, add_30_15,
5797
5798 add_32_00, add_32_01, add_32_02, add_32_03,
5799 add_32_04, add_32_05, add_32_06, add_32_07,
5800 add_32_08, add_32_09, add_32_10, add_32_11,
5801 add_32_12, add_32_13, add_32_14, add_32_15,
5802 };
5803
5804
5805
5806 #if 0
5807 /* No need currently for a subtraction routine */
5808
5809 static void
5810 sub_00 (UINT4 *in, UINT4 decrement) {
5811 abort();
5812 return;
5813 }
5814
5815
5816
5817 static void
5818 sub_02_00 (UINT4 *in, UINT4 decrement) {
5819 *in -= (decrement << 0);
5820 return;
5821 }
5822
5823 static void
5824 sub_02_01 (UINT4 *in, UINT4 decrement) {
5825 *in -= (decrement << 2);
5826 return;
5827 }
5828
5829 static void
5830 sub_02_02 (UINT4 *in, UINT4 decrement) {
5831 *in -= (decrement << 4);
5832 return;
5833 }
5834
5835 static void
5836 sub_02_03 (UINT4 *in, UINT4 decrement) {
5837 *in -= (decrement << 6);
5838 return;
5839 }
5840
5841 static void
5842 sub_02_04 (UINT4 *in, UINT4 decrement) {
5843 *in -= (decrement << 8);
5844 return;
5845 }
5846
5847 static void
5848 sub_02_05 (UINT4 *in, UINT4 decrement) {
5849 *in -= (decrement << 10);
5850 return;
5851 }
5852
5853 static void
5854 sub_02_06 (UINT4 *in, UINT4 decrement) {
5855 *in -= (decrement << 12);
5856 return;
5857 }
5858
5859 static void
5860 sub_02_07 (UINT4 *in, UINT4 decrement) {
5861 *in -= (decrement << 14);
5862 return;
5863 }
5864
5865 static void
5866 sub_02_08 (UINT4 *in, UINT4 decrement) {
5867 *in -= (decrement << 16);
5868 return;
5869 }
5870
5871 static void
5872 sub_02_09 (UINT4 *in, UINT4 decrement) {
5873 *in -= (decrement << 18);
5874 return;
5875 }
5876
5877 static void
5878 sub_02_10 (UINT4 *in, UINT4 decrement) {
5879 *in -= (decrement << 20);
5880 return;
5881 }
5882
5883 static void
5884 sub_02_11 (UINT4 *in, UINT4 decrement) {
5885 *in -= (decrement << 22);
5886 return;
5887 }
5888
5889 static void
5890 sub_02_12 (UINT4 *in, UINT4 decrement) {
5891 *in -= (decrement << 24);
5892 return;
5893 }
5894
5895 static void
5896 sub_02_13 (UINT4 *in, UINT4 decrement) {
5897 *in -= (decrement << 26);
5898 return;
5899 }
5900
5901 static void
5902 sub_02_14 (UINT4 *in, UINT4 decrement) {
5903 *in -= (decrement << 28);
5904 return;
5905 }
5906
5907 static void
5908 sub_02_15 (UINT4 *in, UINT4 decrement) {
5909 *in -= (decrement << 30);
5910 return;
5911 }
5912
5913
5914 static void
5915 sub_04_00 (UINT4 *in, UINT4 decrement) {
5916 *in -= (decrement << 0);
5917 return;
5918 }
5919
5920 static void
5921 sub_04_01 (UINT4 *in, UINT4 decrement) {
5922 *in -= (decrement << 4);
5923 return;
5924 }
5925
5926 static void
5927 sub_04_02 (UINT4 *in, UINT4 decrement) {
5928 *in -= (decrement << 8);
5929 return;
5930 }
5931
5932 static void
5933 sub_04_03 (UINT4 *in, UINT4 decrement) {
5934 *in -= (decrement << 12);
5935 return;
5936 }
5937
5938 static void
5939 sub_04_04 (UINT4 *in, UINT4 decrement) {
5940 *in -= (decrement << 16);
5941 return;
5942 }
5943
5944 static void
5945 sub_04_05 (UINT4 *in, UINT4 decrement) {
5946 *in -= (decrement << 20);
5947 return;
5948 }
5949
5950 static void
5951 sub_04_06 (UINT4 *in, UINT4 decrement) {
5952 *in -= (decrement << 24);
5953 return;
5954 }
5955
5956 static void
5957 sub_04_07 (UINT4 *in, UINT4 decrement) {
5958 *in -= (decrement << 28);
5959 return;
5960 }
5961
5962 static void
5963 sub_04_08 (UINT4 *in, UINT4 decrement) {
5964 in += 1 * WORD_INCR;
5965 *in -= (decrement << 0);
5966 return;
5967 }
5968
5969 static void
5970 sub_04_09 (UINT4 *in, UINT4 decrement) {
5971 in += 1 * WORD_INCR;
5972 *in -= (decrement << 4);
5973 return;
5974 }
5975
5976 static void
5977 sub_04_10 (UINT4 *in, UINT4 decrement) {
5978 in += 1 * WORD_INCR;
5979 *in -= (decrement << 8);
5980 return;
5981 }
5982
5983 static void
5984 sub_04_11 (UINT4 *in, UINT4 decrement) {
5985 in += 1 * WORD_INCR;
5986 *in -= (decrement << 12);
5987 return;
5988 }
5989
5990 static void
5991 sub_04_12 (UINT4 *in, UINT4 decrement) {
5992 in += 1 * WORD_INCR;
5993 *in -= (decrement << 16);
5994 return;
5995 }
5996
5997 static void
5998 sub_04_13 (UINT4 *in, UINT4 decrement) {
5999 in += 1 * WORD_INCR;
6000 *in -= (decrement << 20);
6001 return;
6002 }
6003
6004 static void
6005 sub_04_14 (UINT4 *in, UINT4 decrement) {
6006 in += 1 * WORD_INCR;
6007 *in -= (decrement << 24);
6008 return;
6009 }
6010
6011 static void
6012 sub_04_15 (UINT4 *in, UINT4 decrement) {
6013 in += 1 * WORD_INCR;
6014 *in -= (decrement << 28);
6015 return;
6016 }
6017
6018
6019 static void
6020 sub_06_00 (UINT4 *in, UINT4 decrement) {
6021 *in -= (decrement << 0);
6022 return;
6023 }
6024
6025 static void
6026 sub_06_01 (UINT4 *in, UINT4 decrement) {
6027 *in -= (decrement << 6);
6028 return;
6029 }
6030
6031 static void
6032 sub_06_02 (UINT4 *in, UINT4 decrement) {
6033 *in -= (decrement << 12);
6034 return;
6035 }
6036
6037 static void
6038 sub_06_03 (UINT4 *in, UINT4 decrement) {
6039 *in -= (decrement << 18);
6040 return;
6041 }
6042
6043 static void
6044 sub_06_04 (UINT4 *in, UINT4 decrement) {
6045 *in -= (decrement << 24);
6046 return;
6047 }
6048
6049 static void
6050 sub_06_05 (UINT4 *in, UINT4 decrement) {
6051 UINT4 prev, carry;
6052
6053 prev = ( CONVERT(*in) >> 30 ) % (1U << 6 ) ;
6054 carry = ( (prev - decrement) >> (6 - 4) ) & 0x1;
6055 *in -= (decrement << 30);
6056
6057 in += 1 * WORD_INCR;
6058 *in -= (decrement >> ( 6 - 4 )) + carry;
6059
6060 return;
6061 }
6062
6063 static void
6064 sub_06_06 (UINT4 *in, UINT4 decrement) {
6065 in += 1 * WORD_INCR;
6066 *in -= (decrement << 4);
6067 return;
6068 }
6069
6070 static void
6071 sub_06_07 (UINT4 *in, UINT4 decrement) {
6072 in += 1 * WORD_INCR;
6073 *in -= (decrement << 10);
6074 return;
6075 }
6076
6077 static void
6078 sub_06_08 (UINT4 *in, UINT4 decrement) {
6079 in += 1 * WORD_INCR;
6080 *in -= (decrement << 16);
6081 return;
6082 }
6083
6084 static void
6085 sub_06_09 (UINT4 *in, UINT4 decrement) {
6086 in += 1 * WORD_INCR;
6087 *in -= (decrement << 22);
6088 return;
6089 }
6090
6091 static void
6092 sub_06_10 (UINT4 *in, UINT4 decrement) {
6093 UINT4 prev, carry;
6094
6095 in += 1 * WORD_INCR;
6096 prev = ( CONVERT(*in) >> 28 ) % (1U << 6 ) ;
6097 carry = ( (prev - decrement) >> (6 - 2) ) & 0x1;
6098 *in -= (decrement << 28);
6099
6100 in += 1 * WORD_INCR;
6101 *in -= (decrement >> ( 6 - 2 )) + carry;
6102
6103 return;
6104 }
6105
6106 static void
6107 sub_06_11 (UINT4 *in, UINT4 decrement) {
6108 in += 2 * WORD_INCR;
6109 *in -= (decrement << 2);
6110 return;
6111 }
6112
6113 static void
6114 sub_06_12 (UINT4 *in, UINT4 decrement) {
6115 in += 2 * WORD_INCR;
6116 *in -= (decrement << 8);
6117 return;
6118 }
6119
6120 static void
6121 sub_06_13 (UINT4 *in, UINT4 decrement) {
6122 in += 2 * WORD_INCR;
6123 *in -= (decrement << 14);
6124 return;
6125 }
6126
6127 static void
6128 sub_06_14 (UINT4 *in, UINT4 decrement) {
6129 in += 2 * WORD_INCR;
6130 *in -= (decrement << 20);
6131 return;
6132 }
6133
6134 static void
6135 sub_06_15 (UINT4 *in, UINT4 decrement) {
6136 in += 2 * WORD_INCR;
6137 *in -= (decrement << 26);
6138 return;
6139 }
6140
6141
6142 static void
6143 sub_08_00 (UINT4 *in, UINT4 decrement) {
6144 *in -= (decrement << 0);
6145 return;
6146 }
6147
6148 static void
6149 sub_08_01 (UINT4 *in, UINT4 decrement) {
6150 *in -= (decrement << 8);
6151 return;
6152 }
6153
6154 static void
6155 sub_08_02 (UINT4 *in, UINT4 decrement) {
6156 *in -= (decrement << 16);
6157 return;
6158 }
6159
6160 static void
6161 sub_08_03 (UINT4 *in, UINT4 decrement) {
6162 *in -= (decrement << 24);
6163 return;
6164 }
6165
6166 static void
6167 sub_08_04 (UINT4 *in, UINT4 decrement) {
6168 in += 1 * WORD_INCR;
6169 *in -= (decrement << 0);
6170 return;
6171 }
6172
6173 static void
6174 sub_08_05 (UINT4 *in, UINT4 decrement) {
6175 in += 1 * WORD_INCR;
6176 *in -= (decrement << 8);
6177 return;
6178 }
6179
6180 static void
6181 sub_08_06 (UINT4 *in, UINT4 decrement) {
6182 in += 1 * WORD_INCR;
6183 *in -= (decrement << 16);
6184 return;
6185 }
6186
6187 static void
6188 sub_08_07 (UINT4 *in, UINT4 decrement) {
6189 in += 1 * WORD_INCR;
6190 *in -= (decrement << 24);
6191 return;
6192 }
6193
6194 static void
6195 sub_08_08 (UINT4 *in, UINT4 decrement) {
6196 in += 2 * WORD_INCR;
6197 *in -= (decrement << 0);
6198 return;
6199 }
6200
6201 static void
6202 sub_08_09 (UINT4 *in, UINT4 decrement) {
6203 in += 2 * WORD_INCR;
6204 *in -= (decrement << 8);
6205 return;
6206 }
6207
6208 static void
6209 sub_08_10 (UINT4 *in, UINT4 decrement) {
6210 in += 2 * WORD_INCR;
6211 *in -= (decrement << 16);
6212 return;
6213 }
6214
6215 static void
6216 sub_08_11 (UINT4 *in, UINT4 decrement) {
6217 in += 2 * WORD_INCR;
6218 *in -= (decrement << 24);
6219 return;
6220 }
6221
6222 static void
6223 sub_08_12 (UINT4 *in, UINT4 decrement) {
6224 in += 3 * WORD_INCR;
6225 *in -= (decrement << 0);
6226 return;
6227 }
6228
6229 static void
6230 sub_08_13 (UINT4 *in, UINT4 decrement) {
6231 in += 3 * WORD_INCR;
6232 *in -= (decrement << 8);
6233 return;
6234 }
6235
6236 static void
6237 sub_08_14 (UINT4 *in, UINT4 decrement) {
6238 in += 3 * WORD_INCR;
6239 *in -= (decrement << 16);
6240 return;
6241 }
6242
6243 static void
6244 sub_08_15 (UINT4 *in, UINT4 decrement) {
6245 in += 3 * WORD_INCR;
6246 *in -= (decrement << 24);
6247 return;
6248 }
6249
6250
6251
6252 static void
6253 sub_10_00 (UINT4 *in, UINT4 decrement) {
6254 *in -= (decrement << 0);
6255 return;
6256 }
6257
6258 static void
6259 sub_10_01 (UINT4 *in, UINT4 decrement) {
6260 *in -= (decrement << 10);
6261 return;
6262 }
6263
6264 static void
6265 sub_10_02 (UINT4 *in, UINT4 decrement) {
6266 *in -= (decrement << 20);
6267 return;
6268 }
6269
6270 static void
6271 sub_10_03 (UINT4 *in, UINT4 decrement) {
6272 UINT4 prev, carry;
6273
6274 prev = ( CONVERT(*in) >> 30 ) % (1U << 10 ) ;
6275 carry = ( (prev - decrement) >> (10 - 8) ) & 0x1;
6276 *in -= (decrement << 30);
6277
6278 in += 1 * WORD_INCR;
6279 *in -= (decrement >> ( 10 - 8 )) + carry;
6280
6281 return;
6282 }
6283
6284 static void
6285 sub_10_04 (UINT4 *in, UINT4 decrement) {
6286 in += 1 * WORD_INCR;
6287 *in -= (decrement << 8);
6288 return;
6289 }
6290
6291 static void
6292 sub_10_05 (UINT4 *in, UINT4 decrement) {
6293 in += 1 * WORD_INCR;
6294 *in -= (decrement << 18);
6295 return;
6296 }
6297
6298 static void
6299 sub_10_06 (UINT4 *in, UINT4 decrement) {
6300 UINT4 prev, carry;
6301
6302 in += 1 * WORD_INCR;
6303 prev = ( CONVERT(*in) >> 28 ) % (1U << 10 ) ;
6304 carry = ( (prev - decrement) >> (10 - 6) ) & 0x1;
6305 *in -= (decrement << 28);
6306
6307 in += 1 * WORD_INCR;
6308 *in -= (decrement >> ( 10 - 6 )) + carry;
6309
6310 return;
6311 }
6312
6313 static void
6314 sub_10_07 (UINT4 *in, UINT4 decrement) {
6315 in += 2 * WORD_INCR;
6316 *in -= (decrement << 6);
6317 return;
6318 }
6319
6320 static void
6321 sub_10_08 (UINT4 *in, UINT4 decrement) {
6322 in += 2 * WORD_INCR;
6323 *in -= (decrement << 16);
6324 return;
6325 }
6326
6327 static void
6328 sub_10_09 (UINT4 *in, UINT4 decrement) {
6329 UINT4 prev, carry;
6330
6331 in += 2 * WORD_INCR;
6332 prev = ( CONVERT(*in) >> 26 ) % (1U << 10 ) ;
6333 carry = ( (prev - decrement) >> (10 - 4) ) & 0x1;
6334 *in -= (decrement << 26);
6335
6336 in += 1 * WORD_INCR;
6337 *in -= (decrement >> ( 10 - 4 )) + carry;
6338
6339 return;
6340 }
6341
6342 static void
6343 sub_10_10 (UINT4 *in, UINT4 decrement) {
6344 in += 3 * WORD_INCR;
6345 *in -= (decrement << 4);
6346 return;
6347 }
6348
6349 static void
6350 sub_10_11 (UINT4 *in, UINT4 decrement) {
6351 in += 3 * WORD_INCR;
6352 *in -= (decrement << 14);
6353 return;
6354 }
6355
6356 static void
6357 sub_10_12 (UINT4 *in, UINT4 decrement) {
6358 UINT4 prev, carry;
6359
6360 in += 3 * WORD_INCR;
6361 prev = ( CONVERT(*in) >> 24 ) % (1U << 10 ) ;
6362 carry = ( (prev - decrement) >> (10 - 2) ) & 0x1;
6363 *in -= (decrement << 24);
6364
6365 in += 1 * WORD_INCR;
6366 *in -= (decrement >> ( 10 - 2 )) + carry;
6367
6368 return;
6369 }
6370
6371 static void
6372 sub_10_13 (UINT4 *in, UINT4 decrement) {
6373 in += 4 * WORD_INCR;
6374 *in -= (decrement << 2);
6375 return;
6376 }
6377
6378 static void
6379 sub_10_14 (UINT4 *in, UINT4 decrement) {
6380 in += 4 * WORD_INCR;
6381 *in -= (decrement << 12);
6382 return;
6383 }
6384
6385 static void
6386 sub_10_15 (UINT4 *in, UINT4 decrement) {
6387 in += 4 * WORD_INCR;
6388 *in -= (decrement << 22);
6389 return;
6390 }
6391
6392
6393
6394 static void
6395 sub_12_00 (UINT4 *in, UINT4 decrement) {
6396 *in -= (decrement << 0);
6397 return;
6398 }
6399
6400 static void
6401 sub_12_01 (UINT4 *in, UINT4 decrement) {
6402 *in -= (decrement << 12);
6403 return;
6404 }
6405
6406 static void
6407 sub_12_02 (UINT4 *in, UINT4 decrement) {
6408 UINT4 prev, carry;
6409
6410 prev = ( CONVERT(*in) >> 24 ) % (1U << 12 ) ;
6411 carry = ( (prev - decrement) >> (12 - 4) ) & 0x1;
6412 *in -= (decrement << 24);
6413
6414 in += 1 * WORD_INCR;
6415 *in -= (decrement >> ( 12 - 4 )) + carry;
6416
6417 return;
6418 }
6419
6420 static void
6421 sub_12_03 (UINT4 *in, UINT4 decrement) {
6422 in += 1 * WORD_INCR;
6423 *in -= (decrement << 4);
6424 return;
6425 }
6426
6427 static void
6428 sub_12_04 (UINT4 *in, UINT4 decrement) {
6429 in += 1 * WORD_INCR;
6430 *in -= (decrement << 16);
6431 return;
6432 }
6433
6434 static void
6435 sub_12_05 (UINT4 *in, UINT4 decrement) {
6436 UINT4 prev, carry;
6437
6438 in += 1 * WORD_INCR;
6439 prev = ( CONVERT(*in) >> 28 ) % (1U << 12 ) ;
6440 carry = ( (prev - decrement) >> (12 - 8)) & 0x1;
6441 *in -= (decrement << 28);
6442
6443 in += 1 * WORD_INCR;
6444 *in -= (decrement >> ( 12 - 8 )) + carry;
6445
6446 return;
6447 }
6448
6449 static void
6450 sub_12_06 (UINT4 *in, UINT4 decrement) {
6451 in += 2 * WORD_INCR;
6452 *in -= (decrement << 8);
6453 return;
6454 }
6455
6456 static void
6457 sub_12_07 (UINT4 *in, UINT4 decrement) {
6458 in += 2 * WORD_INCR;
6459 *in -= (decrement << 20);
6460 return;
6461 }
6462
6463 static void
6464 sub_12_08 (UINT4 *in, UINT4 decrement) {
6465 in += 3 * WORD_INCR;
6466 *in -= (decrement << 0);
6467 return;
6468 }
6469
6470 static void
6471 sub_12_09 (UINT4 *in, UINT4 decrement) {
6472 in += 3 * WORD_INCR;
6473 *in -= (decrement << 12);
6474 return;
6475 }
6476
6477 static void
6478 sub_12_10 (UINT4 *in, UINT4 decrement) {
6479 UINT4 prev, carry;
6480
6481 in += 3 * WORD_INCR;
6482 prev = ( CONVERT(*in) >> 24 ) % (1U << 12 ) ;
6483 carry = ( (prev - decrement) >> (12 - 4) ) & 0x1;
6484 *in -= (decrement << 24);
6485
6486 in += 1 * WORD_INCR;
6487 *in -= (decrement >> ( 12 - 4 )) + carry;
6488
6489 return;
6490 }
6491
6492 static void
6493 sub_12_11 (UINT4 *in, UINT4 decrement) {
6494 in += 4 * WORD_INCR;
6495 *in -= (decrement << 4);
6496 return;
6497 }
6498
6499 static void
6500 sub_12_12 (UINT4 *in, UINT4 decrement) {
6501 in += 4 * WORD_INCR;
6502 *in -= (decrement << 16);
6503 return;
6504 }
6505
6506 static void
6507 sub_12_13 (UINT4 *in, UINT4 decrement) {
6508 UINT4 prev, carry;
6509
6510 in += 4 * WORD_INCR;
6511 prev = ( CONVERT(*in) >> 28 ) % (1U << 12 ) ;
6512 carry = ( (prev - decrement) >> (12 - 8)) & 0x1;
6513 *in -= (decrement << 28);
6514
6515 in += 1 * WORD_INCR;
6516 *in -= (decrement >> ( 12 - 8 )) + carry;
6517
6518 return;
6519 }
6520
6521 static void
6522 sub_12_14 (UINT4 *in, UINT4 decrement) {
6523 in += 5 * WORD_INCR;
6524 *in -= (decrement << 8);
6525 return;
6526 }
6527
6528 static void
6529 sub_12_15 (UINT4 *in, UINT4 decrement) {
6530 in += 5 * WORD_INCR;
6531 *in -= (decrement << 20);
6532 return;
6533 }
6534
6535
6536 static void
6537 sub_14_00 (UINT4 *in, UINT4 decrement) {
6538 *in -= (decrement << 0);
6539 return;
6540 }
6541
6542 static void
6543 sub_14_01 (UINT4 *in, UINT4 decrement) {
6544 *in -= (decrement << 14);
6545 return;
6546 }
6547
6548 static void
6549 sub_14_02 (UINT4 *in, UINT4 decrement) {
6550 UINT4 prev, carry;
6551
6552 prev = ( CONVERT(*in) >> 28 ) % (1U << 14 ) ;
6553 carry = ( (prev - decrement) >> (14 - 10) ) & 0x1;
6554 *in -= (decrement << 28);
6555
6556 in += 1 * WORD_INCR;
6557 *in -= (decrement >> ( 14 - 10 )) + carry;
6558
6559 return;
6560 }
6561
6562 static void
6563 sub_14_03 (UINT4 *in, UINT4 decrement) {
6564 in += 1 * WORD_INCR;
6565 *in -= (decrement << 10);
6566 return;
6567 }
6568
6569 static void
6570 sub_14_04 (UINT4 *in, UINT4 decrement) {
6571 UINT4 prev, carry;
6572
6573 in += 1 * WORD_INCR;
6574 prev = ( CONVERT(*in) >> 24 ) % (1U << 14 ) ;
6575 carry = ( (prev - decrement) >> (14 - 6) ) & 0x1;
6576 *in -= (decrement << 24);
6577
6578 in += 1 * WORD_INCR;
6579 *in -= (decrement >> ( 14 - 6 )) + carry;
6580
6581 return;
6582 }
6583
6584 static void
6585 sub_14_05 (UINT4 *in, UINT4 decrement) {
6586 in += 2 * WORD_INCR;
6587 *in -= (decrement << 6);
6588 return;
6589 }
6590
6591 static void
6592 sub_14_06 (UINT4 *in, UINT4 decrement) {
6593 UINT4 prev, carry;
6594
6595 in += 2 * WORD_INCR;
6596 prev = ( CONVERT(*in) >> 20 ) % (1U << 14 ) ;
6597 carry = ( (prev - decrement) >> (14 - 2) ) & 0x1;
6598 *in -= (decrement << 20);
6599
6600 in += 1 * WORD_INCR;
6601 *in -= (decrement >> ( 14 - 2 )) + carry;
6602
6603 return;
6604 }
6605
6606 static void
6607 sub_14_07 (UINT4 *in, UINT4 decrement) {
6608 in += 3 * WORD_INCR;
6609 *in -= (decrement << 2);
6610 return;
6611 }
6612
6613 static void
6614 sub_14_08 (UINT4 *in, UINT4 decrement) {
6615 in += 3 * WORD_INCR;
6616 *in -= (decrement << 16);
6617 return;
6618 }
6619
6620 static void
6621 sub_14_09 (UINT4 *in, UINT4 decrement) {
6622 UINT4 prev, carry;
6623
6624 in += 3 * WORD_INCR;
6625 prev = ( CONVERT(*in) >> 30 ) % (1U << 14 ) ;
6626 carry = ( (prev - decrement) >> (14 - 12) ) & 0x1;
6627 *in -= (decrement << 30);
6628
6629 in += 1 * WORD_INCR;
6630 *in -= (decrement >> ( 14 - 12 )) + carry;
6631
6632 return;
6633 }
6634
6635 static void
6636 sub_14_10 (UINT4 *in, UINT4 decrement) {
6637 in += 4 * WORD_INCR;
6638 *in -= (decrement << 12);
6639 return;
6640 }
6641
6642 static void
6643 sub_14_11 (UINT4 *in, UINT4 decrement) {
6644 UINT4 prev, carry;
6645
6646 in += 4 * WORD_INCR;
6647 prev = ( CONVERT(*in) >> 26 ) % (1U << 14 ) ;
6648 carry = ( (prev - decrement) >> (14 - 8) ) & 0x1;
6649 *in -= (decrement << 26);
6650
6651 in += 1 * WORD_INCR;
6652 *in -= (decrement >> ( 14 - 8 )) + carry;
6653
6654 return;
6655 }
6656
6657 static void
6658 sub_14_12 (UINT4 *in, UINT4 decrement) {
6659 in += 5 * WORD_INCR;
6660 *in -= (decrement << 8);
6661 return;
6662 }
6663
6664 static void
6665 sub_14_13 (UINT4 *in, UINT4 decrement) {
6666 UINT4 prev, carry;
6667
6668 in += 5 * WORD_INCR;
6669 prev = ( CONVERT(*in) >> 22 ) % (1U << 14 ) ;
6670 carry = ( (prev - decrement) >> (14 - 4) ) & 0x1;
6671 *in -= (decrement << 22);
6672
6673 in += 1 * WORD_INCR;
6674 *in -= (decrement >> ( 14 - 4 )) + carry;
6675
6676 return;
6677 }
6678
6679 static void
6680 sub_14_14 (UINT4 *in, UINT4 decrement) {
6681 in += 6 * WORD_INCR;
6682 *in -= (decrement << 4);
6683 return;
6684 }
6685
6686 static void
6687 sub_14_15 (UINT4 *in, UINT4 decrement) {
6688 in += 6 * WORD_INCR;
6689 *in -= (decrement << 18);
6690 return;
6691 }
6692
6693
6694 static void
6695 sub_16_00 (UINT4 *in, UINT4 decrement) {
6696 *in -= (decrement << 0);
6697 return;
6698 }
6699
6700 static void
6701 sub_16_01 (UINT4 *in, UINT4 decrement) {
6702 *in -= (decrement << 16);
6703 return;
6704 }
6705
6706 static void
6707 sub_16_02 (UINT4 *in, UINT4 decrement) {
6708 in += 1 * WORD_INCR;
6709 *in -= (decrement << 0);
6710 return;
6711 }
6712
6713 static void
6714 sub_16_03 (UINT4 *in, UINT4 decrement) {
6715 in += 1 * WORD_INCR;
6716 *in -= (decrement << 16);
6717 return;
6718 }
6719
6720 static void
6721 sub_16_04 (UINT4 *in, UINT4 decrement) {
6722 in += 2 * WORD_INCR;
6723 *in -= (decrement << 0);
6724 return;
6725 }
6726
6727 static void
6728 sub_16_05 (UINT4 *in, UINT4 decrement) {
6729 in += 2 * WORD_INCR;
6730 *in -= (decrement << 16);
6731 return;
6732 }
6733
6734 static void
6735 sub_16_06 (UINT4 *in, UINT4 decrement) {
6736 in += 3 * WORD_INCR;
6737 *in -= (decrement << 0);
6738 return;
6739 }
6740
6741 static void
6742 sub_16_07 (UINT4 *in, UINT4 decrement) {
6743 in += 3 * WORD_INCR;
6744 *in -= (decrement << 16);
6745 return;
6746 }
6747
6748 static void
6749 sub_16_08 (UINT4 *in, UINT4 decrement) {
6750 in += 4 * WORD_INCR;
6751 *in -= (decrement << 0);
6752 return;
6753 }
6754
6755 static void
6756 sub_16_09 (UINT4 *in, UINT4 decrement) {
6757 in += 4 * WORD_INCR;
6758 *in -= (decrement << 16);
6759 return;
6760 }
6761
6762 static void
6763 sub_16_10 (UINT4 *in, UINT4 decrement) {
6764 in += 5 * WORD_INCR;
6765 *in -= (decrement << 0);
6766 return;
6767 }
6768
6769 static void
6770 sub_16_11 (UINT4 *in, UINT4 decrement) {
6771 in += 5 * WORD_INCR;
6772 *in -= (decrement << 16);
6773 return;
6774 }
6775
6776 static void
6777 sub_16_12 (UINT4 *in, UINT4 decrement) {
6778 in += 6 * WORD_INCR;
6779 *in -= (decrement << 0);
6780 return;
6781 }
6782
6783 static void
6784 sub_16_13 (UINT4 *in, UINT4 decrement) {
6785 in += 6 * WORD_INCR;
6786 *in -= (decrement << 16);
6787 return;
6788 }
6789
6790 static void
6791 sub_16_14 (UINT4 *in, UINT4 decrement) {
6792 in += 7 * WORD_INCR;
6793 *in -= (decrement << 0);
6794 return;
6795 }
6796
6797 static void
6798 sub_16_15 (UINT4 *in, UINT4 decrement) {
6799 in += 7 * WORD_INCR;
6800 *in -= (decrement << 16);
6801 return;
6802 }
6803
6804
6805 static void
6806 sub_18_00 (UINT4 *in, UINT4 decrement) {
6807 *in -= (decrement << 0);
6808 return;
6809 }
6810
6811 static void
6812 sub_18_01 (UINT4 *in, UINT4 decrement) {
6813 UINT4 prev, carry;
6814
6815 prev = ( CONVERT(*in) >> 18 ) % (1U << 18 ) ;
6816 carry = ( (prev - decrement) >> (18 - 4) ) & 0x1;
6817 *in -= (decrement << 18);
6818
6819 in += 1 * WORD_INCR;
6820 *in -= (decrement >> ( 18 - 4 )) + carry;
6821
6822 return;
6823 }
6824
6825 static void
6826 sub_18_02 (UINT4 *in, UINT4 decrement) {
6827 in += 1 * WORD_INCR;
6828 *in -= (decrement << 4);
6829 return;
6830 }
6831
6832 static void
6833 sub_18_03 (UINT4 *in, UINT4 decrement) {
6834 UINT4 prev, carry;
6835
6836 in += 1 * WORD_INCR;
6837 prev = ( CONVERT(*in) >> 22 ) % (1U << 18 ) ;
6838 carry = ( (prev - decrement) >> (18 - 8) ) & 0x1;
6839 *in -= (decrement << 22);
6840
6841 in += 1 * WORD_INCR;
6842 *in -= (decrement >> ( 18 - 8 )) + carry;
6843
6844 return;
6845 }
6846
6847 static void
6848 sub_18_04 (UINT4 *in, UINT4 decrement) {
6849 in += 2 * WORD_INCR;
6850 *in -= (decrement << 8);
6851 return;
6852 }
6853
6854 static void
6855 sub_18_05 (UINT4 *in, UINT4 decrement) {
6856 UINT4 prev, carry;
6857
6858 in += 2 * WORD_INCR;
6859 prev = ( CONVERT(*in) >> 26 ) % (1U << 18 ) ;
6860 carry = ( (prev - decrement) >> (18 - 12) ) & 0x1;
6861 *in -= (decrement << 26);
6862
6863 in += 1 * WORD_INCR;
6864 *in -= (decrement >> ( 18 - 12 )) + carry;
6865
6866 return;
6867 }
6868
6869 static void
6870 sub_18_06 (UINT4 *in, UINT4 decrement) {
6871 in += 3 * WORD_INCR;
6872 *in -= (decrement << 12);
6873 return;
6874 }
6875
6876 static void
6877 sub_18_07 (UINT4 *in, UINT4 decrement) {
6878 UINT4 prev, carry;
6879
6880 in += 3 * WORD_INCR;
6881 prev = ( CONVERT(*in) >> 30 ) % (1U << 18 ) ;
6882 carry = ( (prev - decrement) >> (18 - 16) ) & 0x1;
6883 *in -= (decrement << 30);
6884
6885 in += 1 * WORD_INCR;
6886 *in -= (decrement >> ( 18 - 16 )) + carry;
6887
6888 return;
6889 }
6890
6891 static void
6892 sub_18_08 (UINT4 *in, UINT4 decrement) {
6893 UINT4 prev, carry;
6894
6895 in += 4 * WORD_INCR;
6896 prev = ( CONVERT(*in) >> 16 ) % (1U << 18 ) ;
6897 carry = ( (prev - decrement) >> (18 - 2) ) & 0x1;
6898 *in -= (decrement << 16);
6899
6900 in += 1 * WORD_INCR;
6901 *in -= (decrement >> ( 18 - 2 )) + carry;
6902
6903 return;
6904 }
6905
6906 static void
6907 sub_18_09 (UINT4 *in, UINT4 decrement) {
6908 in += 5 * WORD_INCR;
6909 *in -= (decrement << 2);
6910 return;
6911 }
6912
6913 static void
6914 sub_18_10 (UINT4 *in, UINT4 decrement) {
6915 UINT4 prev, carry;
6916
6917 in += 5 * WORD_INCR;
6918 prev = ( CONVERT(*in) >> 20 ) % (1U << 18 ) ;
6919 carry = ( (prev - decrement) >> (18 - 6) ) & 0x1;
6920 *in -= (decrement << 20);
6921
6922 in += 1 * WORD_INCR;
6923 *in -= (decrement >> ( 18 - 6 )) + carry;
6924
6925 return;
6926 }
6927
6928 static void
6929 sub_18_11 (UINT4 *in, UINT4 decrement) {
6930 in += 6 * WORD_INCR;
6931 *in -= (decrement << 6);
6932 return;
6933 }
6934
6935 static void
6936 sub_18_12 (UINT4 *in, UINT4 decrement) {
6937 UINT4 prev, carry;
6938
6939 in += 6 * WORD_INCR;
6940 prev = ( CONVERT(*in) >> 24 ) % (1U << 18 ) ;
6941 carry = ( (prev - decrement) >> (18 - 10) ) & 0x1;
6942 *in -= (decrement << 24);
6943
6944 in += 1 * WORD_INCR;
6945 *in -= (decrement >> ( 18 - 10 )) + carry;
6946
6947 return;
6948 }
6949
6950 static void
6951 sub_18_13 (UINT4 *in, UINT4 decrement) {
6952 in += 7 * WORD_INCR;
6953 *in -= (decrement << 10);
6954 return;
6955 }
6956
6957 static void
6958 sub_18_14 (UINT4 *in, UINT4 decrement) {
6959 UINT4 prev, carry;
6960
6961 in += 7 * WORD_INCR;
6962 prev = ( CONVERT(*in) >> 28 ) % (1U << 18 ) ;
6963 carry = ( (prev - decrement) >> (18 - 14) ) & 0x1;
6964 *in -= (decrement << 28);
6965
6966 in += 1 * WORD_INCR;
6967 *in -= (decrement >> ( 18 - 14 )) + carry;
6968
6969 return;
6970 }
6971
6972 static void
6973 sub_18_15 (UINT4 *in, UINT4 decrement) {
6974 in += 8 * WORD_INCR;
6975 *in -= (decrement << 14);
6976 return;
6977 }
6978
6979
6980 static void
6981 sub_20_00 (UINT4 *in, UINT4 decrement) {
6982 *in -= (decrement << 0);
6983 return;
6984 }
6985
6986 static void
6987 sub_20_01 (UINT4 *in, UINT4 decrement) {
6988 UINT4 prev, carry;
6989
6990 prev = ( CONVERT(*in) >> 20 ) % (1U << 20 ) ;
6991 carry = ( (prev - decrement) >> (20 - 8) ) & 0x1;
6992 *in -= (decrement << 20);
6993
6994 in += 1 * WORD_INCR;
6995 *in -= (decrement >> ( 20 - 8 )) + carry;
6996
6997 return;
6998 }
6999
7000 static void
7001 sub_20_02 (UINT4 *in, UINT4 decrement) {
7002 in += 1 * WORD_INCR;
7003 *in -= (decrement << 8);
7004 return;
7005 }
7006
7007 static void
7008 sub_20_03 (UINT4 *in, UINT4 decrement) {
7009 UINT4 prev, carry;
7010
7011 in += 1 * WORD_INCR;
7012 prev = ( CONVERT(*in) >> 28 ) % (1U << 20 ) ;
7013 carry = ( (prev - decrement) >> (20 - 16) ) & 0x1;
7014 *in -= (decrement << 28);
7015
7016 in += 1 * WORD_INCR;
7017 *in -= (decrement >> ( 20 - 16 )) + carry;
7018
7019 return;
7020 }
7021
7022 static void
7023 sub_20_04 (UINT4 *in, UINT4 decrement) {
7024 UINT4 prev, carry;
7025
7026 in += 2 * WORD_INCR;
7027 prev = ( CONVERT(*in) >> 16 ) % (1U << 20 ) ;
7028 carry = ( (prev - decrement) >> (20 - 4) ) & 0x1;
7029 *in -= (decrement << 16);
7030
7031 in += 1 * WORD_INCR;
7032 *in -= (decrement >> ( 20 - 4 )) + carry;
7033
7034 return;
7035 }
7036
7037 static void
7038 sub_20_05 (UINT4 *in, UINT4 decrement) {
7039 in += 3 * WORD_INCR;
7040 *in -= (decrement << 4);
7041 return;
7042 }
7043
7044 static void
7045 sub_20_06 (UINT4 *in, UINT4 decrement) {
7046 UINT4 prev, carry;
7047
7048 in += 3 * WORD_INCR;
7049 prev = ( CONVERT(*in) >> 24 ) % (1U << 20 ) ;
7050 carry = ( (prev - decrement) >> (20 - 12) ) & 0x1;
7051 *in -= (decrement << 24);
7052
7053 in += 1 * WORD_INCR;
7054 *in -= (decrement >> ( 20 - 12 )) + carry;
7055
7056 return;
7057 }
7058
7059 static void
7060 sub_20_07 (UINT4 *in, UINT4 decrement) {
7061 in += 4 * WORD_INCR;
7062 *in -= (decrement << 12);
7063 return;
7064 }
7065
7066 static void
7067 sub_20_08 (UINT4 *in, UINT4 decrement) {
7068 in += 5 * WORD_INCR;
7069 *in -= (decrement << 0);
7070 return;
7071 }
7072
7073 static void
7074 sub_20_09 (UINT4 *in, UINT4 decrement) {
7075 UINT4 prev, carry;
7076
7077 in += 5 * WORD_INCR;
7078 prev = ( CONVERT(*in) >> 20 ) % (1U << 20 ) ;
7079 carry = ( (prev - decrement) >> (20 - 8) ) & 0x1;
7080 *in -= (decrement << 20);
7081
7082 in += 1 * WORD_INCR;
7083 *in -= (decrement >> ( 20 - 8 )) + carry;
7084
7085 return;
7086 }
7087
7088 static void
7089 sub_20_10 (UINT4 *in, UINT4 decrement) {
7090 in += 6 * WORD_INCR;
7091 *in -= (decrement << 8);
7092 return;
7093 }
7094
7095 static void
7096 sub_20_11 (UINT4 *in, UINT4 decrement) {
7097 UINT4 prev, carry;
7098
7099 in += 6 * WORD_INCR;
7100 prev = ( CONVERT(*in) >> 28 ) % (1U << 20 ) ;
7101 carry = ( (prev - decrement) >> (20 - 16) ) & 0x1;
7102 *in -= (decrement << 28);
7103
7104 in += 1 * WORD_INCR;
7105 *in -= (decrement >> ( 20 - 16 )) + carry;
7106
7107 return;
7108 }
7109
7110 static void
7111 sub_20_12 (UINT4 *in, UINT4 decrement) {
7112 UINT4 prev, carry;
7113
7114 in += 7 * WORD_INCR;
7115 prev = ( CONVERT(*in) >> 16 ) % (1U << 20 ) ;
7116 carry = ( (prev - decrement) >> (20 - 4) ) & 0x1;
7117 *in -= (decrement << 16);
7118
7119 in += 1 * WORD_INCR;
7120 *in -= (decrement >> ( 20 - 4 )) + carry;
7121
7122 return;
7123 }
7124
7125 static void
7126 sub_20_13 (UINT4 *in, UINT4 decrement) {
7127 in += 8 * WORD_INCR;
7128 *in -= (decrement << 4);
7129 return;
7130 }
7131
7132 static void
7133 sub_20_14 (UINT4 *in, UINT4 decrement) {
7134 UINT4 prev, carry;
7135
7136 in += 8 * WORD_INCR;
7137 prev = ( CONVERT(*in) >> 24 ) % (1U << 20 ) ;
7138 carry = ( (prev - decrement) >> (20 - 12) ) & 0x1;
7139 *in -= (decrement << 24);
7140
7141 in += 1 * WORD_INCR;
7142 *in -= (decrement >> ( 20 - 12 )) + carry;
7143
7144 return;
7145 }
7146
7147 static void
7148 sub_20_15 (UINT4 *in, UINT4 decrement) {
7149 in += 9 * WORD_INCR;
7150 *in -= (decrement << 12);
7151 return;
7152 }
7153
7154
7155 static void
7156 sub_22_00 (UINT4 *in, UINT4 decrement) {
7157 *in -= (decrement << 0);
7158 return;
7159 }
7160
7161 static void
7162 sub_22_01 (UINT4 *in, UINT4 decrement) {
7163 UINT4 prev, carry;
7164
7165 prev = ( CONVERT(*in) >> 22 ) % (1U << 22 ) ;
7166 carry = ( (prev - decrement) >> (22 - 12) ) & 0x1;
7167 *in -= (decrement << 22);
7168
7169 in += 1 * WORD_INCR;
7170 *in -= (decrement >> ( 22 - 12 )) + carry;
7171
7172 return;
7173 }
7174
7175 static void
7176 sub_22_02 (UINT4 *in, UINT4 decrement) {
7177 UINT4 prev, carry;
7178
7179 in += 1 * WORD_INCR;
7180 prev = ( CONVERT(*in) >> 12 ) % (1U << 22 ) ;
7181 carry = ( (prev - decrement) >> (22 - 2) ) & 0x1;
7182 *in -= (decrement << 12);
7183
7184 in += 1 * WORD_INCR;
7185 *in -= (decrement >> ( 22 - 2 )) + carry;
7186
7187 return;
7188 }
7189
7190 static void
7191 sub_22_03 (UINT4 *in, UINT4 decrement) {
7192 in += 2 * WORD_INCR;
7193 *in -= (decrement << 2);
7194 return;
7195 }
7196
7197 static void
7198 sub_22_04 (UINT4 *in, UINT4 decrement) {
7199 UINT4 prev, carry;
7200
7201 in += 2 * WORD_INCR;
7202 prev = ( CONVERT(*in) >> 24 ) % (1U << 22 ) ;
7203 carry = ( (prev - decrement) >> (22 - 14) ) & 0x1;
7204 *in -= (decrement << 24);
7205
7206 in += 1 * WORD_INCR;
7207 *in -= (decrement >> ( 22 - 14 )) + carry;
7208
7209 return;
7210 }
7211
7212 static void
7213 sub_22_05 (UINT4 *in, UINT4 decrement) {
7214 UINT4 prev, carry;
7215
7216 in += 3 * WORD_INCR;
7217 prev = ( CONVERT(*in) >> 14 ) % (1U << 22 ) ;
7218 carry = ( (prev - decrement) >> (22 - 4) ) & 0x1;
7219 *in -= (decrement << 14);
7220
7221 in += 1 * WORD_INCR;
7222 *in -= (decrement >> ( 22 - 4 )) + carry;
7223
7224 return;
7225 }
7226
7227 static void
7228 sub_22_06 (UINT4 *in, UINT4 decrement) {
7229 in += 4 * WORD_INCR;
7230 *in -= (decrement << 4);
7231 return;
7232 }
7233
7234 static void
7235 sub_22_07 (UINT4 *in, UINT4 decrement) {
7236 UINT4 prev, carry;
7237
7238 in += 4 * WORD_INCR;
7239 prev = ( CONVERT(*in) >> 26 ) % (1U << 22 ) ;
7240 carry = ( (prev - decrement) >> (22 - 16) ) & 0x1;
7241 *in -= (decrement << 26);
7242
7243 in += 1 * WORD_INCR;
7244 *in -= (decrement >> ( 22 - 16 )) + carry;
7245
7246 return;
7247 }
7248
7249 static void
7250 sub_22_08 (UINT4 *in, UINT4 decrement) {
7251 UINT4 prev, carry;
7252
7253 in += 5 * WORD_INCR;
7254 prev = ( CONVERT(*in) >> 16 ) % (1U << 22 ) ;
7255 carry = ( (prev - decrement) >> (22 - 6) ) & 0x1;
7256 *in -= (decrement << 16);
7257
7258 in += 1 * WORD_INCR;
7259 *in -= (decrement >> ( 22 - 6 )) + carry;
7260
7261 return;
7262 }
7263
7264 static void
7265 sub_22_09 (UINT4 *in, UINT4 decrement) {
7266 in += 6 * WORD_INCR;
7267 *in -= (decrement << 6);
7268 return;
7269 }
7270
7271 static void
7272 sub_22_10 (UINT4 *in, UINT4 decrement) {
7273 UINT4 prev, carry;
7274
7275 in += 6 * WORD_INCR;
7276 prev = ( CONVERT(*in) >> 28 ) % (1U << 22 ) ;
7277 carry = ( (prev - decrement) >> (22 - 18) ) & 0x1;
7278 *in -= (decrement << 28);
7279
7280 in += 1 * WORD_INCR;
7281 *in -= (decrement >> ( 22 - 18 )) + carry;
7282
7283 return;
7284 }
7285
7286 static void
7287 sub_22_11 (UINT4 *in, UINT4 decrement) {
7288 UINT4 prev, carry;
7289
7290 in += 7 * WORD_INCR;
7291 prev = ( CONVERT(*in) >> 18 ) % (1U << 22 ) ;
7292 carry = ( (prev - decrement) >> (22 - 8) ) & 0x1;
7293 *in -= (decrement << 18);
7294
7295 in += 1 * WORD_INCR;
7296 *in -= (decrement >> ( 22 - 8 )) + carry;
7297
7298 return;
7299 }
7300
7301 static void
7302 sub_22_12 (UINT4 *in, UINT4 decrement) {
7303 in += 8 * WORD_INCR;
7304 *in -= (decrement << 8);
7305 return;
7306 }
7307
7308 static void
7309 sub_22_13 (UINT4 *in, UINT4 decrement) {
7310 UINT4 prev, carry;
7311
7312 in += 8 * WORD_INCR;
7313 prev = ( CONVERT(*in) >> 30 ) % (1U << 22 ) ;
7314 carry = ( (prev - decrement) >> (22 - 20) ) & 0x1;
7315 *in -= (decrement << 30);
7316
7317 in += 1 * WORD_INCR;
7318 *in -= (decrement >> ( 22 - 20 )) + carry;
7319
7320 return;
7321 }
7322
7323 static void
7324 sub_22_14 (UINT4 *in, UINT4 decrement) {
7325 UINT4 prev, carry;
7326
7327 in += 9 * WORD_INCR;
7328 prev = ( CONVERT(*in) >> 20 ) % (1U << 22 ) ;
7329 carry = ( (prev - decrement) >> (22 - 10) ) & 0x1;
7330 *in -= (decrement << 20);
7331
7332 in += 1 * WORD_INCR;
7333 *in -= (decrement >> ( 22 - 10 )) + carry;
7334
7335 return;
7336 }
7337
7338 static void
7339 sub_22_15 (UINT4 *in, UINT4 decrement) {
7340 in += 10 * WORD_INCR;
7341 *in -= (decrement << 10);
7342 return;
7343 }
7344
7345
7346
7347 static void
7348 sub_24_00 (UINT4 *in, UINT4 decrement) {
7349 *in -= (decrement << 0);
7350 return;
7351 }
7352
7353 static void
7354 sub_24_01 (UINT4 *in, UINT4 decrement) {
7355 UINT4 prev, carry;
7356
7357 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
7358 carry = ( (prev - decrement) >> (24 - 16) ) & 0x1;
7359 *in -= (decrement << 24);
7360
7361 in += 1 * WORD_INCR;
7362 *in -= (decrement >> ( 24 - 16 )) + carry;
7363
7364 return;
7365 }
7366
7367 static void
7368 sub_24_02 (UINT4 *in, UINT4 decrement) {
7369 UINT4 prev, carry;
7370
7371 in += 1 * WORD_INCR;
7372 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
7373 carry = ( (prev - decrement) >> (24 - 8) ) & 0x1;
7374 *in -= (decrement << 16);
7375
7376 in += 1 * WORD_INCR;
7377 *in -= (decrement >> ( 24 - 8 )) + carry;
7378
7379 return;
7380 }
7381
7382 static void
7383 sub_24_03 (UINT4 *in, UINT4 decrement) {
7384 in += 2 * WORD_INCR;
7385 *in -= (decrement << 8);
7386 return;
7387 }
7388
7389 static void
7390 sub_24_04 (UINT4 *in, UINT4 decrement) {
7391 in += 3 * WORD_INCR;
7392 *in -= (decrement << 0);
7393 return;
7394 }
7395
7396 static void
7397 sub_24_05 (UINT4 *in, UINT4 decrement) {
7398 UINT4 prev, carry;
7399
7400 in += 3 * WORD_INCR;
7401 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
7402 carry = ( (prev - decrement) >> (24 - 16) ) & 0x1;
7403 *in -= (decrement << 24);
7404
7405 in += 1 * WORD_INCR;
7406 *in -= (decrement >> ( 24 - 16 )) + carry;
7407
7408 return;
7409 }
7410
7411 static void
7412 sub_24_06 (UINT4 *in, UINT4 decrement) {
7413 UINT4 prev, carry;
7414
7415 in += 4 * WORD_INCR;
7416 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
7417 carry = ( (prev - decrement) >> (24 - 8) ) & 0x1;
7418 *in -= (decrement << 16);
7419
7420 in += 1 * WORD_INCR;
7421 *in -= (decrement >> ( 24 - 8 )) + carry;
7422
7423 return;
7424 }
7425
7426 static void
7427 sub_24_07 (UINT4 *in, UINT4 decrement) {
7428 in += 5 * WORD_INCR;
7429 *in -= (decrement << 8);
7430 return;
7431 }
7432
7433 static void
7434 sub_24_08 (UINT4 *in, UINT4 decrement) {
7435 in += 6 * WORD_INCR;
7436 *in -= (decrement << 0);
7437 return;
7438 }
7439
7440 static void
7441 sub_24_09 (UINT4 *in, UINT4 decrement) {
7442 UINT4 prev, carry;
7443
7444 in += 6 * WORD_INCR;
7445 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
7446 carry = ( (prev - decrement) >> (24 - 16) ) & 0x1;
7447 *in -= (decrement << 24);
7448
7449 in += 1 * WORD_INCR;
7450 *in -= (decrement >> ( 24 - 16 )) + carry;
7451
7452 return;
7453 }
7454
7455 static void
7456 sub_24_10 (UINT4 *in, UINT4 decrement) {
7457 UINT4 prev, carry;
7458
7459 in += 7 * WORD_INCR;
7460 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
7461 carry = ( (prev - decrement) >> (24 - 8) ) & 0x1;
7462 *in -= (decrement << 16);
7463
7464 in += 1 * WORD_INCR;
7465 *in -= (decrement >> ( 24 - 8 )) + carry;
7466
7467 return;
7468 }
7469
7470 static void
7471 sub_24_11 (UINT4 *in, UINT4 decrement) {
7472 in += 8 * WORD_INCR;
7473 *in -= (decrement << 8);
7474 return;
7475 }
7476
7477 static void
7478 sub_24_12 (UINT4 *in, UINT4 decrement) {
7479 in += 9 * WORD_INCR;
7480 *in -= (decrement << 0);
7481 return;
7482 }
7483
7484 static void
7485 sub_24_13 (UINT4 *in, UINT4 decrement) {
7486 UINT4 prev, carry;
7487
7488 in += 9 * WORD_INCR;
7489 prev = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
7490 carry = ( (prev - decrement) >> (24 - 16) ) & 0x1;
7491 *in -= (decrement << 24);
7492
7493 in += 1 * WORD_INCR;
7494 *in -= (decrement >> ( 24 - 16 )) + carry;
7495
7496 return;
7497 }
7498
7499 static void
7500 sub_24_14 (UINT4 *in, UINT4 decrement) {
7501 UINT4 prev, carry;
7502
7503 in += 10 * WORD_INCR;
7504 prev = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
7505 carry = ( (prev - decrement) >> (24 - 8) ) & 0x1;
7506 *in -= (decrement << 16);
7507
7508 in += 1 * WORD_INCR;
7509 *in -= (decrement >> ( 24 - 8 )) + carry;
7510
7511 return;
7512 }
7513
7514 static void
7515 sub_24_15 (UINT4 *in, UINT4 decrement) {
7516 in += 11 * WORD_INCR;
7517 *in -= (decrement << 8);
7518 return;
7519 }
7520
7521
7522
7523 static void
7524 sub_26_00 (UINT4 *in, UINT4 decrement) {
7525 *in -= (decrement << 0);
7526 return;
7527 }
7528
7529 static void
7530 sub_26_01 (UINT4 *in, UINT4 decrement) {
7531 UINT4 prev, carry;
7532
7533 prev = ( CONVERT(*in) >> 26 ) % (1U << 26 ) ;
7534 carry = ( (prev - decrement) >> (26 - 20) ) & 0x1;
7535 *in -= (decrement << 26);
7536
7537 in += 1 * WORD_INCR;
7538 *in -= (decrement >> ( 26 - 20 )) + carry;
7539
7540 return;
7541 }
7542
7543 static void
7544 sub_26_02 (UINT4 *in, UINT4 decrement) {
7545 UINT4 prev, carry;
7546
7547 in += 1 * WORD_INCR;
7548 prev = ( CONVERT(*in) >> 20 ) % (1U << 26 ) ;
7549 carry = ( (prev - decrement) >> (26 - 14) ) & 0x1;
7550 *in -= (decrement << 20);
7551
7552 in += 1 * WORD_INCR;
7553 *in -= (decrement >> ( 26 - 14 )) + carry;
7554
7555 return;
7556 }
7557
7558 static void
7559 sub_26_03 (UINT4 *in, UINT4 decrement) {
7560 UINT4 prev, carry;
7561
7562 in += 2 * WORD_INCR;
7563 prev = ( CONVERT(*in) >> 14 ) % (1U << 26 ) ;
7564 carry = ( (prev - decrement) >> (26 - 8) ) & 0x1;
7565 *in -= (decrement << 14);
7566
7567 in += 1 * WORD_INCR;
7568 *in -= (decrement >> ( 26 - 8 )) + carry;
7569
7570 return;
7571 }
7572
7573 static void
7574 sub_26_04 (UINT4 *in, UINT4 decrement) {
7575 UINT4 prev, carry;
7576
7577 in += 3 * WORD_INCR;
7578 prev = ( CONVERT(*in) >> 8 ) % (1U << 26 ) ;
7579 carry = ( (prev - decrement) >> (26 - 2) ) & 0x1;
7580 *in -= (decrement << 8);
7581
7582 in += 1 * WORD_INCR;
7583 *in -= (decrement >> ( 26 - 2 )) + carry;
7584
7585 return;
7586 }
7587
7588 static void
7589 sub_26_05 (UINT4 *in, UINT4 decrement) {
7590 in += 4 * WORD_INCR;
7591 *in -= (decrement << 2);
7592 return;
7593 }
7594
7595 static void
7596 sub_26_06 (UINT4 *in, UINT4 decrement) {
7597 UINT4 prev, carry;
7598
7599 in += 4 * WORD_INCR;
7600 prev = ( CONVERT(*in) >> 28 ) % (1U << 26 ) ;
7601 carry = ( (prev - decrement) >> (26 - 22) ) & 0x1;
7602 *in -= (decrement << 28);
7603
7604 in += 1 * WORD_INCR;
7605 *in -= (decrement >> ( 26 - 22 )) + carry;
7606
7607 return;
7608 }
7609
7610 static void
7611 sub_26_07 (UINT4 *in, UINT4 decrement) {
7612 UINT4 prev, carry;
7613
7614 in += 5 * WORD_INCR;
7615 prev = ( CONVERT(*in) >> 22 ) % (1U << 26 ) ;
7616 carry = ( (prev - decrement) >> (26 - 16) ) & 0x1;
7617 *in -= (decrement << 22);
7618
7619 in += 1 * WORD_INCR;
7620 *in -= (decrement >> ( 26 - 16 )) + carry;
7621
7622 return;
7623 }
7624
7625 static void
7626 sub_26_08 (UINT4 *in, UINT4 decrement) {
7627 UINT4 prev, carry;
7628
7629 in += 6 * WORD_INCR;
7630 prev = ( CONVERT(*in) >> 16 ) % (1U << 26 ) ;
7631 carry = ( (prev - decrement) >> (26 - 10) ) & 0x1;
7632 *in -= (decrement << 16);
7633
7634 in += 1 * WORD_INCR;
7635 *in -= (decrement >> ( 26 - 10 )) + carry;
7636
7637 return;
7638 }
7639
7640 static void
7641 sub_26_09 (UINT4 *in, UINT4 decrement) {
7642 UINT4 prev, carry;
7643
7644 in += 7 * WORD_INCR;
7645 prev = ( CONVERT(*in) >> 10 ) % (1U << 26 ) ;
7646 carry = ( (prev - decrement) >> (26 - 4) ) & 0x1;
7647 *in -= (decrement << 10);
7648
7649 in += 1 * WORD_INCR;
7650 *in -= (decrement >> ( 26 - 4 )) + carry;
7651
7652 return;
7653 }
7654
7655 static void
7656 sub_26_10 (UINT4 *in, UINT4 decrement) {
7657 in += 8 * WORD_INCR;
7658 *in -= (decrement << 4);
7659 return;
7660 }
7661
7662 static void
7663 sub_26_11 (UINT4 *in, UINT4 decrement) {
7664 UINT4 prev, carry;
7665
7666 in += 8 * WORD_INCR;
7667 prev = ( CONVERT(*in) >> 30 ) % (1U << 26 ) ;
7668 carry = ( (prev - decrement) >> (26 - 24) ) & 0x1;
7669 *in -= (decrement << 30);
7670
7671 in += 1 * WORD_INCR;
7672 *in -= (decrement >> ( 26 - 24 )) + carry;
7673
7674 return;
7675 }
7676
7677 static void
7678 sub_26_12 (UINT4 *in, UINT4 decrement) {
7679 UINT4 prev, carry;
7680
7681 in += 9 * WORD_INCR;
7682 prev = ( CONVERT(*in) >> 24 ) % (1U << 26 ) ;
7683 carry = ( (prev - decrement) >> (26 - 18) ) & 0x1;
7684 *in -= (decrement << 24);
7685
7686 in += 1 * WORD_INCR;
7687 *in -= (decrement >> ( 26 - 18 )) + carry;
7688
7689 return;
7690 }
7691
7692 static void
7693 sub_26_13 (UINT4 *in, UINT4 decrement) {
7694 UINT4 prev, carry;
7695
7696 in += 10 * WORD_INCR;
7697 prev = ( CONVERT(*in) >> 18 ) % (1U << 26 ) ;
7698 carry = ( (prev - decrement) >> (26 - 12) ) & 0x1;
7699 *in -= (decrement << 18);
7700
7701 in += 1 * WORD_INCR;
7702 *in -= (decrement >> ( 26 - 12 )) + carry;
7703
7704 return;
7705 }
7706
7707 static void
7708 sub_26_14 (UINT4 *in, UINT4 decrement) {
7709 UINT4 prev, carry;
7710
7711 in += 11 * WORD_INCR;
7712 prev = ( CONVERT(*in) >> 12 ) % (1U << 26 ) ;
7713 carry = ( (prev - decrement) >> (26 - 6) ) & 0x1;
7714 *in -= (decrement << 12);
7715
7716 in += 1 * WORD_INCR;
7717 *in -= (decrement >> ( 26 - 6 )) + carry;
7718
7719 return;
7720 }
7721
7722 static void
7723 sub_26_15 (UINT4 *in, UINT4 decrement) {
7724 in += 12 * WORD_INCR;
7725 *in -= (decrement << 6);
7726 return;
7727 }
7728
7729
7730 static void
7731 sub_28_00 (UINT4 *in, UINT4 decrement) {
7732 *in -= (decrement << 0);
7733 return;
7734 }
7735
7736 static void
7737 sub_28_01 (UINT4 *in, UINT4 decrement) {
7738 UINT4 prev, carry;
7739
7740 prev = ( CONVERT(*in) >> 28 ) % (1U << 28 ) ;
7741 carry = ( (prev - decrement) >> (28 - 24) ) & 0x1;
7742 *in -= (decrement << 28);
7743
7744 in += 1 * WORD_INCR;
7745 *in -= (decrement >> ( 28 - 24 )) + carry;
7746
7747 return;
7748 }
7749
7750 static void
7751 sub_28_02 (UINT4 *in, UINT4 decrement) {
7752 UINT4 prev, carry;
7753
7754 in += 1 * WORD_INCR;
7755 prev = ( CONVERT(*in) >> 24 ) % (1U << 28 ) ;
7756 carry = ( (prev - decrement) >> (28 - 20) ) & 0x1;
7757 *in -= (decrement << 24);
7758
7759 in += 1 * WORD_INCR;
7760 *in -= (decrement >> ( 28 - 20 )) + carry;
7761
7762 return;
7763 }
7764
7765 static void
7766 sub_28_03 (UINT4 *in, UINT4 decrement) {
7767 UINT4 prev, carry;
7768
7769 in += 2 * WORD_INCR;
7770 prev = ( CONVERT(*in) >> 20 ) % (1U << 28 ) ;
7771 carry = ( (prev - decrement) >> (28 - 16) ) & 0x1;
7772 *in -= (decrement << 20);
7773
7774 in += 1 * WORD_INCR;
7775 *in -= (decrement >> ( 28 - 16 )) + carry;
7776
7777 return;
7778 }
7779
7780 static void
7781 sub_28_04 (UINT4 *in, UINT4 decrement) {
7782 UINT4 prev, carry;
7783
7784 in += 3 * WORD_INCR;
7785 prev = ( CONVERT(*in) >> 16 ) % (1U << 28 ) ;
7786 carry = ( (prev - decrement) >> (28 - 12) ) & 0x1;
7787 *in -= (decrement << 16);
7788
7789 in += 1 * WORD_INCR;
7790 *in -= (decrement >> ( 28 - 12 )) + carry;
7791
7792 return;
7793 }
7794
7795 static void
7796 sub_28_05 (UINT4 *in, UINT4 decrement) {
7797 UINT4 prev, carry;
7798
7799 in += 4 * WORD_INCR;
7800 prev = ( CONVERT(*in) >> 12 ) % (1U << 28 ) ;
7801 carry = ( (prev - decrement) >> (28 - 8) ) & 0x1;
7802 *in -= (decrement << 12);
7803
7804 in += 1 * WORD_INCR;
7805 *in -= (decrement >> ( 28 - 8 )) + carry;
7806
7807 return;
7808 }
7809
7810 static void
7811 sub_28_06 (UINT4 *in, UINT4 decrement) {
7812 UINT4 prev, carry;
7813
7814 in += 5 * WORD_INCR;
7815 prev = ( CONVERT(*in) >> 8 ) % (1U << 28 ) ;
7816 carry = ( (prev - decrement) >> (28 - 4) ) & 0x1;
7817 *in -= (decrement << 8);
7818
7819 in += 1 * WORD_INCR;
7820 *in -= (decrement >> ( 28 - 4 )) + carry;
7821
7822 return;
7823 }
7824
7825 static void
7826 sub_28_07 (UINT4 *in, UINT4 decrement) {
7827 in += 6 * WORD_INCR;
7828 *in -= (decrement << 4);
7829 return;
7830 }
7831
7832 static void
7833 sub_28_08 (UINT4 *in, UINT4 decrement) {
7834 in += 7 * WORD_INCR;
7835 *in -= (decrement << 0);
7836 return;
7837 }
7838
7839 static void
7840 sub_28_09 (UINT4 *in, UINT4 decrement) {
7841 UINT4 prev, carry;
7842
7843 in += 7 * WORD_INCR;
7844 prev = ( CONVERT(*in) >> 28 ) % (1U << 28 ) ;
7845 carry = ( (prev - decrement) >> (28 - 24) ) & 0x1;
7846 *in -= (decrement << 28);
7847
7848 in += 1 * WORD_INCR;
7849 *in -= (decrement >> ( 28 - 24 )) + carry;
7850
7851 return;
7852 }
7853
7854 static void
7855 sub_28_10 (UINT4 *in, UINT4 decrement) {
7856 UINT4 prev, carry;
7857
7858 in += 8 * WORD_INCR;
7859 prev = ( CONVERT(*in) >> 24 ) % (1U << 28 ) ;
7860 carry = ( (prev - decrement) >> (28 - 20) ) & 0x1;
7861 *in -= (decrement << 24);
7862
7863 in += 1 * WORD_INCR;
7864 *in -= (decrement >> ( 28 - 20 )) + carry;
7865
7866 return;
7867 }
7868
7869 static void
7870 sub_28_11 (UINT4 *in, UINT4 decrement) {
7871 UINT4 prev, carry;
7872
7873 in += 9 * WORD_INCR;
7874 prev = ( CONVERT(*in) >> 20 ) % (1U << 28 ) ;
7875 carry = ( (prev - decrement) >> (28 - 16) ) & 0x1;
7876 *in -= (decrement << 20);
7877
7878 in += 1 * WORD_INCR;
7879 *in -= (decrement >> ( 28 - 16 )) + carry;
7880
7881 return;
7882 }
7883
7884 static void
7885 sub_28_12 (UINT4 *in, UINT4 decrement) {
7886 UINT4 prev, carry;
7887
7888 in += 10 * WORD_INCR;
7889 prev = ( CONVERT(*in) >> 16 ) % (1U << 28 ) ;
7890 carry = ( (prev - decrement) >> (28 - 12) ) & 0x1;
7891 *in -= (decrement << 16);
7892
7893 in += 1 * WORD_INCR;
7894 *in -= (decrement >> ( 28 - 12 )) + carry;
7895
7896 return;
7897 }
7898
7899 static void
7900 sub_28_13 (UINT4 *in, UINT4 decrement) {
7901 UINT4 prev, carry;
7902
7903 in += 11 * WORD_INCR;
7904 prev = ( CONVERT(*in) >> 12 ) % (1U << 28 ) ;
7905 carry = ( (prev - decrement) >> (28 - 8) ) & 0x1;
7906 *in -= (decrement << 12);
7907
7908 in += 1 * WORD_INCR;
7909 *in -= (decrement >> ( 28 - 8 )) + carry;
7910
7911 return;
7912 }
7913
7914 static void
7915 sub_28_14 (UINT4 *in, UINT4 decrement) {
7916 UINT4 prev, carry;
7917
7918 in += 12 * WORD_INCR;
7919 prev = ( CONVERT(*in) >> 8 ) % (1U << 28 ) ;
7920 carry = ( (prev - decrement) >> (28 - 4) ) & 0x1;
7921 *in -= (decrement << 8);
7922
7923 in += 1 * WORD_INCR;
7924 *in -= (decrement >> ( 28 - 4 )) + carry;
7925
7926 return;
7927 }
7928
7929 static void
7930 sub_28_15 (UINT4 *in, UINT4 decrement) {
7931 in += 13 * WORD_INCR;
7932 *in -= (decrement << 4);
7933 return;
7934 }
7935
7936
7937 static void
7938 sub_30_00 (UINT4 *in, UINT4 decrement) {
7939 *in -= (decrement << 0);
7940 return;
7941 }
7942
7943 static void
7944 sub_30_01 (UINT4 *in, UINT4 decrement) {
7945 UINT4 prev, carry;
7946
7947 prev = ( CONVERT(*in) >> 30 ) % (1U << 30 ) ;
7948 carry = ( (prev - decrement) >> (30 - 28) ) & 0x1;
7949 *in -= (decrement << 30);
7950
7951 in += 1 * WORD_INCR;
7952 *in -= (decrement >> ( 30 - 28 )) + carry;
7953
7954 return;
7955 }
7956
7957 static void
7958 sub_30_02 (UINT4 *in, UINT4 decrement) {
7959 UINT4 prev, carry;
7960
7961 in += 1 * WORD_INCR;
7962 prev = ( CONVERT(*in) >> 28 ) % (1U << 30 ) ;
7963 carry = ( (prev - decrement) >> (30 - 26) ) & 0x1;
7964 *in -= (decrement << 28);
7965
7966 in += 1 * WORD_INCR;
7967 *in -= (decrement >> ( 30 - 26 )) + carry;
7968
7969 return;
7970 }
7971
7972 static void
7973 sub_30_03 (UINT4 *in, UINT4 decrement) {
7974 UINT4 prev, carry;
7975
7976 in += 2 * WORD_INCR;
7977 prev = ( CONVERT(*in) >> 26 ) % (1U << 30 ) ;
7978 carry = ( (prev - decrement) >> (30 - 24) ) & 0x1;
7979 *in -= (decrement << 26);
7980
7981 in += 1 * WORD_INCR;
7982 *in -= (decrement >> ( 30 - 24 )) + carry;
7983
7984 return;
7985 }
7986
7987 static void
7988 sub_30_04 (UINT4 *in, UINT4 decrement) {
7989 UINT4 prev, carry;
7990
7991 in += 3 * WORD_INCR;
7992 prev = ( CONVERT(*in) >> 24 ) % (1U << 30 ) ;
7993 carry = ( (prev - decrement) >> (30 - 22) ) & 0x1;
7994 *in -= (decrement << 24);
7995
7996 in += 1 * WORD_INCR;
7997 *in -= (decrement >> ( 30 - 22 )) + carry;
7998
7999 return;
8000 }
8001
8002 static void
8003 sub_30_05 (UINT4 *in, UINT4 decrement) {
8004 UINT4 prev, carry;
8005
8006 in += 4 * WORD_INCR;
8007 prev = ( CONVERT(*in) >> 22 ) % (1U << 30 ) ;
8008 carry = ( (prev - decrement) >> (30 - 20) ) & 0x1;
8009 *in -= (decrement << 22);
8010
8011 in += 1 * WORD_INCR;
8012 *in -= (decrement >> ( 30 - 20 )) + carry;
8013
8014 return;
8015 }
8016
8017 static void
8018 sub_30_06 (UINT4 *in, UINT4 decrement) {
8019 UINT4 prev, carry;
8020
8021 in += 5 * WORD_INCR;
8022 prev = ( CONVERT(*in) >> 20 ) % (1U << 30 ) ;
8023 carry = ( (prev - decrement) >> (30 - 18)) & 0x1;
8024 *in -= (decrement << 20);
8025
8026 in += 1 * WORD_INCR;
8027 *in -= (decrement >> ( 30 - 18 )) + carry;
8028
8029 return;
8030 }
8031
8032 static void
8033 sub_30_07 (UINT4 *in, UINT4 decrement) {
8034 UINT4 prev, carry;
8035
8036 in += 6 * WORD_INCR;
8037 prev = ( CONVERT(*in) >> 18 ) % (1U << 30 ) ;
8038 carry = ( (prev - decrement) >> (30 - 16) ) & 0x1;
8039 *in -= (decrement << 18);
8040
8041 in += 1 * WORD_INCR;
8042 *in -= (decrement >> ( 30 - 16 )) + carry;
8043
8044 return;
8045 }
8046
8047 static void
8048 sub_30_08 (UINT4 *in, UINT4 decrement) {
8049 UINT4 prev, carry;
8050
8051 in += 7 * WORD_INCR;
8052 prev = ( CONVERT(*in) >> 16 ) % (1U << 30 ) ;
8053 carry = ( (prev - decrement) >> (30 - 14) ) & 0x1;
8054 *in -= (decrement << 16);
8055
8056 in += 1 * WORD_INCR;
8057 *in -= (decrement >> ( 30 - 14 )) + carry;
8058
8059 return;
8060 }
8061
8062 static void
8063 sub_30_09 (UINT4 *in, UINT4 decrement) {
8064 UINT4 prev, carry;
8065
8066 in += 8 * WORD_INCR;
8067 prev = ( CONVERT(*in) >> 14 ) % (1U << 30 ) ;
8068 carry = ( (prev - decrement) >> (30 - 12) ) & 0x1;
8069 *in -= (decrement << 14);
8070
8071 in += 1 * WORD_INCR;
8072 *in -= (decrement >> ( 30 - 12 )) + carry;
8073
8074 return;
8075 }
8076
8077 static void
8078 sub_30_10 (UINT4 *in, UINT4 decrement) {
8079 UINT4 prev, carry;
8080
8081 in += 9 * WORD_INCR;
8082 prev = ( CONVERT(*in) >> 12 ) % (1U << 30 ) ;
8083 carry = ( (prev - decrement) >> (30 - 10) ) & 0x1;
8084 *in -= (decrement << 12);
8085
8086 in += 1 * WORD_INCR;
8087 *in -= (decrement >> ( 30 - 10 )) + carry;
8088
8089 return;
8090 }
8091
8092 static void
8093 sub_30_11 (UINT4 *in, UINT4 decrement) {
8094 UINT4 prev, carry;
8095
8096 in += 10 * WORD_INCR;
8097 prev = ( CONVERT(*in) >> 10 ) % (1U << 30 ) ;
8098 carry = ( (prev - decrement) >> (30 - 8) ) & 0x1;
8099 *in -= (decrement << 10);
8100
8101 in += 1 * WORD_INCR;
8102 *in -= (decrement >> ( 30 - 8 )) + carry;
8103
8104 return;
8105 }
8106
8107 static void
8108 sub_30_12 (UINT4 *in, UINT4 decrement) {
8109 UINT4 prev, carry;
8110
8111 in += 11 * WORD_INCR;
8112 prev = ( CONVERT(*in) >> 8 ) % (1U << 30 ) ;
8113 carry = ( (prev - decrement) >> (30 - 6) ) & 0x1;
8114 *in -= (decrement << 8);
8115
8116 in += 1 * WORD_INCR;
8117 *in -= (decrement >> ( 30 - 6 )) + carry;
8118
8119 return;
8120 }
8121
8122 static void
8123 sub_30_13 (UINT4 *in, UINT4 decrement) {
8124 UINT4 prev, carry;
8125
8126 in += 12 * WORD_INCR;
8127 prev = ( CONVERT(*in) >> 6 ) % (1U << 30 ) ;
8128 carry = ( (prev - decrement) >> (30 - 4) ) & 0x1;
8129 *in -= (decrement << 6);
8130
8131 in += 1 * WORD_INCR;
8132 *in -= (decrement >> ( 30 - 4 )) + carry;
8133
8134 return;
8135 }
8136
8137 static void
8138 sub_30_14 (UINT4 *in, UINT4 decrement) {
8139 UINT4 prev, carry;
8140
8141 in += 13 * WORD_INCR;
8142 prev = ( CONVERT(*in) >> 4 ) % (1U << 30 ) ;
8143 carry = ( (prev - decrement) >> (30 - 2) ) & 0x1;
8144 *in -= (decrement << 4);
8145
8146 in += 1 * WORD_INCR;
8147 *in -= (decrement >> ( 30 - 2 )) + carry;
8148
8149 return;
8150 }
8151
8152 static void
8153 sub_30_15 (UINT4 *in, UINT4 decrement) {
8154 in += 14 * WORD_INCR;
8155 *in -= (decrement << 2);
8156 return;
8157 }
8158
8159
8160 static void
8161 sub_32_00 (UINT4 *in, UINT4 decrement) {
8162 *in -= decrement;
8163 return;
8164 }
8165
8166 static void
8167 sub_32_01 (UINT4 *in, UINT4 decrement) {
8168 in += 1 * WORD_INCR;
8169 *in -= decrement;
8170 return;
8171 }
8172
8173 static void
8174 sub_32_02 (UINT4 *in, UINT4 decrement) {
8175 in += 2 * WORD_INCR;
8176 *in -= decrement;
8177 return;
8178 }
8179
8180 static void
8181 sub_32_03 (UINT4 *in, UINT4 decrement) {
8182 in += 3 * WORD_INCR;
8183 *in -= decrement;
8184 return;
8185 }
8186
8187 static void
8188 sub_32_04 (UINT4 *in, UINT4 decrement) {
8189 in += 4 * WORD_INCR;
8190 *in -= decrement;
8191 return;
8192 }
8193
8194 static void
8195 sub_32_05 (UINT4 *in, UINT4 decrement) {
8196 in += 5 * WORD_INCR;
8197 *in -= decrement;
8198 return;
8199 }
8200
8201 static void
8202 sub_32_06 (UINT4 *in, UINT4 decrement) {
8203 in += 6 * WORD_INCR;
8204 *in -= decrement;
8205 return;
8206 }
8207
8208 static void
8209 sub_32_07 (UINT4 *in, UINT4 decrement) {
8210 in += 7 * WORD_INCR;
8211 *in -= decrement;
8212 return;
8213 }
8214
8215 static void
8216 sub_32_08 (UINT4 *in, UINT4 decrement) {
8217 in += 8 * WORD_INCR;
8218 *in -= decrement;
8219 return;
8220 }
8221
8222 static void
8223 sub_32_09 (UINT4 *in, UINT4 decrement) {
8224 in += 9 * WORD_INCR;
8225 *in -= decrement;
8226 return;
8227 }
8228
8229 static void
8230 sub_32_10 (UINT4 *in, UINT4 decrement) {
8231 in += 10 * WORD_INCR;
8232 *in -= decrement;
8233 return;
8234 }
8235
8236 static void
8237 sub_32_11 (UINT4 *in, UINT4 decrement) {
8238 in += 11 * WORD_INCR;
8239 *in -= decrement;
8240 return;
8241 }
8242
8243 static void
8244 sub_32_12 (UINT4 *in, UINT4 decrement) {
8245 in += 12 * WORD_INCR;
8246 *in -= decrement;
8247 return;
8248 }
8249
8250 static void
8251 sub_32_13 (UINT4 *in, UINT4 decrement) {
8252 in += 13 * WORD_INCR;
8253 *in -= decrement;
8254 return;
8255 }
8256
8257 static void
8258 sub_32_14 (UINT4 *in, UINT4 decrement) {
8259 in += 14 * WORD_INCR;
8260 *in -= decrement;
8261 return;
8262 }
8263
8264 static void
8265 sub_32_15 (UINT4 *in, UINT4 decrement) {
8266 in += 15 * WORD_INCR;
8267 *in -= decrement;
8268 return;
8269 }
8270
8271
8272 typedef void (*Subtractor_T) (UINT4 *, UINT4);
8273
8274 static Subtractor_T subtractor_table[272] =
8275 {sub_00, sub_00, sub_00, sub_00,
8276 sub_00, sub_00, sub_00, sub_00,
8277 sub_00, sub_00, sub_00, sub_00,
8278 sub_00, sub_00, sub_00, sub_00,
8279
8280 sub_02_00, sub_02_01, sub_02_02, sub_02_03,
8281 sub_02_04, sub_02_05, sub_02_06, sub_02_07,
8282 sub_02_08, sub_02_09, sub_02_10, sub_02_11,
8283 sub_02_12, sub_02_13, sub_02_14, sub_02_15,
8284
8285 sub_04_00, sub_04_01, sub_04_02, sub_04_03,
8286 sub_04_04, sub_04_05, sub_04_06, sub_04_07,
8287 sub_04_08, sub_04_09, sub_04_10, sub_04_11,
8288 sub_04_12, sub_04_13, sub_04_14, sub_04_15,
8289
8290 sub_06_00, sub_06_01, sub_06_02, sub_06_03,
8291 sub_06_04, sub_06_05, sub_06_06, sub_06_07,
8292 sub_06_08, sub_06_09, sub_06_10, sub_06_11,
8293 sub_06_12, sub_06_13, sub_06_14, sub_06_15,
8294
8295 sub_08_00, sub_08_01, sub_08_02, sub_08_03,
8296 sub_08_04, sub_08_05, sub_08_06, sub_08_07,
8297 sub_08_08, sub_08_09, sub_08_10, sub_08_11,
8298 sub_08_12, sub_08_13, sub_08_14, sub_08_15,
8299
8300 sub_10_00, sub_10_01, sub_10_02, sub_10_03,
8301 sub_10_04, sub_10_05, sub_10_06, sub_10_07,
8302 sub_10_08, sub_10_09, sub_10_10, sub_10_11,
8303 sub_10_12, sub_10_13, sub_10_14, sub_10_15,
8304
8305 sub_12_00, sub_12_01, sub_12_02, sub_12_03,
8306 sub_12_04, sub_12_05, sub_12_06, sub_12_07,
8307 sub_12_08, sub_12_09, sub_12_10, sub_12_11,
8308 sub_12_12, sub_12_13, sub_12_14, sub_12_15,
8309
8310 sub_14_00, sub_14_01, sub_14_02, sub_14_03,
8311 sub_14_04, sub_14_05, sub_14_06, sub_14_07,
8312 sub_14_08, sub_14_09, sub_14_10, sub_14_11,
8313 sub_14_12, sub_14_13, sub_14_14, sub_14_15,
8314
8315 sub_16_00, sub_16_01, sub_16_02, sub_16_03,
8316 sub_16_04, sub_16_05, sub_16_06, sub_16_07,
8317 sub_16_08, sub_16_09, sub_16_10, sub_16_11,
8318 sub_16_12, sub_16_13, sub_16_14, sub_16_15,
8319
8320 sub_18_00, sub_18_01, sub_18_02, sub_18_03,
8321 sub_18_04, sub_18_05, sub_18_06, sub_18_07,
8322 sub_18_08, sub_18_09, sub_18_10, sub_18_11,
8323 sub_18_12, sub_18_13, sub_18_14, sub_18_15,
8324
8325 sub_20_00, sub_20_01, sub_20_02, sub_20_03,
8326 sub_20_04, sub_20_05, sub_20_06, sub_20_07,
8327 sub_20_08, sub_20_09, sub_20_10, sub_20_11,
8328 sub_20_12, sub_20_13, sub_20_14, sub_20_15,
8329
8330 sub_22_00, sub_22_01, sub_22_02, sub_22_03,
8331 sub_22_04, sub_22_05, sub_22_06, sub_22_07,
8332 sub_22_08, sub_22_09, sub_22_10, sub_22_11,
8333 sub_22_12, sub_22_13, sub_22_14, sub_22_15,
8334
8335 sub_24_00, sub_24_01, sub_24_02, sub_24_03,
8336 sub_24_04, sub_24_05, sub_24_06, sub_24_07,
8337 sub_24_08, sub_24_09, sub_24_10, sub_24_11,
8338 sub_24_12, sub_24_13, sub_24_14, sub_24_15,
8339
8340 sub_26_00, sub_26_01, sub_26_02, sub_26_03,
8341 sub_26_04, sub_26_05, sub_26_06, sub_26_07,
8342 sub_26_08, sub_26_09, sub_26_10, sub_26_11,
8343 sub_26_12, sub_26_13, sub_26_14, sub_26_15,
8344
8345 sub_28_00, sub_28_01, sub_28_02, sub_28_03,
8346 sub_28_04, sub_28_05, sub_28_06, sub_28_07,
8347 sub_28_08, sub_28_09, sub_28_10, sub_28_11,
8348 sub_28_12, sub_28_13, sub_28_14, sub_28_15,
8349
8350 sub_30_00, sub_30_01, sub_30_02, sub_30_03,
8351 sub_30_04, sub_30_05, sub_30_06, sub_30_07,
8352 sub_30_08, sub_30_09, sub_30_10, sub_30_11,
8353 sub_30_12, sub_30_13, sub_30_14, sub_30_15,
8354
8355 sub_32_00, sub_32_01, sub_32_02, sub_32_03,
8356 sub_32_04, sub_32_05, sub_32_06, sub_32_07,
8357 sub_32_08, sub_32_09, sub_32_10, sub_32_11,
8358 sub_32_12, sub_32_13, sub_32_14, sub_32_15,
8359 };
8360 #endif
8361
8362
8363
8364
8365
8366 #define DIRECT_METAINFO_SIZE 1
8367
8368 /* Vertical */
8369 UINT4
Bitpack64_incr(Oligospace_T oligo,UINT4 * ptrs,UINT4 * comp)8370 Bitpack64_incr (Oligospace_T oligo, UINT4 *ptrs, UINT4 *comp) {
8371 UINT4 *info, start4;
8372 UINT8 start8;
8373 int nwritten, remainder;
8374 UINT4 *bitpack;
8375 int index, column;
8376 #ifdef CHECK
8377 UINT4 prev, value;
8378 int packsize, i;
8379 #endif
8380
8381 info = &(ptrs[oligo/BLOCKSIZE * DIRECT_METAINFO_SIZE]);
8382
8383 #ifdef WORDS_BIGENDIAN
8384 start4 = Bigendian_convert_uint(info[0]); /* In 128-bit registers */
8385 start8 = 4 * (UINT8) start4; /* In 32-bit words */
8386 bitpack = (UINT4 *) &(comp[start8]);
8387 nwritten = Bigendian_convert_uint(info[1]) - start4;
8388 #else
8389 start4 = info[0]; /* In 128-bit registers */
8390 start8 = 4 * (UINT8) start4; /* In 32-bit words */
8391 bitpack = (UINT4 *) &(comp[start8]);
8392 nwritten = info[1] - start4;
8393 #endif
8394
8395 remainder = oligo % BLOCKSIZE;
8396 index = nwritten*16 + remainder/4;
8397 column = remainder % 4;
8398
8399 #ifdef CHECK
8400 prev = Bitpack64_access(oligo,ptrs,comp);
8401 value = (incrementor_table[index])(&(bitpack[column]));
8402 if (value != prev || Bitpack64_access(oligo,ptrs,comp) != prev + 1) {
8403 packsize = nwritten*2;
8404 printf("Error at Bitpack64_incr with oligo %llu, packsize %d, remainder %d, column %d, index %d\n",
8405 oligo,packsize,remainder,column,index);
8406 printf("bitpack:\n");
8407 for (i = 0; i < nwritten*4; i += 4) {
8408 printf("%08X %08X %08X %08X\n",bitpack[i],bitpack[i+1],bitpack[i+2],bitpack[i+3]);
8409 }
8410 printf("\n");
8411 abort();
8412 }
8413 return value;
8414 #else
8415 return (incrementor_table[index])(&(bitpack[column]));
8416 #endif
8417
8418 }
8419
8420
8421 UINT4
Bitpack64_incr_bitpack(Oligospace_T oligo,int packsize,UINT4 * bitpack)8422 Bitpack64_incr_bitpack (Oligospace_T oligo, int packsize, UINT4 *bitpack) {
8423 int nregisters, remainder;
8424 int index, column;
8425 #ifdef CHECK
8426 UINT4 prev, value;
8427 #endif
8428
8429 nregisters = packsize / 2;
8430 remainder = oligo % BLOCKSIZE;
8431 index = nregisters*16 + remainder/4;
8432 column = remainder % 4;
8433
8434 #ifdef CHECK
8435 prev = Bitpack64_access_bitpack(oligo,packsize,bitpack);
8436 value = (incrementor_table[index])(&(bitpack[column]));
8437 if (value != prev || Bitpack64_access_bitpack(oligo,packsize,bitpack) != prev + 1) {
8438 printf("Error at Bitpack64_incr_bitpack with oligo %llu, packsize %d, remainder %d, column %d, index %d\n",
8439 oligo,packsize,remainder,column,index);
8440 abort();
8441 }
8442 return value;
8443 #else
8444 return (incrementor_table[index])(&(bitpack[column]));
8445 #endif
8446 }
8447
8448
8449 void
Bitpack64_add(Oligospace_T oligo,UINT4 * ptrs,UINT4 * comp,UINT4 increment)8450 Bitpack64_add (Oligospace_T oligo, UINT4 *ptrs, UINT4 *comp, UINT4 increment) {
8451 UINT4 *info, start4;
8452 UINT8 start8;
8453 int nwritten, remainder;
8454 UINT4 *bitpack;
8455 int index, column;
8456 #ifdef CHECK
8457 UINT4 prev;
8458 int packsize, i;
8459 #endif
8460
8461 info = &(ptrs[oligo/BLOCKSIZE * DIRECT_METAINFO_SIZE]);
8462
8463 #ifdef WORDS_BIGENDIAN
8464 start4 = Bigendian_convert_uint(info[0]); /* In 128-bit registers */
8465 start8 = 4 * (UINT8) start4; /* In 32-bit words */
8466 bitpack = (UINT4 *) &(comp[start8]);
8467 nwritten = Bigendian_convert_uint(info[1]) - start4;
8468 #else
8469 start4 = info[0]; /* In 128-bit registers */
8470 start8 = 4 * (UINT8) start4; /* In 32-bit words */
8471 bitpack = (UINT4 *) &(comp[start8]);
8472 nwritten = info[1] - start4;
8473 #endif
8474
8475 remainder = oligo % BLOCKSIZE;
8476 index = nwritten*16 + remainder/4;
8477 column = remainder % 4;
8478
8479 #ifdef CHECK
8480 prev = Bitpack64_access(oligo,ptrs,comp);
8481 (adder_table[index])(&(bitpack[column]),increment);
8482 if (Bitpack64_access(oligo,ptrs,comp) != prev + increment) {
8483 packsize = nwritten*2;
8484 printf("Error at Bitpack64_add with oligo %llu, packsize %d, remainder %d, column %d, index %d\n",
8485 oligo,packsize,remainder,column,index);
8486 printf("bitpack:\n");
8487 for (i = 0; i < nwritten*4; i += 4) {
8488 printf("%08X %08X %08X %08X\n",bitpack[i],bitpack[i+1],bitpack[i+2],bitpack[i+3]);
8489 }
8490 printf("\n");
8491 abort();
8492 }
8493 #else
8494 (adder_table[index])(&(bitpack[column]),increment);
8495 #endif
8496
8497 return;
8498 }
8499
8500
8501
8502 /* Assumes that increment > 0 */
8503 void
Bitpack64_add_bitpack(Oligospace_T oligo,int packsize,UINT4 * bitpack,UINT4 increment)8504 Bitpack64_add_bitpack (Oligospace_T oligo, int packsize, UINT4 *bitpack, UINT4 increment) {
8505 int nregisters, remainder;
8506 int index, column;
8507 #ifdef CHECK
8508 UINT4 prev;
8509 #endif
8510
8511 nregisters = packsize / 2;
8512 remainder = oligo % BLOCKSIZE;
8513 index = nregisters*16 + remainder/4;
8514 column = remainder % 4;
8515
8516 #ifdef CHECK
8517 prev = Bitpack64_access_bitpack(oligo,packsize,bitpack);
8518 (adder_table[index])(&(bitpack[column]),increment);
8519 if (Bitpack64_access_bitpack(oligo,packsize,bitpack) != prev + increment) {
8520 printf("Error at Bitpack64_add_bitpack with oligo %llu, packsize %d, remainder %d, column %d, index %d\n",
8521 oligo,packsize,remainder,column,index);
8522 abort();
8523 }
8524 #else
8525 (adder_table[index])(&(bitpack[column]),increment);
8526 #endif
8527
8528 return;
8529 }
8530
8531
8532
8533
8534 #if 0
8535 /* No need currently for a subtraction routine */
8536
8537 void
8538 Bitpack64_sub_bitpack (Oligospace_T oligo, int packsize, UINT4 *bitpack, UINT4 decrement) {
8539 int nregisters, remainder;
8540 int index, column;
8541 #ifdef CHECK
8542 UINT4 prev;
8543 #endif
8544
8545 nregisters = packsize / 2;
8546 remainder = oligo % BLOCKSIZE;
8547 index = nregisters*16 + remainder/4;
8548 column = remainder % 4;
8549
8550 #ifdef CHECK
8551 prev = Bitpack64_access_bitpack(oligo,packsize,bitpack);
8552 (subtractor_table[index])(&(bitpack[column]),decrement);
8553 if (Bitpack64_access_bitpack(oligo,packsize,bitpack) != prev - decrement) {
8554 printf("Error at Bitpack64_sub_bitpack with oligo %llu, packsize %d, remainder %d, column %d, index %d\n",
8555 oligo,packsize,remainder,column,index);
8556 abort();
8557 }
8558 #else
8559 (subtractor_table[index])(&(bitpack[column]),decrement);
8560 #endif
8561
8562 return;
8563 }
8564 #endif
8565
8566
8567 static void
transfer_00_02(UINT4 * out,const UINT4 * in)8568 transfer_00_02 (UINT4 *out, const UINT4 *in) {
8569 return;
8570 }
8571
8572 static void
transfer_02_04(UINT4 * out,const UINT4 * in)8573 transfer_02_04 (UINT4 *out, const UINT4 *in) {
8574 UINT4 value;
8575
8576 /* 00 */
8577 value = ( CONVERT(*in) >> 0 ) % (1U << 2 ) ;
8578 *out |= (value << 0);
8579
8580 /* 01 */
8581 value = ( CONVERT(*in) >> 2 ) % (1U << 2 ) ;
8582 *out |= (value << 4);
8583
8584 /* 02 */
8585 value = ( CONVERT(*in) >> 4 ) % (1U << 2 ) ;
8586 *out |= (value << 8);
8587
8588 /* 03 */
8589 value = ( CONVERT(*in) >> 6 ) % (1U << 2 ) ;
8590 *out |= (value << 12);
8591
8592 /* 04 */
8593 value = ( CONVERT(*in) >> 8 ) % (1U << 2 ) ;
8594 *out |= (value << 16);
8595
8596 /* 05 */
8597 value = ( CONVERT(*in) >> 10 ) % (1U << 2 ) ;
8598 *out |= (value << 20);
8599
8600 /* 06 */
8601 value = ( CONVERT(*in) >> 12 ) % (1U << 2 ) ;
8602 *out |= (value << 24);
8603
8604 /* 07 */
8605 value = ( CONVERT(*in) >> 14 ) % (1U << 2 ) ;
8606 *out |= (value << 28);
8607
8608 /* 08 */
8609 value = ( CONVERT(*in) >> 16 ) % (1U << 2 ) ;
8610 out += WORD_INCR;
8611 *out |= (value << 0);
8612
8613 /* 09 */
8614 value = ( CONVERT(*in) >> 18 ) % (1U << 2 ) ;
8615 *out |= (value << 4);
8616
8617 /* 10 */
8618 value = ( CONVERT(*in) >> 20 ) % (1U << 2 ) ;
8619 *out |= (value << 8);
8620
8621 /* 11 */
8622 value = ( CONVERT(*in) >> 22 ) % (1U << 2 ) ;
8623 *out |= (value << 12);
8624
8625 /* 12 */
8626 value = ( CONVERT(*in) >> 24 ) % (1U << 2 ) ;
8627 *out |= (value << 16);
8628
8629 /* 13 */
8630 value = ( CONVERT(*in) >> 26 ) % (1U << 2 ) ;
8631 *out |= (value << 20);
8632
8633 /* 14 */
8634 value = ( CONVERT(*in) >> 28 ) % (1U << 2 ) ;
8635 *out |= (value << 24);
8636
8637 /* 15 */
8638 value = ( CONVERT(*in) >> 30 ) % (1U << 2 ) ;
8639 *out |= (value << 28);
8640
8641 return;
8642 }
8643
8644 static void
transfer_04_06(UINT4 * out,const UINT4 * in)8645 transfer_04_06 (UINT4 *out, const UINT4 *in) {
8646 UINT4 value;
8647
8648 /* 00 */
8649 value = ( CONVERT(*in) >> 0 ) % (1U << 4 ) ;
8650 *out |= (value << 0);
8651
8652 /* 01 */
8653 value = ( CONVERT(*in) >> 4 ) % (1U << 4 ) ;
8654 *out |= (value << 6);
8655
8656 /* 02 */
8657 value = ( CONVERT(*in) >> 8 ) % (1U << 4 ) ;
8658 *out |= (value << 12);
8659
8660 /* 03 */
8661 value = ( CONVERT(*in) >> 12 ) % (1U << 4 ) ;
8662 *out |= (value << 18);
8663
8664 /* 04 */
8665 value = ( CONVERT(*in) >> 16 ) % (1U << 4 ) ;
8666 *out |= (value << 24);
8667
8668 /* 05 */
8669 value = ( CONVERT(*in) >> 20 ) % (1U << 4 ) ;
8670 *out |= (value << 30);
8671 out += WORD_INCR;
8672 *out |= (value >> (6 - 4));
8673
8674 /* 06 */
8675 value = ( CONVERT(*in) >> 24 ) % (1U << 4 ) ;
8676 *out |= (value << 4);
8677
8678 /* 07 */
8679 value = ( CONVERT(*in) >> 28 ) % (1U << 4 ) ;
8680 *out |= (value << 10);
8681
8682 /* 08 */
8683 in += WORD_INCR;
8684 value = ( CONVERT(*in) >> 0 ) % (1U << 4 ) ;
8685 *out |= (value << 16);
8686
8687 /* 09 */
8688 value = ( CONVERT(*in) >> 4 ) % (1U << 4 ) ;
8689 *out |= (value << 22);
8690
8691 /* 10 */
8692 value = ( CONVERT(*in) >> 8 ) % (1U << 4 ) ;
8693 *out |= (value << 28);
8694 out += WORD_INCR;
8695 *out |= (value >> (6 - 2));
8696
8697 /* 11 */
8698 value = ( CONVERT(*in) >> 12 ) % (1U << 4 ) ;
8699 *out |= (value << 2);
8700
8701 /* 12 */
8702 value = ( CONVERT(*in) >> 16 ) % (1U << 4 ) ;
8703 *out |= (value << 8);
8704
8705 /* 13 */
8706 value = ( CONVERT(*in) >> 20 ) % (1U << 4 ) ;
8707 *out |= (value << 14);
8708
8709 /* 14 */
8710 value = ( CONVERT(*in) >> 24 ) % (1U << 4 ) ;
8711 *out |= (value << 20);
8712
8713 /* 15 */
8714 value = ( CONVERT(*in) >> 28 ) % (1U << 4 ) ;
8715 *out |= (value << 26);
8716
8717 return;
8718 }
8719
8720
8721 static void
transfer_06_08(UINT4 * out,const UINT4 * in)8722 transfer_06_08 (UINT4 *out, const UINT4 *in) {
8723 UINT4 value;
8724
8725 /* 00 */
8726 value = ( CONVERT(*in) >> 0 ) % (1U << 6 ) ;
8727 *out |= (value << 0);
8728
8729 /* 01 */
8730 value = ( CONVERT(*in) >> 6 ) % (1U << 6 ) ;
8731 *out |= (value << 8);
8732
8733 /* 02 */
8734 value = ( CONVERT(*in) >> 12 ) % (1U << 6 ) ;
8735 *out |= (value << 16);
8736
8737 /* 03 */
8738 value = ( CONVERT(*in) >> 18 ) % (1U << 6 ) ;
8739 *out |= (value << 24);
8740
8741 /* 04 */
8742 value = ( CONVERT(*in) >> 24 ) % (1U << 6 ) ;
8743 out += WORD_INCR;
8744 *out |= (value << 0);
8745
8746 /* 05 */
8747 value = ( CONVERT(*in) >> 30 ) % (1U << 6 ) ;
8748 in += WORD_INCR;
8749 value |= (CONVERT(*in) % (1U<< 4 ))<<( 6 - 4 );
8750 *out |= (value << 8);
8751
8752 /* 06 */
8753 value = ( CONVERT(*in) >> 4 ) % (1U << 6 ) ;
8754 *out |= (value << 16);
8755
8756 /* 07 */
8757 value = ( CONVERT(*in) >> 10 ) % (1U << 6 ) ;
8758 *out |= (value << 24);
8759
8760 /* 08 */
8761 value = ( CONVERT(*in) >> 16 ) % (1U << 6 ) ;
8762 out += WORD_INCR;
8763 *out |= (value << 0);
8764
8765 /* 09 */
8766 value = ( CONVERT(*in) >> 22 ) % (1U << 6 ) ;
8767 *out |= (value << 8);
8768
8769 /* 10 */
8770 value = ( CONVERT(*in) >> 28 ) % (1U << 6 ) ;
8771 in += WORD_INCR;
8772 value |= (CONVERT(*in) % (1U<< 2 ))<<( 6 - 2 );
8773 *out |= (value << 16);
8774
8775 /* 11 */
8776 value = ( CONVERT(*in) >> 2 ) % (1U << 6 ) ;
8777 *out |= (value << 24);
8778
8779 /* 12 */
8780 value = ( CONVERT(*in) >> 8 ) % (1U << 6 ) ;
8781 out += WORD_INCR;
8782 *out |= (value << 0);
8783
8784 /* 13 */
8785 value = ( CONVERT(*in) >> 14 ) % (1U << 6 ) ;
8786 *out |= (value << 8);
8787
8788 /* 14 */
8789 value = ( CONVERT(*in) >> 20 ) % (1U << 6 ) ;
8790 *out |= (value << 16);
8791
8792 /* 15 */
8793 value = ( CONVERT(*in) >> 26 ) % (1U << 6 ) ;
8794 *out |= (value << 24);
8795
8796 return;
8797 }
8798
8799
8800 static void
transfer_08_10(UINT4 * out,const UINT4 * in)8801 transfer_08_10 (UINT4 *out, const UINT4 *in) {
8802 UINT4 value;
8803
8804 /* 00 */
8805 value = ( CONVERT(*in) >> 0 ) % (1U << 8 ) ;
8806 *out |= (value << 0);
8807
8808 /* 01 */
8809 value = ( CONVERT(*in) >> 8 ) % (1U << 8 ) ;
8810 *out |= (value << 10);
8811
8812 /* 02 */
8813 value = ( CONVERT(*in) >> 16 ) % (1U << 8 ) ;
8814 *out |= (value << 20);
8815
8816 /* 03 */
8817 value = ( CONVERT(*in) >> 24 ) % (1U << 8 ) ;
8818 *out |= (value << 30);
8819 out += WORD_INCR;
8820 *out |= (value >> (10 - 8));
8821
8822 /* 04 */
8823 in += WORD_INCR;
8824 value = ( CONVERT(*in) >> 0 ) % (1U << 8 ) ;
8825 *out |= (value << 8);
8826
8827 /* 05 */
8828 value = ( CONVERT(*in) >> 8 ) % (1U << 8 ) ;
8829 *out |= (value << 18);
8830
8831 /* 06 */
8832 value = ( CONVERT(*in) >> 16 ) % (1U << 8 ) ;
8833 *out |= (value << 28);
8834 out += WORD_INCR;
8835 *out |= (value >> (10 - 6));
8836
8837 /* 07 */
8838 value = ( CONVERT(*in) >> 24 ) % (1U << 8 ) ;
8839 *out |= (value << 6);
8840
8841 /* 08 */
8842 in += WORD_INCR;
8843 value = ( CONVERT(*in) >> 0 ) % (1U << 8 ) ;
8844 *out |= (value << 16);
8845
8846 /* 09 */
8847 value = ( CONVERT(*in) >> 8 ) % (1U << 8 ) ;
8848 *out |= (value << 26);
8849 out += WORD_INCR;
8850 *out |= (value >> (10 - 4));
8851
8852 /* 10 */
8853 value = ( CONVERT(*in) >> 16 ) % (1U << 8 ) ;
8854 *out |= (value << 4);
8855
8856 /* 11 */
8857 value = ( CONVERT(*in) >> 24 ) % (1U << 8 ) ;
8858 *out |= (value << 14);
8859
8860 /* 12 */
8861 in += WORD_INCR;
8862 value = ( CONVERT(*in) >> 0 ) % (1U << 8 ) ;
8863 *out |= (value << 24);
8864 out += WORD_INCR;
8865 *out |= (value >> (10 - 2));
8866
8867 /* 13 */
8868 value = ( CONVERT(*in) >> 8 ) % (1U << 8 ) ;
8869 *out |= (value << 2);
8870
8871 /* 14 */
8872 value = ( CONVERT(*in) >> 16 ) % (1U << 8 ) ;
8873 *out |= (value << 12);
8874
8875 /* 15 */
8876 value = ( CONVERT(*in) >> 24 ) % (1U << 8 ) ;
8877 *out |= (value << 22);
8878
8879 return;
8880 }
8881
8882 static void
transfer_10_12(UINT4 * out,const UINT4 * in)8883 transfer_10_12 (UINT4 *out, const UINT4 *in) {
8884 UINT4 value;
8885
8886 /* 00 */
8887 value = ( CONVERT(*in) >> 0 ) % (1U << 10 ) ;
8888 *out |= (value << 0);
8889
8890 /* 01 */
8891 value = ( CONVERT(*in) >> 10 ) % (1U << 10 ) ;
8892 *out |= (value << 12);
8893
8894 /* 02 */
8895 value = ( CONVERT(*in) >> 20 ) % (1U << 10 ) ;
8896 *out |= (value << 24);
8897 out += WORD_INCR;
8898 *out |= (value >> (12 - 4));
8899
8900 /* 03 */
8901 value = ( CONVERT(*in) >> 30 ) % (1U << 10 ) ;
8902 in += WORD_INCR;
8903 value |= (CONVERT(*in) % (1U<< 8 ))<<( 10 - 8 );
8904 *out |= (value << 4);
8905
8906 /* 04 */
8907 value = ( CONVERT(*in) >> 8 ) % (1U << 10 ) ;
8908 *out |= (value << 16);
8909
8910 /* 05 */
8911 value = ( CONVERT(*in) >> 18 ) % (1U << 10 ) ;
8912 *out |= (value << 28);
8913 out += WORD_INCR;
8914 *out |= (value >> (12 - 8));
8915
8916 /* 06 */
8917 value = ( CONVERT(*in) >> 28 ) % (1U << 10 ) ;
8918 in += WORD_INCR;
8919 value |= (CONVERT(*in) % (1U<< 6 ))<<( 10 - 6 );
8920 *out |= (value << 8);
8921
8922 /* 07 */
8923 value = ( CONVERT(*in) >> 6 ) % (1U << 10 ) ;
8924 *out |= (value << 20);
8925
8926 /* 08 */
8927 value = ( CONVERT(*in) >> 16 ) % (1U << 10 ) ;
8928 out += WORD_INCR;
8929 *out |= (value << 0);
8930
8931 /* 09 */
8932 value = ( CONVERT(*in) >> 26 ) % (1U << 10 ) ;
8933 in += WORD_INCR;
8934 value |= (CONVERT(*in) % (1U<< 4 ))<<( 10 - 4 );
8935 *out |= (value << 12);
8936
8937 /* 10 */
8938 value = ( CONVERT(*in) >> 4 ) % (1U << 10 ) ;
8939 *out |= (value << 24);
8940 out += WORD_INCR;
8941 *out |= (value >> (12 - 4));
8942
8943 /* 11 */
8944 value = ( CONVERT(*in) >> 14 ) % (1U << 10 ) ;
8945 *out |= (value << 4);
8946
8947 /* 12 */
8948 value = ( CONVERT(*in) >> 24 ) % (1U << 10 ) ;
8949 in += WORD_INCR;
8950 value |= (CONVERT(*in) % (1U<< 2 ))<<( 10 - 2 );
8951 *out |= (value << 16);
8952
8953 /* 13 */
8954 value = ( CONVERT(*in) >> 2 ) % (1U << 10 ) ;
8955 *out |= (value << 28);
8956 out += WORD_INCR;
8957 *out |= (value >> (12 - 8));
8958
8959 /* 14 */
8960 value = ( CONVERT(*in) >> 12 ) % (1U << 10 ) ;
8961 *out |= (value << 8);
8962
8963 /* 15 */
8964 value = ( CONVERT(*in) >> 22 ) % (1U << 10 ) ;
8965 *out |= (value << 20);
8966
8967 return;
8968 }
8969
8970 static void
transfer_12_14(UINT4 * out,const UINT4 * in)8971 transfer_12_14 (UINT4 *out, const UINT4 *in) {
8972 UINT4 value;
8973
8974 /* 00 */
8975 value = ( CONVERT(*in) >> 0 ) % (1U << 12 ) ;
8976 *out |= (value << 0);
8977
8978 /* 01 */
8979 value = ( CONVERT(*in) >> 12 ) % (1U << 12 ) ;
8980 *out |= (value << 14);
8981
8982 /* 02 */
8983 value = ( CONVERT(*in) >> 24 ) % (1U << 12 ) ;
8984 in += WORD_INCR;
8985 value |= (CONVERT(*in) % (1U<< 4 ))<<( 12 - 4 );
8986 *out |= (value << 28);
8987 out += WORD_INCR;
8988 *out |= (value >> (14 - 10));
8989
8990 /* 03 */
8991 value = ( CONVERT(*in) >> 4 ) % (1U << 12 ) ;
8992 *out |= (value << 10);
8993
8994 /* 04 */
8995 value = ( CONVERT(*in) >> 16 ) % (1U << 12 ) ;
8996 *out |= (value << 24);
8997 out += WORD_INCR;
8998 *out |= (value >> (14 - 6));
8999
9000 /* 05 */
9001 value = ( CONVERT(*in) >> 28 ) % (1U << 12 ) ;
9002 in += WORD_INCR;
9003 value |= (CONVERT(*in) % (1U<< 8 ))<<( 12 - 8 );
9004 *out |= (value << 6);
9005
9006 /* 06 */
9007 value = ( CONVERT(*in) >> 8 ) % (1U << 12 ) ;
9008 *out |= (value << 20);
9009 out += WORD_INCR;
9010 *out |= (value >> (14 - 2));
9011
9012 /* 07 */
9013 value = ( CONVERT(*in) >> 20 ) % (1U << 12 ) ;
9014 *out |= (value << 2);
9015
9016 /* 08 */
9017 in += WORD_INCR;
9018 value = ( CONVERT(*in) >> 0 ) % (1U << 12 ) ;
9019 *out |= (value << 16);
9020
9021 /* 09 */
9022 value = ( CONVERT(*in) >> 12 ) % (1U << 12 ) ;
9023 *out |= (value << 30);
9024 out += WORD_INCR;
9025 *out |= (value >> (14 - 12));
9026
9027 /* 10 */
9028 value = ( CONVERT(*in) >> 24 ) % (1U << 12 ) ;
9029 in += WORD_INCR;
9030 value |= (CONVERT(*in) % (1U<< 4 ))<<( 12 - 4 );
9031 *out |= (value << 12);
9032
9033 /* 11 */
9034 value = ( CONVERT(*in) >> 4 ) % (1U << 12 ) ;
9035 *out |= (value << 26);
9036 out += WORD_INCR;
9037 *out |= (value >> (14 - 8));
9038
9039 /* 12 */
9040 value = ( CONVERT(*in) >> 16 ) % (1U << 12 ) ;
9041 *out |= (value << 8);
9042
9043 /* 13 */
9044 value = ( CONVERT(*in) >> 28 ) % (1U << 12 ) ;
9045 in += WORD_INCR;
9046 value |= (CONVERT(*in) % (1U<< 8 ))<<( 12 - 8 );
9047 *out |= (value << 22);
9048 out += WORD_INCR;
9049 *out |= (value >> (14 - 4));
9050
9051 /* 14 */
9052 value = ( CONVERT(*in) >> 8 ) % (1U << 12 ) ;
9053 *out |= (value << 4);
9054
9055 /* 15 */
9056 value = ( CONVERT(*in) >> 20 ) % (1U << 12 ) ;
9057 *out |= (value << 18);
9058
9059 return;
9060 }
9061
9062
9063 static void
transfer_14_16(UINT4 * out,const UINT4 * in)9064 transfer_14_16 (UINT4 *out, const UINT4 *in) {
9065 UINT4 value;
9066
9067 /* 00 */
9068 value = ( CONVERT(*in) >> 0 ) % (1U << 14 ) ;
9069 *out |= (value << 0);
9070
9071 /* 01 */
9072 value = ( CONVERT(*in) >> 14 ) % (1U << 14 ) ;
9073 *out |= (value << 16);
9074
9075 /* 02 */
9076 value = ( CONVERT(*in) >> 28 ) % (1U << 14 ) ;
9077 in += WORD_INCR;
9078 value |= (CONVERT(*in) % (1U<< 10 ))<<( 14 - 10 );
9079 out += WORD_INCR;
9080 *out |= (value << 0);
9081
9082 /* 03 */
9083 value = ( CONVERT(*in) >> 10 ) % (1U << 14 ) ;
9084 *out |= (value << 16);
9085
9086 /* 04 */
9087 value = ( CONVERT(*in) >> 24 ) % (1U << 14 ) ;
9088 in += WORD_INCR;
9089 value |= (CONVERT(*in) % (1U<< 6 ))<<( 14 - 6 );
9090 out += WORD_INCR;
9091 *out |= (value << 0);
9092
9093 /* 05 */
9094 value = ( CONVERT(*in) >> 6 ) % (1U << 14 ) ;
9095 *out |= (value << 16);
9096
9097 /* 06 */
9098 value = ( CONVERT(*in) >> 20 ) % (1U << 14 ) ;
9099 in += WORD_INCR;
9100 value |= (CONVERT(*in) % (1U<< 2 ))<<( 14 - 2 );
9101 out += WORD_INCR;
9102 *out |= (value << 0);
9103
9104 /* 07 */
9105 value = ( CONVERT(*in) >> 2 ) % (1U << 14 ) ;
9106 *out |= (value << 16);
9107
9108 /* 08 */
9109 value = ( CONVERT(*in) >> 16 ) % (1U << 14 ) ;
9110 out += WORD_INCR;
9111 *out |= (value << 0);
9112
9113 /* 09 */
9114 value = ( CONVERT(*in) >> 30 ) % (1U << 14 ) ;
9115 in += WORD_INCR;
9116 value |= (CONVERT(*in) % (1U<< 12 ))<<( 14 - 12 );
9117 *out |= (value << 16);
9118
9119 /* 10 */
9120 value = ( CONVERT(*in) >> 12 ) % (1U << 14 ) ;
9121 out += WORD_INCR;
9122 *out |= (value << 0);
9123
9124 /* 11 */
9125 value = ( CONVERT(*in) >> 26 ) % (1U << 14 ) ;
9126 in += WORD_INCR;
9127 value |= (CONVERT(*in) % (1U<< 8 ))<<( 14 - 8 );
9128 *out |= (value << 16);
9129
9130 /* 12 */
9131 value = ( CONVERT(*in) >> 8 ) % (1U << 14 ) ;
9132 out += WORD_INCR;
9133 *out |= (value << 0);
9134
9135 /* 13 */
9136 value = ( CONVERT(*in) >> 22 ) % (1U << 14 ) ;
9137 in += WORD_INCR;
9138 value |= (CONVERT(*in) % (1U<< 4 ))<<( 14 - 4 );
9139 *out |= (value << 16);
9140
9141 /* 14 */
9142 value = ( CONVERT(*in) >> 4 ) % (1U << 14 ) ;
9143 out += WORD_INCR;
9144 *out |= (value << 0);
9145
9146 /* 15 */
9147 value = ( CONVERT(*in) >> 18 ) % (1U << 14 ) ;
9148 *out |= (value << 16);
9149
9150 return;
9151 }
9152
9153 static void
transfer_16_18(UINT4 * out,const UINT4 * in)9154 transfer_16_18 (UINT4 *out, const UINT4 *in) {
9155 UINT4 value;
9156
9157 /* 00 */
9158 value = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
9159 *out |= (value << 0);
9160
9161 /* 01 */
9162 value = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
9163 *out |= (value << 18);
9164 out += WORD_INCR;
9165 *out |= (value >> (18 - 4));
9166
9167 /* 02 */
9168 in += WORD_INCR;
9169 value = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
9170 *out |= (value << 4);
9171
9172 /* 03 */
9173 value = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
9174 *out |= (value << 22);
9175 out += WORD_INCR;
9176 *out |= (value >> (18 - 8));
9177
9178 /* 04 */
9179 in += WORD_INCR;
9180 value = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
9181 *out |= (value << 8);
9182
9183 /* 05 */
9184 value = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
9185 *out |= (value << 26);
9186 out += WORD_INCR;
9187 *out |= (value >> (18 - 12));
9188
9189 /* 06 */
9190 in += WORD_INCR;
9191 value = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
9192 *out |= (value << 12);
9193
9194 /* 07 */
9195 value = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
9196 *out |= (value << 30);
9197 out += WORD_INCR;
9198 *out |= (value >> (18 - 16));
9199
9200 /* 08 */
9201 in += WORD_INCR;
9202 value = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
9203 *out |= (value << 16);
9204 out += WORD_INCR;
9205 *out |= (value >> (18 - 2));
9206
9207 /* 09 */
9208 value = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
9209 *out |= (value << 2);
9210
9211 /* 10 */
9212 in += WORD_INCR;
9213 value = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
9214 *out |= (value << 20);
9215 out += WORD_INCR;
9216 *out |= (value >> (18 - 6));
9217
9218 /* 11 */
9219 value = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
9220 *out |= (value << 6);
9221
9222 /* 12 */
9223 in += WORD_INCR;
9224 value = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
9225 *out |= (value << 24);
9226 out += WORD_INCR;
9227 *out |= (value >> (18 - 10));
9228
9229 /* 13 */
9230 value = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
9231 *out |= (value << 10);
9232
9233 /* 14 */
9234 in += WORD_INCR;
9235 value = ( CONVERT(*in) >> 0 ) % (1U << 16 ) ;
9236 *out |= (value << 28);
9237 out += WORD_INCR;
9238 *out |= (value >> (18 - 14));
9239
9240 /* 15 */
9241 value = ( CONVERT(*in) >> 16 ) % (1U << 16 ) ;
9242 *out |= (value << 14);
9243
9244 return;
9245 }
9246
9247
9248 static void
transfer_18_20(UINT4 * out,const UINT4 * in)9249 transfer_18_20 (UINT4 *out, const UINT4 *in) {
9250 UINT4 value;
9251
9252 /* 00 */
9253 value = ( CONVERT(*in) >> 0 ) % (1U << 18 ) ;
9254 *out |= (value << 0);
9255
9256 /* 01 */
9257 value = ( CONVERT(*in) >> 18 ) % (1U << 18 ) ;
9258 in += WORD_INCR;
9259 value |= (CONVERT(*in) % (1U<< 4 ))<<( 18 - 4 );
9260 *out |= (value << 20);
9261 out += WORD_INCR;
9262 *out |= (value >> (20 - 8));
9263
9264 /* 02 */
9265 value = ( CONVERT(*in) >> 4 ) % (1U << 18 ) ;
9266 *out |= (value << 8);
9267
9268 /* 03 */
9269 value = ( CONVERT(*in) >> 22 ) % (1U << 18 ) ;
9270 in += WORD_INCR;
9271 value |= (CONVERT(*in) % (1U<< 8 ))<<( 18 - 8 );
9272 *out |= (value << 28);
9273 out += WORD_INCR;
9274 *out |= (value >> (20 - 16));
9275
9276 /* 04 */
9277 value = ( CONVERT(*in) >> 8 ) % (1U << 18 ) ;
9278 *out |= (value << 16);
9279 out += WORD_INCR;
9280 *out |= (value >> (20 - 4));
9281
9282 /* 05 */
9283 value = ( CONVERT(*in) >> 26 ) % (1U << 18 ) ;
9284 in += WORD_INCR;
9285 value |= (CONVERT(*in) % (1U<< 12 ))<<( 18 - 12 );
9286 *out |= (value << 4);
9287
9288 /* 06 */
9289 value = ( CONVERT(*in) >> 12 ) % (1U << 18 ) ;
9290 *out |= (value << 24);
9291 out += WORD_INCR;
9292 *out |= (value >> (20 - 12));
9293
9294 /* 07 */
9295 value = ( CONVERT(*in) >> 30 ) % (1U << 18 ) ;
9296 in += WORD_INCR;
9297 value |= (CONVERT(*in) % (1U<< 16 ))<<( 18 - 16 );
9298 *out |= (value << 12);
9299
9300 /* 08 */
9301 value = ( CONVERT(*in) >> 16 ) % (1U << 18 ) ;
9302 in += WORD_INCR;
9303 value |= (CONVERT(*in) % (1U<< 2 ))<<( 18 - 2 );
9304 out += WORD_INCR;
9305 *out |= (value << 0);
9306
9307 /* 09 */
9308 value = ( CONVERT(*in) >> 2 ) % (1U << 18 ) ;
9309 *out |= (value << 20);
9310 out += WORD_INCR;
9311 *out |= (value >> (20 - 8));
9312
9313 /* 10 */
9314 value = ( CONVERT(*in) >> 20 ) % (1U << 18 ) ;
9315 in += WORD_INCR;
9316 value |= (CONVERT(*in) % (1U<< 6 ))<<( 18 - 6 );
9317 *out |= (value << 8);
9318
9319 /* 11 */
9320 value = ( CONVERT(*in) >> 6 ) % (1U << 18 ) ;
9321 *out |= (value << 28);
9322 out += WORD_INCR;
9323 *out |= (value >> (20 - 16));
9324
9325 /* 12 */
9326 value = ( CONVERT(*in) >> 24 ) % (1U << 18 ) ;
9327 in += WORD_INCR;
9328 value |= (CONVERT(*in) % (1U<< 10 ))<<( 18 - 10 );
9329 *out |= (value << 16);
9330 out += WORD_INCR;
9331 *out |= (value >> (20 - 4));
9332
9333 /* 13 */
9334 value = ( CONVERT(*in) >> 10 ) % (1U << 18 ) ;
9335 *out |= (value << 4);
9336
9337 /* 14 */
9338 value = ( CONVERT(*in) >> 28 ) % (1U << 18 ) ;
9339 in += WORD_INCR;
9340 value |= (CONVERT(*in) % (1U<< 14 ))<<( 18 - 14 );
9341 *out |= (value << 24);
9342 out += WORD_INCR;
9343 *out |= (value >> (20 - 12));
9344
9345 /* 15 */
9346 value = ( CONVERT(*in) >> 14 ) % (1U << 18 ) ;
9347 *out |= (value << 12);
9348
9349 return;
9350 }
9351
9352 static void
transfer_20_22(UINT4 * out,const UINT4 * in)9353 transfer_20_22 (UINT4 *out, const UINT4 *in) {
9354 UINT4 value;
9355
9356 /* 00 */
9357 value = ( CONVERT(*in) >> 0 ) % (1U << 20 ) ;
9358 *out |= (value << 0);
9359
9360 /* 01 */
9361 value = ( CONVERT(*in) >> 20 ) % (1U << 20 ) ;
9362 in += WORD_INCR;
9363 value |= (CONVERT(*in) % (1U<< 8 ))<<( 20 - 8 );
9364 *out |= (value << 22);
9365 out += WORD_INCR;
9366 *out |= (value >> (22 - 12));
9367
9368 /* 02 */
9369 value = ( CONVERT(*in) >> 8 ) % (1U << 20 ) ;
9370 *out |= (value << 12);
9371 out += WORD_INCR;
9372 *out |= (value >> (22 - 2));
9373
9374 /* 03 */
9375 value = ( CONVERT(*in) >> 28 ) % (1U << 20 ) ;
9376 in += WORD_INCR;
9377 value |= (CONVERT(*in) % (1U<< 16 ))<<( 20 - 16 );
9378 *out |= (value << 2);
9379
9380 /* 04 */
9381 value = ( CONVERT(*in) >> 16 ) % (1U << 20 ) ;
9382 in += WORD_INCR;
9383 value |= (CONVERT(*in) % (1U<< 4 ))<<( 20 - 4 );
9384 *out |= (value << 24);
9385 out += WORD_INCR;
9386 *out |= (value >> (22 - 14));
9387
9388 /* 05 */
9389 value = ( CONVERT(*in) >> 4 ) % (1U << 20 ) ;
9390 *out |= (value << 14);
9391 out += WORD_INCR;
9392 *out |= (value >> (22 - 4));
9393
9394 /* 06 */
9395 value = ( CONVERT(*in) >> 24 ) % (1U << 20 ) ;
9396 in += WORD_INCR;
9397 value |= (CONVERT(*in) % (1U<< 12 ))<<( 20 - 12 );
9398 *out |= (value << 4);
9399
9400 /* 07 */
9401 value = ( CONVERT(*in) >> 12 ) % (1U << 20 ) ;
9402 *out |= (value << 26);
9403 out += WORD_INCR;
9404 *out |= (value >> (22 - 16));
9405
9406 /* 08 */
9407 in += WORD_INCR;
9408 value = ( CONVERT(*in) >> 0 ) % (1U << 20 ) ;
9409 *out |= (value << 16);
9410 out += WORD_INCR;
9411 *out |= (value >> (22 - 6));
9412
9413 /* 09 */
9414 value = ( CONVERT(*in) >> 20 ) % (1U << 20 ) ;
9415 in += WORD_INCR;
9416 value |= (CONVERT(*in) % (1U<< 8 ))<<( 20 - 8 );
9417 *out |= (value << 6);
9418
9419 /* 10 */
9420 value = ( CONVERT(*in) >> 8 ) % (1U << 20 ) ;
9421 *out |= (value << 28);
9422 out += WORD_INCR;
9423 *out |= (value >> (22 - 18));
9424
9425 /* 11 */
9426 value = ( CONVERT(*in) >> 28 ) % (1U << 20 ) ;
9427 in += WORD_INCR;
9428 value |= (CONVERT(*in) % (1U<< 16 ))<<( 20 - 16 );
9429 *out |= (value << 18);
9430 out += WORD_INCR;
9431 *out |= (value >> (22 - 8));
9432
9433 /* 12 */
9434 value = ( CONVERT(*in) >> 16 ) % (1U << 20 ) ;
9435 in += WORD_INCR;
9436 value |= (CONVERT(*in) % (1U<< 4 ))<<( 20 - 4 );
9437 *out |= (value << 8);
9438
9439 /* 13 */
9440 value = ( CONVERT(*in) >> 4 ) % (1U << 20 ) ;
9441 *out |= (value << 30);
9442 out += WORD_INCR;
9443 *out |= (value >> (22 - 20));
9444
9445 /* 14 */
9446 value = ( CONVERT(*in) >> 24 ) % (1U << 20 ) ;
9447 in += WORD_INCR;
9448 value |= (CONVERT(*in) % (1U<< 12 ))<<( 20 - 12 );
9449 *out |= (value << 20);
9450 out += WORD_INCR;
9451 *out |= (value >> (22 - 10));
9452
9453 /* 15 */
9454 value = ( CONVERT(*in) >> 12 ) % (1U << 20 ) ;
9455 *out |= (value << 10);
9456
9457 return;
9458 }
9459
9460 static void
transfer_22_24(UINT4 * out,const UINT4 * in)9461 transfer_22_24 (UINT4 *out, const UINT4 *in) {
9462 UINT4 value;
9463
9464 /* 00 */
9465 value = ( CONVERT(*in) >> 0 ) % (1U << 22 ) ;
9466 *out |= (value << 0);
9467
9468 /* 01 */
9469 value = ( CONVERT(*in) >> 22 ) % (1U << 22 ) ;
9470 in += WORD_INCR;
9471 value |= (CONVERT(*in) % (1U<< 12 ))<<( 22 - 12 );
9472 *out |= (value << 24);
9473 out += WORD_INCR;
9474 *out |= (value >> (24 - 16));
9475
9476 /* 02 */
9477 value = ( CONVERT(*in) >> 12 ) % (1U << 22 ) ;
9478 in += WORD_INCR;
9479 value |= (CONVERT(*in) % (1U<< 2 ))<<( 22 - 2 );
9480 *out |= (value << 16);
9481 out += WORD_INCR;
9482 *out |= (value >> (24 - 8));
9483
9484 /* 03 */
9485 value = ( CONVERT(*in) >> 2 ) % (1U << 22 ) ;
9486 *out |= (value << 8);
9487
9488 /* 04 */
9489 value = ( CONVERT(*in) >> 24 ) % (1U << 22 ) ;
9490 in += WORD_INCR;
9491 value |= (CONVERT(*in) % (1U<< 14 ))<<( 22 - 14 );
9492 out += WORD_INCR;
9493 *out |= (value << 0);
9494
9495 /* 05 */
9496 value = ( CONVERT(*in) >> 14 ) % (1U << 22 ) ;
9497 in += WORD_INCR;
9498 value |= (CONVERT(*in) % (1U<< 4 ))<<( 22 - 4 );
9499 *out |= (value << 24);
9500 out += WORD_INCR;
9501 *out |= (value >> (24 - 16));
9502
9503 /* 06 */
9504 value = ( CONVERT(*in) >> 4 ) % (1U << 22 ) ;
9505 *out |= (value << 16);
9506 out += WORD_INCR;
9507 *out |= (value >> (24 - 8));
9508
9509 /* 07 */
9510 value = ( CONVERT(*in) >> 26 ) % (1U << 22 ) ;
9511 in += WORD_INCR;
9512 value |= (CONVERT(*in) % (1U<< 16 ))<<( 22 - 16 );
9513 *out |= (value << 8);
9514
9515 /* 08 */
9516 value = ( CONVERT(*in) >> 16 ) % (1U << 22 ) ;
9517 in += WORD_INCR;
9518 value |= (CONVERT(*in) % (1U<< 6 ))<<( 22 - 6 );
9519 out += WORD_INCR;
9520 *out |= (value << 0);
9521
9522 /* 09 */
9523 value = ( CONVERT(*in) >> 6 ) % (1U << 22 ) ;
9524 *out |= (value << 24);
9525 out += WORD_INCR;
9526 *out |= (value >> (24 - 16));
9527
9528 /* 10 */
9529 value = ( CONVERT(*in) >> 28 ) % (1U << 22 ) ;
9530 in += WORD_INCR;
9531 value |= (CONVERT(*in) % (1U<< 18 ))<<( 22 - 18 );
9532 *out |= (value << 16);
9533 out += WORD_INCR;
9534 *out |= (value >> (24 - 8));
9535
9536 /* 11 */
9537 value = ( CONVERT(*in) >> 18 ) % (1U << 22 ) ;
9538 in += WORD_INCR;
9539 value |= (CONVERT(*in) % (1U<< 8 ))<<( 22 - 8 );
9540 *out |= (value << 8);
9541
9542 /* 12 */
9543 value = ( CONVERT(*in) >> 8 ) % (1U << 22 ) ;
9544 out += WORD_INCR;
9545 *out |= (value << 0);
9546
9547 /* 13 */
9548 value = ( CONVERT(*in) >> 30 ) % (1U << 22 ) ;
9549 in += WORD_INCR;
9550 value |= (CONVERT(*in) % (1U<< 20 ))<<( 22 - 20 );
9551 *out |= (value << 24);
9552 out += WORD_INCR;
9553 *out |= (value >> (24 - 16));
9554
9555 /* 14 */
9556 value = ( CONVERT(*in) >> 20 ) % (1U << 22 ) ;
9557 in += WORD_INCR;
9558 value |= (CONVERT(*in) % (1U<< 10 ))<<( 22 - 10 );
9559 *out |= (value << 16);
9560 out += WORD_INCR;
9561 *out |= (value >> (24 - 8));
9562
9563 /* 15 */
9564 value = ( CONVERT(*in) >> 10 ) % (1U << 22 ) ;
9565 *out |= (value << 8);
9566
9567 return;
9568 }
9569
9570 static void
transfer_24_26(UINT4 * out,const UINT4 * in)9571 transfer_24_26 (UINT4 *out, const UINT4 *in) {
9572 UINT4 value;
9573
9574 /* 00 */
9575 value = ( CONVERT(*in) >> 0 ) % (1U << 24 ) ;
9576 *out |= (value << 0);
9577
9578 /* 01 */
9579 value = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
9580 in += WORD_INCR;
9581 value |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 );
9582 *out |= (value << 26);
9583 out += WORD_INCR;
9584 *out |= (value >> (26 - 20));
9585
9586 /* 02 */
9587 value = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
9588 in += WORD_INCR;
9589 value |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 );
9590 *out |= (value << 20);
9591 out += WORD_INCR;
9592 *out |= (value >> (26 - 14));
9593
9594 /* 03 */
9595 value = ( CONVERT(*in) >> 8 ) % (1U << 24 ) ;
9596 *out |= (value << 14);
9597 out += WORD_INCR;
9598 *out |= (value >> (26 - 8));
9599
9600 /* 04 */
9601 in += WORD_INCR;
9602 value = ( CONVERT(*in) >> 0 ) % (1U << 24 ) ;
9603 *out |= (value << 8);
9604 out += WORD_INCR;
9605 *out |= (value >> (26 - 2));
9606
9607 /* 05 */
9608 value = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
9609 in += WORD_INCR;
9610 value |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 );
9611 *out |= (value << 2);
9612
9613 /* 06 */
9614 value = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
9615 in += WORD_INCR;
9616 value |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 );
9617 *out |= (value << 28);
9618 out += WORD_INCR;
9619 *out |= (value >> (26 - 22));
9620
9621 /* 07 */
9622 value = ( CONVERT(*in) >> 8 ) % (1U << 24 ) ;
9623 *out |= (value << 22);
9624 out += WORD_INCR;
9625 *out |= (value >> (26 - 16));
9626
9627 /* 08 */
9628 in += WORD_INCR;
9629 value = ( CONVERT(*in) >> 0 ) % (1U << 24 ) ;
9630 *out |= (value << 16);
9631 out += WORD_INCR;
9632 *out |= (value >> (26 - 10));
9633
9634 /* 09 */
9635 value = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
9636 in += WORD_INCR;
9637 value |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 );
9638 *out |= (value << 10);
9639 out += WORD_INCR;
9640 *out |= (value >> (26 - 4));
9641
9642 /* 10 */
9643 value = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
9644 in += WORD_INCR;
9645 value |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 );
9646 *out |= (value << 4);
9647
9648 /* 11 */
9649 value = ( CONVERT(*in) >> 8 ) % (1U << 24 ) ;
9650 *out |= (value << 30);
9651 out += WORD_INCR;
9652 *out |= (value >> (26 - 24));
9653
9654 /* 12 */
9655 in += WORD_INCR;
9656 value = ( CONVERT(*in) >> 0 ) % (1U << 24 ) ;
9657 *out |= (value << 24);
9658 out += WORD_INCR;
9659 *out |= (value >> (26 - 18));
9660
9661 /* 13 */
9662 value = ( CONVERT(*in) >> 24 ) % (1U << 24 ) ;
9663 in += WORD_INCR;
9664 value |= (CONVERT(*in) % (1U<< 16 ))<<( 24 - 16 );
9665 *out |= (value << 18);
9666 out += WORD_INCR;
9667 *out |= (value >> (26 - 12));
9668
9669 /* 14 */
9670 value = ( CONVERT(*in) >> 16 ) % (1U << 24 ) ;
9671 in += WORD_INCR;
9672 value |= (CONVERT(*in) % (1U<< 8 ))<<( 24 - 8 );
9673 *out |= (value << 12);
9674 out += WORD_INCR;
9675 *out |= (value >> (26 - 6));
9676
9677 /* 15 */
9678 value = ( CONVERT(*in) >> 8 ) % (1U << 24 ) ;
9679 *out |= (value << 6);
9680
9681 return;
9682 }
9683
9684 static void
transfer_26_28(UINT4 * out,const UINT4 * in)9685 transfer_26_28 (UINT4 *out, const UINT4 *in) {
9686 UINT4 value;
9687
9688 /* 00 */
9689 value = ( CONVERT(*in) >> 0 ) % (1U << 26 ) ;
9690 *out |= (value << 0);
9691
9692 /* 01 */
9693 value = ( CONVERT(*in) >> 26 ) % (1U << 26 ) ;
9694 in += WORD_INCR;
9695 value |= (CONVERT(*in) % (1U<< 20 ))<<( 26 - 20 );
9696 *out |= (value << 28);
9697 out += WORD_INCR;
9698 *out |= (value >> (28 - 24));
9699
9700 /* 02 */
9701 value = ( CONVERT(*in) >> 20 ) % (1U << 26 ) ;
9702 in += WORD_INCR;
9703 value |= (CONVERT(*in) % (1U<< 14 ))<<( 26 - 14 );
9704 *out |= (value << 24);
9705 out += WORD_INCR;
9706 *out |= (value >> (28 - 20));
9707
9708 /* 03 */
9709 value = ( CONVERT(*in) >> 14 ) % (1U << 26 ) ;
9710 in += WORD_INCR;
9711 value |= (CONVERT(*in) % (1U<< 8 ))<<( 26 - 8 );
9712 *out |= (value << 20);
9713 out += WORD_INCR;
9714 *out |= (value >> (28 - 16));
9715
9716 /* 04 */
9717 value = ( CONVERT(*in) >> 8 ) % (1U << 26 ) ;
9718 in += WORD_INCR;
9719 value |= (CONVERT(*in) % (1U<< 2 ))<<( 26 - 2 );
9720 *out |= (value << 16);
9721 out += WORD_INCR;
9722 *out |= (value >> (28 - 12));
9723
9724 /* 05 */
9725 value = ( CONVERT(*in) >> 2 ) % (1U << 26 ) ;
9726 *out |= (value << 12);
9727 out += WORD_INCR;
9728 *out |= (value >> (28 - 8));
9729
9730 /* 06 */
9731 value = ( CONVERT(*in) >> 28 ) % (1U << 26 ) ;
9732 in += WORD_INCR;
9733 value |= (CONVERT(*in) % (1U<< 22 ))<<( 26 - 22 );
9734 *out |= (value << 8);
9735 out += WORD_INCR;
9736 *out |= (value >> (28 - 4));
9737
9738 /* 07 */
9739 value = ( CONVERT(*in) >> 22 ) % (1U << 26 ) ;
9740 in += WORD_INCR;
9741 value |= (CONVERT(*in) % (1U<< 16 ))<<( 26 - 16 );
9742 *out |= (value << 4);
9743
9744 /* 08 */
9745 value = ( CONVERT(*in) >> 16 ) % (1U << 26 ) ;
9746 in += WORD_INCR;
9747 value |= (CONVERT(*in) % (1U<< 10 ))<<( 26 - 10 );
9748 out += WORD_INCR;
9749 *out |= (value << 0);
9750
9751 /* 09 */
9752 value = ( CONVERT(*in) >> 10 ) % (1U << 26 ) ;
9753 in += WORD_INCR;
9754 value |= (CONVERT(*in) % (1U<< 4 ))<<( 26 - 4 );
9755 *out |= (value << 28);
9756 out += WORD_INCR;
9757 *out |= (value >> (28 - 24));
9758
9759 /* 10 */
9760 value = ( CONVERT(*in) >> 4 ) % (1U << 26 ) ;
9761 *out |= (value << 24);
9762 out += WORD_INCR;
9763 *out |= (value >> (28 - 20));
9764
9765 /* 11 */
9766 value = ( CONVERT(*in) >> 30 ) % (1U << 26 ) ;
9767 in += WORD_INCR;
9768 value |= (CONVERT(*in) % (1U<< 24 ))<<( 26 - 24 );
9769 *out |= (value << 20);
9770 out += WORD_INCR;
9771 *out |= (value >> (28 - 16));
9772
9773 /* 12 */
9774 value = ( CONVERT(*in) >> 24 ) % (1U << 26 ) ;
9775 in += WORD_INCR;
9776 value |= (CONVERT(*in) % (1U<< 18 ))<<( 26 - 18 );
9777 *out |= (value << 16);
9778 out += WORD_INCR;
9779 *out |= (value >> (28 - 12));
9780
9781 /* 13 */
9782 value = ( CONVERT(*in) >> 18 ) % (1U << 26 ) ;
9783 in += WORD_INCR;
9784 value |= (CONVERT(*in) % (1U<< 12 ))<<( 26 - 12 );
9785 *out |= (value << 12);
9786 out += WORD_INCR;
9787 *out |= (value >> (28 - 8));
9788
9789 /* 14 */
9790 value = ( CONVERT(*in) >> 12 ) % (1U << 26 ) ;
9791 in += WORD_INCR;
9792 value |= (CONVERT(*in) % (1U<< 6 ))<<( 26 - 6 );
9793 *out |= (value << 8);
9794 out += WORD_INCR;
9795 *out |= (value >> (28 - 4));
9796
9797 /* 15 */
9798 value = ( CONVERT(*in) >> 6 ) % (1U << 26 ) ;
9799 *out |= (value << 4);
9800
9801 return;
9802 }
9803
9804 static void
transfer_28_30(UINT4 * out,const UINT4 * in)9805 transfer_28_30 (UINT4 *out, const UINT4 *in) {
9806 UINT4 value;
9807
9808 /* 00 */
9809 value = ( CONVERT(*in) >> 0 ) % (1U << 28 ) ;
9810 *out |= (value << 0);
9811
9812 /* 01 */
9813 value = ( CONVERT(*in) >> 28 ) % (1U << 28 ) ;
9814 in += WORD_INCR;
9815 value |= (CONVERT(*in) % (1U<< 24 ))<<( 28 - 24 );
9816 *out |= (value << 30);
9817 out += WORD_INCR;
9818 *out |= (value >> (30 - 28));
9819
9820 /* 02 */
9821 value = ( CONVERT(*in) >> 24 ) % (1U << 28 ) ;
9822 in += WORD_INCR;
9823 value |= (CONVERT(*in) % (1U<< 20 ))<<( 28 - 20 );
9824 *out |= (value << 28);
9825 out += WORD_INCR;
9826 *out |= (value >> (30 - 26));
9827
9828 /* 03 */
9829 value = ( CONVERT(*in) >> 20 ) % (1U << 28 ) ;
9830 in += WORD_INCR;
9831 value |= (CONVERT(*in) % (1U<< 16 ))<<( 28 - 16 );
9832 *out |= (value << 26);
9833 out += WORD_INCR;
9834 *out |= (value >> (30 - 24));
9835
9836 /* 04 */
9837 value = ( CONVERT(*in) >> 16 ) % (1U << 28 ) ;
9838 in += WORD_INCR;
9839 value |= (CONVERT(*in) % (1U<< 12 ))<<( 28 - 12 );
9840 *out |= (value << 24);
9841 out += WORD_INCR;
9842 *out |= (value >> (30 - 22));
9843
9844 /* 05 */
9845 value = ( CONVERT(*in) >> 12 ) % (1U << 28 ) ;
9846 in += WORD_INCR;
9847 value |= (CONVERT(*in) % (1U<< 8 ))<<( 28 - 8 );
9848 *out |= (value << 22);
9849 out += WORD_INCR;
9850 *out |= (value >> (30 - 20));
9851
9852 /* 06 */
9853 value = ( CONVERT(*in) >> 8 ) % (1U << 28 ) ;
9854 in += WORD_INCR;
9855 value |= (CONVERT(*in) % (1U<< 4 ))<<( 28 - 4 );
9856 *out |= (value << 20);
9857 out += WORD_INCR;
9858 *out |= (value >> (30 - 18));
9859
9860 /* 07 */
9861 value = ( CONVERT(*in) >> 4 ) % (1U << 28 ) ;
9862 *out |= (value << 18);
9863 out += WORD_INCR;
9864 *out |= (value >> (30 - 16));
9865
9866 /* 08 */
9867 in += WORD_INCR;
9868 value = ( CONVERT(*in) >> 0 ) % (1U << 28 ) ;
9869 *out |= (value << 16);
9870 out += WORD_INCR;
9871 *out |= (value >> (30 - 14));
9872
9873 /* 09 */
9874 value = ( CONVERT(*in) >> 28 ) % (1U << 28 ) ;
9875 in += WORD_INCR;
9876 value |= (CONVERT(*in) % (1U<< 24 ))<<( 28 - 24 );
9877 *out |= (value << 14);
9878 out += WORD_INCR;
9879 *out |= (value >> (30 - 12));
9880
9881 /* 10 */
9882 value = ( CONVERT(*in) >> 24 ) % (1U << 28 ) ;
9883 in += WORD_INCR;
9884 value |= (CONVERT(*in) % (1U<< 20 ))<<( 28 - 20 );
9885 *out |= (value << 12);
9886 out += WORD_INCR;
9887 *out |= (value >> (30 - 10));
9888
9889 /* 11 */
9890 value = ( CONVERT(*in) >> 20 ) % (1U << 28 ) ;
9891 in += WORD_INCR;
9892 value |= (CONVERT(*in) % (1U<< 16 ))<<( 28 - 16 );
9893 *out |= (value << 10);
9894 out += WORD_INCR;
9895 *out |= (value >> (30 - 8));
9896
9897 /* 12 */
9898 value = ( CONVERT(*in) >> 16 ) % (1U << 28 ) ;
9899 in += WORD_INCR;
9900 value |= (CONVERT(*in) % (1U<< 12 ))<<( 28 - 12 );
9901 *out |= (value << 8);
9902 out += WORD_INCR;
9903 *out |= (value >> (30 - 6));
9904
9905 /* 13 */
9906 value = ( CONVERT(*in) >> 12 ) % (1U << 28 ) ;
9907 in += WORD_INCR;
9908 value |= (CONVERT(*in) % (1U<< 8 ))<<( 28 - 8 );
9909 *out |= (value << 6);
9910 out += WORD_INCR;
9911 *out |= (value >> (30 - 4));
9912
9913 /* 14 */
9914 value = ( CONVERT(*in) >> 8 ) % (1U << 28 ) ;
9915 in += WORD_INCR;
9916 value |= (CONVERT(*in) % (1U<< 4 ))<<( 28 - 4 );
9917 *out |= (value << 4);
9918 out += WORD_INCR;
9919 *out |= (value >> (30 - 2));
9920
9921 /* 15 */
9922 value = ( CONVERT(*in) >> 4 ) % (1U << 28 ) ;
9923 *out |= (value << 2);
9924
9925 return;
9926 }
9927
9928
9929 static void
transfer_30_32(UINT4 * out,const UINT4 * in)9930 transfer_30_32 (UINT4 *out, const UINT4 *in) {
9931 UINT4 value;
9932
9933 /* 00 */
9934 value = ( CONVERT(*in) >> 0 ) % (1U << 30 ) ;
9935 *out |= value;
9936
9937 /* 01 */
9938 value = ( CONVERT(*in) >> 30 ) % (1U << 30 ) ;
9939 in += WORD_INCR;
9940 value |= (CONVERT(*in) % (1U<< 28 ))<<( 30 - 28 );
9941 out += WORD_INCR;
9942 *out |= value;
9943
9944 /* 02 */
9945 value = ( CONVERT(*in) >> 28 ) % (1U << 30 ) ;
9946 in += WORD_INCR;
9947 value |= (CONVERT(*in) % (1U<< 26 ))<<( 30 - 26 );
9948 out += WORD_INCR;
9949 *out |= value;
9950
9951 /* 03 */
9952 value = ( CONVERT(*in) >> 26 ) % (1U << 30 ) ;
9953 in += WORD_INCR;
9954 value |= (CONVERT(*in) % (1U<< 24 ))<<( 30 - 24 );
9955 out += WORD_INCR;
9956 *out |= value;
9957
9958 /* 04 */
9959 value = ( CONVERT(*in) >> 24 ) % (1U << 30 ) ;
9960 in += WORD_INCR;
9961 value |= (CONVERT(*in) % (1U<< 22 ))<<( 30 - 22 );
9962 out += WORD_INCR;
9963 *out |= value;
9964
9965 /* 05 */
9966 value = ( CONVERT(*in) >> 22 ) % (1U << 30 ) ;
9967 in += WORD_INCR;
9968 value |= (CONVERT(*in) % (1U<< 20 ))<<( 30 - 20 );
9969 out += WORD_INCR;
9970 *out |= value;
9971
9972 /* 06 */
9973 value = ( CONVERT(*in) >> 20 ) % (1U << 30 ) ;
9974 in += WORD_INCR;
9975 value |= (CONVERT(*in) % (1U<< 18 ))<<( 30 - 18 );
9976 out += WORD_INCR;
9977 *out |= value;
9978
9979 /* 07 */
9980 value = ( CONVERT(*in) >> 18 ) % (1U << 30 ) ;
9981 in += WORD_INCR;
9982 value |= (CONVERT(*in) % (1U<< 16 ))<<( 30 - 16 );
9983 out += WORD_INCR;
9984 *out |= value;
9985
9986 /* 08 */
9987 value = ( CONVERT(*in) >> 16 ) % (1U << 30 ) ;
9988 in += WORD_INCR;
9989 value |= (CONVERT(*in) % (1U<< 14 ))<<( 30 - 14 );
9990 out += WORD_INCR;
9991 *out |= value;
9992
9993 /* 09 */
9994 value = ( CONVERT(*in) >> 14 ) % (1U << 30 ) ;
9995 in += WORD_INCR;
9996 value |= (CONVERT(*in) % (1U<< 12 ))<<( 30 - 12 );
9997 out += WORD_INCR;
9998 *out |= value;
9999
10000 /* 10 */
10001 value = ( CONVERT(*in) >> 12 ) % (1U << 30 ) ;
10002 in += WORD_INCR;
10003 value |= (CONVERT(*in) % (1U<< 10 ))<<( 30 - 10 );
10004 out += WORD_INCR;
10005 *out |= value;
10006
10007 /* 11 */
10008 value = ( CONVERT(*in) >> 10 ) % (1U << 30 ) ;
10009 in += WORD_INCR;
10010 value |= (CONVERT(*in) % (1U<< 8 ))<<( 30 - 8 );
10011 out += WORD_INCR;
10012 *out |= value;
10013
10014 /* 12 */
10015 value = ( CONVERT(*in) >> 8 ) % (1U << 30 ) ;
10016 in += WORD_INCR;
10017 value |= (CONVERT(*in) % (1U<< 6 ))<<( 30 - 6 );
10018 out += WORD_INCR;
10019 *out |= value;
10020
10021 /* 13 */
10022 value = ( CONVERT(*in) >> 6 ) % (1U << 30 ) ;
10023 in += WORD_INCR;
10024 value |= (CONVERT(*in) % (1U<< 4 ))<<( 30 - 4 );
10025 out += WORD_INCR;
10026 *out |= value;
10027
10028 /* 14 */
10029 value = ( CONVERT(*in) >> 4 ) % (1U << 30 ) ;
10030 in += WORD_INCR;
10031 value |= (CONVERT(*in) % (1U<< 2 ))<<( 30 - 2 );
10032 out += WORD_INCR;
10033 *out |= value;
10034
10035 /* 15 */
10036 value = ( CONVERT(*in) >> 2 ) % (1U << 30 ) ;
10037 out += WORD_INCR;
10038 *out |= value;
10039
10040 return;
10041 }
10042
10043
10044
10045 typedef void (*Transfer_T) (UINT4 *, const UINT4 *);
10046
10047 static Transfer_T transfer_table[16] =
10048 {transfer_00_02, transfer_02_04, transfer_04_06, transfer_06_08,
10049 transfer_08_10, transfer_10_12, transfer_12_14, transfer_14_16,
10050 transfer_16_18, transfer_18_20, transfer_20_22, transfer_22_24,
10051 transfer_24_26, transfer_26_28, transfer_28_30, transfer_30_32};
10052
10053 UINT4 *
Bitpack64_realloc_one(int packsize,UINT4 * bitpack)10054 Bitpack64_realloc_one (int packsize, UINT4 *bitpack) {
10055 UINT4 *new;
10056 int nregisters;
10057 #ifdef CHECK
10058 int i;
10059 #endif
10060
10061 new = (UINT4 *) CALLOC((packsize + 2) / 2 * 4,sizeof(UINT4));
10062
10063 nregisters = packsize/2;
10064 (transfer_table[nregisters])(&(new[/*column*/0]),&(bitpack[/*column*/0]));
10065 (transfer_table[nregisters])(&(new[/*column*/1]),&(bitpack[/*column*/1]));
10066 (transfer_table[nregisters])(&(new[/*column*/2]),&(bitpack[/*column*/2]));
10067 (transfer_table[nregisters])(&(new[/*column*/3]),&(bitpack[/*column*/3]));
10068
10069 #ifdef CHECK
10070 for (i = 0; i < 64; i++) {
10071 if (Bitpack64_access_bitpack(i,packsize+2,new) != Bitpack64_access_bitpack(i,packsize,bitpack)) {
10072 fprintf(stderr,"Difference in packsize %d -> %d, index %d: %u != %u\n",
10073 packsize,packsize+2,i,
10074 Bitpack64_access_bitpack(i,packsize,bitpack),
10075 Bitpack64_access_bitpack(i,packsize+2,new));
10076 abort();
10077 }
10078 }
10079 #endif
10080
10081 FREE(bitpack);
10082 return new;
10083 }
10084
10085
10086 UINT4 *
Bitpack64_realloc_multiple(int old_packsize,int new_packsize,UINT4 * bitpack)10087 Bitpack64_realloc_multiple (int old_packsize, int new_packsize, UINT4 *bitpack) {
10088 UINT4 *new;
10089 int nregisters, packsize;
10090 #ifdef CHECK
10091 int i;
10092 #endif
10093
10094 for (packsize = old_packsize; packsize < new_packsize; packsize += 2) {
10095 new = (UINT4 *) CALLOC((packsize + 2) / 2 * 4,sizeof(UINT4));
10096
10097 nregisters = packsize/2;
10098 (transfer_table[nregisters])(&(new[/*column*/0]),&(bitpack[/*column*/0]));
10099 (transfer_table[nregisters])(&(new[/*column*/1]),&(bitpack[/*column*/1]));
10100 (transfer_table[nregisters])(&(new[/*column*/2]),&(bitpack[/*column*/2]));
10101 (transfer_table[nregisters])(&(new[/*column*/3]),&(bitpack[/*column*/3]));
10102
10103 #ifdef CHECK
10104 for (i = 0; i < 64; i++) {
10105 if (Bitpack64_access_bitpack(i,packsize+2,new) != Bitpack64_access_bitpack(i,packsize,bitpack)) {
10106 fprintf(stderr,"Difference in packsize %d -> %d, index %d: %u != %u\n",
10107 packsize,packsize+2,i,
10108 Bitpack64_access_bitpack(i,packsize,bitpack),
10109 Bitpack64_access_bitpack(i,packsize+2,new));
10110 abort();
10111 }
10112 }
10113 #endif
10114
10115 FREE(bitpack);
10116 bitpack = new;
10117 }
10118
10119 return bitpack;
10120 }
10121
10122