lpn 0.2.0

use std::boxed::Box;
use std::default::Default;
use std::sync::Once;

use fnv::FnvHashMap;

use m4ri_rust::friendly::BinMatrix;
use m4ri_rust::friendly::BinVector;

use crate::codes::BinaryCode;

/// ``[32, 21]`` Wagner code
///
/// Decodes using Syndrome decoding
#[derive(Clone, Serialize)]
pub struct WagnerCode32_21;

static INIT: Once = Once::new();
static mut GENERATOR_MATRIX: *const BinMatrix = 0 as *const BinMatrix;
static mut PARITY_MATRIX: *const BinMatrix = 0 as *const BinMatrix;
static mut PARITY_MATRIX_T: *const BinMatrix = 0 as *const BinMatrix;
static mut SYNDROME_MAP: *const FnvHashMap<u64, &'static [usize; 1]> = 0 as *const FnvHashMap<u64, &'static [usize; 1]>;

fn init() {
    INIT.call_once(|| {
        unsafe {
            let matrix = Box::new(BinMatrix::from_slices(&[
                &[ 383778817 ],
                &[ 2338324482 ],
                &[ 3315597316 ],
                &[ 3804233736 ],
                &[ 1902116880 ],
                &[ 3097493536 ],
                &[ 767557696 ],
                &[ 1535115392 ],
                &[ 3070230784 ],
                &[ 1847591424 ],
                &[ 3695182848 ],
                &[ 610273280 ],
                &[ 1214255104 ],
                &[ 60825600 ],
                &[ 3214950400 ],
                &[ 4022370304 ],
                &[ 4091609088 ],
                &[ 4242669568 ],
                &[ 3909353472 ],
                &[ 1787297792 ],
                &[ 1261436928 ],
                
            ], 32));
            GENERATOR_MATRIX = Box::into_raw(matrix);

            let matrix = Box::new(BinMatrix::from_slices(&[
                &[ 894974977 ],
                &[ 2833163266 ],
                &[ 3859592196 ],
                &[ 1048744968 ],
                &[ 2905771024 ],
                &[ 1693029408 ],
                &[ 242555968 ],
                &[ 2017375360 ],
                &[ 1799427328 ],
                &[ 1302171136 ],
                &[ 4294950912 ],
                
            ], 32));
            let matrix_t = Box::new(matrix.transposed());
            PARITY_MATRIX = Box::into_raw(matrix);
            PARITY_MATRIX_T = Box::into_raw(matrix_t);

            let mut map = Box::new(FnvHashMap::with_capacity_and_hasher(2048, Default::default()));
            map.insert(0, &[0]);     // 0 => [0]
            map.insert(1, &[1]);     // 1 => [1]
            map.insert(2, &[2]);     // 2 => [2]
            map.insert(3, &[3]);     // 3 => [3]
            map.insert(4, &[4]);     // 4 => [4]
            map.insert(5, &[5]);     // 5 => [5]
            map.insert(6, &[6]);     // 6 => [6]
            map.insert(7, &[8320]);     // 7 => [8320]
            map.insert(8, &[8]);     // 8 => [8]
            map.insert(9, &[9]);     // 9 => [9]
            map.insert(10, &[10]);     // 10 => [10]
            map.insert(11, &[11]);     // 11 => [11]
            map.insert(12, &[12]);     // 12 => [12]
            map.insert(13, &[13]);     // 13 => [13]
            map.insert(14, &[14]);     // 14 => [14]
            map.insert(15, &[8328]);     // 15 => [8328]
            map.insert(16, &[16]);     // 16 => [16]
            map.insert(17, &[17]);     // 17 => [17]
            map.insert(18, &[18]);     // 18 => [18]
            map.insert(19, &[268566528]);     // 19 => [268566528]
            map.insert(20, &[20]);     // 20 => [20]
            map.insert(21, &[1310720]);     // 21 => [1310720]
            map.insert(22, &[2147500032]);     // 22 => [2147500032]
            map.insert(23, &[2147500033]);     // 23 => [2147500033]
            map.insert(24, &[24]);     // 24 => [24]
            map.insert(25, &[557056]);     // 25 => [557056]
            map.insert(26, &[26]);     // 26 => [26]
            map.insert(27, &[557058]);     // 27 => [557058]
            map.insert(28, &[28]);     // 28 => [28]
            map.insert(29, &[557060]);     // 29 => [557060]
            map.insert(30, &[2147500040]);     // 30 => [2147500040]
            map.insert(31, &[2415919232]);     // 31 => [2415919232]
            map.insert(32, &[32]);     // 32 => [32]
            map.insert(33, &[33]);     // 33 => [33]
            map.insert(34, &[34]);     // 34 => [34]
            map.insert(35, &[35]);     // 35 => [35]
            map.insert(36, &[36]);     // 36 => [36]
            map.insert(37, &[37]);     // 37 => [37]
            map.insert(38, &[38]);     // 38 => [38]
            map.insert(39, &[37748744]);     // 39 => [37748744]
            map.insert(40, &[40]);     // 40 => [40]
            map.insert(41, &[41]);     // 41 => [41]
            map.insert(42, &[42]);     // 42 => [42]
            map.insert(43, &[37748740]);     // 43 => [37748740]
            map.insert(44, &[44]);     // 44 => [44]
            map.insert(45, &[37748738]);     // 45 => [37748738]
            map.insert(46, &[37748737]);     // 46 => [37748737]
            map.insert(47, &[37748736]);     // 47 => [37748736]
            map.insert(48, &[48]);     // 48 => [48]
            map.insert(49, &[49]);     // 49 => [49]
            map.insert(50, &[50]);     // 50 => [50]
            map.insert(51, &[268566560]);     // 51 => [268566560]
            map.insert(52, &[52]);     // 52 => [52]
            map.insert(53, &[1310752]);     // 53 => [1310752]
            map.insert(54, &[2147500064]);     // 54 => [2147500064]
            map.insert(55, &[268468736]);     // 55 => [268468736]
            map.insert(56, &[56]);     // 56 => [56]
            map.insert(57, &[557088]);     // 57 => [557088]
            map.insert(58, &[134283392]);     // 58 => [134283392]
            map.insert(59, &[67371136]);     // 59 => [67371136]
            map.insert(60, &[2155872768]);     // 60 => [2155872768]
            map.insert(61, &[655872]);     // 61 => [655872]
            map.insert(62, &[1207959616]);     // 62 => [1207959616]
            map.insert(63, &[37748752]);     // 63 => [37748752]
            map.insert(64, &[64]);     // 64 => [64]
            map.insert(65, &[65]);     // 65 => [65]
            map.insert(66, &[66]);     // 66 => [66]
            map.insert(67, &[67]);     // 67 => [67]
            map.insert(68, &[68]);     // 68 => [68]
            map.insert(69, &[69]);     // 69 => [69]
            map.insert(70, &[70]);     // 70 => [70]
            map.insert(71, &[75497488]);     // 71 => [75497488]
            map.insert(72, &[72]);     // 72 => [72]
            map.insert(73, &[73]);     // 73 => [73]
            map.insert(74, &[74]);     // 74 => [74]
            map.insert(75, &[150995072]);     // 75 => [150995072]
            map.insert(76, &[76]);     // 76 => [76]
            map.insert(77, &[1081376]);     // 77 => [1081376]
            map.insert(78, &[2130432]);     // 78 => [2130432]
            map.insert(79, &[538968320]);     // 79 => [538968320]
            map.insert(80, &[80]);     // 80 => [80]
            map.insert(81, &[2560]);     // 81 => [2560]
            map.insert(82, &[82]);     // 82 => [82]
            map.insert(83, &[2562]);     // 83 => [2562]
            map.insert(84, &[84]);     // 84 => [84]
            map.insert(85, &[75497474]);     // 85 => [75497474]
            map.insert(86, &[75497473]);     // 86 => [75497473]
            map.insert(87, &[75497472]);     // 87 => [75497472]
            map.insert(88, &[88]);     // 88 => [88]
            map.insert(89, &[2568]);     // 89 => [2568]
            map.insert(90, &[67633280]);     // 90 => [67633280]
            map.insert(91, &[1073759232]);     // 91 => [1073759232]
            map.insert(92, &[541065344]);     // 92 => [541065344]
            map.insert(93, &[50332160]);     // 93 => [50332160]
            map.insert(94, &[1207959584]);     // 94 => [1207959584]
            map.insert(95, &[75497480]);     // 95 => [75497480]
            map.insert(96, &[96]);     // 96 => [96]
            map.insert(97, &[786432]);     // 97 => [786432]
            map.insert(98, &[98]);     // 98 => [98]
            map.insert(99, &[786434]);     // 99 => [786434]
            map.insert(100, &[100]);     // 100 => [100]
            map.insert(101, &[786436]);     // 101 => [786436]
            map.insert(102, &[2149580928]);     // 102 => [2149580928]
            map.insert(103, &[285213696]);     // 103 => [285213696]
            map.insert(104, &[2228226]);     // 104 => [2228226]
            map.insert(105, &[1081348]);     // 105 => [1081348]
            map.insert(106, &[2228224]);     // 106 => [2228224]
            map.insert(107, &[2228225]);     // 107 => [2228225]
            map.insert(108, &[1081345]);     // 108 => [1081345]
            map.insert(109, &[1081344]);     // 109 => [1081344]
            map.insert(110, &[2228228]);     // 110 => [2228228]
            map.insert(111, &[1081346]);     // 111 => [1081346]
            map.insert(112, &[16842753]);     // 112 => [16842753]
            map.insert(113, &[16842752]);     // 113 => [16842752]
            map.insert(114, &[20972032]);     // 114 => [20972032]
            map.insert(115, &[16842754]);     // 115 => [16842754]
            map.insert(116, &[1572864]);     // 116 => [1572864]
            map.insert(117, &[1572865]);     // 117 => [1572865]
            map.insert(118, &[1572866]);     // 118 => [1572866]
            map.insert(119, &[75497504]);     // 119 => [75497504]
            map.insert(120, &[294912]);     // 120 => [294912]
            map.insert(121, &[270532608]);     // 121 => [270532608]
            map.insert(122, &[294914]);     // 122 => [294914]
            map.insert(123, &[270532610]);     // 123 => [270532610]
            map.insert(124, &[1207959554]);     // 124 => [1207959554]
            map.insert(125, &[270532612]);     // 125 => [270532612]
            map.insert(126, &[1207959552]);     // 126 => [1207959552]
            map.insert(127, &[1207959553]);     // 127 => [1207959553]
            map.insert(128, &[128]);     // 128 => [128]
            map.insert(129, &[129]);     // 129 => [129]
            map.insert(130, &[130]);     // 130 => [130]
            map.insert(131, &[8196]);     // 131 => [8196]
            map.insert(132, &[132]);     // 132 => [132]
            map.insert(133, &[8194]);     // 133 => [8194]
            map.insert(134, &[8193]);     // 134 => [8193]
            map.insert(135, &[8192]);     // 135 => [8192]
            map.insert(136, &[136]);     // 136 => [136]
            map.insert(137, &[268451840]);     // 137 => [268451840]
            map.insert(138, &[138]);     // 138 => [138]
            map.insert(139, &[268451842]);     // 139 => [268451842]
            map.insert(140, &[2147614720]);     // 140 => [2147614720]
            map.insert(141, &[8912896]);     // 141 => [8912896]
            map.insert(142, &[8201]);     // 142 => [8201]
            map.insert(143, &[8200]);     // 143 => [8200]
            map.insert(144, &[144]);     // 144 => [144]
            map.insert(145, &[145]);     // 145 => [145]
            map.insert(146, &[146]);     // 146 => [146]
            map.insert(147, &[8212]);     // 147 => [8212]
            map.insert(148, &[8421376]);     // 148 => [8421376]
            map.insert(149, &[8421377]);     // 149 => [8421377]
            map.insert(150, &[8209]);     // 150 => [8209]
            map.insert(151, &[8208]);     // 151 => [8208]
            map.insert(152, &[147458]);     // 152 => [147458]
            map.insert(153, &[268451856]);     // 153 => [268451856]
            map.insert(154, &[147456]);     // 154 => [147456]
            map.insert(155, &[147457]);     // 155 => [147457]
            map.insert(156, &[8421384]);     // 156 => [8421384]
            map.insert(157, &[2415919106]);     // 157 => [2415919106]
            map.insert(158, &[2415919105]);     // 158 => [2415919105]
            map.insert(159, &[2415919104]);     // 159 => [2415919104]
            map.insert(160, &[160]);     // 160 => [160]
            map.insert(161, &[161]);     // 161 => [161]
            map.insert(162, &[162]);     // 162 => [162]
            map.insert(163, &[8228]);     // 163 => [8228]
            map.insert(164, &[164]);     // 164 => [164]
            map.insert(165, &[8226]);     // 165 => [8226]
            map.insert(166, &[8225]);     // 166 => [8225]
            map.insert(167, &[8224]);     // 167 => [8224]
            map.insert(168, &[168]);     // 168 => [168]
            map.insert(169, &[268451872]);     // 169 => [268451872]
            map.insert(170, &[68157444]);     // 170 => [68157444]
            map.insert(171, &[67371024]);     // 171 => [67371024]
            map.insert(172, &[68157442]);     // 172 => [68157442]
            map.insert(173, &[8912928]);     // 173 => [8912928]
            map.insert(174, &[68157440]);     // 174 => [68157440]
            map.insert(175, &[68157441]);     // 175 => [68157441]
            map.insert(176, &[176]);     // 176 => [176]
            map.insert(177, &[1090519044]);     // 177 => [1090519044]
            map.insert(178, &[134283272]);     // 178 => [134283272]
            map.insert(179, &[67371016]);     // 179 => [67371016]
            map.insert(180, &[1090519041]);     // 180 => [1090519041]
            map.insert(181, &[1090519040]);     // 181 => [1090519040]
            map.insert(182, &[17301760]);     // 182 => [17301760]
            map.insert(183, &[1090519042]);     // 183 => [1090519042]
            map.insert(184, &[134283266]);     // 184 => [134283266]
            map.insert(185, &[67371010]);     // 185 => [67371010]
            map.insert(186, &[134283264]);     // 186 => [134283264]
            map.insert(187, &[67371008]);     // 187 => [67371008]
            map.insert(188, &[35651840]);     // 188 => [35651840]
            map.insert(189, &[1090519048]);     // 189 => [1090519048]
            map.insert(190, &[134283268]);     // 190 => [134283268]
            map.insert(191, &[67371012]);     // 191 => [67371012]
            map.insert(192, &[192]);     // 192 => [192]
            map.insert(193, &[193]);     // 193 => [193]
            map.insert(194, &[67141633]);     // 194 => [67141633]
            map.insert(195, &[67141632]);     // 195 => [67141632]
            map.insert(196, &[1073807360]);     // 196 => [1073807360]
            map.insert(197, &[1073807361]);     // 197 => [1073807361]
            map.insert(198, &[8257]);     // 198 => [8257]
            map.insert(199, &[8256]);     // 199 => [8256]
            map.insert(200, &[200]);     // 200 => [200]
            map.insert(201, &[150994946]);     // 201 => [150994946]
            map.insert(202, &[150994945]);     // 202 => [150994945]
            map.insert(203, &[150994944]);     // 203 => [150994944]
            map.insert(204, &[1073807368]);     // 204 => [1073807368]
            map.insert(205, &[4384]);     // 205 => [4384]
            map.insert(206, &[100664320]);     // 206 => [100664320]
            map.insert(207, &[150994948]);     // 207 => [150994948]
            map.insert(208, &[208]);     // 208 => [208]
            map.insert(209, &[2688]);     // 209 => [2688]
            map.insert(210, &[67633160]);     // 210 => [67633160]
            map.insert(211, &[67141648]);     // 211 => [67141648]
            map.insert(212, &[541065224]);     // 212 => [541065224]
            map.insert(213, &[136315904]);     // 213 => [136315904]
            map.insert(214, &[33685760]);     // 214 => [33685760]
            map.insert(215, &[8272]);     // 215 => [8272]
            map.insert(216, &[67633154]);     // 216 => [67633154]
            map.insert(217, &[9437216]);     // 217 => [9437216]
            map.insert(218, &[67633152]);     // 218 => [67633152]
            map.insert(219, &[67633153]);     // 219 => [67633153]
            map.insert(220, &[541065216]);     // 220 => [541065216]
            map.insert(221, &[541065217]);     // 221 => [541065217]
            map.insert(222, &[541065218]);     // 222 => [541065218]
            map.insert(223, &[2415919168]);     // 223 => [2415919168]
            map.insert(224, &[2113552]);     // 224 => [2113552]
            map.insert(225, &[786560]);     // 225 => [786560]
            map.insert(226, &[2149580804]);     // 226 => [2149580804]
            map.insert(227, &[570425360]);     // 227 => [570425360]
            map.insert(228, &[2149580802]);     // 228 => [2149580802]
            map.insert(229, &[4360]);     // 229 => [4360]
            map.insert(230, &[2149580800]);     // 230 => [2149580800]
            map.insert(231, &[2149580801]);     // 231 => [2149580801]
            map.insert(232, &[8650756]);     // 232 => [8650756]
            map.insert(233, &[4356]);     // 233 => [4356]
            map.insert(234, &[2228352]);     // 234 => [2228352]
            map.insert(235, &[150994976]);     // 235 => [150994976]
            map.insert(236, &[8650752]);     // 236 => [8650752]
            map.insert(237, &[4352]);     // 237 => [4352]
            map.insert(238, &[8650754]);     // 238 => [8650754]
            map.insert(239, &[4354]);     // 239 => [4354]
            map.insert(240, &[2113536]);     // 240 => [2113536]
            map.insert(241, &[2113537]);     // 241 => [2113537]
            map.insert(242, &[570425345]);     // 242 => [570425345]
            map.insert(243, &[570425344]);     // 243 => [570425344]
            map.insert(244, &[2113540]);     // 244 => [2113540]
            map.insert(245, &[1090519104]);     // 245 => [1090519104]
            map.insert(246, &[2149580816]);     // 246 => [2149580816]
            map.insert(247, &[570425348]);     // 247 => [570425348]
            map.insert(248, &[9437185]);     // 248 => [9437185]
            map.insert(249, &[9437184]);     // 249 => [9437184]
            map.insert(250, &[67633184]);     // 250 => [67633184]
            map.insert(251, &[9437186]);     // 251 => [9437186]
            map.insert(252, &[8650768]);     // 252 => [8650768]
            map.insert(253, &[9437188]);     // 253 => [9437188]
            map.insert(254, &[1207959680]);     // 254 => [1207959680]
            map.insert(255, &[1792]);     // 255 => [1792]
            map.insert(256, &[256]);     // 256 => [256]
            map.insert(257, &[257]);     // 257 => [257]
            map.insert(258, &[258]);     // 258 => [258]
            map.insert(259, &[1074266112]);     // 259 => [1074266112]
            map.insert(260, &[260]);     // 260 => [260]
            map.insert(261, &[261]);     // 261 => [261]
            map.insert(262, &[262]);     // 262 => [262]
            map.insert(263, &[1074266116]);     // 263 => [1074266116]
            map.insert(264, &[264]);     // 264 => [264]
            map.insert(265, &[135266304]);     // 265 => [135266304]
            map.insert(266, &[266]);     // 266 => [266]
            map.insert(267, &[135266306]);     // 267 => [135266306]
            map.insert(268, &[268]);     // 268 => [268]
            map.insert(269, &[135266308]);     // 269 => [135266308]
            map.insert(270, &[1082130560]);     // 270 => [1082130560]
            map.insert(271, &[538968128]);     // 271 => [538968128]
            map.insert(272, &[272]);     // 272 => [272]
            map.insert(273, &[273]);     // 273 => [273]
            map.insert(274, &[274]);     // 274 => [274]
            map.insert(275, &[1074266128]);     // 275 => [1074266128]
            map.insert(276, &[276]);     // 276 => [276]
            map.insert(277, &[67174408]);     // 277 => [67174408]
            map.insert(278, &[805306400]);     // 278 => [805306400]
            map.insert(279, &[1107297280]);     // 279 => [1107297280]
            map.insert(280, &[1073774594]);     // 280 => [1073774594]
            map.insert(281, &[67174404]);     // 281 => [67174404]
            map.insert(282, &[1073774592]);     // 282 => [1073774592]
            map.insert(283, &[1073774593]);     // 283 => [1073774593]
            map.insert(284, &[134479872]);     // 284 => [134479872]
            map.insert(285, &[67174400]);     // 285 => [67174400]
            map.insert(286, &[134479874]);     // 286 => [134479874]
            map.insert(287, &[67174402]);     // 287 => [67174402]
            map.insert(288, &[288]);     // 288 => [288]
            map.insert(289, &[289]);     // 289 => [289]
            map.insert(290, &[290]);     // 290 => [290]
            map.insert(291, &[1074266144]);     // 291 => [1074266144]
            map.insert(292, &[537001985]);     // 292 => [537001985]
            map.insert(293, &[537001984]);     // 293 => [537001984]
            map.insert(294, &[805306384]);     // 294 => [805306384]
            map.insert(295, &[537001986]);     // 295 => [537001986]
            map.insert(296, &[296]);     // 296 => [296]
            map.insert(297, &[135266336]);     // 297 => [135266336]
            map.insert(298, &[12352]);     // 298 => [12352]
            map.insert(299, &[25165840]);     // 299 => [25165840]
            map.insert(300, &[83886144]);     // 300 => [83886144]
            map.insert(301, &[537001992]);     // 301 => [537001992]
            map.insert(302, &[3200]);     // 302 => [3200]
            map.insert(303, &[16810112]);     // 303 => [16810112]
            map.insert(304, &[304]);     // 304 => [304]
            map.insert(305, &[100663808]);     // 305 => [100663808]
            map.insert(306, &[805306372]);     // 306 => [805306372]
            map.insert(307, &[25165832]);     // 307 => [25165832]
            map.insert(308, &[805306370]);     // 308 => [805306370]
            map.insert(309, &[537002000]);     // 309 => [537002000]
            map.insert(310, &[805306368]);     // 310 => [805306368]
            map.insert(311, &[805306369]);     // 311 => [805306369]
            map.insert(312, &[1077937152]);     // 312 => [1077937152]
            map.insert(313, &[25165826]);     // 313 => [25165826]
            map.insert(314, &[25165825]);     // 314 => [25165825]
            map.insert(315, &[25165824]);     // 315 => [25165824]
            map.insert(316, &[134479904]);     // 316 => [134479904]
            map.insert(317, &[67174432]);     // 317 => [67174432]
            map.insert(318, &[805306376]);     // 318 => [805306376]
            map.insert(319, &[25165828]);     // 319 => [25165828]
            map.insert(320, &[320]);     // 320 => [320]
            map.insert(321, &[321]);     // 321 => [321]
            map.insert(322, &[322]);     // 322 => [322]
            map.insert(323, &[4210720]);     // 323 => [4210720]
            map.insert(324, &[324]);     // 324 => [324]
            map.insert(325, &[301990016]);     // 325 => [301990016]
            map.insert(326, &[138413056]);     // 326 => [138413056]
            map.insert(327, &[538968072]);     // 327 => [538968072]
            map.insert(328, &[8454146]);     // 328 => [8454146]
            map.insert(329, &[135266368]);     // 329 => [135266368]
            map.insert(330, &[8454144]);     // 330 => [8454144]
            map.insert(331, &[8454145]);     // 331 => [8454145]
            map.insert(332, &[33570816]);     // 332 => [33570816]
            map.insert(333, &[33570817]);     // 333 => [33570817]
            map.insert(334, &[538968065]);     // 334 => [538968065]
            map.insert(335, &[538968064]);     // 335 => [538968064]
            map.insert(336, &[336]);     // 336 => [336]
            map.insert(337, &[2816]);     // 337 => [2816]
            map.insert(338, &[2181038088]);     // 338 => [2181038088]
            map.insert(339, &[402653696]);     // 339 => [402653696]
            map.insert(340, &[1075839488]);     // 340 => [1075839488]
            map.insert(341, &[2151677984]);     // 341 => [2151677984]
            map.insert(342, &[33685632]);     // 342 => [33685632]
            map.insert(343, &[1074790432]);     // 343 => [1074790432]
            map.insert(344, &[2181038082]);     // 344 => [2181038082]
            map.insert(345, &[1140850816]);     // 345 => [1140850816]
            map.insert(346, &[2181038080]);     // 346 => [2181038080]
            map.insert(347, &[2181038081]);     // 347 => [2181038081]
            map.insert(348, &[33570832]);     // 348 => [33570832]
            map.insert(349, &[134742048]);     // 349 => [134742048]
            map.insert(350, &[2181038084]);     // 350 => [2181038084]
            map.insert(351, &[538968080]);     // 351 => [538968080]
            map.insert(352, &[1074003970]);     // 352 => [1074003970]
            map.insert(353, &[4210690]);     // 353 => [4210690]
            map.insert(354, &[1074003968]);     // 354 => [1074003968]
            map.insert(355, &[4210688]);     // 355 => [4210688]
            map.insert(356, &[134250496]);     // 356 => [134250496]
            map.insert(357, &[134250497]);     // 357 => [134250497]
            map.insert(358, &[134250498]);     // 358 => [134250498]
            map.insert(359, &[4210692]);     // 359 => [4210692]
            map.insert(360, &[12290]);     // 360 => [12290]
            map.insert(361, &[4228]);     // 361 => [4228]
            map.insert(362, &[12288]);     // 362 => [12288]
            map.insert(363, &[12289]);     // 363 => [12289]
            map.insert(364, &[83886080]);     // 364 => [83886080]
            map.insert(365, &[4224]);     // 365 => [4224]
            map.insert(366, &[83886082]);     // 366 => [83886082]
            map.insert(367, &[4226]);     // 367 => [4226]
            map.insert(368, &[142606464]);     // 368 => [142606464]
            map.insert(369, &[2151677956]);     // 369 => [2151677956]
            map.insert(370, &[1074003984]);     // 370 => [1074003984]
            map.insert(371, &[1074790404]);     // 371 => [1074790404]
            map.insert(372, &[2151677953]);     // 372 => [2151677953]
            map.insert(373, &[2151677952]);     // 373 => [2151677952]
            map.insert(374, &[1074790401]);     // 374 => [1074790401]
            map.insert(375, &[1074790400]);     // 375 => [1074790400]
            map.insert(376, &[295168]);     // 376 => [295168]
            map.insert(377, &[134742020]);     // 377 => [134742020]
            map.insert(378, &[12304]);     // 378 => [12304]
            map.insert(379, &[25165888]);     // 379 => [25165888]
            map.insert(380, &[134742017]);     // 380 => [134742017]
            map.insert(381, &[134742016]);     // 381 => [134742016]
            map.insert(382, &[1207959808]);     // 382 => [1207959808]
            map.insert(383, &[134742018]);     // 383 => [134742018]
            map.insert(384, &[384]);     // 384 => [384]
            map.insert(385, &[385]);     // 385 => [385]
            map.insert(386, &[386]);     // 386 => [386]
            map.insert(387, &[8452]);     // 387 => [8452]
            map.insert(388, &[388]);     // 388 => [388]
            map.insert(389, &[8450]);     // 389 => [8450]
            map.insert(390, &[8449]);     // 390 => [8449]
            map.insert(391, &[8448]);     // 391 => [8448]
            map.insert(392, &[392]);     // 392 => [392]
            map.insert(393, &[2684354592]);     // 393 => [2684354592]
            map.insert(394, &[1082130436]);     // 394 => [1082130436]
            map.insert(395, &[16908800]);     // 395 => [16908800]
            map.insert(396, &[1082130434]);     // 396 => [1082130434]
            map.insert(397, &[4192]);     // 397 => [4192]
            map.insert(398, &[1082130432]);     // 398 => [1082130432]
            map.insert(399, &[1082130433]);     // 399 => [1082130433]
            map.insert(400, &[400]);     // 400 => [400]
            map.insert(401, &[6291458]);     // 401 => [6291458]
            map.insert(402, &[6291457]);     // 402 => [6291457]
            map.insert(403, &[6291456]);     // 403 => [6291456]
            map.insert(404, &[8421632]);     // 404 => [8421632]
            map.insert(405, &[545260032]);     // 405 => [545260032]
            map.insert(406, &[17301536]);     // 406 => [17301536]
            map.insert(407, &[6291460]);     // 407 => [6291460]
            map.insert(408, &[285213184]);     // 408 => [285213184]
            map.insert(409, &[1140850752]);     // 409 => [1140850752]
            map.insert(410, &[1073774720]);     // 410 => [1073774720]
            map.insert(411, &[6291464]);     // 411 => [6291464]
            map.insert(412, &[35651616]);     // 412 => [35651616]
            map.insert(413, &[67174528]);     // 413 => [67174528]
            map.insert(414, &[1082130448]);     // 414 => [1082130448]
            map.insert(415, &[536887328]);     // 415 => [536887328]
            map.insert(416, &[416]);     // 416 => [416]
            map.insert(417, &[2684354568]);     // 417 => [2684354568]
            map.insert(418, &[327684]);     // 418 => [327684]
            map.insert(419, &[201326596]);     // 419 => [201326596]
            map.insert(420, &[327682]);     // 420 => [327682]
            map.insert(421, &[201326594]);     // 421 => [201326594]
            map.insert(422, &[327680]);     // 422 => [327680]
            map.insert(423, &[201326592]);     // 423 => [201326592]
            map.insert(424, &[2684354561]);     // 424 => [2684354561]
            map.insert(425, &[2684354560]);     // 425 => [2684354560]
            map.insert(426, &[3076]);     // 426 => [3076]
            map.insert(427, &[2684354562]);     // 427 => [2684354562]
            map.insert(428, &[4161]);     // 428 => [4161]
            map.insert(429, &[4160]);     // 429 => [4160]
            map.insert(430, &[3072]);     // 430 => [3072]
            map.insert(431, &[16809984]);     // 431 => [16809984]
            map.insert(432, &[142606400]);     // 432 => [142606400]
            map.insert(433, &[1114114]);     // 433 => [1114114]
            map.insert(434, &[1114113]);     // 434 => [1114113]
            map.insert(435, &[1114112]);     // 435 => [1114112]
            map.insert(436, &[17301506]);     // 436 => [17301506]
            map.insert(437, &[1090519296]);     // 437 => [1090519296]
            map.insert(438, &[17301504]);     // 438 => [17301504]
            map.insert(439, &[17301505]);     // 439 => [17301505]
            map.insert(440, &[35651588]);     // 440 => [35651588]
            map.insert(441, &[2684354576]);     // 441 => [2684354576]
            map.insert(442, &[134283520]);     // 442 => [134283520]
            map.insert(443, &[536887300]);     // 443 => [536887300]
            map.insert(444, &[35651584]);     // 444 => [35651584]
            map.insert(445, &[35651585]);     // 445 => [35651585]
            map.insert(446, &[536887297]);     // 446 => [536887297]
            map.insert(447, &[536887296]);     // 447 => [536887296]
            map.insert(448, &[17825794]);     // 448 => [17825794]
            map.insert(449, &[301989892]);     // 449 => [301989892]
            map.insert(450, &[17825792]);     // 450 => [17825792]
            map.insert(451, &[17825793]);     // 451 => [17825793]
            map.insert(452, &[301989889]);     // 452 => [301989889]
            map.insert(453, &[301989888]);     // 453 => [301989888]
            map.insert(454, &[589825]);     // 454 => [589825]
            map.insert(455, &[589824]);     // 455 => [589824]
            map.insert(456, &[268469248]);     // 456 => [268469248]
            map.insert(457, &[4132]);     // 457 => [4132]
            map.insert(458, &[17825800]);     // 458 => [17825800]
            map.insert(459, &[150995200]);     // 459 => [150995200]
            map.insert(460, &[4129]);     // 460 => [4129]
            map.insert(461, &[4128]);     // 461 => [4128]
            map.insert(462, &[98320]);     // 462 => [98320]
            map.insert(463, &[4130]);     // 463 => [4130]
            map.insert(464, &[142606368]);     // 464 => [142606368]
            map.insert(465, &[1140850696]);     // 465 => [1140850696]
            map.insert(466, &[33685508]);     // 466 => [33685508]
            map.insert(467, &[17039364]);     // 467 => [17039364]
            map.insert(468, &[33685506]);     // 468 => [33685506]
            map.insert(469, &[17039362]);     // 469 => [17039362]
            map.insert(470, &[33685504]);     // 470 => [33685504]
            map.insert(471, &[17039360]);     // 471 => [17039360]
            map.insert(472, &[1140850689]);     // 472 => [1140850689]
            map.insert(473, &[1140850688]);     // 473 => [1140850688]
            map.insert(474, &[98308]);     // 474 => [98308]
            map.insert(475, &[1140850690]);     // 475 => [1140850690]
            map.insert(476, &[98306]);     // 476 => [98306]
            map.insert(477, &[1140850692]);     // 477 => [1140850692]
            map.insert(478, &[98304]);     // 478 => [98304]
            map.insert(479, &[98305]);     // 479 => [98305]
            map.insert(480, &[142606352]);     // 480 => [142606352]
            map.insert(481, &[4108]);     // 481 => [4108]
            map.insert(482, &[272629768]);     // 482 => [272629768]
            map.insert(483, &[4210816]);     // 483 => [4210816]
            map.insert(484, &[4105]);     // 484 => [4105]
            map.insert(485, &[4104]);     // 485 => [4104]
            map.insert(486, &[327744]);     // 486 => [327744]
            map.insert(487, &[4106]);     // 487 => [4106]
            map.insert(488, &[4101]);     // 488 => [4101]
            map.insert(489, &[4100]);     // 489 => [4100]
            map.insert(490, &[272629760]);     // 490 => [272629760]
            map.insert(491, &[272629761]);     // 491 => [272629761]
            map.insert(492, &[4097]);     // 492 => [4097]
            map.insert(493, &[4096]);     // 493 => [4096]
            map.insert(494, &[4099]);     // 494 => [4099]
            map.insert(495, &[4098]);     // 495 => [4098]
            map.insert(496, &[142606336]);     // 496 => [142606336]
            map.insert(497, &[142606337]);     // 497 => [142606337]
            map.insert(498, &[142606338]);     // 498 => [142606338]
            map.insert(499, &[1114176]);     // 499 => [1114176]
            map.insert(500, &[142606340]);     // 500 => [142606340]
            map.insert(501, &[4120]);     // 501 => [4120]
            map.insert(502, &[33685536]);     // 502 => [33685536]
            map.insert(503, &[1544]);     // 503 => [1544]
            map.insert(504, &[4325377]);     // 504 => [4325377]
            map.insert(505, &[4325376]);     // 505 => [4325376]
            map.insert(506, &[272629776]);     // 506 => [272629776]
            map.insert(507, &[4325378]);     // 507 => [4325378]
            map.insert(508, &[4113]);     // 508 => [4113]
            map.insert(509, &[4112]);     // 509 => [4112]
            map.insert(510, &[1537]);     // 510 => [1537]
            map.insert(511, &[1536]);     // 511 => [1536]
            map.insert(512, &[512]);     // 512 => [512]
            map.insert(513, &[513]);     // 513 => [513]
            map.insert(514, &[514]);     // 514 => [514]
            map.insert(515, &[4259840]);     // 515 => [4259840]
            map.insert(516, &[516]);     // 516 => [516]
            map.insert(517, &[517]);     // 517 => [517]
            map.insert(518, &[518]);     // 518 => [518]
            map.insert(519, &[4259844]);     // 519 => [4259844]
            map.insert(520, &[520]);     // 520 => [520]
            map.insert(521, &[521]);     // 521 => [521]
            map.insert(522, &[522]);     // 522 => [522]
            map.insert(523, &[4259848]);     // 523 => [4259848]
            map.insert(524, &[524]);     // 524 => [524]
            map.insert(525, &[69206144]);     // 525 => [69206144]
            map.insert(526, &[268959776]);     // 526 => [268959776]
            map.insert(527, &[268697664]);     // 527 => [268697664]
            map.insert(528, &[528]);     // 528 => [528]
            map.insert(529, &[2112]);     // 529 => [2112]
            map.insert(530, &[5120]);     // 530 => [5120]
            map.insert(531, &[5121]);     // 531 => [5121]
            map.insert(532, &[532]);     // 532 => [532]
            map.insert(533, &[2116]);     // 533 => [2116]
            map.insert(534, &[5124]);     // 534 => [5124]
            map.insert(535, &[268468256]);     // 535 => [268468256]
            map.insert(536, &[536]);     // 536 => [536]
            map.insert(537, &[1610612738]);     // 537 => [1610612738]
            map.insert(538, &[1610612737]);     // 538 => [1610612737]
            map.insert(539, &[1610612736]);     // 539 => [1610612736]
            map.insert(540, &[2155872288]);     // 540 => [2155872288]
            map.insert(541, &[655392]);     // 541 => [655392]
            map.insert(542, &[71303424]);     // 542 => [71303424]
            map.insert(543, &[1610612740]);     // 543 => [1610612740]
            map.insert(544, &[544]);     // 544 => [544]
            map.insert(545, &[545]);     // 545 => [545]
            map.insert(546, &[3145729]);     // 546 => [3145729]
            map.insert(547, &[3145728]);     // 547 => [3145728]
            map.insert(548, &[163840]);     // 548 => [163840]
            map.insert(549, &[163841]);     // 549 => [163841]
            map.insert(550, &[163842]);     // 550 => [163842]
            map.insert(551, &[3145732]);     // 551 => [3145732]
            map.insert(552, &[8404994]);     // 552 => [8404994]
            map.insert(553, &[33686528]);     // 553 => [33686528]
            map.insert(554, &[8404992]);     // 554 => [8404992]
            map.insert(555, &[8404993]);     // 555 => [8404993]
            map.insert(556, &[33619968]);     // 556 => [33619968]
            map.insert(557, &[33619969]);     // 557 => [33619969]
            map.insert(558, &[268959744]);     // 558 => [268959744]
            map.insert(559, &[268959745]);     // 559 => [268959745]
            map.insert(560, &[560]);     // 560 => [560]
            map.insert(561, &[2144]);     // 561 => [2144]
            map.insert(562, &[2359300]);     // 562 => [2359300]
            map.insert(563, &[268468228]);     // 563 => [268468228]
            map.insert(564, &[2359298]);     // 564 => [2359298]
            map.insert(565, &[268468226]);     // 565 => [268468226]
            map.insert(566, &[2359296]);     // 566 => [2359296]
            map.insert(567, &[268468224]);     // 567 => [268468224]
            map.insert(568, &[2155872260]);     // 568 => [2155872260]
            map.insert(569, &[655364]);     // 569 => [655364]
            map.insert(570, &[8405008]);     // 570 => [8405008]
            map.insert(571, &[1610612768]);     // 571 => [1610612768]
            map.insert(572, &[2155872256]);     // 572 => [2155872256]
            map.insert(573, &[655360]);     // 573 => [655360]
            map.insert(574, &[2155872258]);     // 574 => [2155872258]
            map.insert(575, &[655362]);     // 575 => [655362]
            map.insert(576, &[576]);     // 576 => [576]
            map.insert(577, &[2064]);     // 577 => [2064]
            map.insert(578, &[578]);     // 578 => [578]
            map.insert(579, &[2066]);     // 579 => [2066]
            map.insert(580, &[580]);     // 580 => [580]
            map.insert(581, &[2068]);     // 581 => [2068]
            map.insert(582, &[2129928]);     // 582 => [2129928]
            map.insert(583, &[268697608]);     // 583 => [268697608]
            map.insert(584, &[1179649]);     // 584 => [1179649]
            map.insert(585, &[1179648]);     // 585 => [1179648]
            map.insert(586, &[2129924]);     // 586 => [2129924]
            map.insert(587, &[1179650]);     // 587 => [1179650]
            map.insert(588, &[2129922]);     // 588 => [2129922]
            map.insert(589, &[268697602]);     // 589 => [268697602]
            map.insert(590, &[2129920]);     // 590 => [2129920]
            map.insert(591, &[268697600]);     // 591 => [268697600]
            map.insert(592, &[2049]);     // 592 => [2049]
            map.insert(593, &[2048]);     // 593 => [2048]
            map.insert(594, &[2051]);     // 594 => [2051]
            map.insert(595, &[2050]);     // 595 => [2050]
            map.insert(596, &[2053]);     // 596 => [2053]
            map.insert(597, &[2052]);     // 597 => [2052]
            map.insert(598, &[2621441]);     // 598 => [2621441]
            map.insert(599, &[2621440]);     // 599 => [2621440]
            map.insert(600, &[2057]);     // 600 => [2057]
            map.insert(601, &[2056]);     // 601 => [2056]
            map.insert(602, &[269484032]);     // 602 => [269484032]
            map.insert(603, &[269484033]);     // 603 => [269484033]
            map.insert(604, &[393216]);     // 604 => [393216]
            map.insert(605, &[50331648]);     // 605 => [50331648]
            map.insert(606, &[393218]);     // 606 => [393218]
            map.insert(607, &[50331650]);     // 607 => [50331650]
            map.insert(608, &[608]);     // 608 => [608]
            map.insert(609, &[671088644]);     // 609 => [671088644]
            map.insert(610, &[20971536]);     // 610 => [20971536]
            map.insert(611, &[2214592520]);     // 611 => [2214592520]
            map.insert(612, &[671088641]);     // 612 => [671088641]
            map.insert(613, &[671088640]);     // 613 => [671088640]
            map.insert(614, &[41943296]);     // 614 => [41943296]
            map.insert(615, &[671088642]);     // 615 => [671088642]
            map.insert(616, &[1107296384]);     // 616 => [1107296384]
            map.insert(617, &[2214592514]);     // 617 => [2214592514]
            map.insert(618, &[2214592513]);     // 618 => [2214592513]
            map.insert(619, &[2214592512]);     // 619 => [2214592512]
            map.insert(620, &[33620032]);     // 620 => [33620032]
            map.insert(621, &[671088648]);     // 621 => [671088648]
            map.insert(622, &[2129952]);     // 622 => [2129952]
            map.insert(623, &[2214592516]);     // 623 => [2214592516]
            map.insert(624, &[2081]);     // 624 => [2081]
            map.insert(625, &[2080]);     // 625 => [2080]
            map.insert(626, &[20971520]);     // 626 => [20971520]
            map.insert(627, &[20971521]);     // 627 => [20971521]
            map.insert(628, &[335544448]);     // 628 => [335544448]
            map.insert(629, &[2084]);     // 629 => [2084]
            map.insert(630, &[20971524]);     // 630 => [20971524]
            map.insert(631, &[2621472]);     // 631 => [2621472]
            map.insert(632, &[9472]);     // 632 => [9472]
            map.insert(633, &[67125252]);     // 633 => [67125252]
            map.insert(634, &[20971528]);     // 634 => [20971528]
            map.insert(635, &[2214592528]);     // 635 => [2214592528]
            map.insert(636, &[67125249]);     // 636 => [67125249]
            map.insert(637, &[67125248]);     // 637 => [67125248]
            map.insert(638, &[1207960064]);     // 638 => [1207960064]
            map.insert(639, &[67125250]);     // 639 => [67125250]
            map.insert(640, &[640]);     // 640 => [640]
            map.insert(641, &[641]);     // 641 => [641]
            map.insert(642, &[642]);     // 642 => [642]
            map.insert(643, &[8708]);     // 643 => [8708]
            map.insert(644, &[644]);     // 644 => [644]
            map.insert(645, &[8706]);     // 645 => [8706]
            map.insert(646, &[8705]);     // 646 => [8705]
            map.insert(647, &[8704]);     // 647 => [8704]
            map.insert(648, &[648]);     // 648 => [648]
            map.insert(649, &[69206020]);     // 649 => [69206020]
            map.insert(650, &[33816832]);     // 650 => [33816832]
            map.insert(651, &[16908544]);     // 651 => [16908544]
            map.insert(652, &[69206017]);     // 652 => [69206017]
            map.insert(653, &[69206016]);     // 653 => [69206016]
            map.insert(654, &[553648160]);     // 654 => [553648160]
            map.insert(655, &[69206018]);     // 655 => [69206018]
            map.insert(656, &[656]);     // 656 => [656]
            map.insert(657, &[2148007968]);     // 657 => [2148007968]
            map.insert(658, &[167772164]);     // 658 => [167772164]
            map.insert(659, &[1065024]);     // 659 => [1065024]
            map.insert(660, &[167772162]);     // 660 => [167772162]
            map.insert(661, &[545259776]);     // 661 => [545259776]
            map.insert(662, &[167772160]);     // 662 => [167772160]
            map.insert(663, &[167772161]);     // 663 => [167772161]
            map.insert(664, &[285212928]);     // 664 => [285212928]
            map.insert(665, &[138412064]);     // 665 => [138412064]
            map.insert(666, &[10485824]);     // 666 => [10485824]
            map.insert(667, &[1610612864]);     // 667 => [1610612864]
            map.insert(668, &[4211712]);     // 668 => [4211712]
            map.insert(669, &[69206032]);     // 669 => [69206032]
            map.insert(670, &[167772168]);     // 670 => [167772168]
            map.insert(671, &[536936512]);     // 671 => [536936512]
            map.insert(672, &[2147516424]);     // 672 => [2147516424]
            map.insert(673, &[276824066]);     // 673 => [276824066]
            map.insert(674, &[276824065]);     // 674 => [276824065]
            map.insert(675, &[276824064]);     // 675 => [276824064]
            map.insert(676, &[163968]);     // 676 => [163968]
            map.insert(677, &[540674]);     // 677 => [540674]
            map.insert(678, &[540673]);     // 678 => [540673]
            map.insert(679, &[540672]);     // 679 => [540672]
            map.insert(680, &[2147516416]);     // 680 => [2147516416]
            map.insert(681, &[2147516417]);     // 681 => [2147516417]
            map.insert(682, &[2147516418]);     // 682 => [2147516418]
            map.insert(683, &[276824072]);     // 683 => [276824072]
            map.insert(684, &[553648130]);     // 684 => [553648130]
            map.insert(685, &[69206048]);     // 685 => [69206048]
            map.insert(686, &[553648128]);     // 686 => [553648128]
            map.insert(687, &[553648129]);     // 687 => [553648129]
            map.insert(688, &[8519680]);     // 688 => [8519680]
            map.insert(689, &[2148007936]);     // 689 => [2148007936]
            map.insert(690, &[8519682]);     // 690 => [8519682]
            map.insert(691, &[2148007938]);     // 691 => [2148007938]
            map.insert(692, &[8519684]);     // 692 => [8519684]
            map.insert(693, &[2148007940]);     // 693 => [2148007940]
            map.insert(694, &[49160]);     // 694 => [49160]
            map.insert(695, &[540688]);     // 695 => [540688]
            map.insert(696, &[138412033]);     // 696 => [138412033]
            map.insert(697, &[138412032]);     // 697 => [138412032]
            map.insert(698, &[49156]);     // 698 => [49156]
            map.insert(699, &[138412034]);     // 699 => [138412034]
            map.insert(700, &[49154]);     // 700 => [49154]
            map.insert(701, &[138412036]);     // 701 => [138412036]
            map.insert(702, &[49152]);     // 702 => [49152]
            map.insert(703, &[49153]);     // 703 => [49153]
            map.insert(704, &[2147745808]);     // 704 => [2147745808]
            map.insert(705, &[2148532228]);     // 705 => [2148532228]
            map.insert(706, &[278532]);     // 706 => [278532]
            map.insert(707, &[1077936132]);     // 707 => [1077936132]
            map.insert(708, &[2148532225]);     // 708 => [2148532225]
            map.insert(709, &[2148532224]);     // 709 => [2148532224]
            map.insert(710, &[278528]);     // 710 => [278528]
            map.insert(711, &[1077936128]);     // 711 => [1077936128]
            map.insert(712, &[1107296288]);     // 712 => [1107296288]
            map.insert(713, &[1179776]);     // 713 => [1179776]
            map.insert(714, &[10485776]);     // 714 => [10485776]
            map.insert(715, &[150995456]);     // 715 => [150995456]
            map.insert(716, &[2281701632]);     // 716 => [2281701632]
            map.insert(717, &[2148532232]);     // 717 => [2148532232]
            map.insert(718, &[278536]);     // 718 => [278536]
            map.insert(719, &[1077936136]);     // 719 => [1077936136]
            map.insert(720, &[2147745792]);     // 720 => [2147745792]
            map.insert(721, &[2176]);     // 721 => [2176]
            map.insert(722, &[1064961]);     // 722 => [1064961]
            map.insert(723, &[1064960]);     // 723 => [1064960]
            map.insert(724, &[10242]);     // 724 => [10242]
            map.insert(725, &[2180]);     // 725 => [2180]
            map.insert(726, &[10240]);     // 726 => [10240]
            map.insert(727, &[10241]);     // 727 => [10241]
            map.insert(728, &[10485762]);     // 728 => [10485762]
            map.insert(729, &[2184]);     // 729 => [2184]
            map.insert(730, &[10485760]);     // 730 => [10485760]
            map.insert(731, &[10485761]);     // 731 => [10485761]
            map.insert(732, &[393344]);     // 732 => [393344]
            map.insert(733, &[536936450]);     // 733 => [536936450]
            map.insert(734, &[536936449]);     // 734 => [536936449]
            map.insert(735, &[536936448]);     // 735 => [536936448]
            map.insert(736, &[1107296264]);     // 736 => [1107296264]
            map.insert(737, &[18874624]);     // 737 => [18874624]
            map.insert(738, &[67175424]);     // 738 => [67175424]
            map.insert(739, &[67239940]);     // 739 => [67239940]
            map.insert(740, &[335544336]);     // 740 => [335544336]
            map.insert(741, &[67239938]);     // 741 => [67239938]
            map.insert(742, &[67239937]);     // 742 => [67239937]
            map.insert(743, &[67239936]);     // 743 => [67239936]
            map.insert(744, &[1107296256]);     // 744 => [1107296256]
            map.insert(745, &[1107296257]);     // 745 => [1107296257]
            map.insert(746, &[1107296258]);     // 746 => [1107296258]
            map.insert(747, &[2214592640]);     // 747 => [2214592640]
            map.insert(748, &[1107296260]);     // 748 => [1107296260]
            map.insert(749, &[4864]);     // 749 => [4864]
            map.insert(750, &[553648192]);     // 750 => [553648192]
            map.insert(751, &[67239944]);     // 751 => [67239944]
            map.insert(752, &[335544324]);     // 752 => [335544324]
            map.insert(753, &[2208]);     // 753 => [2208]
            map.insert(754, &[20971648]);     // 754 => [20971648]
            map.insert(755, &[1064992]);     // 755 => [1064992]
            map.insert(756, &[335544320]);     // 756 => [335544320]
            map.insert(757, &[335544321]);     // 757 => [335544321]
            map.insert(758, &[335544322]);     // 758 => [335544322]
            map.insert(759, &[1288]);     // 759 => [1288]
            map.insert(760, &[1107296272]);     // 760 => [1107296272]
            map.insert(761, &[138412096]);     // 761 => [138412096]
            map.insert(762, &[10485792]);     // 762 => [10485792]
            map.insert(763, &[1284]);     // 763 => [1284]
            map.insert(764, &[335544328]);     // 764 => [335544328]
            map.insert(765, &[1282]);     // 765 => [1282]
            map.insert(766, &[1281]);     // 766 => [1281]
            map.insert(767, &[1280]);     // 767 => [1280]
            map.insert(768, &[768]);     // 768 => [768]
            map.insert(769, &[536903680]);     // 769 => [536903680]
            map.insert(770, &[770]);     // 770 => [770]
            map.insert(771, &[536903682]);     // 771 => [536903682]
            map.insert(772, &[772]);     // 772 => [772]
            map.insert(773, &[2164260866]);     // 773 => [2164260866]
            map.insert(774, &[2164260865]);     // 774 => [2164260865]
            map.insert(775, &[2164260864]);     // 775 => [2164260864]
            map.insert(776, &[776]);     // 776 => [776]
            map.insert(777, &[536903688]);     // 777 => [536903688]
            map.insert(778, &[136314912]);     // 778 => [136314912]
            map.insert(779, &[16908416]);     // 779 => [16908416]
            map.insert(780, &[570426368]);     // 780 => [570426368]
            map.insert(781, &[1342177312]);     // 781 => [1342177312]
            map.insert(782, &[71303184]);     // 782 => [71303184]
            map.insert(783, &[2164260872]);     // 783 => [2164260872]
            map.insert(784, &[16793601]);     // 784 => [16793601]
            map.insert(785, &[16793600]);     // 785 => [16793600]
            map.insert(786, &[5376]);     // 786 => [5376]
            map.insert(787, &[16793602]);     // 787 => [16793602]
            map.insert(788, &[1075839040]);     // 788 => [1075839040]
            map.insert(789, &[16793604]);     // 789 => [16793604]
            map.insert(790, &[71303176]);     // 790 => [71303176]
            map.insert(791, &[2164260880]);     // 791 => [2164260880]
            map.insert(792, &[537395200]);     // 792 => [537395200]
            map.insert(793, &[537395201]);     // 793 => [537395201]
            map.insert(794, &[537395202]);     // 794 => [537395202]
            map.insert(795, &[1610612992]);     // 795 => [1610612992]
            map.insert(796, &[71303170]);     // 796 => [71303170]
            map.insert(797, &[67174912]);     // 797 => [67174912]
            map.insert(798, &[71303168]);     // 798 => [71303168]
            map.insert(799, &[71303169]);     // 799 => [71303169]
            map.insert(800, &[800]);     // 800 => [800]
            map.insert(801, &[100663312]);     // 801 => [100663312]
            map.insert(802, &[136314888]);     // 802 => [136314888]
            map.insert(803, &[3145984]);     // 803 => [3145984]
            map.insert(804, &[1073758336]);     // 804 => [1073758336]
            map.insert(805, &[1342177288]);     // 805 => [1342177288]
            map.insert(806, &[41943104]);     // 806 => [41943104]
            map.insert(807, &[2164260896]);     // 807 => [2164260896]
            map.insert(808, &[136314882]);     // 808 => [136314882]
            map.insert(809, &[1342177284]);     // 809 => [1342177284]
            map.insert(810, &[136314880]);     // 810 => [136314880]
            map.insert(811, &[136314881]);     // 811 => [136314881]
            map.insert(812, &[1342177281]);     // 812 => [1342177281]
            map.insert(813, &[1342177280]);     // 813 => [1342177280]
            map.insert(814, &[136314884]);     // 814 => [136314884]
            map.insert(815, &[1342177282]);     // 815 => [1342177282]
            map.insert(816, &[100663297]);     // 816 => [100663297]
            map.insert(817, &[100663296]);     // 817 => [100663296]
            map.insert(818, &[3221225600]);     // 818 => [3221225600]
            map.insert(819, &[100663298]);     // 819 => [100663298]
            map.insert(820, &[150995968]);     // 820 => [150995968]
            map.insert(821, &[100663300]);     // 821 => [100663300]
            map.insert(822, &[1073872904]);     // 822 => [1073872904]
            map.insert(823, &[268468480]);     // 823 => [268468480]
            map.insert(824, &[537395232]);     // 824 => [537395232]
            map.insert(825, &[100663304]);     // 825 => [100663304]
            map.insert(826, &[1073872900]);     // 826 => [1073872900]
            map.insert(827, &[25166336]);     // 827 => [25166336]
            map.insert(828, &[1073872898]);     // 828 => [1073872898]
            map.insert(829, &[1342177296]);     // 829 => [1342177296]
            map.insert(830, &[1073872896]);     // 830 => [1073872896]
            map.insert(831, &[1073872897]);     // 831 => [1073872897]
            map.insert(832, &[134348800]);     // 832 => [134348800]
            map.insert(833, &[134348801]);     // 833 => [134348801]
            map.insert(834, &[134348802]);     // 834 => [134348802]
            map.insert(835, &[402653200]);     // 835 => [402653200]
            map.insert(836, &[134348804]);     // 836 => [134348804]
            map.insert(837, &[134284288]);     // 837 => [134284288]
            map.insert(838, &[41943072]);     // 838 => [41943072]
            map.insert(839, &[2164260928]);     // 839 => [2164260928]
            map.insert(840, &[12582913]);     // 840 => [12582913]
            map.insert(841, &[12582912]);     // 841 => [12582912]
            map.insert(842, &[8454656]);     // 842 => [8454656]
            map.insert(843, &[12582914]);     // 843 => [12582914]
            map.insert(844, &[537919520]);     // 844 => [537919520]
            map.insert(845, &[12582916]);     // 845 => [12582916]
            map.insert(846, &[2130176]);     // 846 => [2130176]
            map.insert(847, &[268697856]);     // 847 => [268697856]
            map.insert(848, &[2305]);     // 848 => [2305]
            map.insert(849, &[2304]);     // 849 => [2304]
            map.insert(850, &[402653185]);     // 850 => [402653185]
            map.insert(851, &[402653184]);     // 851 => [402653184]
            map.insert(852, &[1075838976]);     // 852 => [1075838976]
            map.insert(853, &[1075838977]);     // 853 => [1075838977]
            map.insert(854, &[1075838978]);     // 854 => [1075838978]
            map.insert(855, &[402653188]);     // 855 => [402653188]
            map.insert(856, &[9248]);     // 856 => [9248]
            map.insert(857, &[2312]);     // 857 => [2312]
            map.insert(858, &[134234240]);     // 858 => [134234240]
            map.insert(859, &[402653192]);     // 859 => [402653192]
            map.insert(860, &[1075838984]);     // 860 => [1075838984]
            map.insert(861, &[4227200]);     // 861 => [4227200]
            map.insert(862, &[71303232]);     // 862 => [71303232]
            map.insert(863, &[1184]);     // 863 => [1184]
            map.insert(864, &[81920]);     // 864 => [81920]
            map.insert(865, &[81921]);     // 865 => [81921]
            map.insert(866, &[81922]);     // 866 => [81922]
            map.insert(867, &[4211200]);     // 867 => [4211200]
            map.insert(868, &[41943042]);     // 868 => [41943042]
            map.insert(869, &[671088896]);     // 869 => [671088896]
            map.insert(870, &[41943040]);     // 870 => [41943040]
            map.insert(871, &[41943041]);     // 871 => [41943041]
            map.insert(872, &[537919492]);     // 872 => [537919492]
            map.insert(873, &[537133072]);     // 873 => [537133072]
            map.insert(874, &[136314944]);     // 874 => [136314944]
            map.insert(875, &[34078848]);     // 875 => [34078848]
            map.insert(876, &[537919488]);     // 876 => [537919488]
            map.insert(877, &[537919489]);     // 877 => [537919489]
            map.insert(878, &[537919490]);     // 878 => [537919490]
            map.insert(879, &[1168]);     // 879 => [1168]
            map.insert(880, &[9224]);     // 880 => [9224]
            map.insert(881, &[537133064]);     // 881 => [537133064]
            map.insert(882, &[2147549188]);     // 882 => [2147549188]
            map.insert(883, &[402653216]);     // 883 => [402653216]
            map.insert(884, &[2147549186]);     // 884 => [2147549186]
            map.insert(885, &[2151678464]);     // 885 => [2151678464]
            map.insert(886, &[2147549184]);     // 886 => [2147549184]
            map.insert(887, &[2147549185]);     // 887 => [2147549185]
            map.insert(888, &[9216]);     // 888 => [9216]
            map.insert(889, &[537133056]);     // 889 => [537133056]
            map.insert(890, &[9218]);     // 890 => [9218]
            map.insert(891, &[537133058]);     // 891 => [537133058]
            map.insert(892, &[9220]);     // 892 => [9220]
            map.insert(893, &[1154]);     // 893 => [1154]
            map.insert(894, &[1153]);     // 894 => [1153]
            map.insert(895, &[1152]);     // 895 => [1152]
            map.insert(896, &[2162704]);     // 896 => [2162704]
            map.insert(897, &[536903808]);     // 897 => [536903808]
            map.insert(898, &[33816584]);     // 898 => [33816584]
            map.insert(899, &[16908296]);     // 899 => [16908296]
            map.insert(900, &[1073758240]);     // 900 => [1073758240]
            map.insert(901, &[545259536]);     // 901 => [545259536]
            map.insert(902, &[270533632]);     // 902 => [270533632]
            map.insert(903, &[2164260992]);     // 903 => [2164260992]
            map.insert(904, &[33816578]);     // 904 => [33816578]
            map.insert(905, &[16908290]);     // 905 => [16908290]
            map.insert(906, &[33816576]);     // 906 => [33816576]
            map.insert(907, &[16908288]);     // 907 => [16908288]
            map.insert(908, &[2281701440]);     // 908 => [2281701440]
            map.insert(909, &[69206272]);     // 909 => [69206272]
            map.insert(910, &[33816580]);     // 910 => [33816580]
            map.insert(911, &[16908292]);     // 911 => [16908292]
            map.insert(912, &[2162688]);     // 912 => [2162688]
            map.insert(913, &[2162689]);     // 913 => [2162689]
            map.insert(914, &[2162690]);     // 914 => [2162690]
            map.insert(915, &[6291968]);     // 915 => [6291968]
            map.insert(916, &[545259521]);     // 916 => [545259521]
            map.insert(917, &[545259520]);     // 917 => [545259520]
            map.insert(918, &[167772416]);     // 918 => [167772416]
            map.insert(919, &[545259522]);     // 919 => [545259522]
            map.insert(920, &[285212672]);     // 920 => [285212672]
            map.insert(921, &[285212673]);     // 921 => [285212673]
            map.insert(922, &[285212674]);     // 922 => [285212674]
            map.insert(923, &[34603012]);     // 923 => [34603012]
            map.insert(924, &[285212676]);     // 924 => [285212676]
            map.insert(925, &[34603010]);     // 925 => [34603010]
            map.insert(926, &[34603009]);     // 926 => [34603009]
            map.insert(927, &[34603008]);     // 927 => [34603008]
            map.insert(928, &[1073758212]);     // 928 => [1073758212]
            map.insert(929, &[4456452]);     // 929 => [4456452]
            map.insert(930, &[3221225488]);     // 930 => [3221225488]
            map.insert(931, &[276824320]);     // 931 => [276824320]
            map.insert(932, &[1073758208]);     // 932 => [1073758208]
            map.insert(933, &[4456448]);     // 933 => [4456448]
            map.insert(934, &[1073758210]);     // 934 => [1073758210]
            map.insert(935, &[4456450]);     // 935 => [4456450]
            map.insert(936, &[2147516672]);     // 936 => [2147516672]
            map.insert(937, &[268501056]);     // 937 => [268501056]
            map.insert(938, &[33816608]);     // 938 => [33816608]
            map.insert(939, &[16908320]);     // 939 => [16908320]
            map.insert(940, &[1073758216]);     // 940 => [1073758216]
            map.insert(941, &[4456456]);     // 941 => [4456456]
            map.insert(942, &[553648384]);     // 942 => [553648384]
            map.insert(943, &[1104]);     // 943 => [1104]
            map.insert(944, &[5242880]);     // 944 => [5242880]
            map.insert(945, &[5242881]);     // 945 => [5242881]
            map.insert(946, &[3221225472]);     // 946 => [3221225472]
            map.insert(947, &[3221225473]);     // 947 => [3221225473]
            map.insert(948, &[5242884]);     // 948 => [5242884]
            map.insert(949, &[4456464]);     // 949 => [4456464]
            map.insert(950, &[3221225476]);     // 950 => [3221225476]
            map.insert(951, &[1096]);     // 951 => [1096]
            map.insert(952, &[6148]);     // 952 => [6148]
            map.insert(953, &[138412288]);     // 953 => [138412288]
            map.insert(954, &[3221225480]);     // 954 => [3221225480]
            map.insert(955, &[1092]);     // 955 => [1092]
            map.insert(956, &[6144]);     // 956 => [6144]
            map.insert(957, &[6145]);     // 957 => [6145]
            map.insert(958, &[1089]);     // 958 => [1089]
            map.insert(959, &[1088]);     // 959 => [1088]
            map.insert(960, &[603979778]);     // 960 => [603979778]
            map.insert(961, &[18874400]);     // 961 => [18874400]
            map.insert(962, &[603979776]);     // 962 => [603979776]
            map.insert(963, &[603979777]);     // 963 => [603979777]
            map.insert(964, &[4718592]);     // 964 => [4718592]
            map.insert(965, &[4718593]);     // 965 => [4718593]
            map.insert(966, &[4718594]);     // 966 => [4718594]
            map.insert(967, &[1077936384]);     // 967 => [1077936384]
            map.insert(968, &[2281701380]);     // 968 => [2281701380]
            map.insert(969, &[268501024]);     // 969 => [268501024]
            map.insert(970, &[603979784]);     // 970 => [603979784]
            map.insert(971, &[34078752]);     // 971 => [34078752]
            map.insert(972, &[2281701376]);     // 972 => [2281701376]
            map.insert(973, &[2281701377]);     // 973 => [2281701377]
            map.insert(974, &[2281701378]);     // 974 => [2281701378]
            map.insert(975, &[1072]);     // 975 => [1072]
            map.insert(976, &[2162752]);     // 976 => [2162752]
            map.insert(977, &[2432]);     // 977 => [2432]
            map.insert(978, &[134234120]);     // 978 => [134234120]
            map.insert(979, &[402653312]);     // 979 => [402653312]
            map.insert(980, &[4718608]);     // 980 => [4718608]
            map.insert(981, &[4227080]);     // 981 => [4227080]
            map.insert(982, &[10496]);     // 982 => [10496]
            map.insert(983, &[1064]);     // 983 => [1064]
            map.insert(984, &[134234114]);     // 984 => [134234114]
            map.insert(985, &[4227076]);     // 985 => [4227076]
            map.insert(986, &[134234112]);     // 986 => [134234112]
            map.insert(987, &[134234113]);     // 987 => [134234113]
            map.insert(988, &[4227073]);     // 988 => [4227073]
            map.insert(989, &[4227072]);     // 989 => [4227072]
            map.insert(990, &[1057]);     // 990 => [1057]
            map.insert(991, &[1056]);     // 991 => [1056]
            map.insert(992, &[18874369]);     // 992 => [18874369]
            map.insert(993, &[18874368]);     // 993 => [18874368]
            map.insert(994, &[33587216]);     // 994 => [33587216]
            map.insert(995, &[18874370]);     // 995 => [18874370]
            map.insert(996, &[4718624]);     // 996 => [4718624]
            map.insert(997, &[18874372]);     // 997 => [18874372]
            map.insert(998, &[41943168]);     // 998 => [41943168]
            map.insert(999, &[1048]);     // 999 => [1048]
            map.insert(1000, &[268500993]);     // 1000 => [268500993]
            map.insert(1001, &[268500992]);     // 1001 => [268500992]
            map.insert(1002, &[34078721]);     // 1002 => [34078721]
            map.insert(1003, &[34078720]);     // 1003 => [34078720]
            map.insert(1004, &[4609]);     // 1004 => [4609]
            map.insert(1005, &[4608]);     // 1005 => [4608]
            map.insert(1006, &[1041]);     // 1006 => [1041]
            map.insert(1007, &[1040]);     // 1007 => [1040]
            map.insert(1008, &[33587202]);     // 1008 => [33587202]
            map.insert(1009, &[18874384]);     // 1009 => [18874384]
            map.insert(1010, &[33587200]);     // 1010 => [33587200]
            map.insert(1011, &[33587201]);     // 1011 => [33587201]
            map.insert(1012, &[335544576]);     // 1012 => [335544576]
            map.insert(1013, &[1034]);     // 1013 => [1034]
            map.insert(1014, &[1033]);     // 1014 => [1033]
            map.insert(1015, &[1032]);     // 1015 => [1032]
            map.insert(1016, &[196610]);     // 1016 => [196610]
            map.insert(1017, &[1030]);     // 1017 => [1030]
            map.insert(1018, &[196608]);     // 1018 => [196608]
            map.insert(1019, &[1028]);     // 1019 => [1028]
            map.insert(1020, &[1027]);     // 1020 => [1027]
            map.insert(1021, &[1026]);     // 1021 => [1026]
            map.insert(1022, &[1025]);     // 1022 => [1025]
            map.insert(1023, &[1024]);     // 1023 => [1024]
            map.insert(1024, &[16384]);     // 1024 => [16384]
            map.insert(1025, &[16385]);     // 1025 => [16385]
            map.insert(1026, &[16386]);     // 1026 => [16386]
            map.insert(1027, &[16387]);     // 1027 => [16387]
            map.insert(1028, &[16388]);     // 1028 => [16388]
            map.insert(1029, &[16389]);     // 1029 => [16389]
            map.insert(1030, &[2147483664]);     // 1030 => [2147483664]
            map.insert(1031, &[2147483665]);     // 1031 => [2147483665]
            map.insert(1032, &[16392]);     // 1032 => [16392]
            map.insert(1033, &[268435584]);     // 1033 => [268435584]
            map.insert(1034, &[16394]);     // 1034 => [16394]
            map.insert(1035, &[268435586]);     // 1035 => [268435586]
            map.insert(1036, &[268443650]);     // 1036 => [268443650]
            map.insert(1037, &[268435588]);     // 1037 => [268435588]
            map.insert(1038, &[268443648]);     // 1038 => [268443648]
            map.insert(1039, &[268443649]);     // 1039 => [268443649]
            map.insert(1040, &[16400]);     // 1040 => [16400]
            map.insert(1041, &[16401]);     // 1041 => [16401]
            map.insert(1042, &[2147483652]);     // 1042 => [2147483652]
            map.insert(1043, &[2147483653]);     // 1043 => [2147483653]
            map.insert(1044, &[2147483650]);     // 1044 => [2147483650]
            map.insert(1045, &[2147483651]);     // 1045 => [2147483651]
            map.insert(1046, &[2147483648]);     // 1046 => [2147483648]
            map.insert(1047, &[2147483649]);     // 1047 => [2147483649]
            map.insert(1048, &[131202]);     // 1048 => [131202]
            map.insert(1049, &[139268]);     // 1049 => [139268]
            map.insert(1050, &[131200]);     // 1050 => [131200]
            map.insert(1051, &[131201]);     // 1051 => [131201]
            map.insert(1052, &[139265]);     // 1052 => [139265]
            map.insert(1053, &[139264]);     // 1053 => [139264]
            map.insert(1054, &[2147483656]);     // 1054 => [2147483656]
            map.insert(1055, &[2147483657]);     // 1055 => [2147483657]
            map.insert(1056, &[16416]);     // 1056 => [16416]
            map.insert(1057, &[16417]);     // 1057 => [16417]
            map.insert(1058, &[16418]);     // 1058 => [16418]
            map.insert(1059, &[4194624]);     // 1059 => [4194624]
            map.insert(1060, &[134218753]);     // 1060 => [134218753]
            map.insert(1061, &[134218752]);     // 1061 => [134218752]
            map.insert(1062, &[2147483696]);     // 1062 => [2147483696]
            map.insert(1063, &[134218754]);     // 1063 => [134218754]
            map.insert(1064, &[8389122]);     // 1064 => [8389122]
            map.insert(1065, &[268435616]);     // 1065 => [268435616]
            map.insert(1066, &[8389120]);     // 1066 => [8389120]
            map.insert(1067, &[8389121]);     // 1067 => [8389121]
            map.insert(1068, &[67110912]);     // 1068 => [67110912]
            map.insert(1069, &[67110913]);     // 1069 => [67110913]
            map.insert(1070, &[67110914]);     // 1070 => [67110914]
            map.insert(1071, &[37765120]);     // 1071 => [37765120]
            map.insert(1072, &[16432]);     // 1072 => [16432]
            map.insert(1073, &[67840]);     // 1073 => [67840]
            map.insert(1074, &[2147483684]);     // 1074 => [2147483684]
            map.insert(1075, &[69238784]);     // 1075 => [69238784]
            map.insert(1076, &[2147483682]);     // 1076 => [2147483682]
            map.insert(1077, &[134218768]);     // 1077 => [134218768]
            map.insert(1078, &[2147483680]);     // 1078 => [2147483680]
            map.insert(1079, &[2147483681]);     // 1079 => [2147483681]
            map.insert(1080, &[536879360]);     // 1080 => [536879360]
            map.insert(1081, &[263424]);     // 1081 => [263424]
            map.insert(1082, &[8389136]);     // 1082 => [8389136]
            map.insert(1083, &[8390720]);     // 1083 => [8390720]
            map.insert(1084, &[67110928]);     // 1084 => [67110928]
            map.insert(1085, &[139296]);     // 1085 => [139296]
            map.insert(1086, &[2147483688]);     // 1086 => [2147483688]
            map.insert(1087, &[536871296]);     // 1087 => [536871296]
            map.insert(1088, &[16448]);     // 1088 => [16448]
            map.insert(1089, &[16449]);     // 1089 => [16449]
            map.insert(1090, &[16450]);     // 1090 => [16450]
            map.insert(1091, &[4194592]);     // 1091 => [4194592]
            map.insert(1092, &[16452]);     // 1092 => [16452]
            map.insert(1093, &[168820736]);     // 1093 => [168820736]
            map.insert(1094, &[2147483728]);     // 1094 => [2147483728]
            map.insert(1095, &[2147486208]);     // 1095 => [2147486208]
            map.insert(1096, &[33554692]);     // 1096 => [33554692]
            map.insert(1097, &[268435648]);     // 1097 => [268435648]
            map.insert(1098, &[335577088]);     // 1098 => [335577088]
            map.insert(1099, &[1073742864]);     // 1099 => [1073742864]
            map.insert(1100, &[33554688]);     // 1100 => [33554688]
            map.insert(1101, &[33554689]);     // 1101 => [33554689]
            map.insert(1102, &[33554690]);     // 1102 => [33554690]
            map.insert(1103, &[1107820544]);     // 1103 => [1107820544]
            map.insert(1104, &[536875010]);     // 1104 => [536875010]
            map.insert(1105, &[18944]);     // 1105 => [18944]
            map.insert(1106, &[536875008]);     // 1106 => [536875008]
            map.insert(1107, &[536875009]);     // 1107 => [536875009]
            map.insert(1108, &[2147483714]);     // 1108 => [2147483714]
            map.insert(1109, &[809500672]);     // 1109 => [809500672]
            map.insert(1110, &[2147483712]);     // 1110 => [2147483712]
            map.insert(1111, &[2147483713]);     // 1111 => [2147483713]
            map.insert(1112, &[525568]);     // 1112 => [525568]
            map.insert(1113, &[1073742850]);     // 1113 => [1073742850]
            map.insert(1114, &[1073742849]);     // 1114 => [1073742849]
            map.insert(1115, &[1073742848]);     // 1115 => [1073742848]
            map.insert(1116, &[33554704]);     // 1116 => [33554704]
            map.insert(1117, &[67109408]);     // 1117 => [67109408]
            map.insert(1118, &[2147483720]);     // 1118 => [2147483720]
            map.insert(1119, &[1073742852]);     // 1119 => [1073742852]
            map.insert(1120, &[2097296]);     // 1120 => [2097296]
            map.insert(1121, &[4194562]);     // 1121 => [4194562]
            map.insert(1122, &[4194561]);     // 1122 => [4194561]
            map.insert(1123, &[4194560]);     // 1123 => [4194560]
            map.insert(1124, &[268439808]);     // 1124 => [268439808]
            map.insert(1125, &[134218816]);     // 1125 => [134218816]
            map.insert(1126, &[134223872]);     // 1126 => [134223872]
            map.insert(1127, &[4194564]);     // 1127 => [4194564]
            map.insert(1128, &[43008]);     // 1128 => [43008]
            map.insert(1129, &[16786432]);     // 1129 => [16786432]
            map.insert(1130, &[8389184]);     // 1130 => [8389184]
            map.insert(1131, &[4194568]);     // 1131 => [4194568]
            map.insert(1132, &[33554720]);     // 1132 => [33554720]
            map.insert(1133, &[67109392]);     // 1133 => [67109392]
            map.insert(1134, &[16778368]);     // 1134 => [16778368]
            map.insert(1135, &[34944]);     // 1135 => [34944]
            map.insert(1136, &[2097280]);     // 1136 => [2097280]
            map.insert(1137, &[2097281]);     // 1137 => [2097281]
            map.insert(1138, &[2097282]);     // 1138 => [2097282]
            map.insert(1139, &[2105348]);     // 1139 => [2105348]
            map.insert(1140, &[2097284]);     // 1140 => [2097284]
            map.insert(1141, &[2105346]);     // 1141 => [2105346]
            map.insert(1142, &[2105345]);     // 1142 => [2105345]
            map.insert(1143, &[2105344]);     // 1143 => [2105344]
            map.insert(1144, &[2097288]);     // 1144 => [2097288]
            map.insert(1145, &[8390658]);     // 1145 => [8390658]
            map.insert(1146, &[8390657]);     // 1146 => [8390657]
            map.insert(1147, &[8390656]);     // 1147 => [8390656]
            map.insert(1148, &[67109377]);     // 1148 => [67109377]
            map.insert(1149, &[67109376]);     // 1149 => [67109376]
            map.insert(1150, &[1207975936]);     // 1150 => [1207975936]
            map.insert(1151, &[67109378]);     // 1151 => [67109378]
            map.insert(1152, &[16512]);     // 1152 => [16512]
            map.insert(1153, &[268435464]);     // 1153 => [268435464]
            map.insert(1154, &[1050624]);     // 1154 => [1050624]
            map.insert(1155, &[1050625]);     // 1155 => [1050625]
            map.insert(1156, &[16516]);     // 1156 => [16516]
            map.insert(1157, &[24578]);     // 1157 => [24578]
            map.insert(1158, &[24577]);     // 1158 => [24577]
            map.insert(1159, &[24576]);     // 1159 => [24576]
            map.insert(1160, &[268435457]);     // 1160 => [268435457]
            map.insert(1161, &[268435456]);     // 1161 => [268435456]
            map.insert(1162, &[131088]);     // 1162 => [131088]
            map.insert(1163, &[268435458]);     // 1163 => [268435458]
            map.insert(1164, &[268435461]);     // 1164 => [268435461]
            map.insert(1165, &[268435460]);     // 1165 => [268435460]
            map.insert(1166, &[4198400]);     // 1166 => [4198400]
            map.insert(1167, &[4198401]);     // 1167 => [4198401]
            map.insert(1168, &[2147491841]);     // 1168 => [2147491841]
            map.insert(1169, &[2147491840]);     // 1169 => [2147491840]
            map.insert(1170, &[131080]);     // 1170 => [131080]
            map.insert(1171, &[131081]);     // 1171 => [131081]
            map.insert(1172, &[2147483778]);     // 1172 => [2147483778]
            map.insert(1173, &[264194]);     // 1173 => [264194]
            map.insert(1174, &[2147483776]);     // 1174 => [2147483776]
            map.insert(1175, &[264192]);     // 1175 => [264192]
            map.insert(1176, &[131074]);     // 1176 => [131074]
            map.insert(1177, &[268435472]);     // 1177 => [268435472]
            map.insert(1178, &[131072]);     // 1178 => [131072]
            map.insert(1179, &[131073]);     // 1179 => [131073]
            map.insert(1180, &[131078]);     // 1180 => [131078]
            map.insert(1181, &[66562]);     // 1181 => [66562]
            map.insert(1182, &[131076]);     // 1182 => [131076]
            map.insert(1183, &[66560]);     // 1183 => [66560]
            map.insert(1184, &[33558529]);     // 1184 => [33558529]
            map.insert(1185, &[33558528]);     // 1185 => [33558528]
            map.insert(1186, &[1050656]);     // 1186 => [1050656]
            map.insert(1187, &[33558530]);     // 1187 => [33558530]
            map.insert(1188, &[1073742592]);     // 1188 => [1073742592]
            map.insert(1189, &[524802]);     // 1189 => [524802]
            map.insert(1190, &[524801]);     // 1190 => [524801]
            map.insert(1191, &[524800]);     // 1191 => [524800]
            map.insert(1192, &[268435489]);     // 1192 => [268435489]
            map.insert(1193, &[268435488]);     // 1193 => [268435488]
            map.insert(1194, &[131120]);     // 1194 => [131120]
            map.insert(1195, &[268435490]);     // 1195 => [268435490]
            map.insert(1196, &[67111040]);     // 1196 => [67111040]
            map.insert(1197, &[268435492]);     // 1197 => [268435492]
            map.insert(1198, &[33296]);     // 1198 => [33296]
            map.insert(1199, &[524808]);     // 1199 => [524808]
            map.insert(1200, &[2097216]);     // 1200 => [2097216]
            map.insert(1201, &[2097217]);     // 1201 => [2097217]
            map.insert(1202, &[2097218]);     // 1202 => [2097218]
            map.insert(1203, &[33555968]);     // 1203 => [33555968]
            map.insert(1204, &[2097220]);     // 1204 => [2097220]
            map.insert(1205, &[529408]);     // 1205 => [529408]
            map.insert(1206, &[33288]);     // 1206 => [33288]
            map.insert(1207, &[536871176]);     // 1207 => [536871176]
            map.insert(1208, &[131106]);     // 1208 => [131106]
            map.insert(1209, &[268435504]);     // 1209 => [268435504]
            map.insert(1210, &[131104]);     // 1210 => [131104]
            map.insert(1211, &[131105]);     // 1211 => [131105]
            map.insert(1212, &[33282]);     // 1212 => [33282]
            map.insert(1213, &[536871170]);     // 1213 => [536871170]
            map.insert(1214, &[33280]);     // 1214 => [33280]
            map.insert(1215, &[536871168]);     // 1215 => [536871168]
            map.insert(1216, &[2097200]);     // 1216 => [2097200]
            map.insert(1217, &[268435528]);     // 1217 => [268435528]
            map.insert(1218, &[262660]);     // 1218 => [262660]
            map.insert(1219, &[1049104]);     // 1219 => [1049104]
            map.insert(1220, &[262658]);     // 1220 => [262658]
            map.insert(1221, &[4521984]);     // 1221 => [4521984]
            map.insert(1222, &[262656]);     // 1222 => [262656]
            map.insert(1223, &[262657]);     // 1223 => [262657]
            map.insert(1224, &[268435521]);     // 1224 => [268435521]
            map.insert(1225, &[268435520]);     // 1225 => [268435520]
            map.insert(1226, &[131152]);     // 1226 => [131152]
            map.insert(1227, &[268435522]);     // 1227 => [268435522]
            map.insert(1228, &[33554816]);     // 1228 => [33554816]
            map.insert(1229, &[268435524]);     // 1229 => [268435524]
            map.insert(1230, &[262664]);     // 1230 => [262664]
            map.insert(1231, &[34848]);     // 1231 => [34848]
            map.insert(1232, &[2097184]);     // 1232 => [2097184]
            map.insert(1233, &[2097185]);     // 1233 => [2097185]
            map.insert(1234, &[1049089]);     // 1234 => [1049089]
            map.insert(1235, &[1049088]);     // 1235 => [1049088]
            map.insert(1236, &[2097188]);     // 1236 => [2097188]
            map.insert(1237, &[8389888]);     // 1237 => [8389888]
            map.insert(1238, &[262672]);     // 1238 => [262672]
            map.insert(1239, &[1049092]);     // 1239 => [1049092]
            map.insert(1240, &[131138]);     // 1240 => [131138]
            map.insert(1241, &[268435536]);     // 1241 => [268435536]
            map.insert(1242, &[131136]);     // 1242 => [131136]
            map.insert(1243, &[131137]);     // 1243 => [131137]
            map.insert(1244, &[1073751040]);     // 1244 => [1073751040]
            map.insert(1245, &[1610874880]);     // 1245 => [1610874880]
            map.insert(1246, &[131140]);     // 1246 => [131140]
            map.insert(1247, &[66624]);     // 1247 => [66624]
            map.insert(1248, &[2097168]);     // 1248 => [2097168]
            map.insert(1249, &[2097169]);     // 1249 => [2097169]
            map.insert(1250, &[2097170]);     // 1250 => [2097170]
            map.insert(1251, &[4194688]);     // 1251 => [4194688]
            map.insert(1252, &[2097172]);     // 1252 => [2097172]
            map.insert(1253, &[3407872]);     // 1253 => [3407872]
            map.insert(1254, &[16778248]);     // 1254 => [16778248]
            map.insert(1255, &[34824]);     // 1255 => [34824]
            map.insert(1256, &[2097176]);     // 1256 => [2097176]
            map.insert(1257, &[268435552]);     // 1257 => [268435552]
            map.insert(1258, &[16778244]);     // 1258 => [16778244]
            map.insert(1259, &[34820]);     // 1259 => [34820]
            map.insert(1260, &[16778242]);     // 1260 => [16778242]
            map.insert(1261, &[34818]);     // 1261 => [34818]
            map.insert(1262, &[16778240]);     // 1262 => [16778240]
            map.insert(1263, &[34816]);     // 1263 => [34816]
            map.insert(1264, &[2097152]);     // 1264 => [2097152]
            map.insert(1265, &[2097153]);     // 1265 => [2097153]
            map.insert(1266, &[2097154]);     // 1266 => [2097154]
            map.insert(1267, &[2097155]);     // 1267 => [2097155]
            map.insert(1268, &[2097156]);     // 1268 => [2097156]
            map.insert(1269, &[2097157]);     // 1269 => [2097157]
            map.insert(1270, &[526336]);     // 1270 => [526336]
            map.insert(1271, &[526337]);     // 1271 => [526337]
            map.insert(1272, &[2097160]);     // 1272 => [2097160]
            map.insert(1273, &[2097161]);     // 1273 => [2097161]
            map.insert(1274, &[2097162]);     // 1274 => [2097162]
            map.insert(1275, &[8390784]);     // 1275 => [8390784]
            map.insert(1276, &[2097164]);     // 1276 => [2097164]
            map.insert(1277, &[67109504]);     // 1277 => [67109504]
            map.insert(1278, &[526344]);     // 1278 => [526344]
            map.insert(1279, &[34832]);     // 1279 => [34832]
            map.insert(1280, &[16640]);     // 1280 => [16640]
            map.insert(1281, &[16641]);     // 1281 => [16641]
            map.insert(1282, &[16642]);     // 1282 => [16642]
            map.insert(1283, &[4194400]);     // 1283 => [4194400]
            map.insert(1284, &[16644]);     // 1284 => [16644]
            map.insert(1285, &[67118080]);     // 1285 => [67118080]
            map.insert(1286, &[2147483920]);     // 1286 => [2147483920]
            map.insert(1287, &[1350565888]);     // 1287 => [1350565888]
            map.insert(1288, &[33554500]);     // 1288 => [33554500]
            map.insert(1289, &[268435840]);     // 1289 => [268435840]
            map.insert(1290, &[2281963520]);     // 1290 => [2281963520]
            map.insert(1291, &[134219904]);     // 1291 => [134219904]
            map.insert(1292, &[33554496]);     // 1292 => [33554496]
            map.insert(1293, &[33554497]);     // 1293 => [33554497]
            map.insert(1294, &[33554498]);     // 1294 => [33554498]
            map.insert(1295, &[2098688]);     // 1295 => [2098688]
            map.insert(1296, &[16777729]);     // 1296 => [16777729]
            map.insert(1297, &[16777728]);     // 1297 => [16777728]
            map.insert(1298, &[2147483908]);     // 1298 => [2147483908]
            map.insert(1299, &[16777730]);     // 1299 => [16777730]
            map.insert(1300, &[2147483906]);     // 1300 => [2147483906]
            map.insert(1301, &[16777732]);     // 1301 => [16777732]
            map.insert(1302, &[2147483904]);     // 1302 => [2147483904]
            map.insert(1303, &[2147483905]);     // 1303 => [2147483905]
            map.insert(1304, &[536879136]);     // 1304 => [536879136]
            map.insert(1305, &[2101252]);     // 1305 => [2101252]
            map.insert(1306, &[131456]);     // 1306 => [131456]
            map.insert(1307, &[530432]);     // 1307 => [530432]
            map.insert(1308, &[2101249]);     // 1308 => [2101249]
            map.insert(1309, &[2101248]);     // 1309 => [2101248]
            map.insert(1310, &[2147483912]);     // 1310 => [2147483912]
            map.insert(1311, &[2101250]);     // 1311 => [2101250]
            map.insert(1312, &[16672]);     // 1312 => [16672]
            map.insert(1313, &[4194370]);     // 1313 => [4194370]
            map.insert(1314, &[4194369]);     // 1314 => [4194369]
            map.insert(1315, &[4194368]);     // 1315 => [4194368]
            map.insert(1316, &[1049608]);     // 1316 => [1049608]
            map.insert(1317, &[134219008]);     // 1317 => [134219008]
            map.insert(1318, &[285245440]);     // 1318 => [285245440]
            map.insert(1319, &[4194372]);     // 1319 => [4194372]
            map.insert(1320, &[1049604]);     // 1320 => [1049604]
            map.insert(1321, &[263184]);     // 1321 => [263184]
            map.insert(1322, &[8389376]);     // 1322 => [8389376]
            map.insert(1323, &[4194376]);     // 1323 => [4194376]
            map.insert(1324, &[1049600]);     // 1324 => [1049600]
            map.insert(1325, &[1049601]);     // 1325 => [1049601]
            map.insert(1326, &[1049602]);     // 1326 => [1049602]
            map.insert(1327, &[536871056]);     // 1327 => [536871056]
            map.insert(1328, &[67585]);     // 1328 => [67585]
            map.insert(1329, &[67584]);     // 1329 => [67584]
            map.insert(1330, &[4196864]);     // 1330 => [4196864]
            map.insert(1331, &[67586]);     // 1331 => [67586]
            map.insert(1332, &[134144]);     // 1332 => [134144]
            map.insert(1333, &[67588]);     // 1333 => [67588]
            map.insert(1334, &[2147483936]);     // 1334 => [2147483936]
            map.insert(1335, &[536871048]);     // 1335 => [536871048]
            map.insert(1336, &[536879104]);     // 1336 => [536879104]
            map.insert(1337, &[263168]);     // 1337 => [263168]
            map.insert(1338, &[536879106]);     // 1338 => [536879106]
            map.insert(1339, &[263170]);     // 1339 => [263170]
            map.insert(1340, &[536879108]);     // 1340 => [536879108]
            map.insert(1341, &[536871042]);     // 1341 => [536871042]
            map.insert(1342, &[536871041]);     // 1342 => [536871041]
            map.insert(1343, &[536871040]);     // 1343 => [536871040]
            map.insert(1344, &[16779264]);     // 1344 => [16779264]
            map.insert(1345, &[33792]);     // 1345 => [33792]
            map.insert(1346, &[4194337]);     // 1346 => [4194337]
            map.insert(1347, &[4194336]);     // 1347 => [4194336]
            map.insert(1348, &[33554440]);     // 1348 => [33554440]
            map.insert(1349, &[33554441]);     // 1349 => [33554441]
            map.insert(1350, &[33554442]);     // 1350 => [33554442]
            map.insert(1351, &[4194340]);     // 1351 => [4194340]
            map.insert(1352, &[33554436]);     // 1352 => [33554436]
            map.insert(1353, &[33554437]);     // 1353 => [33554437]
            map.insert(1354, &[33554438]);     // 1354 => [33554438]
            map.insert(1355, &[4194344]);     // 1355 => [4194344]
            map.insert(1356, &[33554432]);     // 1356 => [33554432]
            map.insert(1357, &[33554433]);     // 1357 => [33554433]
            map.insert(1358, &[33554434]);     // 1358 => [33554434]
            map.insert(1359, &[33554435]);     // 1359 => [33554435]
            map.insert(1360, &[525320]);     // 1360 => [525320]
            map.insert(1361, &[33808]);     // 1361 => [33808]
            map.insert(1362, &[536875264]);     // 1362 => [536875264]
            map.insert(1363, &[4194352]);     // 1363 => [4194352]
            map.insert(1364, &[33554456]);     // 1364 => [33554456]
            map.insert(1365, &[8389760]);     // 1365 => [8389760]
            map.insert(1366, &[2147483968]);     // 1366 => [2147483968]
            map.insert(1367, &[135200]);     // 1367 => [135200]
            map.insert(1368, &[525312]);     // 1368 => [525312]
            map.insert(1369, &[525313]);     // 1369 => [525313]
            map.insert(1370, &[525314]);     // 1370 => [525314]
            map.insert(1371, &[1073743104]);     // 1371 => [1073743104]
            map.insert(1372, &[33554448]);     // 1372 => [33554448]
            map.insert(1373, &[33554449]);     // 1373 => [33554449]
            map.insert(1374, &[33554450]);     // 1374 => [33554450]
            map.insert(1375, &[18907136]);     // 1375 => [18907136]
            map.insert(1376, &[66048]);     // 1376 => [66048]
            map.insert(1377, &[4194306]);     // 1377 => [4194306]
            map.insert(1378, &[4194305]);     // 1378 => [4194305]
            map.insert(1379, &[4194304]);     // 1379 => [4194304]
            map.insert(1380, &[268439552]);     // 1380 => [268439552]
            map.insert(1381, &[268439553]);     // 1381 => [268439553]
            map.insert(1382, &[4194309]);     // 1382 => [4194309]
            map.insert(1383, &[4194308]);     // 1383 => [4194308]
            map.insert(1384, &[33554468]);     // 1384 => [33554468]
            map.insert(1385, &[4194314]);     // 1385 => [4194314]
            map.insert(1386, &[4194313]);     // 1386 => [4194313]
            map.insert(1387, &[4194312]);     // 1387 => [4194312]
            map.insert(1388, &[33554464]);     // 1388 => [33554464]
            map.insert(1389, &[33554465]);     // 1389 => [33554465]
            map.insert(1390, &[33554466]);     // 1390 => [33554466]
            map.insert(1391, &[4194316]);     // 1391 => [4194316]
            map.insert(1392, &[66064]);     // 1392 => [66064]
            map.insert(1393, &[4194322]);     // 1393 => [4194322]
            map.insert(1394, &[4194321]);     // 1394 => [4194321]
            map.insert(1395, &[4194320]);     // 1395 => [4194320]
            map.insert(1396, &[268439568]);     // 1396 => [268439568]
            map.insert(1397, &[135170]);     // 1397 => [135170]
            map.insert(1398, &[135169]);     // 1398 => [135169]
            map.insert(1399, &[135168]);     // 1399 => [135168]
            map.insert(1400, &[525344]);     // 1400 => [525344]
            map.insert(1401, &[263232]);     // 1401 => [263232]
            map.insert(1402, &[268288]);     // 1402 => [268288]
            map.insert(1403, &[4194328]);     // 1403 => [4194328]
            map.insert(1404, &[33554480]);     // 1404 => [33554480]
            map.insert(1405, &[67109632]);     // 1405 => [67109632]
            map.insert(1406, &[1084227584]);     // 1406 => [1084227584]
            map.insert(1407, &[135176]);     // 1407 => [135176]
            map.insert(1408, &[67109890]);     // 1408 => [67109890]
            map.insert(1409, &[268435720]);     // 1409 => [268435720]
            map.insert(1410, &[67109888]);     // 1410 => [67109888]
            map.insert(1411, &[67109889]);     // 1411 => [67109889]
            map.insert(1412, &[1073742368]);     // 1412 => [1073742368]
            map.insert(1413, &[2153775104]);     // 1413 => [2153775104]
            map.insert(1414, &[67109892]);     // 1414 => [67109892]
            map.insert(1415, &[24832]);     // 1415 => [24832]
            map.insert(1416, &[268435713]);     // 1416 => [268435713]
            map.insert(1417, &[268435712]);     // 1417 => [268435712]
            map.insert(1418, &[134219777]);     // 1418 => [134219777]
            map.insert(1419, &[134219776]);     // 1419 => [134219776]
            map.insert(1420, &[33554624]);     // 1420 => [33554624]
            map.insert(1421, &[268435716]);     // 1421 => [268435716]
            map.insert(1422, &[4198656]);     // 1422 => [4198656]
            map.insert(1423, &[134219780]);     // 1423 => [134219780]
            map.insert(1424, &[67113472]);     // 1424 => [67113472]
            map.insert(1425, &[16777856]);     // 1425 => [16777856]
            map.insert(1426, &[131336]);     // 1426 => [131336]
            map.insert(1427, &[6307840]);     // 1427 => [6307840]
            map.insert(1428, &[136347648]);     // 1428 => [136347648]
            map.insert(1429, &[8389696]);     // 1429 => [8389696]
            map.insert(1430, &[2147484032]);     // 1430 => [2147484032]
            map.insert(1431, &[536870952]);     // 1431 => [536870952]
            map.insert(1432, &[131330]);     // 1432 => [131330]
            map.insert(1433, &[268435728]);     // 1433 => [268435728]
            map.insert(1434, &[131328]);     // 1434 => [131328]
            map.insert(1435, &[131329]);     // 1435 => [131329]
            map.insert(1436, &[85983232]);     // 1436 => [85983232]
            map.insert(1437, &[536870946]);     // 1437 => [536870946]
            map.insert(1438, &[536870945]);     // 1438 => [536870945]
            map.insert(1439, &[536870944]);     // 1439 => [536870944]
            map.insert(1440, &[1073742340]);     // 1440 => [1073742340]
            map.insert(1441, &[33558784]);     // 1441 => [33558784]
            map.insert(1442, &[67109920]);     // 1442 => [67109920]
            map.insert(1443, &[4194496]);     // 1443 => [4194496]
            map.insert(1444, &[1073742336]);     // 1444 => [1073742336]
            map.insert(1445, &[1073742337]);     // 1445 => [1073742337]
            map.insert(1446, &[1073742338]);     // 1446 => [1073742338]
            map.insert(1447, &[536870936]);     // 1447 => [536870936]
            map.insert(1448, &[155189248]);     // 1448 => [155189248]
            map.insert(1449, &[268435744]);     // 1449 => [268435744]
            map.insert(1450, &[538181632]);     // 1450 => [538181632]
            map.insert(1451, &[536870932]);     // 1451 => [536870932]
            map.insert(1452, &[1073742344]);     // 1452 => [1073742344]
            map.insert(1453, &[536870930]);     // 1453 => [536870930]
            map.insert(1454, &[536870929]);     // 1454 => [536870929]
            map.insert(1455, &[536870928]);     // 1455 => [536870928]
            map.insert(1456, &[2097472]);     // 1456 => [2097472]
            map.insert(1457, &[67712]);     // 1457 => [67712]
            map.insert(1458, &[293601280]);     // 1458 => [293601280]
            map.insert(1459, &[536870924]);     // 1459 => [536870924]
            map.insert(1460, &[1073742352]);     // 1460 => [1073742352]
            map.insert(1461, &[536870922]);     // 1461 => [536870922]
            map.insert(1462, &[536870921]);     // 1462 => [536870921]
            map.insert(1463, &[536870920]);     // 1463 => [536870920]
            map.insert(1464, &[536879232]);     // 1464 => [536879232]
            map.insert(1465, &[536870918]);     // 1465 => [536870918]
            map.insert(1466, &[536870917]);     // 1466 => [536870917]
            map.insert(1467, &[536870916]);     // 1467 => [536870916]
            map.insert(1468, &[536870915]);     // 1468 => [536870915]
            map.insert(1469, &[536870914]);     // 1469 => [536870914]
            map.insert(1470, &[536870913]);     // 1470 => [536870913]
            map.insert(1471, &[536870912]);     // 1471 => [536870912]
            map.insert(1472, &[16779392]);     // 1472 => [16779392]
            map.insert(1473, &[33920]);     // 1473 => [33920]
            map.insert(1474, &[67109952]);     // 1474 => [67109952]
            map.insert(1475, &[33562632]);     // 1475 => [33562632]
            map.insert(1476, &[33554568]);     // 1476 => [33554568]
            map.insert(1477, &[8389648]);     // 1477 => [8389648]
            map.insert(1478, &[262912]);     // 1478 => [262912]
            map.insert(1479, &[8393216]);     // 1479 => [8393216]
            map.insert(1480, &[33554564]);     // 1480 => [33554564]
            map.insert(1481, &[33562626]);     // 1481 => [33562626]
            map.insert(1482, &[33562625]);     // 1482 => [33562625]
            map.insert(1483, &[33562624]);     // 1483 => [33562624]
            map.insert(1484, &[33554560]);     // 1484 => [33554560]
            map.insert(1485, &[33554561]);     // 1485 => [33554561]
            map.insert(1486, &[33554562]);     // 1486 => [33554562]
            map.insert(1487, &[33562628]);     // 1487 => [33562628]
            map.insert(1488, &[2097440]);     // 1488 => [2097440]
            map.insert(1489, &[8389636]);     // 1489 => [8389636]
            map.insert(1490, &[134218248]);     // 1490 => [134218248]
            map.insert(1491, &[1049344]);     // 1491 => [1049344]
            map.insert(1492, &[8389633]);     // 1492 => [8389633]
            map.insert(1493, &[8389632]);     // 1493 => [8389632]
            map.insert(1494, &[33701888]);     // 1494 => [33701888]
            map.insert(1495, &[8389634]);     // 1495 => [8389634]
            map.insert(1496, &[134218242]);     // 1496 => [134218242]
            map.insert(1497, &[1140867072]);     // 1497 => [1140867072]
            map.insert(1498, &[134218240]);     // 1498 => [134218240]
            map.insert(1499, &[134218241]);     // 1499 => [134218241]
            map.insert(1500, &[33554576]);     // 1500 => [33554576]
            map.insert(1501, &[8389640]);     // 1501 => [8389640]
            map.insert(1502, &[134218244]);     // 1502 => [134218244]
            map.insert(1503, &[536871008]);     // 1503 => [536871008]
            map.insert(1504, &[4202500]);     // 1504 => [4202500]
            map.insert(1505, &[4194434]);     // 1505 => [4194434]
            map.insert(1506, &[4194433]);     // 1506 => [4194433]
            map.insert(1507, &[4194432]);     // 1507 => [4194432]
            map.insert(1508, &[4202496]);     // 1508 => [4202496]
            map.insert(1509, &[4202497]);     // 1509 => [4202497]
            map.insert(1510, &[4202498]);     // 1510 => [4202498]
            map.insert(1511, &[4194436]);     // 1511 => [4194436]
            map.insert(1512, &[612368384]);     // 1512 => [612368384]
            map.insert(1513, &[20484]);     // 1513 => [20484]
            map.insert(1514, &[272646144]);     // 1514 => [272646144]
            map.insert(1515, &[4194440]);     // 1515 => [4194440]
            map.insert(1516, &[20481]);     // 1516 => [20481]
            map.insert(1517, &[20480]);     // 1517 => [20480]
            map.insert(1518, &[16778496]);     // 1518 => [16778496]
            map.insert(1519, &[20482]);     // 1519 => [20482]
            map.insert(1520, &[2097408]);     // 1520 => [2097408]
            map.insert(1521, &[2097409]);     // 1521 => [2097409]
            map.insert(1522, &[2097410]);     // 1522 => [2097410]
            map.insert(1523, &[2147487752]);     // 1523 => [2147487752]
            map.insert(1524, &[1073743873]);     // 1524 => [1073743873]
            map.insert(1525, &[1073743872]);     // 1525 => [1073743872]
            map.insert(1526, &[526592]);     // 1526 => [526592]
            map.insert(1527, &[1073743874]);     // 1527 => [1073743874]
            map.insert(1528, &[2097416]);     // 1528 => [2097416]
            map.insert(1529, &[2147487746]);     // 1529 => [2147487746]
            map.insert(1530, &[2147487745]);     // 1530 => [2147487745]
            map.insert(1531, &[2147487744]);     // 1531 => [2147487744]
            map.insert(1532, &[2420113408]);     // 1532 => [2420113408]
            map.insert(1533, &[536870978]);     // 1533 => [536870978]
            map.insert(1534, &[536870977]);     // 1534 => [536870977]
            map.insert(1535, &[536870976]);     // 1535 => [536870976]
            map.insert(1536, &[16896]);     // 1536 => [16896]
            map.insert(1537, &[16897]);     // 1537 => [16897]
            map.insert(1538, &[16898]);     // 1538 => [16898]
            map.insert(1539, &[536877056]);     // 1539 => [536877056]
            map.insert(1540, &[16900]);     // 1540 => [16900]
            map.insert(1541, &[67403776]);     // 1541 => [67403776]
            map.insert(1542, &[2147484176]);     // 1542 => [2147484176]
            map.insert(1543, &[524448]);     // 1543 => [524448]
            map.insert(1544, &[8388642]);     // 1544 => [8388642]
            map.insert(1545, &[1073745984]);     // 1545 => [1073745984]
            map.insert(1546, &[8388640]);     // 1546 => [8388640]
            map.insert(1547, &[8388641]);     // 1547 => [8388641]
            map.insert(1548, &[83951616]);     // 1548 => [83951616]
            map.insert(1549, &[69760]);     // 1549 => [69760]
            map.insert(1550, &[8388644]);     // 1550 => [8388644]
            map.insert(1551, &[2098432]);     // 1551 => [2098432]
            map.insert(1552, &[16777473]);     // 1552 => [16777473]
            map.insert(1553, &[16777472]);     // 1553 => [16777472]
            map.insert(1554, &[2147484164]);     // 1554 => [2147484164]
            map.insert(1555, &[16777474]);     // 1555 => [16777474]
            map.insert(1556, &[2147484162]);     // 1556 => [2147484162]
            map.insert(1557, &[16777476]);     // 1557 => [16777476]
            map.insert(1558, &[2147484160]);     // 1558 => [2147484160]
            map.insert(1559, &[2147484161]);     // 1559 => [2147484161]
            map.insert(1560, &[152043520]);     // 1560 => [152043520]
            map.insert(1561, &[16777480]);     // 1561 => [16777480]
            map.insert(1562, &[8388656]);     // 1562 => [8388656]
            map.insert(1563, &[4203520]);     // 1563 => [4203520]
            map.insert(1564, &[4195456]);     // 1564 => [4195456]
            map.insert(1565, &[67108960]);     // 1565 => [67108960]
            map.insert(1566, &[2147484168]);     // 1566 => [2147484168]
            map.insert(1567, &[436207616]);     // 1567 => [436207616]
            map.insert(1568, &[532480]);     // 1568 => [532480]
            map.insert(1569, &[532481]);     // 1569 => [532481]
            map.insert(1570, &[8388616]);     // 1570 => [8388616]
            map.insert(1571, &[8388617]);     // 1571 => [8388617]
            map.insert(1572, &[532484]);     // 1572 => [532484]
            map.insert(1573, &[524418]);     // 1573 => [524418]
            map.insert(1574, &[524417]);     // 1574 => [524417]
            map.insert(1575, &[524416]);     // 1575 => [524416]
            map.insert(1576, &[8388610]);     // 1576 => [8388610]
            map.insert(1577, &[8388611]);     // 1577 => [8388611]
            map.insert(1578, &[8388608]);     // 1578 => [8388608]
            map.insert(1579, &[8388609]);     // 1579 => [8388609]
            map.insert(1580, &[8388614]);     // 1580 => [8388614]
            map.insert(1581, &[67108944]);     // 1581 => [67108944]
            map.insert(1582, &[8388612]);     // 1582 => [8388612]
            map.insert(1583, &[8388613]);     // 1583 => [8388613]
            map.insert(1584, &[532496]);     // 1584 => [532496]
            map.insert(1585, &[40968]);     // 1585 => [40968]
            map.insert(1586, &[8388632]);     // 1586 => [8388632]
            map.insert(1587, &[134221828]);     // 1587 => [134221828]
            map.insert(1588, &[33563648]);     // 1588 => [33563648]
            map.insert(1589, &[134221826]);     // 1589 => [134221826]
            map.insert(1590, &[134221825]);     // 1590 => [134221825]
            map.insert(1591, &[134221824]);     // 1591 => [134221824]
            map.insert(1592, &[40961]);     // 1592 => [40961]
            map.insert(1593, &[40960]);     // 1593 => [40960]
            map.insert(1594, &[8388624]);     // 1594 => [8388624]
            map.insert(1595, &[8388625]);     // 1595 => [8388625]
            map.insert(1596, &[67108929]);     // 1596 => [67108929]
            map.insert(1597, &[67108928]);     // 1597 => [67108928]
            map.insert(1598, &[32896]);     // 1598 => [32896]
            map.insert(1599, &[32897]);     // 1599 => [32897]
            map.insert(1600, &[536871936]);     // 1600 => [536871936]
            map.insert(1601, &[270336]);     // 1601 => [270336]
            map.insert(1602, &[536871938]);     // 1602 => [536871938]
            map.insert(1603, &[270338]);     // 1603 => [270338]
            map.insert(1604, &[262274]);     // 1604 => [262274]
            map.insert(1605, &[2147485698]);     // 1605 => [2147485698]
            map.insert(1606, &[262272]);     // 1606 => [262272]
            map.insert(1607, &[2147485696]);     // 1607 => [2147485696]
            map.insert(1608, &[1073745921]);     // 1608 => [1073745921]
            map.insert(1609, &[1073745920]);     // 1609 => [1073745920]
            map.insert(1610, &[8388704]);     // 1610 => [8388704]
            map.insert(1611, &[1073745922]);     // 1611 => [1073745922]
            map.insert(1612, &[33555200]);     // 1612 => [33555200]
            map.insert(1613, &[1073745924]);     // 1613 => [1073745924]
            map.insert(1614, &[262280]);     // 1614 => [262280]
            map.insert(1615, &[2147485704]);     // 1615 => [2147485704]
            map.insert(1616, &[18433]);     // 1616 => [18433]
            map.insert(1617, &[18432]);     // 1617 => [18432]
            map.insert(1618, &[1048705]);     // 1618 => [1048705]
            map.insert(1619, &[1048704]);     // 1619 => [1048704]
            map.insert(1620, &[1056768]);     // 1620 => [1056768]
            map.insert(1621, &[1056769]);     // 1621 => [1056769]
            map.insert(1622, &[1056770]);     // 1622 => [1056770]
            map.insert(1623, &[1048708]);     // 1623 => [1048708]
            map.insert(1624, &[268437632]);     // 1624 => [268437632]
            map.insert(1625, &[67108900]);     // 1625 => [67108900]
            map.insert(1626, &[134218112]);     // 1626 => [134218112]
            map.insert(1627, &[1048712]);     // 1627 => [1048712]
            map.insert(1628, &[67108897]);     // 1628 => [67108897]
            map.insert(1629, &[67108896]);     // 1629 => [67108896]
            map.insert(1630, &[9961472]);     // 1630 => [9961472]
            map.insert(1631, &[67108898]);     // 1631 => [67108898]
            map.insert(1632, &[65792]);     // 1632 => [65792]
            map.insert(1633, &[65793]);     // 1633 => [65793]
            map.insert(1634, &[65794]);     // 1634 => [65794]
            map.insert(1635, &[4195072]);     // 1635 => [4195072]
            map.insert(1636, &[65796]);     // 1636 => [65796]
            map.insert(1637, &[67108888]);     // 1637 => [67108888]
            map.insert(1638, &[262304]);     // 1638 => [262304]
            map.insert(1639, &[2147485728]);     // 1639 => [2147485728]
            map.insert(1640, &[8388674]);     // 1640 => [8388674]
            map.insert(1641, &[67108884]);     // 1641 => [67108884]
            map.insert(1642, &[8388672]);     // 1642 => [8388672]
            map.insert(1643, &[8388673]);     // 1643 => [8388673]
            map.insert(1644, &[67108881]);     // 1644 => [67108881]
            map.insert(1645, &[67108880]);     // 1645 => [67108880]
            map.insert(1646, &[8388676]);     // 1646 => [8388676]
            map.insert(1647, &[67108882]);     // 1647 => [67108882]
            map.insert(1648, &[65808]);     // 1648 => [65808]
            map.insert(1649, &[67108876]);     // 1649 => [67108876]
            map.insert(1650, &[20987904]);     // 1650 => [20987904]
            map.insert(1651, &[1048736]);     // 1651 => [1048736]
            map.insert(1652, &[67108873]);     // 1652 => [67108873]
            map.insert(1653, &[67108872]);     // 1653 => [67108872]
            map.insert(1654, &[268436736]);     // 1654 => [268436736]
            map.insert(1655, &[67108874]);     // 1655 => [67108874]
            map.insert(1656, &[67108869]);     // 1656 => [67108869]
            map.insert(1657, &[67108868]);     // 1657 => [67108868]
            map.insert(1658, &[8388688]);     // 1658 => [8388688]
            map.insert(1659, &[67108870]);     // 1659 => [67108870]
            map.insert(1660, &[67108865]);     // 1660 => [67108865]
            map.insert(1661, &[67108864]);     // 1661 => [67108864]
            map.insert(1662, &[67108867]);     // 1662 => [67108867]
            map.insert(1663, &[67108866]);     // 1663 => [67108866]
            map.insert(1664, &[17024]);     // 1664 => [17024]
            map.insert(1665, &[268435976]);     // 1665 => [268435976]
            map.insert(1666, &[262212]);     // 1666 => [262212]
            map.insert(1667, &[524324]);     // 1667 => [524324]
            map.insert(1668, &[262210]);     // 1668 => [262210]
            map.insert(1669, &[524322]);     // 1669 => [524322]
            map.insert(1670, &[262208]);     // 1670 => [262208]
            map.insert(1671, &[524320]);     // 1671 => [524320]
            map.insert(1672, &[268435969]);     // 1672 => [268435969]
            map.insert(1673, &[268435968]);     // 1673 => [268435968]
            map.insert(1674, &[131600]);     // 1674 => [131600]
            map.insert(1675, &[268435970]);     // 1675 => [268435970]
            map.insert(1676, &[69633]);     // 1676 => [69633]
            map.insert(1677, &[69632]);     // 1677 => [69632]
            map.insert(1678, &[262216]);     // 1678 => [262216]
            map.insert(1679, &[69634]);     // 1679 => [69634]
            map.insert(1680, &[67113216]);     // 1680 => [67113216]
            map.insert(1681, &[1048642]);     // 1681 => [1048642]
            map.insert(1682, &[1048641]);     // 1682 => [1048641]
            map.insert(1683, &[1048640]);     // 1683 => [1048640]
            map.insert(1684, &[4195336]);     // 1684 => [4195336]
            map.insert(1685, &[673185792]);     // 1685 => [673185792]
            map.insert(1686, &[32808]);     // 1686 => [32808]
            map.insert(1687, &[1048644]);     // 1687 => [1048644]
            map.insert(1688, &[131586]);     // 1688 => [131586]
            map.insert(1689, &[268435984]);     // 1689 => [268435984]
            map.insert(1690, &[131584]);     // 1690 => [131584]
            map.insert(1691, &[131585]);     // 1691 => [131585]
            map.insert(1692, &[4195328]);     // 1692 => [4195328]
            map.insert(1693, &[4195329]);     // 1693 => [4195329]
            map.insert(1694, &[32800]);     // 1694 => [32800]
            map.insert(1695, &[32801]);     // 1695 => [32801]
            map.insert(1696, &[2099201]);     // 1696 => [2099201]
            map.insert(1697, &[2099200]);     // 1697 => [2099200]
            map.insert(1698, &[524293]);     // 1698 => [524293]
            map.insert(1699, &[524292]);     // 1699 => [524292]
            map.insert(1700, &[1073742080]);     // 1700 => [1073742080]
            map.insert(1701, &[524290]);     // 1701 => [524290]
            map.insert(1702, &[524289]);     // 1702 => [524289]
            map.insert(1703, &[524288]);     // 1703 => [524288]
            map.insert(1704, &[8388738]);     // 1704 => [8388738]
            map.insert(1705, &[8396804]);     // 1705 => [8396804]
            map.insert(1706, &[8388736]);     // 1706 => [8388736]
            map.insert(1707, &[8388737]);     // 1707 => [8388737]
            map.insert(1708, &[8396801]);     // 1708 => [8396801]
            map.insert(1709, &[8396800]);     // 1709 => [8396800]
            map.insert(1710, &[32784]);     // 1710 => [32784]
            map.insert(1711, &[524296]);     // 1711 => [524296]
            map.insert(1712, &[2097728]);     // 1712 => [2097728]
            map.insert(1713, &[33555458]);     // 1713 => [33555458]
            map.insert(1714, &[33555457]);     // 1714 => [33555457]
            map.insert(1715, &[33555456]);     // 1715 => [33555456]
            map.insert(1716, &[32778]);     // 1716 => [32778]
            map.insert(1717, &[524306]);     // 1717 => [524306]
            map.insert(1718, &[32776]);     // 1718 => [32776]
            map.insert(1719, &[524304]);     // 1719 => [524304]
            map.insert(1720, &[32774]);     // 1720 => [32774]
            map.insert(1721, &[41088]);     // 1721 => [41088]
            map.insert(1722, &[32772]);     // 1722 => [32772]
            map.insert(1723, &[32773]);     // 1723 => [32773]
            map.insert(1724, &[32770]);     // 1724 => [32770]
            map.insert(1725, &[32771]);     // 1725 => [32771]
            map.insert(1726, &[32768]);     // 1726 => [32768]
            map.insert(1727, &[32769]);     // 1727 => [32769]
            map.insert(1728, &[262150]);     // 1728 => [262150]
            map.insert(1729, &[1048594]);     // 1729 => [1048594]
            map.insert(1730, &[262148]);     // 1730 => [262148]
            map.insert(1731, &[1048592]);     // 1731 => [1048592]
            map.insert(1732, &[262146]);     // 1732 => [262146]
            map.insert(1733, &[262147]);     // 1733 => [262147]
            map.insert(1734, &[262144]);     // 1734 => [262144]
            map.insert(1735, &[262145]);     // 1735 => [262145]
            map.insert(1736, &[268437520]);     // 1736 => [268437520]
            map.insert(1737, &[133122]);     // 1737 => [133122]
            map.insert(1738, &[133121]);     // 1738 => [133121]
            map.insert(1739, &[133120]);     // 1739 => [133120]
            map.insert(1740, &[262154]);     // 1740 => [262154]
            map.insert(1741, &[69696]);     // 1741 => [69696]
            map.insert(1742, &[262152]);     // 1742 => [262152]
            map.insert(1743, &[262153]);     // 1743 => [262153]
            map.insert(1744, &[1048579]);     // 1744 => [1048579]
            map.insert(1745, &[1048578]);     // 1745 => [1048578]
            map.insert(1746, &[1048577]);     // 1746 => [1048577]
            map.insert(1747, &[1048576]);     // 1747 => [1048576]
            map.insert(1748, &[262162]);     // 1748 => [262162]
            map.insert(1749, &[1048582]);     // 1749 => [1048582]
            map.insert(1750, &[262160]);     // 1750 => [262160]
            map.insert(1751, &[1048580]);     // 1751 => [1048580]
            map.insert(1752, &[268437504]);     // 1752 => [268437504]
            map.insert(1753, &[268437505]);     // 1753 => [268437505]
            map.insert(1754, &[134217984]);     // 1754 => [134217984]
            map.insert(1755, &[1048584]);     // 1755 => [1048584]
            map.insert(1756, &[268437508]);     // 1756 => [268437508]
            map.insert(1757, &[67109024]);     // 1757 => [67109024]
            map.insert(1758, &[134217988]);     // 1758 => [134217988]
            map.insert(1759, &[1048588]);     // 1759 => [1048588]
            map.insert(1760, &[2097680]);     // 1760 => [2097680]
            map.insert(1761, &[2099264]);     // 1761 => [2099264]
            map.insert(1762, &[262180]);     // 1762 => [262180]
            map.insert(1763, &[524356]);     // 1763 => [524356]
            map.insert(1764, &[262178]);     // 1764 => [262178]
            map.insert(1765, &[524354]);     // 1765 => [524354]
            map.insert(1766, &[262176]);     // 1766 => [262176]
            map.insert(1767, &[524352]);     // 1767 => [524352]
            map.insert(1768, &[1107312640]);     // 1768 => [1107312640]
            map.insert(1769, &[2147484928]);     // 1769 => [2147484928]
            map.insert(1770, &[67117072]);     // 1770 => [67117072]
            map.insert(1771, &[133152]);     // 1771 => [133152]
            map.insert(1772, &[16781328]);     // 1772 => [16781328]
            map.insert(1773, &[67109008]);     // 1773 => [67109008]
            map.insert(1774, &[262184]);     // 1774 => [262184]
            map.insert(1775, &[524360]);     // 1775 => [524360]
            map.insert(1776, &[2097664]);     // 1776 => [2097664]
            map.insert(1777, &[2097665]);     // 1777 => [2097665]
            map.insert(1778, &[1048609]);     // 1778 => [1048609]
            map.insert(1779, &[1048608]);     // 1779 => [1048608]
            map.insert(1780, &[2097668]);     // 1780 => [2097668]
            map.insert(1781, &[67109000]);     // 1781 => [67109000]
            map.insert(1782, &[32840]);     // 1782 => [32840]
            map.insert(1783, &[1048612]);     // 1783 => [1048612]
            map.insert(1784, &[67117058]);     // 1784 => [67117058]
            map.insert(1785, &[67108996]);     // 1785 => [67108996]
            map.insert(1786, &[67117056]);     // 1786 => [67117056]
            map.insert(1787, &[67117057]);     // 1787 => [67117057]
            map.insert(1788, &[16781312]);     // 1788 => [16781312]
            map.insert(1789, &[67108992]);     // 1789 => [67108992]
            map.insert(1790, &[32832]);     // 1790 => [32832]
            map.insert(1791, &[32833]);     // 1791 => [32833]
            map.insert(1792, &[16777233]);     // 1792 => [16777233]
            map.insert(1793, &[16777232]);     // 1793 => [16777232]
            map.insert(1794, &[35684352]);     // 1794 => [35684352]
            map.insert(1795, &[16777234]);     // 1795 => [16777234]
            map.insert(1796, &[1073741984]);     // 1796 => [1073741984]
            map.insert(1797, &[16777236]);     // 1797 => [16777236]
            map.insert(1798, &[675282944]);     // 1798 => [675282944]
            map.insert(1799, &[2098184]);     // 1799 => [2098184]
            map.insert(1800, &[17334272]);     // 1800 => [17334272]
            map.insert(1801, &[16777240]);     // 1801 => [16777240]
            map.insert(1802, &[8388896]);     // 1802 => [8388896]
            map.insert(1803, &[2098180]);     // 1803 => [2098180]
            map.insert(1804, &[33555008]);     // 1804 => [33555008]
            map.insert(1805, &[2098178]);     // 1805 => [2098178]
            map.insert(1806, &[2098177]);     // 1806 => [2098177]
            map.insert(1807, &[2098176]);     // 1807 => [2098176]
            map.insert(1808, &[16777217]);     // 1808 => [16777217]
            map.insert(1809, &[16777216]);     // 1809 => [16777216]
            map.insert(1810, &[16777219]);     // 1810 => [16777219]
            map.insert(1811, &[16777218]);     // 1811 => [16777218]
            map.insert(1812, &[16777221]);     // 1812 => [16777221]
            map.insert(1813, &[16777220]);     // 1813 => [16777220]
            map.insert(1814, &[16785536]);     // 1814 => [16785536]
            map.insert(1815, &[16777222]);     // 1815 => [16777222]
            map.insert(1816, &[16777225]);     // 1816 => [16777225]
            map.insert(1817, &[16777224]);     // 1817 => [16777224]
            map.insert(1818, &[134217920]);     // 1818 => [134217920]
            map.insert(1819, &[16777226]);     // 1819 => [16777226]
            map.insert(1820, &[33556481]);     // 1820 => [33556481]
            map.insert(1821, &[33556480]);     // 1821 => [33556480]
            map.insert(1822, &[1052704]);     // 1822 => [1052704]
            map.insert(1823, &[33556482]);     // 1823 => [33556482]
            map.insert(1824, &[65600]);     // 1824 => [65600]
            map.insert(1825, &[65601]);     // 1825 => [65601]
            map.insert(1826, &[1073750017]);     // 1826 => [1073750017]
            map.insert(1827, &[1073750016]);     // 1827 => [1073750016]
            map.insert(1828, &[1073741952]);     // 1828 => [1073741952]
            map.insert(1829, &[1073741953]);     // 1829 => [1073741953]
            map.insert(1830, &[1073741954]);     // 1830 => [1073741954]
            map.insert(1831, &[1073750020]);     // 1831 => [1073750020]
            map.insert(1832, &[8388866]);     // 1832 => [8388866]
            map.insert(1833, &[266242]);     // 1833 => [266242]
            map.insert(1834, &[8388864]);     // 1834 => [8388864]
            map.insert(1835, &[266240]);     // 1835 => [266240]
            map.insert(1836, &[1073741960]);     // 1836 => [1073741960]
            map.insert(1837, &[1342193664]);     // 1837 => [1342193664]
            map.insert(1838, &[8388868]);     // 1838 => [8388868]
            map.insert(1839, &[266244]);     // 1839 => [266244]
            map.insert(1840, &[16777249]);     // 1840 => [16777249]
            map.insert(1841, &[16777248]);     // 1841 => [16777248]
            map.insert(1842, &[4196352]);     // 1842 => [4196352]
            map.insert(1843, &[4196353]);     // 1843 => [4196353]
            map.insert(1844, &[1073741968]);     // 1844 => [1073741968]
            map.insert(1845, &[16777252]);     // 1845 => [16777252]
            map.insert(1846, &[4196356]);     // 1846 => [4196356]
            map.insert(1847, &[134222080]);     // 1847 => [134222080]
            map.insert(1848, &[536879616]);     // 1848 => [536879616]
            map.insert(1849, &[16777256]);     // 1849 => [16777256]
            map.insert(1850, &[1052676]);     // 1850 => [1052676]
            map.insert(1851, &[266256]);     // 1851 => [266256]
            map.insert(1852, &[1052674]);     // 1852 => [1052674]
            map.insert(1853, &[33556512]);     // 1853 => [33556512]
            map.insert(1854, &[1052672]);     // 1854 => [1052672]
            map.insert(1855, &[1052673]);     // 1855 => [1052673]
            map.insert(1856, &[65568]);     // 1856 => [65568]
            map.insert(1857, &[65569]);     // 1857 => [65569]
            map.insert(1858, &[65570]);     // 1858 => [65570]
            map.insert(1859, &[36880]);     // 1859 => [36880]
            map.insert(1860, &[65572]);     // 1860 => [65572]
            map.insert(1861, &[132128]);     // 1861 => [132128]
            map.insert(1862, &[262528]);     // 1862 => [262528]
            map.insert(1863, &[8392832]);     // 1863 => [8392832]
            map.insert(1864, &[528386]);     // 1864 => [528386]
            map.insert(1865, &[1073746176]);     // 1865 => [1073746176]
            map.insert(1866, &[528384]);     // 1866 => [528384]
            map.insert(1867, &[528385]);     // 1867 => [528385]
            map.insert(1868, &[33554944]);     // 1868 => [33554944]
            map.insert(1869, &[33554945]);     // 1869 => [33554945]
            map.insert(1870, &[33554946]);     // 1870 => [33554946]
            map.insert(1871, &[2098240]);     // 1871 => [2098240]
            map.insert(1872, &[16777281]);     // 1872 => [16777281]
            map.insert(1873, &[16777280]);     // 1873 => [16777280]
            map.insert(1874, &[36865]);     // 1874 => [36865]
            map.insert(1875, &[36864]);     // 1875 => [36864]
            map.insert(1876, &[1057024]);     // 1876 => [1057024]
            map.insert(1877, &[16777284]);     // 1877 => [16777284]
            map.insert(1878, &[268436512]);     // 1878 => [268436512]
            map.insert(1879, &[36868]);     // 1879 => [36868]
            map.insert(1880, &[134217858]);     // 1880 => [134217858]
            map.insert(1881, &[134225924]);     // 1881 => [134225924]
            map.insert(1882, &[134217856]);     // 1882 => [134217856]
            map.insert(1883, &[134217857]);     // 1883 => [134217857]
            map.insert(1884, &[134225921]);     // 1884 => [134225921]
            map.insert(1885, &[134225920]);     // 1885 => [134225920]
            map.insert(1886, &[134217860]);     // 1886 => [134217860]
            map.insert(1887, &[134225922]);     // 1887 => [134225922]
            map.insert(1888, &[65536]);     // 1888 => [65536]
            map.insert(1889, &[65537]);     // 1889 => [65537]
            map.insert(1890, &[65538]);     // 1890 => [65538]
            map.insert(1891, &[4194816]);     // 1891 => [4194816]
            map.insert(1892, &[65540]);     // 1892 => [65540]
            map.insert(1893, &[132096]);     // 1893 => [132096]
            map.insert(1894, &[65542]);     // 1894 => [65542]
            map.insert(1895, &[132098]);     // 1895 => [132098]
            map.insert(1896, &[65544]);     // 1896 => [65544]
            map.insert(1897, &[65545]);     // 1897 => [65545]
            map.insert(1898, &[65546]);     // 1898 => [65546]
            map.insert(1899, &[4194824]);     // 1899 => [4194824]
            map.insert(1900, &[65548]);     // 1900 => [65548]
            map.insert(1901, &[132104]);     // 1901 => [132104]
            map.insert(1902, &[536873088]);     // 1902 => [536873088]
            map.insert(1903, &[2684616704]);     // 1903 => [2684616704]
            map.insert(1904, &[65552]);     // 1904 => [65552]
            map.insert(1905, &[65553]);     // 1905 => [65553]
            map.insert(1906, &[65554]);     // 1906 => [65554]
            map.insert(1907, &[4194832]);     // 1907 => [4194832]
            map.insert(1908, &[268436482]);     // 1908 => [268436482]
            map.insert(1909, &[67109128]);     // 1909 => [67109128]
            map.insert(1910, &[268436480]);     // 1910 => [268436480]
            map.insert(1911, &[268436481]);     // 1911 => [268436481]
            map.insert(1912, &[65560]);     // 1912 => [65560]
            map.insert(1913, &[67109124]);     // 1913 => [67109124]
            map.insert(1914, &[134217888]);     // 1914 => [134217888]
            map.insert(1915, &[302022656]);     // 1915 => [302022656]
            map.insert(1916, &[67109121]);     // 1916 => [67109121]
            map.insert(1917, &[67109120]);     // 1917 => [67109120]
            map.insert(1918, &[268436488]);     // 1918 => [268436488]
            map.insert(1919, &[67109122]);     // 1919 => [67109122]
            map.insert(1920, &[1073741860]);     // 1920 => [1073741860]
            map.insert(1921, &[16777360]);     // 1921 => [16777360]
            map.insert(1922, &[67110400]);     // 1922 => [67110400]
            map.insert(1923, &[2692743168]);     // 1923 => [2692743168]
            map.insert(1924, &[1073741856]);     // 1924 => [1073741856]
            map.insert(1925, &[1073741857]);     // 1925 => [1073741857]
            map.insert(1926, &[1073741858]);     // 1926 => [1073741858]
            map.insert(1927, &[524576]);     // 1927 => [524576]
            map.insert(1928, &[2106368]);     // 1928 => [2106368]
            map.insert(1929, &[268436224]);     // 1929 => [268436224]
            map.insert(1930, &[134217808]);     // 1930 => [134217808]
            map.insert(1931, &[134220288]);     // 1931 => [134220288]
            map.insert(1932, &[1073741864]);     // 1932 => [1073741864]
            map.insert(1933, &[69888]);     // 1933 => [69888]
            map.insert(1934, &[2432696320]);     // 1934 => [2432696320]
            map.insert(1935, &[2098304]);     // 1935 => [2098304]
            map.insert(1936, &[67112960]);     // 1936 => [67112960]
            map.insert(1937, &[16777344]);     // 1937 => [16777344]
            map.insert(1938, &[67112962]);     // 1938 => [67112962]
            map.insert(1939, &[16777346]);     // 1939 => [16777346]
            map.insert(1940, &[16785410]);     // 1940 => [16785410]
            map.insert(1941, &[16777348]);     // 1941 => [16777348]
            map.insert(1942, &[16785408]);     // 1942 => [16785408]
            map.insert(1943, &[16785409]);     // 1943 => [16785409]
            map.insert(1944, &[134217794]);     // 1944 => [134217794]
            map.insert(1945, &[16777352]);     // 1945 => [16777352]
            map.insert(1946, &[134217792]);     // 1946 => [134217792]
            map.insert(1947, &[134217793]);     // 1947 => [134217793]
            map.insert(1948, &[4195584]);     // 1948 => [4195584]
            map.insert(1949, &[33556608]);     // 1949 => [33556608]
            map.insert(1950, &[134217796]);     // 1950 => [134217796]
            map.insert(1951, &[536871456]);     // 1951 => [536871456]
            map.insert(1952, &[1073741828]);     // 1952 => [1073741828]
            map.insert(1953, &[1073741829]);     // 1953 => [1073741829]
            map.insert(1954, &[1073741830]);     // 1954 => [1073741830]
            map.insert(1955, &[524548]);     // 1955 => [524548]
            map.insert(1956, &[1073741824]);     // 1956 => [1073741824]
            map.insert(1957, &[1073741825]);     // 1957 => [1073741825]
            map.insert(1958, &[1073741826]);     // 1958 => [1073741826]
            map.insert(1959, &[524544]);     // 1959 => [524544]
            map.insert(1960, &[1073741836]);     // 1960 => [1073741836]
            map.insert(1961, &[2147484736]);     // 1961 => [2147484736]
            map.insert(1962, &[8388992]);     // 1962 => [8388992]
            map.insert(1963, &[266368]);     // 1963 => [266368]
            map.insert(1964, &[1073741832]);     // 1964 => [1073741832]
            map.insert(1965, &[1073741833]);     // 1965 => [1073741833]
            map.insert(1966, &[1073741834]);     // 1966 => [1073741834]
            map.insert(1967, &[524552]);     // 1967 => [524552]
            map.insert(1968, &[1073741844]);     // 1968 => [1073741844]
            map.insert(1969, &[16777376]);     // 1969 => [16777376]
            map.insert(1970, &[4196480]);     // 1970 => [4196480]
            map.insert(1971, &[33555712]);     // 1971 => [33555712]
            map.insert(1972, &[1073741840]);     // 1972 => [1073741840]
            map.insert(1973, &[1073741841]);     // 1973 => [1073741841]
            map.insert(1974, &[1073741842]);     // 1974 => [1073741842]
            map.insert(1975, &[536871432]);     // 1975 => [536871432]
            map.insert(1976, &[369098752]);     // 1976 => [369098752]
            map.insert(1977, &[1060864]);     // 1977 => [1060864]
            map.insert(1978, &[33028]);     // 1978 => [33028]
            map.insert(1979, &[536871428]);     // 1979 => [536871428]
            map.insert(1980, &[33026]);     // 1980 => [33026]
            map.insert(1981, &[536871426]);     // 1981 => [536871426]
            map.insert(1982, &[33024]);     // 1982 => [33024]
            map.insert(1983, &[536871424]);     // 1983 => [536871424]
            map.insert(1984, &[65696]);     // 1984 => [65696]
            map.insert(1985, &[102760448]);     // 1985 => [102760448]
            map.insert(1986, &[262404]);     // 1986 => [262404]
            map.insert(1987, &[8392708]);     // 1987 => [8392708]
            map.insert(1988, &[262402]);     // 1988 => [262402]
            map.insert(1989, &[8392706]);     // 1989 => [8392706]
            map.insert(1990, &[262400]);     // 1990 => [262400]
            map.insert(1991, &[8392704]);     // 1991 => [8392704]
            map.insert(1992, &[134217746]);     // 1992 => [134217746]
            map.insert(1993, &[2147484704]);     // 1993 => [2147484704]
            map.insert(1994, &[134217744]);     // 1994 => [134217744]
            map.insert(1995, &[134217745]);     // 1995 => [134217745]
            map.insert(1996, &[33555072]);     // 1996 => [33555072]
            map.insert(1997, &[536576]);     // 1997 => [536576]
            map.insert(1998, &[134217748]);     // 1998 => [134217748]
            map.insert(1999, &[8392712]);     // 1999 => [8392712]
            map.insert(2000, &[134217738]);     // 2000 => [134217738]
            map.insert(2001, &[1048834]);     // 2001 => [1048834]
            map.insert(2002, &[134217736]);     // 2002 => [134217736]
            map.insert(2003, &[1048832]);     // 2003 => [1048832]
            map.insert(2004, &[45056]);     // 2004 => [45056]
            map.insert(2005, &[8390144]);     // 2005 => [8390144]
            map.insert(2006, &[134217740]);     // 2006 => [134217740]
            map.insert(2007, &[1048836]);     // 2007 => [1048836]
            map.insert(2008, &[134217730]);     // 2008 => [134217730]
            map.insert(2009, &[134217731]);     // 2009 => [134217731]
            map.insert(2010, &[134217728]);     // 2010 => [134217728]
            map.insert(2011, &[134217729]);     // 2011 => [134217729]
            map.insert(2012, &[134217734]);     // 2012 => [134217734]
            map.insert(2013, &[134226048]);     // 2013 => [134226048]
            map.insert(2014, &[134217732]);     // 2014 => [134217732]
            map.insert(2015, &[134217733]);     // 2015 => [134217733]
            map.insert(2016, &[65664]);     // 2016 => [65664]
            map.insert(2017, &[65665]);     // 2017 => [65665]
            map.insert(2018, &[65666]);     // 2018 => [65666]
            map.insert(2019, &[73732]);     // 2019 => [73732]
            map.insert(2020, &[1073741888]);     // 2020 => [1073741888]
            map.insert(2021, &[1073741889]);     // 2021 => [1073741889]
            map.insert(2022, &[73729]);     // 2022 => [73729]
            map.insert(2023, &[73728]);     // 2023 => [73728]
            map.insert(2024, &[2147484673]);     // 2024 => [2147484673]
            map.insert(2025, &[2147484672]);     // 2025 => [2147484672]
            map.insert(2026, &[536872964]);     // 2026 => [536872964]
            map.insert(2027, &[2147484674]);     // 2027 => [2147484674]
            map.insert(2028, &[536872962]);     // 2028 => [536872962]
            map.insert(2029, &[2147484676]);     // 2029 => [2147484676]
            map.insert(2030, &[536872960]);     // 2030 => [536872960]
            map.insert(2031, &[536872961]);     // 2031 => [536872961]
            map.insert(2032, &[65680]);     // 2032 => [65680]
            map.insert(2033, &[268444672]);     // 2033 => [268444672]
            map.insert(2034, &[134217768]);     // 2034 => [134217768]
            map.insert(2035, &[1048864]);     // 2035 => [1048864]
            map.insert(2036, &[1073741904]);     // 2036 => [1073741904]
            map.insert(2037, &[1073744384]);     // 2037 => [1073744384]
            map.insert(2038, &[268436608]);     // 2038 => [268436608]
            map.insert(2039, &[17416]);     // 2039 => [17416]
            map.insert(2040, &[134217762]);     // 2040 => [134217762]
            map.insert(2041, &[2147484688]);     // 2041 => [2147484688]
            map.insert(2042, &[134217760]);     // 2042 => [134217760]
            map.insert(2043, &[134217761]);     // 2043 => [134217761]
            map.insert(2044, &[16781568]);     // 2044 => [16781568]
            map.insert(2045, &[17410]);     // 2045 => [17410]
            map.insert(2046, &[17409]);     // 2046 => [17409]
            map.insert(2047, &[17408]);     // 2047 => [17408]
            
            SYNDROME_MAP = Box::into_raw(map);
        }
    });
}

