bitmaps/
types.rs

1// This Source Code Form is subject to the terms of the Mozilla Public
2// License, v. 2.0. If a copy of the MPL was not distributed with this
3// file, You can obtain one at http://mozilla.org/MPL/2.0/.
4
5use core::fmt::Debug;
6
7/// A trait that defines generalised operations on a `Bits::Store` type.
8pub trait BitOps {
9    fn get(bits: &Self, index: usize) -> bool;
10    fn set(bits: &mut Self, index: usize, value: bool) -> bool;
11    fn len(bits: &Self) -> usize;
12    fn first_index(bits: &Self) -> Option<usize>;
13    fn first_false_index(bits: &Self) -> Option<usize>;
14    fn last_index(bits: &Self) -> Option<usize>;
15    fn last_false_index(bits: &Self) -> Option<usize>;
16    fn next_index(bits: &Self, index: usize) -> Option<usize>;
17    fn next_false_index(bits: &Self, index: usize) -> Option<usize>;
18    fn prev_index(bits: &Self, index: usize) -> Option<usize>;
19    fn prev_false_index(bits: &Self, index: usize) -> Option<usize>;
20    fn bit_and(bits: &mut Self, other_bits: &Self);
21    fn bit_or(bits: &mut Self, other_bits: &Self);
22    fn bit_xor(bits: &mut Self, other_bits: &Self);
23    fn invert(bits: &mut Self);
24    fn make_mask(shift: usize) -> Self;
25    fn bit_size() -> usize;
26    #[cfg(feature = "std")]
27    fn to_hex(bits: &Self) -> String;
28}
29
30impl BitOps for bool {
31    #[inline]
32    fn get(bits: &Self, index: usize) -> bool {
33        debug_assert!(index == 0);
34        *bits
35    }
36
37    #[inline]
38    fn set(bits: &mut Self, index: usize, value: bool) -> bool {
39        debug_assert!(index == 0);
40        core::mem::replace(bits, value)
41    }
42
43    #[inline]
44    fn len(bits: &Self) -> usize {
45        if *bits {
46            1
47        } else {
48            0
49        }
50    }
51
52    #[inline]
53    fn first_index(bits: &Self) -> Option<usize> {
54        if *bits {
55            Some(0)
56        } else {
57            None
58        }
59    }
60
61    #[inline]
62    fn first_false_index(bits: &Self) -> Option<usize> {
63        if !*bits {
64            Some(0)
65        } else {
66            None
67        }
68    }
69
70    #[inline]
71    fn last_index(bits: &Self) -> Option<usize> {
72        if *bits {
73            Some(0)
74        } else {
75            None
76        }
77    }
78
79    #[inline]
80    fn last_false_index(bits: &Self) -> Option<usize> {
81        if !*bits {
82            Some(0)
83        } else {
84            None
85        }
86    }
87    #[inline]
88    fn next_index(bits: &Self, index: usize) -> Option<usize> {
89        debug_assert!(index == 0);
90        if *bits {
91            None
92        } else {
93            None
94        }
95    }
96
97    #[inline]
98    fn next_false_index(bits: &Self, index: usize) -> Option<usize> {
99        debug_assert!(index == 0);
100        if *bits {
101            None
102        } else {
103            None
104        }
105    }
106
107    #[inline]
108    fn prev_index(bits: &Self, index: usize) -> Option<usize> {
109        debug_assert!(index == 0);
110        if *bits {
111            None
112        } else {
113            None
114        }
115    }
116
117    #[inline]
118    fn prev_false_index(bits: &Self, index: usize) -> Option<usize> {
119        debug_assert!(index == 0);
120        if *bits {
121            None
122        } else {
123            None
124        }
125    }
126
127    #[inline]
128    fn bit_and(bits: &mut Self, other_bits: &Self) {
129        *bits &= *other_bits;
130    }
131
132    #[inline]
133    fn bit_or(bits: &mut Self, other_bits: &Self) {
134        *bits |= *other_bits;
135    }
136
137    #[inline]
138    fn bit_xor(bits: &mut Self, other_bits: &Self) {
139        *bits ^= *other_bits;
140    }
141
142    #[inline]
143    fn invert(bits: &mut Self) {
144        *bits = !*bits;
145    }
146
147    #[inline]
148    fn make_mask(shift: usize) -> Self {
149        shift > 0
150    }
151
152    #[cfg(feature = "std")]
153    fn to_hex(bits: &Self) -> String {
154        if *bits {
155            "1".to_owned()
156        } else {
157            "0".to_owned()
158        }
159    }
160
161    fn bit_size() -> usize {
162        1
163    }
164}
165
166macro_rules! bitops_for {
167    ($target:ty) => {
168        impl BitOps for $target {
169            #[inline]
170            fn get(bits: &Self, index: usize) -> bool {
171                bits & (1 << index) != 0
172            }
173
174            #[inline]
175            fn set(bits: &mut Self, index: usize, value: bool) -> bool {
176                let mask = 1 << index;
177                let prev = *bits & mask;
178                if value {
179                    *bits |= mask;
180                } else {
181                    *bits &= !mask;
182                }
183                prev != 0
184            }
185
186            #[inline]
187            fn len(bits: &Self) -> usize {
188                bits.count_ones() as usize
189            }
190
191            #[inline]
192            fn first_index(bits: &Self) -> Option<usize> {
193                if *bits == 0 {
194                    None
195                } else {
196                    Some(bits.trailing_zeros() as usize)
197                }
198            }
199
200            #[inline]
201            fn first_false_index(bits: &Self) -> Option<usize> {
202                if *bits == <$target>::MAX {
203                    None
204                } else {
205                    Some(bits.trailing_ones() as usize)
206                }
207            }
208
209            #[inline]
210            fn last_index(bits: &Self) -> Option<usize> {
211                if *bits == 0 {
212                    None
213                } else {
214                    Some(<$target>::BITS as usize - 1 - (bits.leading_zeros() as usize))
215                }
216            }
217
218            #[inline]
219            fn last_false_index(bits: &Self) -> Option<usize> {
220                if *bits == <$target>::MAX {
221                    None
222                } else {
223                    Some(<$target>::BITS as usize - 1 - bits.leading_ones() as usize)
224                }
225            }
226
227            #[inline]
228            fn next_index(bits: &Self, index: usize) -> Option<usize> {
229                if *bits == 0 || index >= <$target>::BITS as usize - 1 {
230                    None
231                } else {
232                    let intermediate = (*bits & (<$target>::MAX.overflowing_shl(1 + index as u32).0));
233
234                    if intermediate == 0 {
235                        None
236                    } else {
237                        Some(intermediate.trailing_zeros() as usize)
238                    }
239                }
240            }
241
242            #[inline]
243            fn next_false_index(bits: &Self, index: usize) -> Option<usize> {
244                if *bits == <$target>::MAX || index >= <$target>::BITS as usize - 1 {
245                    None
246                } else {
247                    let intermediate = (*bits | ((1 << (index + 1)) - 1));
248
249                    if intermediate == <$target>::MAX {
250                        None
251                    } else {
252                        Some(intermediate.trailing_ones() as usize)
253                    }
254                }
255            }
256
257            #[inline]
258            fn prev_index(bits: &Self, index: usize) -> Option<usize> {
259                if *bits == 0 || index == 0 {
260                    None
261                } else {
262                    let intermediate = bits & ((1 << index) - 1);
263
264                    if intermediate == 0 {
265                        None
266                    } else {
267                        Some(<$target>::BITS as usize - 1 - (intermediate.leading_zeros() as usize))
268                    }
269                }
270            }
271
272            #[inline]
273            fn prev_false_index(bits: &Self, index: usize) -> Option<usize> {
274                if *bits == <$target>::MAX || index == 0 {
275                    None
276                } else {
277                    let intermediate = bits | (<$target>::MAX.overflowing_shl(index as u32 - 1).0);
278
279                    if intermediate == <$target>::MAX {
280                        None
281                    } else {
282                        Some(<$target>::BITS as usize - 1 - (intermediate.leading_zeros() as usize))
283                    }
284                }
285            }
286
287            #[inline]
288            fn bit_and(bits: &mut Self, other_bits: &Self) {
289                *bits &= *other_bits;
290            }
291
292            #[inline]
293            fn bit_or(bits: &mut Self, other_bits: &Self) {
294                *bits |= *other_bits;
295            }
296
297            #[inline]
298            fn bit_xor(bits: &mut Self, other_bits: &Self) {
299                *bits ^= *other_bits;
300            }
301
302            #[inline]
303            fn invert(bits: &mut Self) {
304                *bits = !*bits;
305            }
306
307            #[inline]
308            fn make_mask(shift: usize) -> Self {
309                let (x, overflow) = (1 as Self).overflowing_shl(shift as u32);
310                if overflow { Self::MAX } else { x - 1 }
311            }
312
313            #[cfg(feature = "std")]
314            fn to_hex(bits: &Self) -> String {
315                format!("{:x}", bits)
316            }
317
318            #[inline]
319            fn bit_size() -> usize {
320                <$target>::BITS as usize
321            }
322        }
323    };
324}
325
326macro_rules! bitops_for_big {
327    ($words:expr) => {
328        impl BitOps for [u128; $words] {
329            #[inline]
330            fn get(bits: &Self, index: usize) -> bool {
331                let word_index = index / 128;
332                let index = index & 127;
333                bits[word_index] & (1 << index) != 0
334            }
335
336            #[inline]
337            fn set(bits: &mut Self, index: usize, value: bool) -> bool {
338                let word_index = index / 128;
339                let index = index & 127;
340
341                let mask = 1 << (index & 127);
342                let bits = &mut bits[word_index];
343                let prev = *bits & mask;
344                if value {
345                    *bits |= mask;
346                } else {
347                    *bits &= !mask;
348                }
349                prev != 0
350            }
351
352            fn make_mask(shift: usize) -> Self {
353                let word_index = shift / 128;
354                let index = shift & 127;
355                let mut out = [0; $words];
356                for (chunk_index, chunk) in out.iter_mut().enumerate() {
357                    if chunk_index < word_index {
358                        *chunk = !0u128;
359                    } else if chunk_index == word_index {
360                        *chunk = (1 << index) - 1;
361                    } else {
362                        return out;
363                    }
364                }
365                out
366            }
367
368            #[inline]
369            fn len(bits: &Self) -> usize {
370                bits.iter().fold(0, |acc, next| acc + next.count_ones()) as usize
371            }
372
373            #[inline]
374            fn first_index(bits: &Self) -> Option<usize> {
375                for (index, part) in bits.iter().enumerate() {
376                    if *part != 0u128 {
377                        return Some(part.trailing_zeros() as usize + (128 * index));
378                    }
379                }
380                None
381            }
382
383            #[inline]
384            fn last_index(bits: &Self) -> Option<usize> {
385                for (index, part) in bits.iter().enumerate().rev() {
386                    if *part != 0u128 {
387                        return Some((128 * index) + <u128 as BitOps>::last_index(part).unwrap());
388                    }
389                }
390                None
391            }
392
393            #[inline]
394            fn next_index(bits: &Self, index: usize) -> Option<usize> {
395                let segment: usize = index / 128;
396
397                if (segment >= bits.len()) {
398                    return None
399                }
400
401                let intermediate = <u128 as BitOps>::next_index(&bits[segment], index % 128);
402
403                if let Some(index) = intermediate {
404                    Some(segment * 128 + index)
405                } else {
406                    for (index, part) in bits[(segment + 1)..].iter().enumerate() {
407                        if *part != 0u128 {
408                            return Some(128 * (segment + 1 + index) + <u128 as BitOps>::first_index(part).unwrap());
409                        }
410                    }
411
412                    None
413                }
414            }
415
416            #[inline]
417            fn prev_index(bits: &Self, index: usize) -> Option<usize> {
418                let segment: usize = index / 128;
419
420                if (segment >= bits.len()) {
421                    return None
422                }
423
424                let intermediate = <u128 as BitOps>::prev_index(&bits[segment], index % 128);
425
426                if let Some(index) = intermediate {
427                    Some(segment * 128 + index)
428                } else {
429                    for (index, part) in bits[..segment].iter().enumerate().rev() {
430                        if *part != 0u128 {
431                            return Some(<u128 as BitOps>::last_index(part).unwrap() + (128 * index));
432                        }
433                    }
434                    None
435                }
436            }
437
438            #[inline]
439            fn first_false_index(bits: &Self) -> Option<usize> {
440                for (index, part) in bits.iter().enumerate() {
441                    if *part != u128::MAX {
442                        return Some(part.trailing_ones() as usize + (128 * index));
443                    }
444                }
445                None
446            }
447
448            #[inline]
449            fn last_false_index(bits: &Self) -> Option<usize> {
450                for (index, part) in bits.iter().enumerate().rev() {
451                    if *part != u128::MAX {
452                        return Some(<u128 as BitOps>::last_false_index(part).unwrap() + (128 * index));
453                    }
454                }
455                None
456            }
457
458            #[inline]
459            fn next_false_index(bits: &Self, index: usize) -> Option<usize> {
460                let segment: usize = index / 128;
461
462                if (segment >= bits.len()) {
463                    return None
464                }
465
466                let intermediate = <u128 as BitOps>::next_false_index(&bits[segment], index % 128);
467
468                if let Some(index) = intermediate {
469                    Some(segment * 128 + index)
470                } else {
471                    for (index, part) in bits[(segment + 1)..].iter().enumerate() {
472                        if *part != u128::MAX {
473                            return Some(128 * (segment + 1 + index) + <u128 as BitOps>::first_false_index(part).unwrap());
474                        }
475                    }
476
477                    None
478                }
479            }
480
481            #[inline]
482            fn prev_false_index(bits: &Self, index: usize) -> Option<usize> {
483                let segment: usize = index / 128;
484
485                if (segment >= bits.len()) {
486                    return None
487                }
488
489                let intermediate = <u128 as BitOps>::prev_false_index(&bits[segment], index % 128);
490
491                if let Some(index) = intermediate {
492                    Some(segment * 128 + index)
493                } else {
494                    for (index, part) in bits[..segment].iter().enumerate().rev() {
495                        if *part != u128::MAX {
496                            return Some(<u128 as BitOps>::last_false_index(part).unwrap() + (128 * index));
497                        }
498                    }
499
500                    None
501                }
502            }
503
504            #[inline]
505            fn bit_and(bits: &mut Self, other_bits: &Self) {
506                for (left, right) in bits.iter_mut().zip(other_bits.iter()) {
507                    *left &= *right;
508                }
509            }
510
511            #[inline]
512            fn bit_or(bits: &mut Self, other_bits: &Self) {
513                for (left, right) in bits.iter_mut().zip(other_bits.iter()) {
514                    *left |= *right;
515                }
516            }
517
518            #[inline]
519            fn bit_xor(bits: &mut Self, other_bits: &Self) {
520                for (left, right) in bits.iter_mut().zip(other_bits.iter()) {
521                    *left ^= *right;
522                }
523            }
524
525            #[inline]
526            fn invert(bits: &mut Self) {
527                for chunk in bits.iter_mut() {
528                    *chunk = !*chunk;
529                }
530            }
531
532            #[cfg(feature = "std")]
533            fn to_hex(bits: &Self) -> String {
534                let mut out = String::new();
535                for chunk in bits {
536                    out += &format!("{:x}", chunk);
537                }
538                out
539            }
540
541            #[inline]
542            fn bit_size() -> usize {
543                (<u128>::BITS * $words) as usize
544            }
545        }
546    };
547}
548
549bitops_for!(u8);
550bitops_for!(u16);
551bitops_for!(u32);
552bitops_for!(u64);
553bitops_for!(u128);
554
555bitops_for_big!(2);
556bitops_for_big!(3);
557bitops_for_big!(4);
558bitops_for_big!(5);
559bitops_for_big!(6);
560bitops_for_big!(7);
561bitops_for_big!(8);
562
563/// A type level number signifying the number of bits in a bitmap.
564///
565/// This trait is implemented for type level numbers from `U1` to `U1024`.
566///
567/// # Examples
568///
569/// ```rust
570/// # #[macro_use] extern crate bitmaps;
571/// # use bitmaps::{Bits, BitsImpl};
572/// assert_eq!(
573///     std::mem::size_of::<<BitsImpl<10> as Bits>::Store>(),
574///     std::mem::size_of::<u16>()
575/// );
576/// ```
577pub trait Bits {
578    /// The number of bits
579    const VALUE: usize;
580    /// A primitive integer type suitable for storing this many bits.
581    type Store: BitOps + Default + Copy + PartialEq + Debug;
582
583    /// The underlying data type might have some trailing bits, which would
584    /// result in an invalid value being returned.
585    ///
586    /// Thankfully, this only happens for 'false_index'-functions (bits higher
587    /// than VALUE - 1 cannot be set), and even then only for functions that
588    /// might seek in that area: that is all forward seeking functions, and
589    /// the one seeking backwards from the end (last_false_index).
590    /// prev_false_index is not affected, because the supplied index must be
591    /// valid, and any index lower than that is also valid.
592    #[inline]
593    fn corrected_first_false_index(store: &Self::Store) -> Option<usize> {
594        let result = Self::Store::first_false_index(store);
595
596        if Self::Store::bit_size() == Self::VALUE {
597            result
598        } else if let Some(result) = result {
599            if result >= Self::VALUE {
600                None
601            } else {
602                Some(result)
603            }
604        } else {
605            None
606        }
607    }
608
609    /// The underlying data type might have some trailing bits, which would
610    /// result in an invalid result, so we check against that here.
611    #[inline]
612    fn corrected_last_false_index(store: &Self::Store) -> Option<usize> {
613        if Self::Store::bit_size() == Self::VALUE {
614            Self::Store::last_false_index(store)
615        } else {
616            Self::Store::prev_false_index(store, Self::VALUE)
617        }
618    }
619
620    #[inline]
621    fn corrected_next_false_index(store: &Self::Store, index: usize) -> Option<usize> {
622        let result = Self::Store::next_false_index(store, index);
623
624        if Self::Store::bit_size() == Self::VALUE {
625            result
626        } else if let Some(result) = result {
627            if result >= Self::VALUE {
628                None
629            } else {
630                Some(result)
631            }
632        } else {
633            None
634        }
635    }
636}
637
638#[doc(hidden)]
639pub struct BitsImpl<const N: usize>;
640
641impl Bits for BitsImpl<1> {
642    const VALUE: usize = 1;
643    type Store = bool;
644}
645
646macro_rules! bits_for {
647    ($num:expr, $result:ty) => {
648        impl Bits for BitsImpl<$num> {
649            const VALUE: usize = $num;
650            type Store = $result;
651        }
652    };
653}
654
655macro_rules! bits_for_big {
656    ($num:expr, $words:expr) => {
657        impl Bits for BitsImpl<$num> {
658            const VALUE: usize = $num;
659            type Store = [u128; $words];
660        }
661    };
662}
663
664bits_for!(2, u8);
665bits_for!(3, u8);
666bits_for!(4, u8);
667bits_for!(5, u8);
668bits_for!(6, u8);
669bits_for!(7, u8);
670bits_for!(8, u8);
671bits_for!(9, u16);
672bits_for!(10, u16);
673bits_for!(11, u16);
674bits_for!(12, u16);
675bits_for!(13, u16);
676bits_for!(14, u16);
677bits_for!(15, u16);
678bits_for!(16, u16);
679bits_for!(17, u32);
680bits_for!(18, u32);
681bits_for!(19, u32);
682bits_for!(20, u32);
683bits_for!(21, u32);
684bits_for!(22, u32);
685bits_for!(23, u32);
686bits_for!(24, u32);
687bits_for!(25, u32);
688bits_for!(26, u32);
689bits_for!(27, u32);
690bits_for!(28, u32);
691bits_for!(29, u32);
692bits_for!(30, u32);
693bits_for!(31, u32);
694bits_for!(32, u32);
695bits_for!(33, u64);
696bits_for!(34, u64);
697bits_for!(35, u64);
698bits_for!(36, u64);
699bits_for!(37, u64);
700bits_for!(38, u64);
701bits_for!(39, u64);
702bits_for!(40, u64);
703bits_for!(41, u64);
704bits_for!(42, u64);
705bits_for!(43, u64);
706bits_for!(44, u64);
707bits_for!(45, u64);
708bits_for!(46, u64);
709bits_for!(47, u64);
710bits_for!(48, u64);
711bits_for!(49, u64);
712bits_for!(50, u64);
713bits_for!(51, u64);
714bits_for!(52, u64);
715bits_for!(53, u64);
716bits_for!(54, u64);
717bits_for!(55, u64);
718bits_for!(56, u64);
719bits_for!(57, u64);
720bits_for!(58, u64);
721bits_for!(59, u64);
722bits_for!(60, u64);
723bits_for!(61, u64);
724bits_for!(62, u64);
725bits_for!(63, u64);
726bits_for!(64, u64);
727bits_for!(65, u128);
728bits_for!(66, u128);
729bits_for!(67, u128);
730bits_for!(68, u128);
731bits_for!(69, u128);
732bits_for!(70, u128);
733bits_for!(71, u128);
734bits_for!(72, u128);
735bits_for!(73, u128);
736bits_for!(74, u128);
737bits_for!(75, u128);
738bits_for!(76, u128);
739bits_for!(77, u128);
740bits_for!(78, u128);
741bits_for!(79, u128);
742bits_for!(80, u128);
743bits_for!(81, u128);
744bits_for!(82, u128);
745bits_for!(83, u128);
746bits_for!(84, u128);
747bits_for!(85, u128);
748bits_for!(86, u128);
749bits_for!(87, u128);
750bits_for!(88, u128);
751bits_for!(89, u128);
752bits_for!(90, u128);
753bits_for!(91, u128);
754bits_for!(92, u128);
755bits_for!(93, u128);
756bits_for!(94, u128);
757bits_for!(95, u128);
758bits_for!(96, u128);
759bits_for!(97, u128);
760bits_for!(98, u128);
761bits_for!(99, u128);
762bits_for!(100, u128);
763bits_for!(101, u128);
764bits_for!(102, u128);
765bits_for!(103, u128);
766bits_for!(104, u128);
767bits_for!(105, u128);
768bits_for!(106, u128);
769bits_for!(107, u128);
770bits_for!(108, u128);
771bits_for!(109, u128);
772bits_for!(110, u128);
773bits_for!(111, u128);
774bits_for!(112, u128);
775bits_for!(113, u128);
776bits_for!(114, u128);
777bits_for!(115, u128);
778bits_for!(116, u128);
779bits_for!(117, u128);
780bits_for!(118, u128);
781bits_for!(119, u128);
782bits_for!(120, u128);
783bits_for!(121, u128);
784bits_for!(122, u128);
785bits_for!(123, u128);
786bits_for!(124, u128);
787bits_for!(125, u128);
788bits_for!(126, u128);
789bits_for!(127, u128);
790bits_for!(128, u128);
791
792bits_for_big!(129, 2);
793bits_for_big!(130, 2);
794bits_for_big!(131, 2);
795bits_for_big!(132, 2);
796bits_for_big!(133, 2);
797bits_for_big!(134, 2);
798bits_for_big!(135, 2);
799bits_for_big!(136, 2);
800bits_for_big!(137, 2);
801bits_for_big!(138, 2);
802bits_for_big!(139, 2);
803bits_for_big!(140, 2);
804bits_for_big!(141, 2);
805bits_for_big!(142, 2);
806bits_for_big!(143, 2);
807bits_for_big!(144, 2);
808bits_for_big!(145, 2);
809bits_for_big!(146, 2);
810bits_for_big!(147, 2);
811bits_for_big!(148, 2);
812bits_for_big!(149, 2);
813bits_for_big!(150, 2);
814bits_for_big!(151, 2);
815bits_for_big!(152, 2);
816bits_for_big!(153, 2);
817bits_for_big!(154, 2);
818bits_for_big!(155, 2);
819bits_for_big!(156, 2);
820bits_for_big!(157, 2);
821bits_for_big!(158, 2);
822bits_for_big!(159, 2);
823bits_for_big!(160, 2);
824bits_for_big!(161, 2);
825bits_for_big!(162, 2);
826bits_for_big!(163, 2);
827bits_for_big!(164, 2);
828bits_for_big!(165, 2);
829bits_for_big!(166, 2);
830bits_for_big!(167, 2);
831bits_for_big!(168, 2);
832bits_for_big!(169, 2);
833bits_for_big!(170, 2);
834bits_for_big!(171, 2);
835bits_for_big!(172, 2);
836bits_for_big!(173, 2);
837bits_for_big!(174, 2);
838bits_for_big!(175, 2);
839bits_for_big!(176, 2);
840bits_for_big!(177, 2);
841bits_for_big!(178, 2);
842bits_for_big!(179, 2);
843bits_for_big!(180, 2);
844bits_for_big!(181, 2);
845bits_for_big!(182, 2);
846bits_for_big!(183, 2);
847bits_for_big!(184, 2);
848bits_for_big!(185, 2);
849bits_for_big!(186, 2);
850bits_for_big!(187, 2);
851bits_for_big!(188, 2);
852bits_for_big!(189, 2);
853bits_for_big!(190, 2);
854bits_for_big!(191, 2);
855bits_for_big!(192, 2);
856bits_for_big!(193, 2);
857bits_for_big!(194, 2);
858bits_for_big!(195, 2);
859bits_for_big!(196, 2);
860bits_for_big!(197, 2);
861bits_for_big!(198, 2);
862bits_for_big!(199, 2);
863bits_for_big!(200, 2);
864bits_for_big!(201, 2);
865bits_for_big!(202, 2);
866bits_for_big!(203, 2);
867bits_for_big!(204, 2);
868bits_for_big!(205, 2);
869bits_for_big!(206, 2);
870bits_for_big!(207, 2);
871bits_for_big!(208, 2);
872bits_for_big!(209, 2);
873bits_for_big!(210, 2);
874bits_for_big!(211, 2);
875bits_for_big!(212, 2);
876bits_for_big!(213, 2);
877bits_for_big!(214, 2);
878bits_for_big!(215, 2);
879bits_for_big!(216, 2);
880bits_for_big!(217, 2);
881bits_for_big!(218, 2);
882bits_for_big!(219, 2);
883bits_for_big!(220, 2);
884bits_for_big!(221, 2);
885bits_for_big!(222, 2);
886bits_for_big!(223, 2);
887bits_for_big!(224, 2);
888bits_for_big!(225, 2);
889bits_for_big!(226, 2);
890bits_for_big!(227, 2);
891bits_for_big!(228, 2);
892bits_for_big!(229, 2);
893bits_for_big!(230, 2);
894bits_for_big!(231, 2);
895bits_for_big!(232, 2);
896bits_for_big!(233, 2);
897bits_for_big!(234, 2);
898bits_for_big!(235, 2);
899bits_for_big!(236, 2);
900bits_for_big!(237, 2);
901bits_for_big!(238, 2);
902bits_for_big!(239, 2);
903bits_for_big!(240, 2);
904bits_for_big!(241, 2);
905bits_for_big!(242, 2);
906bits_for_big!(243, 2);
907bits_for_big!(244, 2);
908bits_for_big!(245, 2);
909bits_for_big!(246, 2);
910bits_for_big!(247, 2);
911bits_for_big!(248, 2);
912bits_for_big!(249, 2);
913bits_for_big!(250, 2);
914bits_for_big!(251, 2);
915bits_for_big!(252, 2);
916bits_for_big!(253, 2);
917bits_for_big!(254, 2);
918bits_for_big!(255, 2);
919bits_for_big!(256, 2);
920
921bits_for_big!(257, 3);
922bits_for_big!(258, 3);
923bits_for_big!(259, 3);
924bits_for_big!(260, 3);
925bits_for_big!(261, 3);
926bits_for_big!(262, 3);
927bits_for_big!(263, 3);
928bits_for_big!(264, 3);
929bits_for_big!(265, 3);
930bits_for_big!(266, 3);
931bits_for_big!(267, 3);
932bits_for_big!(268, 3);
933bits_for_big!(269, 3);
934bits_for_big!(270, 3);
935bits_for_big!(271, 3);
936bits_for_big!(272, 3);
937bits_for_big!(273, 3);
938bits_for_big!(274, 3);
939bits_for_big!(275, 3);
940bits_for_big!(276, 3);
941bits_for_big!(277, 3);
942bits_for_big!(278, 3);
943bits_for_big!(279, 3);
944bits_for_big!(280, 3);
945bits_for_big!(281, 3);
946bits_for_big!(282, 3);
947bits_for_big!(283, 3);
948bits_for_big!(284, 3);
949bits_for_big!(285, 3);
950bits_for_big!(286, 3);
951bits_for_big!(287, 3);
952bits_for_big!(288, 3);
953bits_for_big!(289, 3);
954bits_for_big!(290, 3);
955bits_for_big!(291, 3);
956bits_for_big!(292, 3);
957bits_for_big!(293, 3);
958bits_for_big!(294, 3);
959bits_for_big!(295, 3);
960bits_for_big!(296, 3);
961bits_for_big!(297, 3);
962bits_for_big!(298, 3);
963bits_for_big!(299, 3);
964bits_for_big!(300, 3);
965bits_for_big!(301, 3);
966bits_for_big!(302, 3);
967bits_for_big!(303, 3);
968bits_for_big!(304, 3);
969bits_for_big!(305, 3);
970bits_for_big!(306, 3);
971bits_for_big!(307, 3);
972bits_for_big!(308, 3);
973bits_for_big!(309, 3);
974bits_for_big!(310, 3);
975bits_for_big!(311, 3);
976bits_for_big!(312, 3);
977bits_for_big!(313, 3);
978bits_for_big!(314, 3);
979bits_for_big!(315, 3);
980bits_for_big!(316, 3);
981bits_for_big!(317, 3);
982bits_for_big!(318, 3);
983bits_for_big!(319, 3);
984bits_for_big!(320, 3);
985bits_for_big!(321, 3);
986bits_for_big!(322, 3);
987bits_for_big!(323, 3);
988bits_for_big!(324, 3);
989bits_for_big!(325, 3);
990bits_for_big!(326, 3);
991bits_for_big!(327, 3);
992bits_for_big!(328, 3);
993bits_for_big!(329, 3);
994bits_for_big!(330, 3);
995bits_for_big!(331, 3);
996bits_for_big!(332, 3);
997bits_for_big!(333, 3);
998bits_for_big!(334, 3);
999bits_for_big!(335, 3);
1000bits_for_big!(336, 3);
1001bits_for_big!(337, 3);
1002bits_for_big!(338, 3);
1003bits_for_big!(339, 3);
1004bits_for_big!(340, 3);
1005bits_for_big!(341, 3);
1006bits_for_big!(342, 3);
1007bits_for_big!(343, 3);
1008bits_for_big!(344, 3);
1009bits_for_big!(345, 3);
1010bits_for_big!(346, 3);
1011bits_for_big!(347, 3);
1012bits_for_big!(348, 3);
1013bits_for_big!(349, 3);
1014bits_for_big!(350, 3);
1015bits_for_big!(351, 3);
1016bits_for_big!(352, 3);
1017bits_for_big!(353, 3);
1018bits_for_big!(354, 3);
1019bits_for_big!(355, 3);
1020bits_for_big!(356, 3);
1021bits_for_big!(357, 3);
1022bits_for_big!(358, 3);
1023bits_for_big!(359, 3);
1024bits_for_big!(360, 3);
1025bits_for_big!(361, 3);
1026bits_for_big!(362, 3);
1027bits_for_big!(363, 3);
1028bits_for_big!(364, 3);
1029bits_for_big!(365, 3);
1030bits_for_big!(366, 3);
1031bits_for_big!(367, 3);
1032bits_for_big!(368, 3);
1033bits_for_big!(369, 3);
1034bits_for_big!(370, 3);
1035bits_for_big!(371, 3);
1036bits_for_big!(372, 3);
1037bits_for_big!(373, 3);
1038bits_for_big!(374, 3);
1039bits_for_big!(375, 3);
1040bits_for_big!(376, 3);
1041bits_for_big!(377, 3);
1042bits_for_big!(378, 3);
1043bits_for_big!(379, 3);
1044bits_for_big!(380, 3);
1045bits_for_big!(381, 3);
1046bits_for_big!(382, 3);
1047bits_for_big!(383, 3);
1048bits_for_big!(384, 3);
1049
1050bits_for_big!(385, 4);
1051bits_for_big!(386, 4);
1052bits_for_big!(387, 4);
1053bits_for_big!(388, 4);
1054bits_for_big!(389, 4);
1055bits_for_big!(390, 4);
1056bits_for_big!(391, 4);
1057bits_for_big!(392, 4);
1058bits_for_big!(393, 4);
1059bits_for_big!(394, 4);
1060bits_for_big!(395, 4);
1061bits_for_big!(396, 4);
1062bits_for_big!(397, 4);
1063bits_for_big!(398, 4);
1064bits_for_big!(399, 4);
1065bits_for_big!(400, 4);
1066bits_for_big!(401, 4);
1067bits_for_big!(402, 4);
1068bits_for_big!(403, 4);
1069bits_for_big!(404, 4);
1070bits_for_big!(405, 4);
1071bits_for_big!(406, 4);
1072bits_for_big!(407, 4);
1073bits_for_big!(408, 4);
1074bits_for_big!(409, 4);
1075bits_for_big!(410, 4);
1076bits_for_big!(411, 4);
1077bits_for_big!(412, 4);
1078bits_for_big!(413, 4);
1079bits_for_big!(414, 4);
1080bits_for_big!(415, 4);
1081bits_for_big!(416, 4);
1082bits_for_big!(417, 4);
1083bits_for_big!(418, 4);
1084bits_for_big!(419, 4);
1085bits_for_big!(420, 4);
1086bits_for_big!(421, 4);
1087bits_for_big!(422, 4);
1088bits_for_big!(423, 4);
1089bits_for_big!(424, 4);
1090bits_for_big!(425, 4);
1091bits_for_big!(426, 4);
1092bits_for_big!(427, 4);
1093bits_for_big!(428, 4);
1094bits_for_big!(429, 4);
1095bits_for_big!(430, 4);
1096bits_for_big!(431, 4);
1097bits_for_big!(432, 4);
1098bits_for_big!(433, 4);
1099bits_for_big!(434, 4);
1100bits_for_big!(435, 4);
1101bits_for_big!(436, 4);
1102bits_for_big!(437, 4);
1103bits_for_big!(438, 4);
1104bits_for_big!(439, 4);
1105bits_for_big!(440, 4);
1106bits_for_big!(441, 4);
1107bits_for_big!(442, 4);
1108bits_for_big!(443, 4);
1109bits_for_big!(444, 4);
1110bits_for_big!(445, 4);
1111bits_for_big!(446, 4);
1112bits_for_big!(447, 4);
1113bits_for_big!(448, 4);
1114bits_for_big!(449, 4);
1115bits_for_big!(450, 4);
1116bits_for_big!(451, 4);
1117bits_for_big!(452, 4);
1118bits_for_big!(453, 4);
1119bits_for_big!(454, 4);
1120bits_for_big!(455, 4);
1121bits_for_big!(456, 4);
1122bits_for_big!(457, 4);
1123bits_for_big!(458, 4);
1124bits_for_big!(459, 4);
1125bits_for_big!(460, 4);
1126bits_for_big!(461, 4);
1127bits_for_big!(462, 4);
1128bits_for_big!(463, 4);
1129bits_for_big!(464, 4);
1130bits_for_big!(465, 4);
1131bits_for_big!(466, 4);
1132bits_for_big!(467, 4);
1133bits_for_big!(468, 4);
1134bits_for_big!(469, 4);
1135bits_for_big!(470, 4);
1136bits_for_big!(471, 4);
1137bits_for_big!(472, 4);
1138bits_for_big!(473, 4);
1139bits_for_big!(474, 4);
1140bits_for_big!(475, 4);
1141bits_for_big!(476, 4);
1142bits_for_big!(477, 4);
1143bits_for_big!(478, 4);
1144bits_for_big!(479, 4);
1145bits_for_big!(480, 4);
1146bits_for_big!(481, 4);
1147bits_for_big!(482, 4);
1148bits_for_big!(483, 4);
1149bits_for_big!(484, 4);
1150bits_for_big!(485, 4);
1151bits_for_big!(486, 4);
1152bits_for_big!(487, 4);
1153bits_for_big!(488, 4);
1154bits_for_big!(489, 4);
1155bits_for_big!(490, 4);
1156bits_for_big!(491, 4);
1157bits_for_big!(492, 4);
1158bits_for_big!(493, 4);
1159bits_for_big!(494, 4);
1160bits_for_big!(495, 4);
1161bits_for_big!(496, 4);
1162bits_for_big!(497, 4);
1163bits_for_big!(498, 4);
1164bits_for_big!(499, 4);
1165bits_for_big!(500, 4);
1166bits_for_big!(501, 4);
1167bits_for_big!(502, 4);
1168bits_for_big!(503, 4);
1169bits_for_big!(504, 4);
1170bits_for_big!(505, 4);
1171bits_for_big!(506, 4);
1172bits_for_big!(507, 4);
1173bits_for_big!(508, 4);
1174bits_for_big!(509, 4);
1175bits_for_big!(510, 4);
1176bits_for_big!(511, 4);
1177bits_for_big!(512, 4);
1178
1179bits_for_big!(513, 5);
1180bits_for_big!(514, 5);
1181bits_for_big!(515, 5);
1182bits_for_big!(516, 5);
1183bits_for_big!(517, 5);
1184bits_for_big!(518, 5);
1185bits_for_big!(519, 5);
1186bits_for_big!(520, 5);
1187bits_for_big!(521, 5);
1188bits_for_big!(522, 5);
1189bits_for_big!(523, 5);
1190bits_for_big!(524, 5);
1191bits_for_big!(525, 5);
1192bits_for_big!(526, 5);
1193bits_for_big!(527, 5);
1194bits_for_big!(528, 5);
1195bits_for_big!(529, 5);
1196bits_for_big!(530, 5);
1197bits_for_big!(531, 5);
1198bits_for_big!(532, 5);
1199bits_for_big!(533, 5);
1200bits_for_big!(534, 5);
1201bits_for_big!(535, 5);
1202bits_for_big!(536, 5);
1203bits_for_big!(537, 5);
1204bits_for_big!(538, 5);
1205bits_for_big!(539, 5);
1206bits_for_big!(540, 5);
1207bits_for_big!(541, 5);
1208bits_for_big!(542, 5);
1209bits_for_big!(543, 5);
1210bits_for_big!(544, 5);
1211bits_for_big!(545, 5);
1212bits_for_big!(546, 5);
1213bits_for_big!(547, 5);
1214bits_for_big!(548, 5);
1215bits_for_big!(549, 5);
1216bits_for_big!(550, 5);
1217bits_for_big!(551, 5);
1218bits_for_big!(552, 5);
1219bits_for_big!(553, 5);
1220bits_for_big!(554, 5);
1221bits_for_big!(555, 5);
1222bits_for_big!(556, 5);
1223bits_for_big!(557, 5);
1224bits_for_big!(558, 5);
1225bits_for_big!(559, 5);
1226bits_for_big!(560, 5);
1227bits_for_big!(561, 5);
1228bits_for_big!(562, 5);
1229bits_for_big!(563, 5);
1230bits_for_big!(564, 5);
1231bits_for_big!(565, 5);
1232bits_for_big!(566, 5);
1233bits_for_big!(567, 5);
1234bits_for_big!(568, 5);
1235bits_for_big!(569, 5);
1236bits_for_big!(570, 5);
1237bits_for_big!(571, 5);
1238bits_for_big!(572, 5);
1239bits_for_big!(573, 5);
1240bits_for_big!(574, 5);
1241bits_for_big!(575, 5);
1242bits_for_big!(576, 5);
1243bits_for_big!(577, 5);
1244bits_for_big!(578, 5);
1245bits_for_big!(579, 5);
1246bits_for_big!(580, 5);
1247bits_for_big!(581, 5);
1248bits_for_big!(582, 5);
1249bits_for_big!(583, 5);
1250bits_for_big!(584, 5);
1251bits_for_big!(585, 5);
1252bits_for_big!(586, 5);
1253bits_for_big!(587, 5);
1254bits_for_big!(588, 5);
1255bits_for_big!(589, 5);
1256bits_for_big!(590, 5);
1257bits_for_big!(591, 5);
1258bits_for_big!(592, 5);
1259bits_for_big!(593, 5);
1260bits_for_big!(594, 5);
1261bits_for_big!(595, 5);
1262bits_for_big!(596, 5);
1263bits_for_big!(597, 5);
1264bits_for_big!(598, 5);
1265bits_for_big!(599, 5);
1266bits_for_big!(600, 5);
1267bits_for_big!(601, 5);
1268bits_for_big!(602, 5);
1269bits_for_big!(603, 5);
1270bits_for_big!(604, 5);
1271bits_for_big!(605, 5);
1272bits_for_big!(606, 5);
1273bits_for_big!(607, 5);
1274bits_for_big!(608, 5);
1275bits_for_big!(609, 5);
1276bits_for_big!(610, 5);
1277bits_for_big!(611, 5);
1278bits_for_big!(612, 5);
1279bits_for_big!(613, 5);
1280bits_for_big!(614, 5);
1281bits_for_big!(615, 5);
1282bits_for_big!(616, 5);
1283bits_for_big!(617, 5);
1284bits_for_big!(618, 5);
1285bits_for_big!(619, 5);
1286bits_for_big!(620, 5);
1287bits_for_big!(621, 5);
1288bits_for_big!(622, 5);
1289bits_for_big!(623, 5);
1290bits_for_big!(624, 5);
1291bits_for_big!(625, 5);
1292bits_for_big!(626, 5);
1293bits_for_big!(627, 5);
1294bits_for_big!(628, 5);
1295bits_for_big!(629, 5);
1296bits_for_big!(630, 5);
1297bits_for_big!(631, 5);
1298bits_for_big!(632, 5);
1299bits_for_big!(633, 5);
1300bits_for_big!(634, 5);
1301bits_for_big!(635, 5);
1302bits_for_big!(636, 5);
1303bits_for_big!(637, 5);
1304bits_for_big!(638, 5);
1305bits_for_big!(639, 5);
1306bits_for_big!(640, 5);
1307
1308bits_for_big!(641, 6);
1309bits_for_big!(642, 6);
1310bits_for_big!(643, 6);
1311bits_for_big!(644, 6);
1312bits_for_big!(645, 6);
1313bits_for_big!(646, 6);
1314bits_for_big!(647, 6);
1315bits_for_big!(648, 6);
1316bits_for_big!(649, 6);
1317bits_for_big!(650, 6);
1318bits_for_big!(651, 6);
1319bits_for_big!(652, 6);
1320bits_for_big!(653, 6);
1321bits_for_big!(654, 6);
1322bits_for_big!(655, 6);
1323bits_for_big!(656, 6);
1324bits_for_big!(657, 6);
1325bits_for_big!(658, 6);
1326bits_for_big!(659, 6);
1327bits_for_big!(660, 6);
1328bits_for_big!(661, 6);
1329bits_for_big!(662, 6);
1330bits_for_big!(663, 6);
1331bits_for_big!(664, 6);
1332bits_for_big!(665, 6);
1333bits_for_big!(666, 6);
1334bits_for_big!(667, 6);
1335bits_for_big!(668, 6);
1336bits_for_big!(669, 6);
1337bits_for_big!(670, 6);
1338bits_for_big!(671, 6);
1339bits_for_big!(672, 6);
1340bits_for_big!(673, 6);
1341bits_for_big!(674, 6);
1342bits_for_big!(675, 6);
1343bits_for_big!(676, 6);
1344bits_for_big!(677, 6);
1345bits_for_big!(678, 6);
1346bits_for_big!(679, 6);
1347bits_for_big!(680, 6);
1348bits_for_big!(681, 6);
1349bits_for_big!(682, 6);
1350bits_for_big!(683, 6);
1351bits_for_big!(684, 6);
1352bits_for_big!(685, 6);
1353bits_for_big!(686, 6);
1354bits_for_big!(687, 6);
1355bits_for_big!(688, 6);
1356bits_for_big!(689, 6);
1357bits_for_big!(690, 6);
1358bits_for_big!(691, 6);
1359bits_for_big!(692, 6);
1360bits_for_big!(693, 6);
1361bits_for_big!(694, 6);
1362bits_for_big!(695, 6);
1363bits_for_big!(696, 6);
1364bits_for_big!(697, 6);
1365bits_for_big!(698, 6);
1366bits_for_big!(699, 6);
1367bits_for_big!(700, 6);
1368bits_for_big!(701, 6);
1369bits_for_big!(702, 6);
1370bits_for_big!(703, 6);
1371bits_for_big!(704, 6);
1372bits_for_big!(705, 6);
1373bits_for_big!(706, 6);
1374bits_for_big!(707, 6);
1375bits_for_big!(708, 6);
1376bits_for_big!(709, 6);
1377bits_for_big!(710, 6);
1378bits_for_big!(711, 6);
1379bits_for_big!(712, 6);
1380bits_for_big!(713, 6);
1381bits_for_big!(714, 6);
1382bits_for_big!(715, 6);
1383bits_for_big!(716, 6);
1384bits_for_big!(717, 6);
1385bits_for_big!(718, 6);
1386bits_for_big!(719, 6);
1387bits_for_big!(720, 6);
1388bits_for_big!(721, 6);
1389bits_for_big!(722, 6);
1390bits_for_big!(723, 6);
1391bits_for_big!(724, 6);
1392bits_for_big!(725, 6);
1393bits_for_big!(726, 6);
1394bits_for_big!(727, 6);
1395bits_for_big!(728, 6);
1396bits_for_big!(729, 6);
1397bits_for_big!(730, 6);
1398bits_for_big!(731, 6);
1399bits_for_big!(732, 6);
1400bits_for_big!(733, 6);
1401bits_for_big!(734, 6);
1402bits_for_big!(735, 6);
1403bits_for_big!(736, 6);
1404bits_for_big!(737, 6);
1405bits_for_big!(738, 6);
1406bits_for_big!(739, 6);
1407bits_for_big!(740, 6);
1408bits_for_big!(741, 6);
1409bits_for_big!(742, 6);
1410bits_for_big!(743, 6);
1411bits_for_big!(744, 6);
1412bits_for_big!(745, 6);
1413bits_for_big!(746, 6);
1414bits_for_big!(747, 6);
1415bits_for_big!(748, 6);
1416bits_for_big!(749, 6);
1417bits_for_big!(750, 6);
1418bits_for_big!(751, 6);
1419bits_for_big!(752, 6);
1420bits_for_big!(753, 6);
1421bits_for_big!(754, 6);
1422bits_for_big!(755, 6);
1423bits_for_big!(756, 6);
1424bits_for_big!(757, 6);
1425bits_for_big!(758, 6);
1426bits_for_big!(759, 6);
1427bits_for_big!(760, 6);
1428bits_for_big!(761, 6);
1429bits_for_big!(762, 6);
1430bits_for_big!(763, 6);
1431bits_for_big!(764, 6);
1432bits_for_big!(765, 6);
1433bits_for_big!(766, 6);
1434bits_for_big!(767, 6);
1435bits_for_big!(768, 6);
1436
1437bits_for_big!(769, 7);
1438bits_for_big!(770, 7);
1439bits_for_big!(771, 7);
1440bits_for_big!(772, 7);
1441bits_for_big!(773, 7);
1442bits_for_big!(774, 7);
1443bits_for_big!(775, 7);
1444bits_for_big!(776, 7);
1445bits_for_big!(777, 7);
1446bits_for_big!(778, 7);
1447bits_for_big!(779, 7);
1448bits_for_big!(780, 7);
1449bits_for_big!(781, 7);
1450bits_for_big!(782, 7);
1451bits_for_big!(783, 7);
1452bits_for_big!(784, 7);
1453bits_for_big!(785, 7);
1454bits_for_big!(786, 7);
1455bits_for_big!(787, 7);
1456bits_for_big!(788, 7);
1457bits_for_big!(789, 7);
1458bits_for_big!(790, 7);
1459bits_for_big!(791, 7);
1460bits_for_big!(792, 7);
1461bits_for_big!(793, 7);
1462bits_for_big!(794, 7);
1463bits_for_big!(795, 7);
1464bits_for_big!(796, 7);
1465bits_for_big!(797, 7);
1466bits_for_big!(798, 7);
1467bits_for_big!(799, 7);
1468bits_for_big!(800, 7);
1469bits_for_big!(801, 7);
1470bits_for_big!(802, 7);
1471bits_for_big!(803, 7);
1472bits_for_big!(804, 7);
1473bits_for_big!(805, 7);
1474bits_for_big!(806, 7);
1475bits_for_big!(807, 7);
1476bits_for_big!(808, 7);
1477bits_for_big!(809, 7);
1478bits_for_big!(810, 7);
1479bits_for_big!(811, 7);
1480bits_for_big!(812, 7);
1481bits_for_big!(813, 7);
1482bits_for_big!(814, 7);
1483bits_for_big!(815, 7);
1484bits_for_big!(816, 7);
1485bits_for_big!(817, 7);
1486bits_for_big!(818, 7);
1487bits_for_big!(819, 7);
1488bits_for_big!(820, 7);
1489bits_for_big!(821, 7);
1490bits_for_big!(822, 7);
1491bits_for_big!(823, 7);
1492bits_for_big!(824, 7);
1493bits_for_big!(825, 7);
1494bits_for_big!(826, 7);
1495bits_for_big!(827, 7);
1496bits_for_big!(828, 7);
1497bits_for_big!(829, 7);
1498bits_for_big!(830, 7);
1499bits_for_big!(831, 7);
1500bits_for_big!(832, 7);
1501bits_for_big!(833, 7);
1502bits_for_big!(834, 7);
1503bits_for_big!(835, 7);
1504bits_for_big!(836, 7);
1505bits_for_big!(837, 7);
1506bits_for_big!(838, 7);
1507bits_for_big!(839, 7);
1508bits_for_big!(840, 7);
1509bits_for_big!(841, 7);
1510bits_for_big!(842, 7);
1511bits_for_big!(843, 7);
1512bits_for_big!(844, 7);
1513bits_for_big!(845, 7);
1514bits_for_big!(846, 7);
1515bits_for_big!(847, 7);
1516bits_for_big!(848, 7);
1517bits_for_big!(849, 7);
1518bits_for_big!(850, 7);
1519bits_for_big!(851, 7);
1520bits_for_big!(852, 7);
1521bits_for_big!(853, 7);
1522bits_for_big!(854, 7);
1523bits_for_big!(855, 7);
1524bits_for_big!(856, 7);
1525bits_for_big!(857, 7);
1526bits_for_big!(858, 7);
1527bits_for_big!(859, 7);
1528bits_for_big!(860, 7);
1529bits_for_big!(861, 7);
1530bits_for_big!(862, 7);
1531bits_for_big!(863, 7);
1532bits_for_big!(864, 7);
1533bits_for_big!(865, 7);
1534bits_for_big!(866, 7);
1535bits_for_big!(867, 7);
1536bits_for_big!(868, 7);
1537bits_for_big!(869, 7);
1538bits_for_big!(870, 7);
1539bits_for_big!(871, 7);
1540bits_for_big!(872, 7);
1541bits_for_big!(873, 7);
1542bits_for_big!(874, 7);
1543bits_for_big!(875, 7);
1544bits_for_big!(876, 7);
1545bits_for_big!(877, 7);
1546bits_for_big!(878, 7);
1547bits_for_big!(879, 7);
1548bits_for_big!(880, 7);
1549bits_for_big!(881, 7);
1550bits_for_big!(882, 7);
1551bits_for_big!(883, 7);
1552bits_for_big!(884, 7);
1553bits_for_big!(885, 7);
1554bits_for_big!(886, 7);
1555bits_for_big!(887, 7);
1556bits_for_big!(888, 7);
1557bits_for_big!(889, 7);
1558bits_for_big!(890, 7);
1559bits_for_big!(891, 7);
1560bits_for_big!(892, 7);
1561bits_for_big!(893, 7);
1562bits_for_big!(894, 7);
1563bits_for_big!(895, 7);
1564bits_for_big!(896, 7);
1565
1566bits_for_big!(897, 8);
1567bits_for_big!(898, 8);
1568bits_for_big!(899, 8);
1569bits_for_big!(900, 8);
1570bits_for_big!(901, 8);
1571bits_for_big!(902, 8);
1572bits_for_big!(903, 8);
1573bits_for_big!(904, 8);
1574bits_for_big!(905, 8);
1575bits_for_big!(906, 8);
1576bits_for_big!(907, 8);
1577bits_for_big!(908, 8);
1578bits_for_big!(909, 8);
1579bits_for_big!(910, 8);
1580bits_for_big!(911, 8);
1581bits_for_big!(912, 8);
1582bits_for_big!(913, 8);
1583bits_for_big!(914, 8);
1584bits_for_big!(915, 8);
1585bits_for_big!(916, 8);
1586bits_for_big!(917, 8);
1587bits_for_big!(918, 8);
1588bits_for_big!(919, 8);
1589bits_for_big!(920, 8);
1590bits_for_big!(921, 8);
1591bits_for_big!(922, 8);
1592bits_for_big!(923, 8);
1593bits_for_big!(924, 8);
1594bits_for_big!(925, 8);
1595bits_for_big!(926, 8);
1596bits_for_big!(927, 8);
1597bits_for_big!(928, 8);
1598bits_for_big!(929, 8);
1599bits_for_big!(930, 8);
1600bits_for_big!(931, 8);
1601bits_for_big!(932, 8);
1602bits_for_big!(933, 8);
1603bits_for_big!(934, 8);
1604bits_for_big!(935, 8);
1605bits_for_big!(936, 8);
1606bits_for_big!(937, 8);
1607bits_for_big!(938, 8);
1608bits_for_big!(939, 8);
1609bits_for_big!(940, 8);
1610bits_for_big!(941, 8);
1611bits_for_big!(942, 8);
1612bits_for_big!(943, 8);
1613bits_for_big!(944, 8);
1614bits_for_big!(945, 8);
1615bits_for_big!(946, 8);
1616bits_for_big!(947, 8);
1617bits_for_big!(948, 8);
1618bits_for_big!(949, 8);
1619bits_for_big!(950, 8);
1620bits_for_big!(951, 8);
1621bits_for_big!(952, 8);
1622bits_for_big!(953, 8);
1623bits_for_big!(954, 8);
1624bits_for_big!(955, 8);
1625bits_for_big!(956, 8);
1626bits_for_big!(957, 8);
1627bits_for_big!(958, 8);
1628bits_for_big!(959, 8);
1629bits_for_big!(960, 8);
1630bits_for_big!(961, 8);
1631bits_for_big!(962, 8);
1632bits_for_big!(963, 8);
1633bits_for_big!(964, 8);
1634bits_for_big!(965, 8);
1635bits_for_big!(966, 8);
1636bits_for_big!(967, 8);
1637bits_for_big!(968, 8);
1638bits_for_big!(969, 8);
1639bits_for_big!(970, 8);
1640bits_for_big!(971, 8);
1641bits_for_big!(972, 8);
1642bits_for_big!(973, 8);
1643bits_for_big!(974, 8);
1644bits_for_big!(975, 8);
1645bits_for_big!(976, 8);
1646bits_for_big!(977, 8);
1647bits_for_big!(978, 8);
1648bits_for_big!(979, 8);
1649bits_for_big!(980, 8);
1650bits_for_big!(981, 8);
1651bits_for_big!(982, 8);
1652bits_for_big!(983, 8);
1653bits_for_big!(984, 8);
1654bits_for_big!(985, 8);
1655bits_for_big!(986, 8);
1656bits_for_big!(987, 8);
1657bits_for_big!(988, 8);
1658bits_for_big!(989, 8);
1659bits_for_big!(990, 8);
1660bits_for_big!(991, 8);
1661bits_for_big!(992, 8);
1662bits_for_big!(993, 8);
1663bits_for_big!(994, 8);
1664bits_for_big!(995, 8);
1665bits_for_big!(996, 8);
1666bits_for_big!(997, 8);
1667bits_for_big!(998, 8);
1668bits_for_big!(999, 8);
1669bits_for_big!(1000, 8);
1670bits_for_big!(1001, 8);
1671bits_for_big!(1002, 8);
1672bits_for_big!(1003, 8);
1673bits_for_big!(1004, 8);
1674bits_for_big!(1005, 8);
1675bits_for_big!(1006, 8);
1676bits_for_big!(1007, 8);
1677bits_for_big!(1008, 8);
1678bits_for_big!(1009, 8);
1679bits_for_big!(1010, 8);
1680bits_for_big!(1011, 8);
1681bits_for_big!(1012, 8);
1682bits_for_big!(1013, 8);
1683bits_for_big!(1014, 8);
1684bits_for_big!(1015, 8);
1685bits_for_big!(1016, 8);
1686bits_for_big!(1017, 8);
1687bits_for_big!(1018, 8);
1688bits_for_big!(1019, 8);
1689bits_for_big!(1020, 8);
1690bits_for_big!(1021, 8);
1691bits_for_big!(1022, 8);
1692bits_for_big!(1023, 8);
1693bits_for_big!(1024, 8);
bitmaps/types.rs

bitmaps/
types.rs