impl WagnerCode32_21 {
    fn parity_check_matrix_transposed(&self) -> &BinMatrix {
        init();
        unsafe {
            PARITY_MATRIX_T.as_ref().unwrap()
        }
    }
}

impl BinaryCode for WagnerCode32_21 {
    fn name(&self) -> String {
        "[32, 21] Wagner code".to_owned()
    }

    fn length(&self) -> usize {
        32
    }

    fn dimension(&self) -> usize {
        21
    }

    fn generator_matrix(&self) -> &BinMatrix {
        init();
        unsafe {
            GENERATOR_MATRIX.as_ref().unwrap()
        }
    }

    fn parity_check_matrix(&self) -> &BinMatrix {
        init();
        unsafe {
            PARITY_MATRIX.as_ref().unwrap()
        }
    }

    fn decode_to_code(&self, c: &BinVector) -> Result<BinVector, &str> {
        init();
        let map = unsafe {
            SYNDROME_MAP.as_ref().unwrap()
        };
        debug_assert_eq!(c.len(), self.length(), "the length doesn't match the expected length (length of the code)");
        let he = c * self.parity_check_matrix_transposed();
        let mut error = BinVector::with_capacity(32);
        let stor = unsafe { error.get_storage_mut() };
        let errbytes = map[&he.as_u64()];
        debug_assert_eq!(errbytes.len(), 32 / 64 + if 32 % 64 != 0 { 1 } else { 0 });
        stor.clear();
        stor.extend_from_slice(&errbytes[..]);
        unsafe { error.set_len(32) };
        debug_assert_eq!(error.len(), self.length(), "internal: the error vector is of the wrong length");
        let result = c + &error;
        debug_assert_eq!(result.len(), self.length(), "internal: the result vector is of the wrong length");
        debug_assert_eq!((&result * self.parity_check_matrix_transposed()).count_ones(), 0);
        Ok(result)
    }

    fn decode_to_message(&self, c: &BinVector) -> Result<BinVector, &str> {
        
        let mut codeword = self.decode_to_code(c)?;
        codeword.truncate(21);
        Ok(codeword)
        
    }

    fn decode_slice(&self, c: &mut [u64]) {
        init();
        
        debug_assert_eq!(c[32 / 64] & !((1 << 32) - 1), 0, "this message has excess bits");

        let map = unsafe {
            SYNDROME_MAP.as_ref().unwrap()
        };
        let he = &BinMatrix::from_slices(&[&c[..]], self.length()) * self.parity_check_matrix_transposed();
        let error = map[unsafe { &he.get_word_unchecked(0, 0) }];
        c.iter_mut().zip(error.iter().copied()).for_each(|(sample, error)| *sample ^= error as u64);
    }

    
}

#[cfg(test)]
mod tests {
    use super::*;
    use m4ri_rust::friendly::BinVector;
    use crate::oracle::Sample;

    #[test]
    fn size() {
        let code = WagnerCode32_21.generator_matrix();
        assert_eq!(code.ncols(), 32);
        assert_eq!(code.nrows(), 21);
    }

    #[test]
    fn test_decode_sample() {
        let code = WagnerCode32_21;
        for _ in 0..1000 {
            // setup
            let vec = BinVector::random(code.length());
            let mut sample_a = Sample::from_binvector(&vec, false);
            let mut sample_b = Sample::from_binvector(&vec, true);
            
            let decoded_vec = code.decode_to_message(&vec).unwrap();
            println!("decoded_vec: {:?}", decoded_vec);

            // test vectors
            let decoded_vec_sample_a = Sample::from_binvector(&decoded_vec, false);
            let decoded_vec_sample_b = Sample::from_binvector(&decoded_vec, true);

            code.decode_sample(&mut sample_a);
            code.decode_sample(&mut sample_b);
            assert_eq!(sample_a.get_product(), false);
            assert_eq!(sample_b.get_product(), true);
            assert_eq!(sample_a, decoded_vec_sample_a);
            assert_eq!(sample_b, decoded_vec_sample_b);
        }
    }

    #[test]
    fn random_decode_tests() {

        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, false, true, false, false, true, false, false, false, true, true, false, false, true, true, false, false, true, false, false, true, true, true, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, true, false, false, true, false, false, false, true, true, false, false, true, false, false, false, true, false, false, true, true, true, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, false, true, true, true, true, true, false, true, false, false, true, false, true, false, true, false, false, true, false, true, true, false, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, true, true, true, true, true, true, true, true, false, false, true, false, false, false, true, false, false, true, false, true, true, false, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, false, true, false, false, true, true, false, false, true, true, false, true, false, true, true, true, true, false, true, true, false, false, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, false, true, false, false, false, true, false, false, true, true, false, true, false, true, true, true, true, false, true, true, true, true, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, false, true, true, true, false, true, true, true, false, false, false, false, false, false, true, true, false, true, false, true, true, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, true, false, true, true, true, false, true, true, true, false, false, false, false, false, false, true, false, false, true, false, true, true, true, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, false, false, true, false, true, true, true, true, false, true, true, false, false, true, true, true, true, true, false, true, false, false, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, false, true, true, false, true, true, true, true, false, true, true, false, false, true, true, true, true, true, false, true, false, false, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, true, false, true, false, true, false, false, false, true, true, false, true, false, true, true, false, false, false, false, false, false, false, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, true, false, true, false, true, false, false, false, true, true, false, true, false, true, true, false, true, false, false, false, false, false, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, true, false, true, false, false, true, false, true, true, true, true, true, true, true, false, false, false, false, true, true, true, true, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, true, false, true, false, false, false, false, true, true, true, true, true, true, true, false, false, false, false, false, true, true, true, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, true, true, false, false, false, true, false, false, false, true, false, false, false, true, true, true, true, true, false, true, false, false, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, true, false, false, false, true, false, false, false, false, false, false, false, true, true, true, false, true, false, true, false, false, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, true, true, false, false, true, false, false, false, false, true, false, true, true, true, true, false, false, false, true, true, true, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, true, true, true, false, false, true, false, false, false, false, true, false, true, true, true, true, false, false, false, true, true, true, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, true, true, true, true, false, false, true, false, false, false, true, true, true, false, false, true, true, false, true, true, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, false, true, true, true, true, false, false, true, false, false, false, false, true, true, false, false, true, true, false, true, true, true, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, true, true, false, false, false, true, true, false, true, true, true, false, false, true, false, true, true, true, true, false, true, true, false, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, true, true, false, false, true, true, false, true, true, true, false, false, true, false, true, true, true, true, false, true, true, false, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, false, true, false, false, false, false, false, false, true, false, false, true, true, true, false, true, true, true, true, false, true, true, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, true, true, false, false, false, false, true, false, true, false, false, true, true, true, false, true, true, true, true, false, false, true, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, false, true, true, true, false, false, true, false, false, true, true, false, true, false, false, true, false, false, false, false, false, true, false, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, true, true, true, false, false, true, false, false, true, false, false, true, false, false, true, false, false, false, false, false, true, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, false, true, true, false, true, false, false, true, true, false, true, false, true, true, false, true, false, false, true, false, false, false, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, false, true, false, false, true, false, false, true, true, false, false, false, true, true, false, true, false, false, true, true, false, false, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, false, true, false, true, true, true, false, true, true, false, false, false, false, true, true, true, true, true, true, true, true, false, false, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, false, true, false, true, true, true, false, true, true, false, false, false, true, true, true, true, true, true, true, true, true, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, true, false, false, true, false, true, true, true, true, true, false, false, false, false, true, false, true, false, false, false, true, false, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, false, false, true, false, true, true, true, true, true, false, false, false, true, true, false, true, true, false, false, true, false, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, false, false, true, false, true, false, false, true, true, false, false, true, true, true, false, false, false, true, false, true, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, false, false, true, false, true, false, false, true, true, false, false, true, true, false, false, false, false, true, false, true, true, true, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, true, true, false, false, false, false, true, false, false, true, false, false, false, false, false, false, true, true, false, false, false, true, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, true, true, true, false, false, false, true, false, false, true, false, false, false, false, false, false, true, true, false, false, false, false, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, true, true, false, true, false, true, false, true, true, false, false, true, true, true, true, true, true, true, false, true, false, false, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, true, true, false, true, false, false, false, true, true, false, false, true, true, true, true, true, true, true, false, true, false, false, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, false, true, true, true, false, false, true, false, false, false, false, true, true, false, true, true, true, true, true, false, true, false, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, true, true, true, false, false, false, false, false, false, true, true, true, false, true, true, true, true, true, false, true, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, false, true, true, true, true, true, false, false, true, true, false, false, true, true, false, true, false, true, false, false, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, false, true, true, true, true, false, false, false, true, false, false, false, true, true, false, true, false, false, false, false, true, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, false, true, false, false, true, false, true, true, true, true, true, true, false, true, false, false, true, false, true, true, false, true, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, true, false, false, true, false, true, true, true, true, true, true, false, true, false, true, true, false, true, false, false, true, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, false, false, false, true, true, true, false, true, false, true, false, false, true, false, true, false, true, true, true, true, true, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, false, false, false, true, true, true, false, true, false, true, false, false, false, false, true, true, true, true, true, true, true, false, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, false, true, true, false, false, true, true, false, false, false, false, false, true, false, false, true, false, true, false, true, false, true, false, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, false, true, false, false, false, true, true, false, false, false, false, false, false, false, false, true, false, true, false, true, false, true, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, false, true, false, false, true, true, true, true, false, true, true, false, false, false, false, true, true, true, true, false, true, true, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, false, true, true, false, true, true, true, false, false, true, true, false, false, false, false, true, true, true, false, false, true, true, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, false, false, false, true, false, false, true, false, false, false, true, true, false, true, true, true, false, false, true, false, false, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, false, true, false, true, true, false, false, true, false, false, false, true, true, false, true, true, true, true, false, true, false, false, false, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, false, false, true, false, false, true, false, false, true, false, true, true, true, false, false, false, true, true, false, true, true, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, false, false, true, false, false, true, false, false, true, false, true, false, true, false, false, false, true, true, false, true, true, true, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, true, true, false, true, false, false, true, true, true, true, true, false, true, false, false, false, false, false, true, true, false, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, true, true, true, false, false, false, false, true, true, true, false, true, false, true, false, false, false, false, false, true, true, false, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, true, true, false, false, false, false, false, true, true, false, false, true, true, true, true, true, false, false, true, false, false, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, true, false, false, false, false, false, true, true, false, false, true, true, true, true, true, false, false, true, false, false, true, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, false, false, true, true, false, true, false, false, true, false, false, true, true, false, false, false, true, false, false, false, false, true, false, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, true, false, false, true, false, true, false, false, true, false, false, true, true, false, false, false, true, false, false, false, false, true, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, false, false, true, true, false, false, false, true, true, false, true, true, true, true, true, true, false, false, false, true, false, false, true, false, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, true, false, false, false, true, true, false, true, true, true, true, true, false, false, false, false, true, false, false, true, false, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, true, false, false, false, false, true, true, true, true, true, false, false, true, false, false, true, true, false, true, true, true, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, false, true, false, false, false, false, true, false, true, true, true, false, false, true, false, false, true, true, false, true, true, true, true, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, false, true, false, true, false, true, true, false, true, true, false, false, true, false, false, true, false, false, true, true, true, false, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, false, true, false, true, false, false, true, false, true, true, false, false, true, false, false, true, false, false, true, true, true, false, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, true, true, false, true, true, false, true, false, false, false, true, true, false, true, false, true, false, true, true, true, true, false, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, true, false, true, true, false, true, true, false, false, true, true, false, true, false, true, false, true, true, true, true, false, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, false, true, true, false, true, false, true, false, false, false, false, false, true, true, true, false, false, false, true, false, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, false, false, false, true, true, false, true, false, true, true, false, false, false, false, true, true, true, false, false, false, true, true, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, false, false, false, false, true, false, false, false, true, false, false, true, false, false, true, false, false, true, true, false, true, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, true, false, false, false, false, true, false, false, false, true, false, false, true, false, false, true, false, false, true, true, false, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, true, true, true, true, false, false, false, false, true, false, true, true, false, true, false, true, false, false, false, false, false, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, false, false, true, true, true, false, false, false, false, false, true, false, true, true, false, true, false, true, false, false, false, false, true, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, true, true, true, false, true, false, true, true, false, true, false, true, false, false, true, false, false, true, true, false, true, false, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, true, true, false, true, false, true, true, false, true, false, true, false, false, true, false, false, true, true, false, true, false, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, false, false, true, true, false, true, true, false, true, false, true, false, true, false, false, true, true, true, true, true, false, true, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, false, false, true, true, false, true, true, false, true, false, true, false, true, false, false, false, true, false, true, true, false, true, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, true, false, false, true, true, true, true, false, true, true, false, false, false, false, false, false, false, false, true, true, false, true, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, true, false, false, true, true, true, true, false, true, true, false, false, false, false, false, false, false, false, true, true, false, true, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, true, true, false, false, false, true, false, true, true, true, true, true, false, false, true, true, false, false, false, false, false, true, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, true, false, false, false, true, false, true, true, true, true, true, false, false, true, true, true, false, false, false, false, true, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, true, false, false, false, true, false, true, true, true, false, true, true, false, false, true, true, true, false, false, false, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, true, false, false, false, false, true, false, true, true, true, false, false, true, true, false, true, true, true, false, false, false, true, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, false, false, false, false, true, true, false, false, true, true, false, true, false, false, true, false, false, true, true, false, false, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, false, false, false, false, false, true, true, false, false, true, true, false, true, false, false, true, true, false, true, true, false, false, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, false, false, true, true, false, true, false, false, false, false, true, false, true, true, false, false, false, true, true, false, false, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, false, false, false, true, true, false, true, false, false, false, false, true, false, true, true, false, false, true, true, true, false, false, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, true, false, false, false, false, false, true, false, true, true, true, true, true, false, false, true, false, true, false, false, true, true, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, false, false, false, false, false, true, false, true, true, true, true, true, false, false, true, false, true, false, false, true, true, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, false, false, true, true, true, true, true, true, false, false, true, false, false, true, true, true, false, true, false, false, false, false, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, true, false, false, true, true, true, true, true, false, false, true, false, false, true, true, true, false, true, false, false, false, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, false, false, false, true, true, false, true, true, false, true, true, true, true, true, true, true, true, true, false, true, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, false, true, false, true, true, false, true, true, false, true, true, true, true, true, true, true, true, true, false, false, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, true, false, true, true, false, false, false, true, false, true, true, true, true, false, false, true, false, false, true, false, false, true, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, true, true, false, true, true, false, false, false, true, false, true, true, true, true, false, false, false, false, false, true, false, false, false, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, true, true, true, true, true, true, false, true, false, false, true, true, false, false, true, false, true, true, false, true, true, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, true, true, true, true, true, false, true, false, false, true, true, true, false, true, false, true, true, false, true, true, false, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, true, false, false, false, false, true, true, false, true, true, true, true, true, false, false, true, true, true, false, true, false, true, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, true, false, false, false, true, true, false, true, true, true, false, true, false, false, true, true, true, false, true, false, true, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, false, false, false, false, false, false, true, false, false, true, false, true, true, false, false, false, true, true, false, true, true, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, false, false, true, false, false, false, true, false, false, true, false, true, true, false, false, false, false, true, false, true, true, true, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, false, false, true, true, false, true, true, true, false, true, false, true, false, false, false, true, false, false, false, false, false, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, true, false, false, true, true, false, true, true, true, false, true, false, true, false, false, false, true, false, false, false, false, false, true, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, false, true, true, true, false, true, false, false, true, true, true, true, false, true, false, true, true, false, true, false, true, false, false, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, false, true, true, true, false, true, false, false, true, true, true, true, false, true, false, true, false, false, true, false, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, true, false, false, false, false, true, true, true, true, false, true, true, false, false, true, true, false, true, false, false, false, true, true, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, false, false, false, false, true, true, true, true, false, true, true, false, false, true, false, false, true, false, false, false, false, true, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, false, false, true, false, false, true, true, true, false, true, false, true, true, true, false, true, true, true, true, false, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, true, false, false, true, false, false, true, true, true, false, true, false, true, true, true, false, true, true, true, true, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, false, false, true, false, true, false, false, false, false, false, false, true, true, true, false, true, true, true, false, true, false, false, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, false, false, true, false, true, false, false, false, false, false, false, false, true, true, false, true, true, true, false, true, false, false, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, false, false, true, true, false, true, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, false, true, true, false, true, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, false, true, true, true, true, true, false, true, false, true, true, true, false, true, true, false, true, true, true, true, false, true, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, true, true, true, true, false, false, true, false, true, true, true, false, true, true, false, false, true, true, true, false, true, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, true, true, true, false, true, false, true, false, true, true, false, false, false, true, true, false, false, false, true, true, true, false, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, true, true, true, false, true, false, true, false, true, true, false, false, false, false, true, false, true, false, true, true, true, false, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, true, false, false, true, true, true, true, true, true, false, false, false, false, false, true, true, true, true, false, false, false, true, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, false, true, true, true, true, true, true, true, false, false, false, false, false, true, true, true, true, false, false, false, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, false, true, true, false, false, false, true, false, true, false, true, false, true, false, true, false, true, true, false, true, false, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, false, true, true, false, false, false, true, false, true, false, true, false, true, false, false, false, true, true, false, true, false, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, true, false, false, false, true, false, true, true, true, true, false, false, true, true, true, true, true, false, true, true, true, true, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, false, false, false, true, false, true, true, true, true, false, false, true, true, true, true, true, false, true, true, true, true, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, true, false, false, true, false, true, true, true, true, false, true, true, true, false, false, true, false, false, true, false, true, false, true, false, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, false, false, true, false, true, true, true, true, true, true, true, true, false, false, true, false, true, true, false, true, false, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, true, false, true, true, false, true, false, true, false, false, false, false, false, false, false, true, true, false, false, true, true, true, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, true, false, true, true, false, true, false, true, false, true, false, false, false, false, false, true, false, false, false, true, true, true, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, false, true, true, false, true, true, false, true, true, false, false, false, true, false, true, false, true, true, true, false, false, true, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, false, true, true, false, true, true, false, true, true, false, false, false, true, false, true, false, false, true, true, false, false, true, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, true, false, true, false, false, false, false, true, true, false, true, true, true, false, false, false, false, false, false, false, false, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, false, false, false, false, false, true, true, true, false, true, false, true, false, false, false, false, false, false, false, false, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, false, true, true, false, true, false, true, false, true, false, true, true, false, true, true, false, true, true, true, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, true, false, true, true, true, true, false, true, false, true, false, true, true, false, true, true, false, true, true, true, true, true, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, false, true, false, false, false, false, false, false, true, false, true, false, true, true, true, true, false, true, false, false, false, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, false, true, true, false, false, false, false, false, true, false, true, true, true, true, true, true, false, true, false, false, false, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, false, false, false, true, true, false, true, false, false, true, true, false, false, false, true, true, true, true, true, true, false, false, false, true, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, false, true, false, false, true, false, false, true, true, false, false, false, true, true, true, true, true, true, false, false, false, false, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, false, true, true, true, false, false, false, true, false, false, false, true, false, true, true, true, false, true, true, true, true, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, false, false, true, true, true, true, false, false, true, false, false, false, true, false, true, true, true, false, true, true, false, true, false, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, false, true, true, false, false, false, false, false, false, false, false, false, true, false, true, true, true, true, true, true, false, false, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, false, true, true, false, false, false, false, true, false, false, false, false, true, false, true, true, true, true, true, false, false, false, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, false, false, true, true, false, false, false, false, false, false, false, true, false, true, false, true, false, true, true, false, true, true, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, false, false, true, true, false, false, false, false, false, false, false, false, false, true, false, true, false, false, true, false, true, true, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, false, false, true, false, false, true, false, false, true, false, false, false, true, true, false, false, true, false, true, false, false, true, false, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, true, false, false, true, false, true, true, false, false, false, true, true, false, false, true, false, false, false, false, true, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, true, true, true, true, true, false, false, false, true, true, false, true, false, true, false, false, true, false, true, false, true, false, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, true, true, true, true, false, false, false, true, false, false, true, false, true, false, false, true, false, true, false, true, false, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, false, false, true, false, true, true, false, false, false, false, true, false, false, true, false, true, false, false, true, true, true, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, true, false, false, true, false, true, true, false, false, false, false, true, false, false, true, true, true, false, false, true, true, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, false, false, false, false, false, true, true, false, true, true, true, true, true, true, false, true, true, true, false, false, false, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, false, false, false, false, false, true, true, false, true, true, false, true, true, true, false, true, true, true, false, false, false, false, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, true, false, false, true, true, true, true, true, true, true, true, false, false, false, true, false, false, false, false, true, true, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, false, false, true, true, true, true, true, false, true, true, false, false, false, true, false, false, false, false, true, true, true, true, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, true, true, false, true, true, true, false, false, true, false, true, false, true, false, true, true, false, false, false, true, true, false, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, true, true, false, true, true, true, false, false, true, false, true, false, true, false, true, true, false, false, false, true, true, false, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, true, true, true, false, false, false, true, true, false, false, true, true, false, false, false, false, false, false, false, false, false, true, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, false, true, true, false, false, false, true, true, false, false, false, true, false, false, false, false, false, false, false, false, false, true, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, false, true, true, false, true, true, false, false, true, false, true, false, true, false, true, false, false, false, false, false, true, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, true, true, false, true, true, false, false, false, false, true, false, true, false, true, false, false, false, false, false, true, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, false, true, false, false, false, true, false, true, false, true, false, false, false, false, false, false, true, false, true, false, false, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, false, false, true, false, false, true, false, true, false, true, false, false, false, false, false, false, true, true, true, false, false, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, true, false, false, false, true, false, false, true, true, false, false, false, true, true, false, false, false, true, true, true, false, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, false, false, false, true, false, false, false, true, false, true, false, true, true, false, false, false, true, true, true, false, true, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, true, true, false, false, true, false, true, false, false, false, true, true, false, false, false, false, false, true, false, false, true, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, true, true, true, false, false, true, false, false, false, false, true, true, true, false, false, false, false, false, true, false, false, true, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, false, true, true, true, false, false, true, true, true, false, true, true, true, false, true, true, false, true, true, false, true, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, false, true, true, true, false, false, true, true, true, true, true, true, true, false, true, true, false, true, true, false, true, false, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, false, true, true, true, true, true, false, true, true, true, true, false, false, false, false, true, true, true, false, false, false, false, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, false, true, true, true, true, true, false, false, false, true, true, false, false, false, false, true, true, true, false, false, false, false, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, true, true, false, true, true, true, true, false, false, true, true, true, false, false, false, true, false, false, false, false, true, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, true, true, false, true, true, true, true, false, false, true, true, true, false, false, false, true, false, false, false, false, true, false, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, true, false, true, true, true, true, true, true, true, false, true, true, true, false, true, false, true, true, false, false, false, false, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, true, false, true, true, true, true, true, true, true, false, true, true, true, false, true, false, true, false, false, false, false, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, true, false, false, false, true, true, true, true, true, true, true, false, true, true, false, true, true, false, true, true, false, true, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, false, false, true, true, true, true, true, false, true, true, false, true, true, false, true, true, false, true, true, false, true, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, false, true, false, true, false, true, false, false, true, false, true, false, false, false, false, true, true, true, false, false, false, true, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, true, false, true, true, true, false, false, true, false, true, false, false, false, false, true, true, true, false, false, false, false, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, false, false, true, true, true, true, false, false, false, true, true, true, false, true, false, true, true, false, false, true, false, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, false, true, false, true, true, true, true, true, false, false, false, true, true, true, false, true, false, true, true, false, false, true, false, true, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, true, false, false, true, false, true, true, false, false, true, true, false, true, false, false, true, true, true, false, true, false, false, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, true, false, false, true, false, true, true, false, false, true, true, false, true, false, false, true, true, true, false, true, false, true, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, true, false, true, false, true, false, false, true, false, false, false, true, false, false, false, false, true, false, true, false, false, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, false, true, true, true, false, true, false, false, true, false, false, false, true, true, false, false, false, true, false, true, false, false, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, true, false, false, false, false, true, true, false, true, false, false, false, true, false, false, true, true, false, false, true, false, true, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, true, true, false, false, false, true, true, false, true, false, false, false, true, false, false, true, true, false, false, true, true, true, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, true, true, true, false, true, true, true, true, false, true, true, true, false, true, false, true, false, false, false, true, false, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, true, true, true, false, true, true, true, true, false, true, true, true, true, true, false, true, false, false, false, true, false, false, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, true, true, false, true, true, true, true, true, false, true, false, true, false, true, false, false, false, false, true, false, true, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, true, true, true, false, true, true, true, false, true, false, true, false, true, false, true, false, false, false, false, true, false, true, true, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, false, false, false, true, false, true, false, false, false, true, false, false, true, false, false, false, true, true, true, true, true, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, false, false, true, true, false, true, false, true, false, true, false, false, true, false, false, false, true, true, true, true, true, false, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, true, true, true, false, true, false, false, false, false, false, true, false, false, false, true, true, false, false, false, true, false, false, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, false, true, false, true, false, false, false, false, false, false, false, false, false, true, true, false, false, false, true, false, false, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, false, false, false, true, false, false, true, true, true, false, true, true, false, false, true, true, true, true, false, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, false, false, false, false, true, false, false, true, true, true, false, true, true, true, false, true, false, true, true, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, false, false, false, true, false, false, true, false, false, true, true, false, false, false, true, false, true, false, true, true, false, true, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, false, false, false, true, false, false, true, false, false, false, true, false, false, false, true, false, true, false, true, true, false, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, true, true, false, false, true, false, true, true, false, true, true, false, true, false, false, true, false, false, false, false, true, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, false, true, true, false, false, true, false, true, true, false, true, true, false, true, false, false, true, false, false, false, false, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, false, false, false, true, true, false, false, true, false, true, true, false, true, false, true, false, false, true, true, false, false, false, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, false, false, false, true, true, false, false, true, false, true, true, true, true, false, true, false, false, true, true, true, false, false, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, true, true, true, true, false, false, false, true, true, true, false, true, true, false, false, false, true, false, true, false, true, true, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, true, true, true, false, false, false, true, true, true, false, true, false, false, false, false, true, false, true, false, false, true, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, false, false, true, false, false, true, false, true, false, true, true, false, false, false, false, false, false, true, false, false, false, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, true, false, false, true, false, false, true, false, true, false, true, true, false, false, false, false, false, false, true, false, true, false, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, true, true, true, true, false, false, true, true, true, true, false, false, false, false, true, false, true, true, false, true, false, true, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, true, true, true, true, false, false, true, true, true, true, false, false, false, false, true, false, true, true, false, true, false, true, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, false, true, true, false, false, true, false, false, true, false, false, false, false, true, false, true, false, false, false, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, false, true, false, true, true, false, false, true, false, false, true, false, false, false, false, true, false, true, false, false, true, false, true, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, true, true, false, true, false, false, true, true, true, true, true, true, false, false, false, true, false, true, false, true, false, true, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, false, false, true, false, false, true, true, true, true, true, true, false, true, false, true, false, true, false, true, false, true, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, true, false, true, true, true, true, false, true, true, true, true, false, true, true, false, true, false, true, true, false, false, true, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, false, true, true, true, true, false, true, true, true, true, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, false, false, true, false, true, false, false, false, false, true, true, false, true, false, true, false, false, false, true, true, true, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, false, false, true, false, false, false, false, false, false, true, true, false, true, false, true, false, false, false, true, true, true, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, true, false, true, true, true, true, false, false, true, false, true, false, false, false, true, true, false, false, true, true, true, true, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, true, true, true, true, true, true, false, false, true, false, true, false, false, false, true, false, false, false, true, true, true, true, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, true, true, true, true, false, true, false, true, true, false, false, true, false, true, false, true, true, false, false, false, false, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, false, true, true, true, false, false, false, false, true, true, false, false, true, false, true, false, true, true, false, false, false, false, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, true, true, false, true, false, false, true, false, false, true, true, true, false, false, false, true, false, false, true, true, false, false, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, true, false, true, true, true, true, false, false, true, true, true, false, false, false, true, true, false, true, true, false, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, false, false, true, true, false, true, true, false, false, true, true, false, false, false, false, false, false, true, false, false, false, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, false, false, true, false, false, true, true, false, false, true, true, false, false, false, false, false, false, true, false, false, false, false, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, false, false, true, false, true, true, false, true, true, true, true, false, true, false, true, false, false, true, true, false, true, true, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, true, false, false, true, false, true, true, false, true, true, true, true, true, true, false, true, false, false, true, true, false, false, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, true, false, true, true, false, true, true, true, true, true, true, true, false, true, false, false, true, true, false, true, true, false, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, false, false, true, false, true, true, true, true, true, true, true, false, true, false, false, true, true, false, true, true, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, true, false, true, false, true, false, false, true, false, true, false, false, true, false, false, true, false, false, true, true, true, false, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, true, false, true, false, true, false, false, true, false, true, false, false, true, false, false, true, false, false, true, false, true, false, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, true, true, true, false, true, true, true, false, false, false, true, true, false, true, true, false, false, false, true, true, false, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, true, true, true, false, true, true, true, false, false, false, true, true, true, true, true, false, false, false, true, true, false, false, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, false, true, true, true, false, false, false, true, false, true, true, true, false, false, true, true, false, false, true, false, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, false, true, true, true, false, false, false, true, false, true, true, true, false, false, true, true, false, false, false, false, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, true, false, true, true, true, false, false, true, false, false, false, true, false, false, true, true, true, false, true, true, false, true, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, false, true, false, true, false, false, true, false, false, false, true, false, false, true, true, true, false, true, true, true, true, true, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, false, false, false, false, true, false, true, false, false, true, true, true, true, false, true, false, false, false, false, true, true, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, false, false, false, false, true, false, false, false, false, true, true, true, true, false, true, false, false, false, false, true, true, true, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, true, true, true, false, true, true, false, false, true, false, false, true, true, false, false, true, false, false, true, true, true, false, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, false, true, true, true, false, true, true, false, true, true, false, false, true, true, false, false, true, false, false, true, false, true, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, false, true, false, false, false, true, false, true, true, false, false, false, true, true, false, true, false, true, true, true, false, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, false, false, false, false, false, true, false, true, true, true, false, false, true, true, false, true, false, true, true, true, false, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, true, false, false, false, true, false, true, false, true, false, true, false, true, false, false, false, false, true, true, false, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, true, false, false, true, false, true, false, true, false, true, false, true, false, true, false, false, false, false, false, true, false, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, true, true, true, false, true, false, false, false, true, true, true, true, false, true, true, true, false, true, true, true, false, false, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, true, true, false, true, false, false, false, true, true, true, false, false, true, true, true, false, true, true, true, false, false, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, true, true, false, false, true, false, true, true, true, false, false, true, false, true, false, true, true, false, false, false, false, true, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, true, true, false, false, true, false, true, true, true, false, false, true, false, true, false, true, true, true, false, false, false, false, false, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, false, false, true, true, false, true, false, false, true, true, true, true, false, true, true, false, false, true, true, false, false, false, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, true, false, false, true, true, false, true, true, true, true, true, true, true, false, true, true, false, false, true, true, false, false, false, false, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, false, true, true, true, false, false, true, false, false, false, true, false, false, true, true, true, false, false, false, false, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, false, false, false, true, true, true, false, false, true, false, false, false, true, false, false, true, true, true, false, false, true, false, false, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, true, true, false, true, true, false, true, false, false, true, false, true, false, true, false, true, true, false, true, true, true, true, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, true, true, false, true, true, false, false, true, false, true, false, true, false, true, true, true, true, false, true, true, true, true, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, true, true, false, true, true, true, true, true, false, true, false, false, false, false, true, false, true, true, true, false, false, true, false, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, true, true, false, true, true, true, true, true, false, true, true, false, false, false, true, false, true, true, true, false, true, true, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, false, false, false, false, false, false, true, true, false, true, false, false, true, false, true, false, true, false, false, true, true, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, true, false, true, false, false, false, false, true, true, false, true, false, false, true, false, true, false, true, false, false, true, true, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, true, true, true, true, true, false, true, false, true, true, true, true, false, true, false, false, true, false, false, false, false, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, true, true, false, true, true, true, false, true, false, true, true, true, true, false, true, true, false, true, false, false, false, false, false, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, false, true, false, false, true, false, false, true, true, true, false, false, true, false, true, true, true, true, true, true, false, false, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, false, false, false, false, true, false, false, true, true, true, false, false, true, false, true, true, true, true, false, false, false, false, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, true, false, false, false, true, true, false, false, false, true, false, false, true, false, true, true, true, true, false, true, false, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, true, false, false, false, true, true, false, false, false, true, false, false, true, false, true, true, true, true, false, true, true, false, true, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, false, true, true, true, false, true, false, false, true, false, false, false, true, true, true, true, false, false, true, false, false, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, false, true, true, true, false, true, false, false, true, false, false, false, true, true, true, true, false, false, true, true, false, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, true, true, false, true, false, true, true, false, false, true, true, false, true, true, false, true, true, true, true, true, false, true, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, true, true, false, true, false, true, true, false, false, true, true, false, true, true, false, true, true, true, false, true, false, true, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, false, true, false, false, true, false, false, false, true, false, true, true, false, true, false, false, true, true, false, true, false, false, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, false, true, false, false, true, false, false, false, true, false, true, false, false, true, true, false, true, true, false, true, false, false, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, false, true, false, false, true, true, false, false, true, true, true, false, false, false, false, false, true, false, false, true, true, false, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, true, true, false, false, true, true, false, false, true, true, true, false, true, false, true, false, true, false, false, true, true, false, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, true, true, true, true, false, true, true, false, false, true, false, false, false, true, true, false, true, false, false, true, true, true, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, false, true, false, true, false, true, false, false, false, true, false, false, false, true, true, false, true, false, false, true, true, true, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, false, false, false, true, false, true, true, false, true, false, true, false, false, true, false, false, true, true, true, true, false, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, false, false, false, false, true, false, true, true, false, true, false, true, false, true, true, false, false, true, true, true, true, false, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, true, false, true, false, true, true, false, false, false, true, false, true, true, false, false, false, true, false, true, true, true, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, true, true, true, false, true, true, false, false, false, true, false, true, true, false, false, false, true, false, true, true, true, true, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, true, false, false, true, false, false, false, true, false, true, false, false, true, false, true, true, true, false, false, false, true, true, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, false, false, true, true, false, false, true, false, true, false, false, true, false, true, true, true, true, false, false, true, true, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, true, false, false, false, false, false, true, false, false, false, false, false, true, false, false, false, false, false, true, false, false, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, false, false, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, false, false, false, false, true, true, false, true, false, false, false, false, true, true, false, false, false, true, true, false, false, false, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, false, false, false, false, true, true, false, true, false, false, false, true, true, true, false, false, false, true, true, false, false, false, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, false, true, true, true, false, true, true, true, true, false, false, true, false, true, true, true, true, true, false, false, false, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, false, true, true, true, false, true, true, true, true, false, false, true, false, true, true, true, true, true, false, false, false, false, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, false, false, true, false, true, false, true, false, false, true, false, true, false, true, true, false, false, true, false, false, true, false, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, false, false, true, false, true, false, true, false, false, true, false, true, false, true, true, false, false, true, false, true, true, false, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, false, false, false, true, true, true, true, true, true, false, true, true, false, true, true, true, false, true, false, true, true, true, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, false, false, false, true, true, false, true, true, true, false, true, true, false, false, true, true, false, true, false, true, true, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, false, false, false, false, false, false, true, false, false, false, true, true, false, false, true, true, false, false, false, true, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, false, false, false, true, true, false, false, false, true, false, false, false, true, true, false, true, true, true, false, false, false, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, true, true, true, true, false, true, false, false, false, false, true, false, true, true, true, true, true, true, false, true, false, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, true, true, false, true, false, true, false, false, false, false, true, false, false, true, true, true, false, true, false, true, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, false, true, false, false, false, false, false, false, false, true, true, false, false, true, false, true, true, true, false, true, true, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, true, false, false, false, true, false, false, false, false, true, false, false, true, true, true, false, true, false, true, true, true, false, true, true, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, true, false, false, true, false, false, true, false, true, true, true, true, true, true, false, false, true, false, true, true, false, false, true, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, true, false, false, true, false, false, true, false, true, true, true, true, true, true, false, false, true, true, false, true, false, false, true, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, true, false, false, true, false, false, true, false, true, true, true, true, false, true, false, true, true, true, true, true, true, true, true, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, false, false, true, false, false, true, false, true, false, true, true, false, true, false, true, true, true, true, true, true, false, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, false, false, false, true, true, false, false, true, true, false, false, true, false, false, true, true, true, true, true, false, false, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, true, false, false, false, true, true, false, false, true, true, false, false, true, false, false, true, true, true, true, true, false, false, false, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, true, true, true, false, false, false, true, false, true, false, true, true, false, false, false, true, false, true, false, true, false, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, false, true, true, true, false, false, false, true, false, true, false, true, true, true, false, false, true, false, true, false, true, false, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, true, false, false, false, true, true, false, true, false, false, false, false, false, false, false, true, false, true, false, false, true, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, true, false, false, false, false, true, false, true, false, false, false, false, false, true, false, true, false, true, false, false, true, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, true, false, false, true, false, true, true, false, false, true, false, true, true, true, true, true, true, true, true, false, true, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, true, false, false, true, false, true, false, false, false, true, false, false, true, true, true, true, true, true, true, false, true, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, false, true, true, true, false, false, true, true, false, false, false, false, true, false, true, true, true, true, false, true, false, true, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, false, true, true, true, false, false, true, true, true, false, false, false, true, false, true, true, false, true, false, true, false, true, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, true, false, false, true, true, false, true, true, false, true, true, false, true, true, true, true, true, false, false, false, false, true, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, false, false, true, true, false, true, true, false, true, true, false, true, true, true, true, false, false, false, false, false, true, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, false, false, false, false, true, false, true, false, false, true, false, false, false, true, false, false, false, false, true, false, true, false, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, true, false, false, false, true, false, true, false, false, true, false, false, false, true, false, false, false, false, true, false, true, false, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, true, false, true, true, true, false, false, true, true, true, true, false, false, false, false, false, true, true, true, false, true, true, false, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, false, true, false, true, true, true, false, false, true, true, true, true, false, false, false, false, false, true, true, true, false, true, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, true, false, false, false, false, true, true, false, true, true, false, true, true, true, false, false, false, false, false, true, false, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, false, false, true, true, false, false, false, true, true, false, true, true, false, true, true, true, false, false, false, false, false, true, false, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, true, true, false, true, false, true, true, false, false, false, true, false, false, true, false, true, true, true, true, true, false, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, false, true, false, true, false, true, true, false, false, false, true, false, false, true, false, true, true, true, true, true, false, false, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, false, true, true, false, true, false, true, false, false, false, false, true, false, true, false, false, true, false, false, true, true, true, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, false, true, true, false, true, false, true, false, false, false, false, true, false, false, false, false, true, false, false, true, true, false, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, false, false, true, false, false, true, true, true, true, false, false, false, true, false, true, true, true, true, false, true, true, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, false, false, true, false, false, true, true, true, true, false, false, false, true, true, true, true, true, true, false, true, true, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, true, false, false, true, false, true, false, true, true, false, false, true, true, true, false, false, false, true, true, false, false, false, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, false, false, false, false, true, false, false, true, false, false, true, true, true, false, false, false, true, true, false, false, true, true, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, true, false, true, false, true, false, true, true, true, true, false, false, true, true, false, false, false, false, false, true, false, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, true, true, false, true, false, true, true, true, true, false, false, true, true, false, false, true, false, false, true, false, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, false, false, false, true, true, false, true, true, true, true, false, true, false, false, false, true, false, false, false, false, true, false, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, false, false, false, true, true, false, true, true, true, true, false, true, false, false, false, true, true, true, false, false, true, false, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, false, true, false, true, true, false, true, false, true, true, true, false, true, false, false, false, true, false, false, false, true, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, true, false, true, true, false, true, false, true, true, true, false, true, false, false, false, true, false, false, false, false, false, true, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, true, false, false, true, true, false, true, false, true, false, true, true, true, true, false, true, false, true, false, false, false, false, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, true, false, true, true, true, true, false, true, false, true, true, true, true, false, true, false, true, false, false, false, false, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, true, false, false, false, false, true, true, false, false, true, false, true, true, false, true, false, true, true, false, false, false, true, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, true, false, false, false, false, true, true, false, false, true, false, true, true, false, true, false, false, true, false, false, false, true, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, true, true, true, false, true, false, true, true, false, false, false, true, true, false, true, true, true, false, false, true, false, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, true, false, true, true, true, false, true, false, true, true, false, false, false, true, true, false, true, true, true, false, false, true, false, true, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, true, false, true, false, false, false, false, false, true, false, false, true, false, true, false, true, false, false, true, false, false, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, false, false, true, true, true, false, false, false, false, false, true, false, false, true, false, true, false, true, false, false, true, false, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, true, true, false, true, false, true, false, false, true, false, true, false, false, true, true, true, true, true, false, true, false, false, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, false, true, false, true, false, true, false, false, true, false, true, false, true, true, false, true, true, true, false, true, false, false, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, false, true, false, true, true, true, true, false, true, true, false, false, false, true, true, true, true, true, true, true, false, false, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, true, false, true, false, true, false, true, true, false, true, true, false, false, false, true, true, true, true, true, true, true, false, false, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, false, false, false, false, true, false, true, false, false, false, false, false, false, false, true, false, true, false, false, true, false, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, true, false, false, false, false, true, false, true, false, true, false, false, false, true, false, true, false, true, false, false, true, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, true, false, false, true, true, false, true, false, false, false, true, false, false, false, false, false, false, false, false, true, false, false, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, true, false, true, false, false, true, false, false, false, true, false, false, false, false, false, false, false, false, true, false, false, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, true, true, true, true, false, true, true, true, true, true, false, true, true, false, true, true, true, false, true, true, false, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, false, true, true, true, false, true, true, true, true, true, false, false, true, false, true, true, true, false, true, true, false, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, false, true, true, false, true, true, true, false, true, false, true, false, false, true, false, false, false, false, false, true, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, true, false, false, true, false, true, false, true, false, true, false, true, false, false, true, false, false, false, false, false, true, true, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, true, false, false, true, false, false, true, false, false, true, false, false, false, false, true, false, true, false, true, true, true, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, true, false, false, true, false, true, true, false, false, true, false, false, false, false, true, false, true, false, true, true, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, true, true, false, false, false, false, false, false, true, false, true, true, false, false, false, true, false, false, false, false, true, false, false, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, true, true, false, false, false, false, false, true, false, true, true, false, false, false, true, false, false, true, false, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, false, true, true, false, true, false, false, true, false, true, false, false, false, true, true, false, true, false, true, true, true, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, false, true, true, true, false, false, false, true, false, true, false, false, false, true, true, false, true, true, true, true, true, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, true, false, false, false, true, true, false, true, true, true, true, true, false, true, true, false, true, false, true, false, true, false, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, false, true, false, true, true, false, true, true, true, true, false, false, true, true, false, true, false, true, false, true, false, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, true, false, true, true, false, true, false, false, true, false, true, false, true, false, false, true, false, true, false, false, true, true, true, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, false, true, true, false, true, false, false, true, false, true, false, true, false, false, true, false, true, false, true, true, true, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, true, false, true, true, true, true, false, false, true, false, false, true, false, false, true, false, true, false, true, false, true, false, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, false, true, false, true, false, false, false, true, false, false, true, false, false, true, false, true, false, true, false, true, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, true, false, false, false, false, true, false, true, false, true, false, true, true, true, true, false, false, false, true, true, false, true, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, false, false, false, false, true, false, false, false, true, true, true, true, true, true, false, false, false, true, true, false, true, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, true, true, false, false, false, true, true, true, true, false, false, true, false, false, true, false, true, true, false, true, false, false, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, true, false, false, false, false, true, true, true, true, false, false, false, false, false, true, true, true, true, false, true, false, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, false, true, true, false, false, true, true, false, true, false, false, true, true, true, false, false, true, false, false, false, false, false, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, false, true, false, true, false, true, true, false, true, false, false, true, true, true, false, false, true, false, false, false, false, false, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, false, false, true, true, false, false, false, true, true, false, false, false, true, false, false, false, false, false, true, true, true, true, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, false, false, true, false, false, false, false, true, true, false, false, true, true, false, false, false, false, false, true, true, true, true, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, false, false, true, false, true, true, false, true, true, true, true, true, true, false, false, false, false, false, true, false, true, true, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, false, false, true, false, true, true, false, true, true, true, true, true, true, false, false, true, false, false, true, false, true, true, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, true, true, false, true, true, false, true, false, false, false, true, false, true, false, false, false, false, true, true, false, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, true, true, false, true, true, false, true, false, true, false, true, false, true, false, false, false, false, true, true, true, true, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, true, false, true, false, false, true, true, false, true, true, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, true, false, true, false, true, true, true, true, true, false, false, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, false, true, true, false, true, false, false, true, false, true, true, true, true, false, true, false, false, false, false, false, false, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, false, false, true, true, false, true, false, false, true, false, true, true, true, true, false, true, false, false, false, false, false, false, false, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, true, false, false, false, false, false, true, false, false, true, false, false, true, false, true, true, false, false, false, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, true, true, false, false, false, false, false, true, false, false, true, false, false, true, false, true, true, false, false, false, true, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, false, true, false, true, true, true, true, false, true, true, true, false, true, true, true, true, false, true, false, false, true, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, false, true, false, true, true, true, true, false, true, true, false, false, true, true, true, true, false, true, false, false, true, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, true, true, false, true, false, true, false, false, true, false, true, false, false, true, false, true, true, false, false, true, false, false, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, true, false, true, false, true, false, false, true, false, true, false, true, true, false, true, true, false, false, true, false, false, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, false, false, false, false, false, true, false, true, false, true, true, false, true, false, true, false, true, true, false, false, false, false, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, false, true, false, false, true, false, true, false, true, true, false, true, false, true, false, true, true, true, false, false, false, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, false, false, true, true, true, true, false, true, true, true, false, true, false, false, true, true, false, false, false, true, false, true, false, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, false, true, true, false, true, true, true, true, true, false, true, false, false, true, true, false, false, false, true, false, true, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, true, false, true, false, false, true, false, false, true, false, true, false, false, false, true, false, true, true, false, false, true, true, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, false, true, false, false, true, false, false, true, false, true, true, false, false, true, false, true, true, false, false, true, true, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, false, true, true, false, true, true, false, false, false, false, false, true, false, false, true, false, false, false, false, true, false, false, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, false, true, true, false, true, true, false, false, false, false, false, true, false, false, true, false, false, true, false, true, false, false, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, false, false, true, true, true, false, true, false, true, true, true, true, false, true, true, false, false, true, false, true, true, true, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, false, false, true, true, true, false, true, false, true, true, true, true, false, true, true, false, false, true, false, true, true, true, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, false, false, false, true, false, true, false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, true, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, false, false, true, false, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, true, true, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = WagnerCode32_21;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, false, false, false, false, true, true, false, true, false, true, true, false, true, true, false, true, true, false, true, true, true, false, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, false, false, false, false, true, true, false, true, false, true, true, false, false, false, false, true, true, false, true, true, true, false, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
    }

    #[test]
    fn test_generator_representation() {
        init();
        let generator_matrix = unsafe { GENERATOR_MATRIX.as_ref().unwrap() };
        let first_row = generator_matrix.get_window(0, 0, 1, generator_matrix.ncols());
        let vector = BinVector::from_bools(&[ true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, true, false, true, true, false, true, false, false, false ]);
        assert_eq!(vector, first_row.as_vector());
    }

}