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;

/// ``[19, 7]`` Bogosrnd code
///
/// Decodes using Syndrome decoding
#[derive(Clone, Serialize)]
pub struct BogosrndCode19_7;

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(&[
                &[ 403201 ],
                &[ 298498 ],
                &[ 260612 ],
                &[ 193288 ],
                &[ 482064 ],
                &[ 106016 ],
                &[ 138176 ],
                
            ], 19));
            GENERATOR_MATRIX = Box::into_raw(matrix);

            let matrix = Box::new(BinMatrix::from_slices(&[
                &[ 468993 ],
                &[ 286722 ],
                &[ 368644 ],
                &[ 174088 ],
                &[ 477200 ],
                &[ 256032 ],
                &[ 354368 ],
                &[ 354432 ],
                &[ 499968 ],
                &[ 363008 ],
                &[ 41984 ],
                &[ 446464 ],
                
            ], 19));
            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(4096, 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, &[7]);     // 7 => [7]
            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, &[15]);     // 15 => [15]
            map.insert(16, &[16]);     // 16 => [16]
            map.insert(17, &[17]);     // 17 => [17]
            map.insert(18, &[18]);     // 18 => [18]
            map.insert(19, &[19]);     // 19 => [19]
            map.insert(20, &[20]);     // 20 => [20]
            map.insert(21, &[21]);     // 21 => [21]
            map.insert(22, &[22]);     // 22 => [22]
            map.insert(23, &[395264]);     // 23 => [395264]
            map.insert(24, &[24]);     // 24 => [24]
            map.insert(25, &[25]);     // 25 => [25]
            map.insert(26, &[26]);     // 26 => [26]
            map.insert(27, &[27]);     // 27 => [27]
            map.insert(28, &[28]);     // 28 => [28]
            map.insert(29, &[29]);     // 29 => [29]
            map.insert(30, &[30]);     // 30 => [30]
            map.insert(31, &[395272]);     // 31 => [395272]
            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, &[39]);     // 39 => [39]
            map.insert(40, &[40]);     // 40 => [40]
            map.insert(41, &[41]);     // 41 => [41]
            map.insert(42, &[42]);     // 42 => [42]
            map.insert(43, &[43]);     // 43 => [43]
            map.insert(44, &[44]);     // 44 => [44]
            map.insert(45, &[45]);     // 45 => [45]
            map.insert(46, &[46]);     // 46 => [46]
            map.insert(47, &[47]);     // 47 => [47]
            map.insert(48, &[48]);     // 48 => [48]
            map.insert(49, &[49]);     // 49 => [49]
            map.insert(50, &[50]);     // 50 => [50]
            map.insert(51, &[51]);     // 51 => [51]
            map.insert(52, &[52]);     // 52 => [52]
            map.insert(53, &[53]);     // 53 => [53]
            map.insert(54, &[54]);     // 54 => [54]
            map.insert(55, &[395296]);     // 55 => [395296]
            map.insert(56, &[56]);     // 56 => [56]
            map.insert(57, &[135424]);     // 57 => [135424]
            map.insert(58, &[58]);     // 58 => [58]
            map.insert(59, &[135426]);     // 59 => [135426]
            map.insert(60, &[60]);     // 60 => [60]
            map.insert(61, &[135428]);     // 61 => [135428]
            map.insert(62, &[213504]);     // 62 => [213504]
            map.insert(63, &[213505]);     // 63 => [213505]
            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, &[71]);     // 71 => [71]
            map.insert(72, &[72]);     // 72 => [72]
            map.insert(73, &[73]);     // 73 => [73]
            map.insert(74, &[74]);     // 74 => [74]
            map.insert(75, &[75]);     // 75 => [75]
            map.insert(76, &[76]);     // 76 => [76]
            map.insert(77, &[77]);     // 77 => [77]
            map.insert(78, &[78]);     // 78 => [78]
            map.insert(79, &[79]);     // 79 => [79]
            map.insert(80, &[80]);     // 80 => [80]
            map.insert(81, &[81]);     // 81 => [81]
            map.insert(82, &[82]);     // 82 => [82]
            map.insert(83, &[83]);     // 83 => [83]
            map.insert(84, &[84]);     // 84 => [84]
            map.insert(85, &[85]);     // 85 => [85]
            map.insert(86, &[86]);     // 86 => [86]
            map.insert(87, &[395328]);     // 87 => [395328]
            map.insert(88, &[88]);     // 88 => [88]
            map.insert(89, &[89]);     // 89 => [89]
            map.insert(90, &[90]);     // 90 => [90]
            map.insert(91, &[91]);     // 91 => [91]
            map.insert(92, &[92]);     // 92 => [92]
            map.insert(93, &[93]);     // 93 => [93]
            map.insert(94, &[94]);     // 94 => [94]
            map.insert(95, &[395336]);     // 95 => [395336]
            map.insert(96, &[96]);     // 96 => [96]
            map.insert(97, &[97]);     // 97 => [97]
            map.insert(98, &[98]);     // 98 => [98]
            map.insert(99, &[99]);     // 99 => [99]
            map.insert(100, &[100]);     // 100 => [100]
            map.insert(101, &[101]);     // 101 => [101]
            map.insert(102, &[102]);     // 102 => [102]
            map.insert(103, &[103]);     // 103 => [103]
            map.insert(104, &[104]);     // 104 => [104]
            map.insert(105, &[105]);     // 105 => [105]
            map.insert(106, &[106]);     // 106 => [106]
            map.insert(107, &[107]);     // 107 => [107]
            map.insert(108, &[108]);     // 108 => [108]
            map.insert(109, &[109]);     // 109 => [109]
            map.insert(110, &[393856]);     // 110 => [393856]
            map.insert(111, &[9600]);     // 111 => [9600]
            map.insert(112, &[112]);     // 112 => [112]
            map.insert(113, &[113]);     // 113 => [113]
            map.insert(114, &[20608]);     // 114 => [20608]
            map.insert(115, &[20609]);     // 115 => [20609]
            map.insert(116, &[116]);     // 116 => [116]
            map.insert(117, &[66432]);     // 117 => [66432]
            map.insert(118, &[20612]);     // 118 => [20612]
            map.insert(119, &[20613]);     // 119 => [20613]
            map.insert(120, &[2689]);     // 120 => [2689]
            map.insert(121, &[2688]);     // 121 => [2688]
            map.insert(122, &[20616]);     // 122 => [20616]
            map.insert(123, &[2690]);     // 123 => [2690]
            map.insert(124, &[2693]);     // 124 => [2693]
            map.insert(125, &[2692]);     // 125 => [2692]
            map.insert(126, &[20620]);     // 126 => [20620]
            map.insert(127, &[2694]);     // 127 => [2694]
            map.insert(128, &[128]);     // 128 => [128]
            map.insert(129, &[129]);     // 129 => [129]
            map.insert(130, &[130]);     // 130 => [130]
            map.insert(131, &[131]);     // 131 => [131]
            map.insert(132, &[132]);     // 132 => [132]
            map.insert(133, &[133]);     // 133 => [133]
            map.insert(134, &[134]);     // 134 => [134]
            map.insert(135, &[135]);     // 135 => [135]
            map.insert(136, &[136]);     // 136 => [136]
            map.insert(137, &[137]);     // 137 => [137]
            map.insert(138, &[138]);     // 138 => [138]
            map.insert(139, &[139]);     // 139 => [139]
            map.insert(140, &[140]);     // 140 => [140]
            map.insert(141, &[141]);     // 141 => [141]
            map.insert(142, &[142]);     // 142 => [142]
            map.insert(143, &[143]);     // 143 => [143]
            map.insert(144, &[144]);     // 144 => [144]
            map.insert(145, &[145]);     // 145 => [145]
            map.insert(146, &[146]);     // 146 => [146]
            map.insert(147, &[147]);     // 147 => [147]
            map.insert(148, &[148]);     // 148 => [148]
            map.insert(149, &[149]);     // 149 => [149]
            map.insert(150, &[150]);     // 150 => [150]
            map.insert(151, &[395392]);     // 151 => [395392]
            map.insert(152, &[152]);     // 152 => [152]
            map.insert(153, &[153]);     // 153 => [153]
            map.insert(154, &[154]);     // 154 => [154]
            map.insert(155, &[155]);     // 155 => [155]
            map.insert(156, &[156]);     // 156 => [156]
            map.insert(157, &[157]);     // 157 => [157]
            map.insert(158, &[158]);     // 158 => [158]
            map.insert(159, &[395400]);     // 159 => [395400]
            map.insert(160, &[160]);     // 160 => [160]
            map.insert(161, &[161]);     // 161 => [161]
            map.insert(162, &[162]);     // 162 => [162]
            map.insert(163, &[163]);     // 163 => [163]
            map.insert(164, &[164]);     // 164 => [164]
            map.insert(165, &[165]);     // 165 => [165]
            map.insert(166, &[166]);     // 166 => [166]
            map.insert(167, &[167]);     // 167 => [167]
            map.insert(168, &[168]);     // 168 => [168]
            map.insert(169, &[169]);     // 169 => [169]
            map.insert(170, &[170]);     // 170 => [170]
            map.insert(171, &[171]);     // 171 => [171]
            map.insert(172, &[172]);     // 172 => [172]
            map.insert(173, &[173]);     // 173 => [173]
            map.insert(174, &[393792]);     // 174 => [393792]
            map.insert(175, &[9536]);     // 175 => [9536]
            map.insert(176, &[176]);     // 176 => [176]
            map.insert(177, &[177]);     // 177 => [177]
            map.insert(178, &[20544]);     // 178 => [20544]
            map.insert(179, &[20545]);     // 179 => [20545]
            map.insert(180, &[180]);     // 180 => [180]
            map.insert(181, &[66368]);     // 181 => [66368]
            map.insert(182, &[20548]);     // 182 => [20548]
            map.insert(183, &[20549]);     // 183 => [20549]
            map.insert(184, &[2625]);     // 184 => [2625]
            map.insert(185, &[2624]);     // 185 => [2624]
            map.insert(186, &[20552]);     // 186 => [20552]
            map.insert(187, &[2626]);     // 187 => [2626]
            map.insert(188, &[2629]);     // 188 => [2629]
            map.insert(189, &[2628]);     // 189 => [2628]
            map.insert(190, &[20556]);     // 190 => [20556]
            map.insert(191, &[2630]);     // 191 => [2630]
            map.insert(192, &[192]);     // 192 => [192]
            map.insert(193, &[193]);     // 193 => [193]
            map.insert(194, &[194]);     // 194 => [194]
            map.insert(195, &[195]);     // 195 => [195]
            map.insert(196, &[196]);     // 196 => [196]
            map.insert(197, &[197]);     // 197 => [197]
            map.insert(198, &[198]);     // 198 => [198]
            map.insert(199, &[215040]);     // 199 => [215040]
            map.insert(200, &[200]);     // 200 => [200]
            map.insert(201, &[201]);     // 201 => [201]
            map.insert(202, &[147713]);     // 202 => [147713]
            map.insert(203, &[147712]);     // 203 => [147712]
            map.insert(204, &[204]);     // 204 => [204]
            map.insert(205, &[205]);     // 205 => [205]
            map.insert(206, &[393760]);     // 206 => [393760]
            map.insert(207, &[147716]);     // 207 => [147716]
            map.insert(208, &[208]);     // 208 => [208]
            map.insert(209, &[209]);     // 209 => [209]
            map.insert(210, &[20512]);     // 210 => [20512]
            map.insert(211, &[20513]);     // 211 => [20513]
            map.insert(212, &[212]);     // 212 => [212]
            map.insert(213, &[66336]);     // 213 => [66336]
            map.insert(214, &[20516]);     // 214 => [20516]
            map.insert(215, &[267008]);     // 215 => [267008]
            map.insert(216, &[2593]);     // 216 => [2593]
            map.insert(217, &[2592]);     // 217 => [2592]
            map.insert(218, &[20520]);     // 218 => [20520]
            map.insert(219, &[2594]);     // 219 => [2594]
            map.insert(220, &[280832]);     // 220 => [280832]
            map.insert(221, &[2596]);     // 221 => [2596]
            map.insert(222, &[280834]);     // 222 => [280834]
            map.insert(223, &[2598]);     // 223 => [2598]
            map.insert(224, &[224]);     // 224 => [224]
            map.insert(225, &[225]);     // 225 => [225]
            map.insert(226, &[20496]);     // 226 => [20496]
            map.insert(227, &[20497]);     // 227 => [20497]
            map.insert(228, &[228]);     // 228 => [228]
            map.insert(229, &[66320]);     // 229 => [66320]
            map.insert(230, &[20500]);     // 230 => [20500]
            map.insert(231, &[9480]);     // 231 => [9480]
            map.insert(232, &[2577]);     // 232 => [2577]
            map.insert(233, &[2576]);     // 233 => [2576]
            map.insert(234, &[393732]);     // 234 => [393732]
            map.insert(235, &[2578]);     // 235 => [2578]
            map.insert(236, &[393730]);     // 236 => [393730]
            map.insert(237, &[9474]);     // 237 => [9474]
            map.insert(238, &[393728]);     // 238 => [393728]
            map.insert(239, &[9472]);     // 239 => [9472]
            map.insert(240, &[20482]);     // 240 => [20482]
            map.insert(241, &[2568]);     // 241 => [2568]
            map.insert(242, &[20480]);     // 242 => [20480]
            map.insert(243, &[20481]);     // 243 => [20481]
            map.insert(244, &[66305]);     // 244 => [66305]
            map.insert(245, &[66304]);     // 245 => [66304]
            map.insert(246, &[20484]);     // 246 => [20484]
            map.insert(247, &[20485]);     // 247 => [20485]
            map.insert(248, &[2561]);     // 248 => [2561]
            map.insert(249, &[2560]);     // 249 => [2560]
            map.insert(250, &[20488]);     // 250 => [20488]
            map.insert(251, &[2562]);     // 251 => [2562]
            map.insert(252, &[2565]);     // 252 => [2565]
            map.insert(253, &[2564]);     // 253 => [2564]
            map.insert(254, &[20492]);     // 254 => [20492]
            map.insert(255, &[2566]);     // 255 => [2566]
            map.insert(256, &[256]);     // 256 => [256]
            map.insert(257, &[257]);     // 257 => [257]
            map.insert(258, &[258]);     // 258 => [258]
            map.insert(259, &[259]);     // 259 => [259]
            map.insert(260, &[260]);     // 260 => [260]
            map.insert(261, &[261]);     // 261 => [261]
            map.insert(262, &[262]);     // 262 => [262]
            map.insert(263, &[263]);     // 263 => [263]
            map.insert(264, &[264]);     // 264 => [264]
            map.insert(265, &[265]);     // 265 => [265]
            map.insert(266, &[266]);     // 266 => [266]
            map.insert(267, &[267]);     // 267 => [267]
            map.insert(268, &[67584]);     // 268 => [67584]
            map.insert(269, &[67585]);     // 269 => [67585]
            map.insert(270, &[67586]);     // 270 => [67586]
            map.insert(271, &[67587]);     // 271 => [67587]
            map.insert(272, &[272]);     // 272 => [272]
            map.insert(273, &[273]);     // 273 => [273]
            map.insert(274, &[274]);     // 274 => [274]
            map.insert(275, &[275]);     // 275 => [275]
            map.insert(276, &[276]);     // 276 => [276]
            map.insert(277, &[277]);     // 277 => [277]
            map.insert(278, &[278]);     // 278 => [278]
            map.insert(279, &[395520]);     // 279 => [395520]
            map.insert(280, &[280]);     // 280 => [280]
            map.insert(281, &[135200]);     // 281 => [135200]
            map.insert(282, &[458753]);     // 282 => [458753]
            map.insert(283, &[458752]);     // 283 => [458752]
            map.insert(284, &[67600]);     // 284 => [67600]
            map.insert(285, &[67601]);     // 285 => [67601]
            map.insert(286, &[67602]);     // 286 => [67602]
            map.insert(287, &[458756]);     // 287 => [458756]
            map.insert(288, &[288]);     // 288 => [288]
            map.insert(289, &[289]);     // 289 => [289]
            map.insert(290, &[290]);     // 290 => [290]
            map.insert(291, &[291]);     // 291 => [291]
            map.insert(292, &[292]);     // 292 => [292]
            map.insert(293, &[279040]);     // 293 => [279040]
            map.insert(294, &[294]);     // 294 => [294]
            map.insert(295, &[279042]);     // 295 => [279042]
            map.insert(296, &[296]);     // 296 => [296]
            map.insert(297, &[135184]);     // 297 => [135184]
            map.insert(298, &[298]);     // 298 => [298]
            map.insert(299, &[135186]);     // 299 => [135186]
            map.insert(300, &[67616]);     // 300 => [67616]
            map.insert(301, &[67617]);     // 301 => [67617]
            map.insert(302, &[268288]);     // 302 => [268288]
            map.insert(303, &[268289]);     // 303 => [268289]
            map.insert(304, &[304]);     // 304 => [304]
            map.insert(305, &[135176]);     // 305 => [135176]
            map.insert(306, &[306]);     // 306 => [306]
            map.insert(307, &[135178]);     // 307 => [135178]
            map.insert(308, &[308]);     // 308 => [308]
            map.insert(309, &[135180]);     // 309 => [135180]
            map.insert(310, &[110592]);     // 310 => [110592]
            map.insert(311, &[110593]);     // 311 => [110593]
            map.insert(312, &[135169]);     // 312 => [135169]
            map.insert(313, &[135168]);     // 313 => [135168]
            map.insert(314, &[135171]);     // 314 => [135171]
            map.insert(315, &[135170]);     // 315 => [135170]
            map.insert(316, &[135173]);     // 316 => [135173]
            map.insert(317, &[135172]);     // 317 => [135172]
            map.insert(318, &[268304]);     // 318 => [268304]
            map.insert(319, &[135174]);     // 319 => [135174]
            map.insert(320, &[320]);     // 320 => [320]
            map.insert(321, &[321]);     // 321 => [321]
            map.insert(322, &[322]);     // 322 => [322]
            map.insert(323, &[323]);     // 323 => [323]
            map.insert(324, &[324]);     // 324 => [324]
            map.insert(325, &[325]);     // 325 => [325]
            map.insert(326, &[326]);     // 326 => [326]
            map.insert(327, &[327]);     // 327 => [327]
            map.insert(328, &[328]);     // 328 => [328]
            map.insert(329, &[329]);     // 329 => [329]
            map.insert(330, &[147585]);     // 330 => [147585]
            map.insert(331, &[147584]);     // 331 => [147584]
            map.insert(332, &[67648]);     // 332 => [67648]
            map.insert(333, &[67649]);     // 333 => [67649]
            map.insert(334, &[67650]);     // 334 => [67650]
            map.insert(335, &[147588]);     // 335 => [147588]
            map.insert(336, &[336]);     // 336 => [336]
            map.insert(337, &[337]);     // 337 => [337]
            map.insert(338, &[338]);     // 338 => [338]
            map.insert(339, &[339]);     // 339 => [339]
            map.insert(340, &[340]);     // 340 => [340]
            map.insert(341, &[66208]);     // 341 => [66208]
            map.insert(342, &[266881]);     // 342 => [266881]
            map.insert(343, &[266880]);     // 343 => [266880]
            map.insert(344, &[344]);     // 344 => [344]
            map.insert(345, &[135264]);     // 345 => [135264]
            map.insert(346, &[147601]);     // 346 => [147601]
            map.insert(347, &[147600]);     // 347 => [147600]
            map.insert(348, &[67664]);     // 348 => [67664]
            map.insert(349, &[67665]);     // 349 => [67665]
            map.insert(350, &[67666]);     // 350 => [67666]
            map.insert(351, &[147604]);     // 351 => [147604]
            map.insert(352, &[352]);     // 352 => [352]
            map.insert(353, &[353]);     // 353 => [353]
            map.insert(354, &[354]);     // 354 => [354]
            map.insert(355, &[355]);     // 355 => [355]
            map.insert(356, &[356]);     // 356 => [356]
            map.insert(357, &[66192]);     // 357 => [66192]
            map.insert(358, &[9353]);     // 358 => [9353]
            map.insert(359, &[9352]);     // 359 => [9352]
            map.insert(360, &[360]);     // 360 => [360]
            map.insert(361, &[135248]);     // 361 => [135248]
            map.insert(362, &[9349]);     // 362 => [9349]
            map.insert(363, &[9348]);     // 363 => [9348]
            map.insert(364, &[67680]);     // 364 => [67680]
            map.insert(365, &[9346]);     // 365 => [9346]
            map.insert(366, &[9345]);     // 366 => [9345]
            map.insert(367, &[9344]);     // 367 => [9344]
            map.insert(368, &[368]);     // 368 => [368]
            map.insert(369, &[66180]);     // 369 => [66180]
            map.insert(370, &[20864]);     // 370 => [20864]
            map.insert(371, &[20865]);     // 371 => [20865]
            map.insert(372, &[66177]);     // 372 => [66177]
            map.insert(373, &[66176]);     // 373 => [66176]
            map.insert(374, &[66179]);     // 374 => [66179]
            map.insert(375, &[66178]);     // 375 => [66178]
            map.insert(376, &[135233]);     // 376 => [135233]
            map.insert(377, &[135232]);     // 377 => [135232]
            map.insert(378, &[135235]);     // 378 => [135235]
            map.insert(379, &[135234]);     // 379 => [135234]
            map.insert(380, &[135237]);     // 380 => [135237]
            map.insert(381, &[135236]);     // 381 => [135236]
            map.insert(382, &[9361]);     // 382 => [9361]
            map.insert(383, &[9360]);     // 383 => [9360]
            map.insert(384, &[384]);     // 384 => [384]
            map.insert(385, &[385]);     // 385 => [385]
            map.insert(386, &[386]);     // 386 => [386]
            map.insert(387, &[387]);     // 387 => [387]
            map.insert(388, &[388]);     // 388 => [388]
            map.insert(389, &[389]);     // 389 => [389]
            map.insert(390, &[390]);     // 390 => [390]
            map.insert(391, &[391]);     // 391 => [391]
            map.insert(392, &[392]);     // 392 => [392]
            map.insert(393, &[393]);     // 393 => [393]
            map.insert(394, &[147521]);     // 394 => [147521]
            map.insert(395, &[147520]);     // 395 => [147520]
            map.insert(396, &[67712]);     // 396 => [67712]
            map.insert(397, &[67713]);     // 397 => [67713]
            map.insert(398, &[67714]);     // 398 => [67714]
            map.insert(399, &[147524]);     // 399 => [147524]
            map.insert(400, &[400]);     // 400 => [400]
            map.insert(401, &[401]);     // 401 => [401]
            map.insert(402, &[402]);     // 402 => [402]
            map.insert(403, &[403]);     // 403 => [403]
            map.insert(404, &[404]);     // 404 => [404]
            map.insert(405, &[66144]);     // 405 => [66144]
            map.insert(406, &[266817]);     // 406 => [266817]
            map.insert(407, &[266816]);     // 407 => [266816]
            map.insert(408, &[408]);     // 408 => [408]
            map.insert(409, &[135328]);     // 409 => [135328]
            map.insert(410, &[147537]);     // 410 => [147537]
            map.insert(411, &[147536]);     // 411 => [147536]
            map.insert(412, &[67728]);     // 412 => [67728]
            map.insert(413, &[67729]);     // 413 => [67729]
            map.insert(414, &[67730]);     // 414 => [67730]
            map.insert(415, &[147540]);     // 415 => [147540]
            map.insert(416, &[416]);     // 416 => [416]
            map.insert(417, &[417]);     // 417 => [417]
            map.insert(418, &[418]);     // 418 => [418]
            map.insert(419, &[419]);     // 419 => [419]
            map.insert(420, &[420]);     // 420 => [420]
            map.insert(421, &[66128]);     // 421 => [66128]
            map.insert(422, &[9289]);     // 422 => [9289]
            map.insert(423, &[9288]);     // 423 => [9288]
            map.insert(424, &[424]);     // 424 => [424]
            map.insert(425, &[135312]);     // 425 => [135312]
            map.insert(426, &[9285]);     // 426 => [9285]
            map.insert(427, &[9284]);     // 427 => [9284]
            map.insert(428, &[67744]);     // 428 => [67744]
            map.insert(429, &[9282]);     // 429 => [9282]
            map.insert(430, &[9281]);     // 430 => [9281]
            map.insert(431, &[9280]);     // 431 => [9280]
            map.insert(432, &[432]);     // 432 => [432]
            map.insert(433, &[66116]);     // 433 => [66116]
            map.insert(434, &[20800]);     // 434 => [20800]
            map.insert(435, &[20801]);     // 435 => [20801]
            map.insert(436, &[66113]);     // 436 => [66113]
            map.insert(437, &[66112]);     // 437 => [66112]
            map.insert(438, &[66115]);     // 438 => [66115]
            map.insert(439, &[66114]);     // 439 => [66114]
            map.insert(440, &[135297]);     // 440 => [135297]
            map.insert(441, &[135296]);     // 441 => [135296]
            map.insert(442, &[135299]);     // 442 => [135299]
            map.insert(443, &[135298]);     // 443 => [135298]
            map.insert(444, &[135301]);     // 444 => [135301]
            map.insert(445, &[135300]);     // 445 => [135300]
            map.insert(446, &[9297]);     // 446 => [9297]
            map.insert(447, &[9296]);     // 447 => [9296]
            map.insert(448, &[448]);     // 448 => [448]
            map.insert(449, &[449]);     // 449 => [449]
            map.insert(450, &[147465]);     // 450 => [147465]
            map.insert(451, &[147464]);     // 451 => [147464]
            map.insert(452, &[452]);     // 452 => [452]
            map.insert(453, &[66096]);     // 453 => [66096]
            map.insert(454, &[147469]);     // 454 => [147469]
            map.insert(455, &[147468]);     // 455 => [147468]
            map.insert(456, &[147459]);     // 456 => [147459]
            map.insert(457, &[147458]);     // 457 => [147458]
            map.insert(458, &[147457]);     // 458 => [147457]
            map.insert(459, &[147456]);     // 459 => [147456]
            map.insert(460, &[280592]);     // 460 => [280592]
            map.insert(461, &[147462]);     // 461 => [147462]
            map.insert(462, &[147461]);     // 462 => [147461]
            map.insert(463, &[147460]);     // 463 => [147460]
            map.insert(464, &[464]);     // 464 => [464]
            map.insert(465, &[66084]);     // 465 => [66084]
            map.insert(466, &[20768]);     // 466 => [20768]
            map.insert(467, &[266756]);     // 467 => [266756]
            map.insert(468, &[66081]);     // 468 => [66081]
            map.insert(469, &[66080]);     // 469 => [66080]
            map.insert(470, &[266753]);     // 470 => [266753]
            map.insert(471, &[266752]);     // 471 => [266752]
            map.insert(472, &[280580]);     // 472 => [280580]
            map.insert(473, &[147474]);     // 473 => [147474]
            map.insert(474, &[147473]);     // 474 => [147473]
            map.insert(475, &[147472]);     // 475 => [147472]
            map.insert(476, &[280576]);     // 476 => [280576]
            map.insert(477, &[280577]);     // 477 => [280577]
            map.insert(478, &[280578]);     // 478 => [280578]
            map.insert(479, &[147476]);     // 479 => [147476]
            map.insert(480, &[480]);     // 480 => [480]
            map.insert(481, &[66068]);     // 481 => [66068]
            map.insert(482, &[20752]);     // 482 => [20752]
            map.insert(483, &[9228]);     // 483 => [9228]
            map.insert(484, &[66065]);     // 484 => [66065]
            map.insert(485, &[66064]);     // 485 => [66064]
            map.insert(486, &[9225]);     // 486 => [9225]
            map.insert(487, &[9224]);     // 487 => [9224]
            map.insert(488, &[9223]);     // 488 => [9223]
            map.insert(489, &[9222]);     // 489 => [9222]
            map.insert(490, &[9221]);     // 490 => [9221]
            map.insert(491, &[9220]);     // 491 => [9220]
            map.insert(492, &[9219]);     // 492 => [9219]
            map.insert(493, &[9218]);     // 493 => [9218]
            map.insert(494, &[9217]);     // 494 => [9217]
            map.insert(495, &[9216]);     // 495 => [9216]
            map.insert(496, &[66053]);     // 496 => [66053]
            map.insert(497, &[66052]);     // 497 => [66052]
            map.insert(498, &[20736]);     // 498 => [20736]
            map.insert(499, &[20737]);     // 499 => [20737]
            map.insert(500, &[66049]);     // 500 => [66049]
            map.insert(501, &[66048]);     // 501 => [66048]
            map.insert(502, &[66051]);     // 502 => [66051]
            map.insert(503, &[66050]);     // 503 => [66050]
            map.insert(504, &[2817]);     // 504 => [2817]
            map.insert(505, &[2816]);     // 505 => [2816]
            map.insert(506, &[20744]);     // 506 => [20744]
            map.insert(507, &[2818]);     // 507 => [2818]
            map.insert(508, &[66057]);     // 508 => [66057]
            map.insert(509, &[66056]);     // 509 => [66056]
            map.insert(510, &[9233]);     // 510 => [9233]
            map.insert(511, &[9232]);     // 511 => [9232]
            map.insert(512, &[512]);     // 512 => [512]
            map.insert(513, &[513]);     // 513 => [513]
            map.insert(514, &[514]);     // 514 => [514]
            map.insert(515, &[515]);     // 515 => [515]
            map.insert(516, &[516]);     // 516 => [516]
            map.insert(517, &[517]);     // 517 => [517]
            map.insert(518, &[518]);     // 518 => [518]
            map.insert(519, &[519]);     // 519 => [519]
            map.insert(520, &[520]);     // 520 => [520]
            map.insert(521, &[521]);     // 521 => [521]
            map.insert(522, &[522]);     // 522 => [522]
            map.insert(523, &[22528]);     // 523 => [22528]
            map.insert(524, &[524]);     // 524 => [524]
            map.insert(525, &[525]);     // 525 => [525]
            map.insert(526, &[526]);     // 526 => [526]
            map.insert(527, &[22532]);     // 527 => [22532]
            map.insert(528, &[528]);     // 528 => [528]
            map.insert(529, &[529]);     // 529 => [529]
            map.insert(530, &[530]);     // 530 => [530]
            map.insert(531, &[531]);     // 531 => [531]
            map.insert(532, &[532]);     // 532 => [532]
            map.insert(533, &[164864]);     // 533 => [164864]
            map.insert(534, &[534]);     // 534 => [534]
            map.insert(535, &[164866]);     // 535 => [164866]
            map.insert(536, &[536]);     // 536 => [536]
            map.insert(537, &[537]);     // 537 => [537]
            map.insert(538, &[74752]);     // 538 => [74752]
            map.insert(539, &[74753]);     // 539 => [74753]
            map.insert(540, &[540]);     // 540 => [540]
            map.insert(541, &[164872]);     // 541 => [164872]
            map.insert(542, &[74756]);     // 542 => [74756]
            map.insert(543, &[74757]);     // 543 => [74757]
            map.insert(544, &[544]);     // 544 => [544]
            map.insert(545, &[545]);     // 545 => [545]
            map.insert(546, &[546]);     // 546 => [546]
            map.insert(547, &[547]);     // 547 => [547]
            map.insert(548, &[548]);     // 548 => [548]
            map.insert(549, &[278784]);     // 549 => [278784]
            map.insert(550, &[550]);     // 550 => [550]
            map.insert(551, &[278786]);     // 551 => [278786]
            map.insert(552, &[552]);     // 552 => [552]
            map.insert(553, &[553]);     // 553 => [553]
            map.insert(554, &[554]);     // 554 => [554]
            map.insert(555, &[22560]);     // 555 => [22560]
            map.insert(556, &[556]);     // 556 => [556]
            map.insert(557, &[278792]);     // 557 => [278792]
            map.insert(558, &[213008]);     // 558 => [213008]
            map.insert(559, &[213009]);     // 559 => [213009]
            map.insert(560, &[560]);     // 560 => [560]
            map.insert(561, &[57344]);     // 561 => [57344]
            map.insert(562, &[562]);     // 562 => [562]
            map.insert(563, &[57346]);     // 563 => [57346]
            map.insert(564, &[564]);     // 564 => [564]
            map.insert(565, &[57348]);     // 565 => [57348]
            map.insert(566, &[213000]);     // 566 => [213000]
            map.insert(567, &[213001]);     // 567 => [213001]
            map.insert(568, &[2241]);     // 568 => [2241]
            map.insert(569, &[2240]);     // 569 => [2240]
            map.insert(570, &[212996]);     // 570 => [212996]
            map.insert(571, &[2242]);     // 571 => [2242]
            map.insert(572, &[212994]);     // 572 => [212994]
            map.insert(573, &[2244]);     // 573 => [2244]
            map.insert(574, &[212992]);     // 574 => [212992]
            map.insert(575, &[212993]);     // 575 => [212993]
            map.insert(576, &[576]);     // 576 => [576]
            map.insert(577, &[577]);     // 577 => [577]
            map.insert(578, &[578]);     // 578 => [578]
            map.insert(579, &[579]);     // 579 => [579]
            map.insert(580, &[580]);     // 580 => [580]
            map.insert(581, &[581]);     // 581 => [581]
            map.insert(582, &[582]);     // 582 => [582]
            map.insert(583, &[583]);     // 583 => [583]
            map.insert(584, &[584]);     // 584 => [584]
            map.insert(585, &[585]);     // 585 => [585]
            map.insert(586, &[586]);     // 586 => [586]
            map.insert(587, &[22592]);     // 587 => [22592]
            map.insert(588, &[588]);     // 588 => [588]
            map.insert(589, &[589]);     // 589 => [589]
            map.insert(590, &[393376]);     // 590 => [393376]
            map.insert(591, &[393377]);     // 591 => [393377]
            map.insert(592, &[592]);     // 592 => [592]
            map.insert(593, &[593]);     // 593 => [593]
            map.insert(594, &[594]);     // 594 => [594]
            map.insert(595, &[595]);     // 595 => [595]
            map.insert(596, &[596]);     // 596 => [596]
            map.insert(597, &[65952]);     // 597 => [65952]
            map.insert(598, &[266625]);     // 598 => [266625]
            map.insert(599, &[266624]);     // 599 => [266624]
            map.insert(600, &[2209]);     // 600 => [2209]
            map.insert(601, &[2208]);     // 601 => [2208]
            map.insert(602, &[74816]);     // 602 => [74816]
            map.insert(603, &[2210]);     // 603 => [2210]
            map.insert(604, &[2213]);     // 604 => [2213]
            map.insert(605, &[2212]);     // 605 => [2212]
            map.insert(606, &[74820]);     // 606 => [74820]
            map.insert(607, &[2214]);     // 607 => [2214]
            map.insert(608, &[608]);     // 608 => [608]
            map.insert(609, &[609]);     // 609 => [609]
            map.insert(610, &[610]);     // 610 => [610]
            map.insert(611, &[611]);     // 611 => [611]
            map.insert(612, &[612]);     // 612 => [612]
            map.insert(613, &[65936]);     // 613 => [65936]
            map.insert(614, &[393352]);     // 614 => [393352]
            map.insert(615, &[393353]);     // 615 => [393353]
            map.insert(616, &[2193]);     // 616 => [2193]
            map.insert(617, &[2192]);     // 617 => [2192]
            map.insert(618, &[393348]);     // 618 => [393348]
            map.insert(619, &[2194]);     // 619 => [2194]
            map.insert(620, &[393346]);     // 620 => [393346]
            map.insert(621, &[2196]);     // 621 => [2196]
            map.insert(622, &[393344]);     // 622 => [393344]
            map.insert(623, &[393345]);     // 623 => [393345]
            map.insert(624, &[2185]);     // 624 => [2185]
            map.insert(625, &[2184]);     // 625 => [2184]
            map.insert(626, &[21120]);     // 626 => [21120]
            map.insert(627, &[2186]);     // 627 => [2186]
            map.insert(628, &[65921]);     // 628 => [65921]
            map.insert(629, &[65920]);     // 629 => [65920]
            map.insert(630, &[65923]);     // 630 => [65923]
            map.insert(631, &[65922]);     // 631 => [65922]
            map.insert(632, &[2177]);     // 632 => [2177]
            map.insert(633, &[2176]);     // 633 => [2176]
            map.insert(634, &[2179]);     // 634 => [2179]
            map.insert(635, &[2178]);     // 635 => [2178]
            map.insert(636, &[2181]);     // 636 => [2181]
            map.insert(637, &[2180]);     // 637 => [2180]
            map.insert(638, &[393360]);     // 638 => [393360]
            map.insert(639, &[2182]);     // 639 => [2182]
            map.insert(640, &[640]);     // 640 => [640]
            map.insert(641, &[641]);     // 641 => [641]
            map.insert(642, &[642]);     // 642 => [642]
            map.insert(643, &[643]);     // 643 => [643]
            map.insert(644, &[644]);     // 644 => [644]
            map.insert(645, &[645]);     // 645 => [645]
            map.insert(646, &[646]);     // 646 => [646]
            map.insert(647, &[647]);     // 647 => [647]
            map.insert(648, &[648]);     // 648 => [648]
            map.insert(649, &[649]);     // 649 => [649]
            map.insert(650, &[650]);     // 650 => [650]
            map.insert(651, &[22656]);     // 651 => [22656]
            map.insert(652, &[652]);     // 652 => [652]
            map.insert(653, &[653]);     // 653 => [653]
            map.insert(654, &[393312]);     // 654 => [393312]
            map.insert(655, &[393313]);     // 655 => [393313]
            map.insert(656, &[656]);     // 656 => [656]
            map.insert(657, &[657]);     // 657 => [657]
            map.insert(658, &[658]);     // 658 => [658]
            map.insert(659, &[659]);     // 659 => [659]
            map.insert(660, &[660]);     // 660 => [660]
            map.insert(661, &[65888]);     // 661 => [65888]
            map.insert(662, &[266561]);     // 662 => [266561]
            map.insert(663, &[266560]);     // 663 => [266560]
            map.insert(664, &[2145]);     // 664 => [2145]
            map.insert(665, &[2144]);     // 665 => [2144]
            map.insert(666, &[74880]);     // 666 => [74880]
            map.insert(667, &[2146]);     // 667 => [2146]
            map.insert(668, &[2149]);     // 668 => [2149]
            map.insert(669, &[2148]);     // 669 => [2148]
            map.insert(670, &[74884]);     // 670 => [74884]
            map.insert(671, &[2150]);     // 671 => [2150]
            map.insert(672, &[672]);     // 672 => [672]
            map.insert(673, &[673]);     // 673 => [673]
            map.insert(674, &[674]);     // 674 => [674]
            map.insert(675, &[675]);     // 675 => [675]
            map.insert(676, &[676]);     // 676 => [676]
            map.insert(677, &[65872]);     // 677 => [65872]
            map.insert(678, &[393288]);     // 678 => [393288]
            map.insert(679, &[393289]);     // 679 => [393289]
            map.insert(680, &[2129]);     // 680 => [2129]
            map.insert(681, &[2128]);     // 681 => [2128]
            map.insert(682, &[393284]);     // 682 => [393284]
            map.insert(683, &[2130]);     // 683 => [2130]
            map.insert(684, &[393282]);     // 684 => [393282]
            map.insert(685, &[2132]);     // 685 => [2132]
            map.insert(686, &[393280]);     // 686 => [393280]
            map.insert(687, &[393281]);     // 687 => [393281]
            map.insert(688, &[2121]);     // 688 => [2121]
            map.insert(689, &[2120]);     // 689 => [2120]
            map.insert(690, &[21056]);     // 690 => [21056]
            map.insert(691, &[2122]);     // 691 => [2122]
            map.insert(692, &[65857]);     // 692 => [65857]
            map.insert(693, &[65856]);     // 693 => [65856]
            map.insert(694, &[65859]);     // 694 => [65859]
            map.insert(695, &[65858]);     // 695 => [65858]
            map.insert(696, &[2113]);     // 696 => [2113]
            map.insert(697, &[2112]);     // 697 => [2112]
            map.insert(698, &[2115]);     // 698 => [2115]
            map.insert(699, &[2114]);     // 699 => [2114]
            map.insert(700, &[2117]);     // 700 => [2117]
            map.insert(701, &[2116]);     // 701 => [2116]
            map.insert(702, &[393296]);     // 702 => [393296]
            map.insert(703, &[2118]);     // 703 => [2118]
            map.insert(704, &[704]);     // 704 => [704]
            map.insert(705, &[705]);     // 705 => [705]
            map.insert(706, &[45057]);     // 706 => [45057]
            map.insert(707, &[45056]);     // 707 => [45056]
            map.insert(708, &[708]);     // 708 => [708]
            map.insert(709, &[65840]);     // 709 => [65840]
            map.insert(710, &[393256]);     // 710 => [393256]
            map.insert(711, &[45060]);     // 711 => [45060]
            map.insert(712, &[2097]);     // 712 => [2097]
            map.insert(713, &[2096]);     // 713 => [2096]
            map.insert(714, &[393252]);     // 714 => [393252]
            map.insert(715, &[2098]);     // 715 => [2098]
            map.insert(716, &[200704]);     // 716 => [200704]
            map.insert(717, &[200705]);     // 717 => [200705]
            map.insert(718, &[393248]);     // 718 => [393248]
            map.insert(719, &[393249]);     // 719 => [393249]
            map.insert(720, &[2089]);     // 720 => [2089]
            map.insert(721, &[2088]);     // 721 => [2088]
            map.insert(722, &[21024]);     // 722 => [21024]
            map.insert(723, &[2090]);     // 723 => [2090]
            map.insert(724, &[65825]);     // 724 => [65825]
            map.insert(725, &[65824]);     // 725 => [65824]
            map.insert(726, &[266497]);     // 726 => [266497]
            map.insert(727, &[266496]);     // 727 => [266496]
            map.insert(728, &[2081]);     // 728 => [2081]
            map.insert(729, &[2080]);     // 729 => [2080]
            map.insert(730, &[2083]);     // 730 => [2083]
            map.insert(731, &[2082]);     // 731 => [2082]
            map.insert(732, &[2085]);     // 732 => [2085]
            map.insert(733, &[2084]);     // 733 => [2084]
            map.insert(734, &[393264]);     // 734 => [393264]
            map.insert(735, &[2086]);     // 735 => [2086]
            map.insert(736, &[2073]);     // 736 => [2073]
            map.insert(737, &[2072]);     // 737 => [2072]
            map.insert(738, &[393228]);     // 738 => [393228]
            map.insert(739, &[2074]);     // 739 => [2074]
            map.insert(740, &[65809]);     // 740 => [65809]
            map.insert(741, &[65808]);     // 741 => [65808]
            map.insert(742, &[393224]);     // 742 => [393224]
            map.insert(743, &[393225]);     // 743 => [393225]
            map.insert(744, &[2065]);     // 744 => [2065]
            map.insert(745, &[2064]);     // 745 => [2064]
            map.insert(746, &[393220]);     // 746 => [393220]
            map.insert(747, &[2066]);     // 747 => [2066]
            map.insert(748, &[393218]);     // 748 => [393218]
            map.insert(749, &[2068]);     // 749 => [2068]
            map.insert(750, &[393216]);     // 750 => [393216]
            map.insert(751, &[393217]);     // 751 => [393217]
            map.insert(752, &[2057]);     // 752 => [2057]
            map.insert(753, &[2056]);     // 753 => [2056]
            map.insert(754, &[20992]);     // 754 => [20992]
            map.insert(755, &[2058]);     // 755 => [2058]
            map.insert(756, &[65793]);     // 756 => [65793]
            map.insert(757, &[65792]);     // 757 => [65792]
            map.insert(758, &[65795]);     // 758 => [65795]
            map.insert(759, &[65794]);     // 759 => [65794]
            map.insert(760, &[2049]);     // 760 => [2049]
            map.insert(761, &[2048]);     // 761 => [2048]
            map.insert(762, &[2051]);     // 762 => [2051]
            map.insert(763, &[2050]);     // 763 => [2050]
            map.insert(764, &[2053]);     // 764 => [2053]
            map.insert(765, &[2052]);     // 765 => [2052]
            map.insert(766, &[393232]);     // 766 => [393232]
            map.insert(767, &[2054]);     // 767 => [2054]
            map.insert(768, &[768]);     // 768 => [768]
            map.insert(769, &[769]);     // 769 => [769]
            map.insert(770, &[770]);     // 770 => [770]
            map.insert(771, &[771]);     // 771 => [771]
            map.insert(772, &[772]);     // 772 => [772]
            map.insert(773, &[278560]);     // 773 => [278560]
            map.insert(774, &[86017]);     // 774 => [86017]
            map.insert(775, &[86016]);     // 775 => [86016]
            map.insert(776, &[776]);     // 776 => [776]
            map.insert(777, &[777]);     // 777 => [777]
            map.insert(778, &[778]);     // 778 => [778]
            map.insert(779, &[22784]);     // 779 => [22784]
            map.insert(780, &[68096]);     // 780 => [68096]
            map.insert(781, &[68097]);     // 781 => [68097]
            map.insert(782, &[68098]);     // 782 => [68098]
            map.insert(783, &[86024]);     // 783 => [86024]
            map.insert(784, &[784]);     // 784 => [784]
            map.insert(785, &[785]);     // 785 => [785]
            map.insert(786, &[786]);     // 786 => [786]
            map.insert(787, &[787]);     // 787 => [787]
            map.insert(788, &[11266]);     // 788 => [11266]
            map.insert(789, &[278576]);     // 789 => [278576]
            map.insert(790, &[11264]);     // 790 => [11264]
            map.insert(791, &[11265]);     // 791 => [11265]
            map.insert(792, &[792]);     // 792 => [792]
            map.insert(793, &[135712]);     // 793 => [135712]
            map.insert(794, &[75008]);     // 794 => [75008]
            map.insert(795, &[459264]);     // 795 => [459264]
            map.insert(796, &[68112]);     // 796 => [68112]
            map.insert(797, &[68113]);     // 797 => [68113]
            map.insert(798, &[11272]);     // 798 => [11272]
            map.insert(799, &[11273]);     // 799 => [11273]
            map.insert(800, &[800]);     // 800 => [800]
            map.insert(801, &[278532]);     // 801 => [278532]
            map.insert(802, &[802]);     // 802 => [802]
            map.insert(803, &[278534]);     // 803 => [278534]
            map.insert(804, &[278529]);     // 804 => [278529]
            map.insert(805, &[278528]);     // 805 => [278528]
            map.insert(806, &[278531]);     // 806 => [278531]
            map.insert(807, &[278530]);     // 807 => [278530]
            map.insert(808, &[37892]);     // 808 => [37892]
            map.insert(809, &[278540]);     // 809 => [278540]
            map.insert(810, &[37894]);     // 810 => [37894]
            map.insert(811, &[278542]);     // 811 => [278542]
            map.insert(812, &[37888]);     // 812 => [37888]
            map.insert(813, &[278536]);     // 813 => [278536]
            map.insert(814, &[37890]);     // 814 => [37890]
            map.insert(815, &[278538]);     // 815 => [278538]
            map.insert(816, &[149506]);     // 816 => [149506]
            map.insert(817, &[278548]);     // 817 => [278548]
            map.insert(818, &[149504]);     // 818 => [149504]
            map.insert(819, &[149505]);     // 819 => [149505]
            map.insert(820, &[278545]);     // 820 => [278545]
            map.insert(821, &[278544]);     // 821 => [278544]
            map.insert(822, &[149508]);     // 822 => [149508]
            map.insert(823, &[278546]);     // 823 => [278546]
            map.insert(824, &[135681]);     // 824 => [135681]
            map.insert(825, &[135680]);     // 825 => [135680]
            map.insert(826, &[149512]);     // 826 => [149512]
            map.insert(827, &[135682]);     // 827 => [135682]
            map.insert(828, &[37904]);     // 828 => [37904]
            map.insert(829, &[135684]);     // 829 => [135684]
            map.insert(830, &[213248]);     // 830 => [213248]
            map.insert(831, &[213249]);     // 831 => [213249]
            map.insert(832, &[832]);     // 832 => [832]
            map.insert(833, &[833]);     // 833 => [833]
            map.insert(834, &[834]);     // 834 => [834]
            map.insert(835, &[835]);     // 835 => [835]
            map.insert(836, &[836]);     // 836 => [836]
            map.insert(837, &[65712]);     // 837 => [65712]
            map.insert(838, &[266385]);     // 838 => [266385]
            map.insert(839, &[266384]);     // 839 => [266384]
            map.insert(840, &[840]);     // 840 => [840]
            map.insert(841, &[841]);     // 841 => [841]
            map.insert(842, &[148097]);     // 842 => [148097]
            map.insert(843, &[148096]);     // 843 => [148096]
            map.insert(844, &[68160]);     // 844 => [68160]
            map.insert(845, &[68161]);     // 845 => [68161]
            map.insert(846, &[68162]);     // 846 => [68162]
            map.insert(847, &[148100]);     // 847 => [148100]
            map.insert(848, &[848]);     // 848 => [848]
            map.insert(849, &[65700]);     // 849 => [65700]
            map.insert(850, &[266373]);     // 850 => [266373]
            map.insert(851, &[266372]);     // 851 => [266372]
            map.insert(852, &[65697]);     // 852 => [65697]
            map.insert(853, &[65696]);     // 853 => [65696]
            map.insert(854, &[266369]);     // 854 => [266369]
            map.insert(855, &[266368]);     // 855 => [266368]
            map.insert(856, &[2465]);     // 856 => [2465]
            map.insert(857, &[2464]);     // 857 => [2464]
            map.insert(858, &[50308]);     // 858 => [50308]
            map.insert(859, &[2466]);     // 859 => [2466]
            map.insert(860, &[65705]);     // 860 => [65705]
            map.insert(861, &[65704]);     // 861 => [65704]
            map.insert(862, &[50304]);     // 862 => [50304]
            map.insert(863, &[266376]);     // 863 => [266376]
            map.insert(864, &[864]);     // 864 => [864]
            map.insert(865, &[65684]);     // 865 => [65684]
            map.insert(866, &[866]);     // 866 => [866]
            map.insert(867, &[65686]);     // 867 => [65686]
            map.insert(868, &[65681]);     // 868 => [65681]
            map.insert(869, &[65680]);     // 869 => [65680]
            map.insert(870, &[65683]);     // 870 => [65683]
            map.insert(871, &[65682]);     // 871 => [65682]
            map.insert(872, &[2449]);     // 872 => [2449]
            map.insert(873, &[2448]);     // 873 => [2448]
            map.insert(874, &[393604]);     // 874 => [393604]
            map.insert(875, &[2450]);     // 875 => [2450]
            map.insert(876, &[37952]);     // 876 => [37952]
            map.insert(877, &[65688]);     // 877 => [65688]
            map.insert(878, &[393600]);     // 878 => [393600]
            map.insert(879, &[9856]);     // 879 => [9856]
            map.insert(880, &[65669]);     // 880 => [65669]
            map.insert(881, &[65668]);     // 881 => [65668]
            map.insert(882, &[149568]);     // 882 => [149568]
            map.insert(883, &[65670]);     // 883 => [65670]
            map.insert(884, &[65665]);     // 884 => [65665]
            map.insert(885, &[65664]);     // 885 => [65664]
            map.insert(886, &[65667]);     // 886 => [65667]
            map.insert(887, &[65666]);     // 887 => [65666]
            map.insert(888, &[2433]);     // 888 => [2433]
            map.insert(889, &[2432]);     // 889 => [2432]
            map.insert(890, &[172160]);     // 890 => [172160]
            map.insert(891, &[2434]);     // 891 => [2434]
            map.insert(892, &[65673]);     // 892 => [65673]
            map.insert(893, &[65672]);     // 893 => [65672]
            map.insert(894, &[65675]);     // 894 => [65675]
            map.insert(895, &[65674]);     // 895 => [65674]
            map.insert(896, &[896]);     // 896 => [896]
            map.insert(897, &[897]);     // 897 => [897]
            map.insert(898, &[898]);     // 898 => [898]
            map.insert(899, &[899]);     // 899 => [899]
            map.insert(900, &[900]);     // 900 => [900]
            map.insert(901, &[65648]);     // 901 => [65648]
            map.insert(902, &[266321]);     // 902 => [266321]
            map.insert(903, &[266320]);     // 903 => [266320]
            map.insert(904, &[904]);     // 904 => [904]
            map.insert(905, &[905]);     // 905 => [905]
            map.insert(906, &[148033]);     // 906 => [148033]
            map.insert(907, &[148032]);     // 907 => [148032]
            map.insert(908, &[68224]);     // 908 => [68224]
            map.insert(909, &[68225]);     // 909 => [68225]
            map.insert(910, &[68226]);     // 910 => [68226]
            map.insert(911, &[148036]);     // 911 => [148036]
            map.insert(912, &[912]);     // 912 => [912]
            map.insert(913, &[65636]);     // 913 => [65636]
            map.insert(914, &[266309]);     // 914 => [266309]
            map.insert(915, &[266308]);     // 915 => [266308]
            map.insert(916, &[65633]);     // 916 => [65633]
            map.insert(917, &[65632]);     // 917 => [65632]
            map.insert(918, &[266305]);     // 918 => [266305]
            map.insert(919, &[266304]);     // 919 => [266304]
            map.insert(920, &[2401]);     // 920 => [2401]
            map.insert(921, &[2400]);     // 921 => [2400]
            map.insert(922, &[50244]);     // 922 => [50244]
            map.insert(923, &[2402]);     // 923 => [2402]
            map.insert(924, &[65641]);     // 924 => [65641]
            map.insert(925, &[65640]);     // 925 => [65640]
            map.insert(926, &[50240]);     // 926 => [50240]
            map.insert(927, &[266312]);     // 927 => [266312]
            map.insert(928, &[928]);     // 928 => [928]
            map.insert(929, &[65620]);     // 929 => [65620]
            map.insert(930, &[930]);     // 930 => [930]
            map.insert(931, &[65622]);     // 931 => [65622]
            map.insert(932, &[65617]);     // 932 => [65617]
            map.insert(933, &[65616]);     // 933 => [65616]
            map.insert(934, &[65619]);     // 934 => [65619]
            map.insert(935, &[65618]);     // 935 => [65618]
            map.insert(936, &[2385]);     // 936 => [2385]
            map.insert(937, &[2384]);     // 937 => [2384]
            map.insert(938, &[393540]);     // 938 => [393540]
            map.insert(939, &[2386]);     // 939 => [2386]
            map.insert(940, &[38016]);     // 940 => [38016]
            map.insert(941, &[65624]);     // 941 => [65624]
            map.insert(942, &[393536]);     // 942 => [393536]
            map.insert(943, &[9792]);     // 943 => [9792]
            map.insert(944, &[65605]);     // 944 => [65605]
            map.insert(945, &[65604]);     // 945 => [65604]
            map.insert(946, &[149632]);     // 946 => [149632]
            map.insert(947, &[65606]);     // 947 => [65606]
            map.insert(948, &[65601]);     // 948 => [65601]
            map.insert(949, &[65600]);     // 949 => [65600]
            map.insert(950, &[65603]);     // 950 => [65603]
            map.insert(951, &[65602]);     // 951 => [65602]
            map.insert(952, &[2369]);     // 952 => [2369]
            map.insert(953, &[2368]);     // 953 => [2368]
            map.insert(954, &[172096]);     // 954 => [172096]
            map.insert(955, &[2370]);     // 955 => [2370]
            map.insert(956, &[65609]);     // 956 => [65609]
            map.insert(957, &[65608]);     // 957 => [65608]
            map.insert(958, &[65611]);     // 958 => [65611]
            map.insert(959, &[65610]);     // 959 => [65610]
            map.insert(960, &[137216]);     // 960 => [137216]
            map.insert(961, &[137217]);     // 961 => [137217]
            map.insert(962, &[137218]);     // 962 => [137218]
            map.insert(963, &[266260]);     // 963 => [266260]
            map.insert(964, &[65585]);     // 964 => [65585]
            map.insert(965, &[65584]);     // 965 => [65584]
            map.insert(966, &[266257]);     // 966 => [266257]
            map.insert(967, &[266256]);     // 967 => [266256]
            map.insert(968, &[137224]);     // 968 => [137224]
            map.insert(969, &[147970]);     // 969 => [147970]
            map.insert(970, &[147969]);     // 970 => [147969]
            map.insert(971, &[147968]);     // 971 => [147968]
            map.insert(972, &[200960]);     // 972 => [200960]
            map.insert(973, &[65592]);     // 973 => [65592]
            map.insert(974, &[50192]);     // 974 => [50192]
            map.insert(975, &[147972]);     // 975 => [147972]
            map.insert(976, &[65573]);     // 976 => [65573]
            map.insert(977, &[65572]);     // 977 => [65572]
            map.insert(978, &[266245]);     // 978 => [266245]
            map.insert(979, &[266244]);     // 979 => [266244]
            map.insert(980, &[65569]);     // 980 => [65569]
            map.insert(981, &[65568]);     // 981 => [65568]
            map.insert(982, &[266241]);     // 982 => [266241]
            map.insert(983, &[266240]);     // 983 => [266240]
            map.insert(984, &[2337]);     // 984 => [2337]
            map.insert(985, &[2336]);     // 985 => [2336]
            map.insert(986, &[50180]);     // 986 => [50180]
            map.insert(987, &[2338]);     // 987 => [2338]
            map.insert(988, &[65577]);     // 988 => [65577]
            map.insert(989, &[65576]);     // 989 => [65576]
            map.insert(990, &[50176]);     // 990 => [50176]
            map.insert(991, &[266248]);     // 991 => [266248]
            map.insert(992, &[65557]);     // 992 => [65557]
            map.insert(993, &[65556]);     // 993 => [65556]
            map.insert(994, &[460800]);     // 994 => [460800]
            map.insert(995, &[65558]);     // 995 => [65558]
            map.insert(996, &[65553]);     // 996 => [65553]
            map.insert(997, &[65552]);     // 997 => [65552]
            map.insert(998, &[65555]);     // 998 => [65555]
            map.insert(999, &[65554]);     // 999 => [65554]
            map.insert(1000, &[2321]);     // 1000 => [2321]
            map.insert(1001, &[2320]);     // 1001 => [2320]
            map.insert(1002, &[393476]);     // 1002 => [393476]
            map.insert(1003, &[2322]);     // 1003 => [2322]
            map.insert(1004, &[65561]);     // 1004 => [65561]
            map.insert(1005, &[65560]);     // 1005 => [65560]
            map.insert(1006, &[393472]);     // 1006 => [393472]
            map.insert(1007, &[9728]);     // 1007 => [9728]
            map.insert(1008, &[65541]);     // 1008 => [65541]
            map.insert(1009, &[65540]);     // 1009 => [65540]
            map.insert(1010, &[65543]);     // 1010 => [65543]
            map.insert(1011, &[65542]);     // 1011 => [65542]
            map.insert(1012, &[65537]);     // 1012 => [65537]
            map.insert(1013, &[65536]);     // 1013 => [65536]
            map.insert(1014, &[65539]);     // 1014 => [65539]
            map.insert(1015, &[65538]);     // 1015 => [65538]
            map.insert(1016, &[2305]);     // 1016 => [2305]
            map.insert(1017, &[2304]);     // 1017 => [2304]
            map.insert(1018, &[172032]);     // 1018 => [172032]
            map.insert(1019, &[2306]);     // 1019 => [2306]
            map.insert(1020, &[65545]);     // 1020 => [65545]
            map.insert(1021, &[65544]);     // 1021 => [65544]
            map.insert(1022, &[65547]);     // 1022 => [65547]
            map.insert(1023, &[65546]);     // 1023 => [65546]
            map.insert(1024, &[1024]);     // 1024 => [1024]
            map.insert(1025, &[1025]);     // 1025 => [1025]
            map.insert(1026, &[1026]);     // 1026 => [1026]
            map.insert(1027, &[1027]);     // 1027 => [1027]
            map.insert(1028, &[1028]);     // 1028 => [1028]
            map.insert(1029, &[1029]);     // 1029 => [1029]
            map.insert(1030, &[1030]);     // 1030 => [1030]
            map.insert(1031, &[1031]);     // 1031 => [1031]
            map.insert(1032, &[1032]);     // 1032 => [1032]
            map.insert(1033, &[1033]);     // 1033 => [1033]
            map.insert(1034, &[1034]);     // 1034 => [1034]
            map.insert(1035, &[1035]);     // 1035 => [1035]
            map.insert(1036, &[1036]);     // 1036 => [1036]
            map.insert(1037, &[1037]);     // 1037 => [1037]
            map.insert(1038, &[1038]);     // 1038 => [1038]
            map.insert(1039, &[1039]);     // 1039 => [1039]
            map.insert(1040, &[1040]);     // 1040 => [1040]
            map.insert(1041, &[1041]);     // 1041 => [1041]
            map.insert(1042, &[1042]);     // 1042 => [1042]
            map.insert(1043, &[1043]);     // 1043 => [1043]
            map.insert(1044, &[1044]);     // 1044 => [1044]
            map.insert(1045, &[164352]);     // 1045 => [164352]
            map.insert(1046, &[1046]);     // 1046 => [1046]
            map.insert(1047, &[164354]);     // 1047 => [164354]
            map.insert(1048, &[1048]);     // 1048 => [1048]
            map.insert(1049, &[1049]);     // 1049 => [1049]
            map.insert(1050, &[74240]);     // 1050 => [74240]
            map.insert(1051, &[74241]);     // 1051 => [74241]
            map.insert(1052, &[1052]);     // 1052 => [1052]
            map.insert(1053, &[164360]);     // 1053 => [164360]
            map.insert(1054, &[74244]);     // 1054 => [74244]
            map.insert(1055, &[74245]);     // 1055 => [74245]
            map.insert(1056, &[1056]);     // 1056 => [1056]
            map.insert(1057, &[1057]);     // 1057 => [1057]
            map.insert(1058, &[1058]);     // 1058 => [1058]
            map.insert(1059, &[1059]);     // 1059 => [1059]
            map.insert(1060, &[1060]);     // 1060 => [1060]
            map.insert(1061, &[1061]);     // 1061 => [1061]
            map.insert(1062, &[1062]);     // 1062 => [1062]
            map.insert(1063, &[51456]);     // 1063 => [51456]
            map.insert(1064, &[1064]);     // 1064 => [1064]
            map.insert(1065, &[1065]);     // 1065 => [1065]
            map.insert(1066, &[114689]);     // 1066 => [114689]
            map.insert(1067, &[114688]);     // 1067 => [114688]
            map.insert(1068, &[1068]);     // 1068 => [1068]
            map.insert(1069, &[1069]);     // 1069 => [1069]
            map.insert(1070, &[114693]);     // 1070 => [114693]
            map.insert(1071, &[114692]);     // 1071 => [114692]
            map.insert(1072, &[1072]);     // 1072 => [1072]
            map.insert(1073, &[1073]);     // 1073 => [1073]
            map.insert(1074, &[1074]);     // 1074 => [1074]
            map.insert(1075, &[288768]);     // 1075 => [288768]
            map.insert(1076, &[1076]);     // 1076 => [1076]
            map.insert(1077, &[164384]);     // 1077 => [164384]
            map.insert(1078, &[1078]);     // 1078 => [1078]
            map.insert(1079, &[164386]);     // 1079 => [164386]
            map.insert(1080, &[1080]);     // 1080 => [1080]
            map.insert(1081, &[136448]);     // 1081 => [136448]
            map.insert(1082, &[74272]);     // 1082 => [74272]
            map.insert(1083, &[114704]);     // 1083 => [114704]
            map.insert(1084, &[1084]);     // 1084 => [1084]
            map.insert(1085, &[136452]);     // 1085 => [136452]
            map.insert(1086, &[74276]);     // 1086 => [74276]
            map.insert(1087, &[114708]);     // 1087 => [114708]
            map.insert(1088, &[1088]);     // 1088 => [1088]
            map.insert(1089, &[1089]);     // 1089 => [1089]
            map.insert(1090, &[1090]);     // 1090 => [1090]
            map.insert(1091, &[1091]);     // 1091 => [1091]
            map.insert(1092, &[1092]);     // 1092 => [1092]
            map.insert(1093, &[1093]);     // 1093 => [1093]
            map.insert(1094, &[1094]);     // 1094 => [1094]
            map.insert(1095, &[1095]);     // 1095 => [1095]
            map.insert(1096, &[1096]);     // 1096 => [1096]
            map.insert(1097, &[1097]);     // 1097 => [1097]
            map.insert(1098, &[1098]);     // 1098 => [1098]
            map.insert(1099, &[1099]);     // 1099 => [1099]
            map.insert(1100, &[1100]);     // 1100 => [1100]
            map.insert(1101, &[1101]);     // 1101 => [1101]
            map.insert(1102, &[8609]);     // 1102 => [8609]
            map.insert(1103, &[8608]);     // 1103 => [8608]
            map.insert(1104, &[1104]);     // 1104 => [1104]
            map.insert(1105, &[1105]);     // 1105 => [1105]
            map.insert(1106, &[1106]);     // 1106 => [1106]
            map.insert(1107, &[1107]);     // 1107 => [1107]
            map.insert(1108, &[1108]);     // 1108 => [1108]
            map.insert(1109, &[164416]);     // 1109 => [164416]
            map.insert(1110, &[143488]);     // 1110 => [143488]
            map.insert(1111, &[143489]);     // 1111 => [143489]
            map.insert(1112, &[1112]);     // 1112 => [1112]
            map.insert(1113, &[102528]);     // 1113 => [102528]
            map.insert(1114, &[74304]);     // 1114 => [74304]
            map.insert(1115, &[295072]);     // 1115 => [295072]
            map.insert(1116, &[1116]);     // 1116 => [1116]
            map.insert(1117, &[102532]);     // 1117 => [102532]
            map.insert(1118, &[74308]);     // 1118 => [74308]
            map.insert(1119, &[295076]);     // 1119 => [295076]
            map.insert(1120, &[1120]);     // 1120 => [1120]
            map.insert(1121, &[1121]);     // 1121 => [1121]
            map.insert(1122, &[1122]);     // 1122 => [1122]
            map.insert(1123, &[75904]);     // 1123 => [75904]
            map.insert(1124, &[1124]);     // 1124 => [1124]
            map.insert(1125, &[1125]);     // 1125 => [1125]
            map.insert(1126, &[8585]);     // 1126 => [8585]
            map.insert(1127, &[8584]);     // 1127 => [8584]
            map.insert(1128, &[1128]);     // 1128 => [1128]
            map.insert(1129, &[1129]);     // 1129 => [1129]
            map.insert(1130, &[8581]);     // 1130 => [8581]
            map.insert(1131, &[8580]);     // 1131 => [8580]
            map.insert(1132, &[166016]);     // 1132 => [166016]
            map.insert(1133, &[8578]);     // 1133 => [8578]
            map.insert(1134, &[8577]);     // 1134 => [8577]
            map.insert(1135, &[8576]);     // 1135 => [8576]
            map.insert(1136, &[1136]);     // 1136 => [1136]
            map.insert(1137, &[1137]);     // 1137 => [1137]
            map.insert(1138, &[21632]);     // 1138 => [21632]
            map.insert(1139, &[295048]);     // 1139 => [295048]
            map.insert(1140, &[1140]);     // 1140 => [1140]
            map.insert(1141, &[164448]);     // 1141 => [164448]
            map.insert(1142, &[21636]);     // 1142 => [21636]
            map.insert(1143, &[295052]);     // 1143 => [295052]
            map.insert(1144, &[295043]);     // 1144 => [295043]
            map.insert(1145, &[295042]);     // 1145 => [295042]
            map.insert(1146, &[295041]);     // 1146 => [295041]
            map.insert(1147, &[295040]);     // 1147 => [295040]
            map.insert(1148, &[166032]);     // 1148 => [166032]
            map.insert(1149, &[295046]);     // 1149 => [295046]
            map.insert(1150, &[295045]);     // 1150 => [295045]
            map.insert(1151, &[295044]);     // 1151 => [295044]
            map.insert(1152, &[1152]);     // 1152 => [1152]
            map.insert(1153, &[1153]);     // 1153 => [1153]
            map.insert(1154, &[1154]);     // 1154 => [1154]
            map.insert(1155, &[1155]);     // 1155 => [1155]
            map.insert(1156, &[1156]);     // 1156 => [1156]
            map.insert(1157, &[1157]);     // 1157 => [1157]
            map.insert(1158, &[1158]);     // 1158 => [1158]
            map.insert(1159, &[1159]);     // 1159 => [1159]
            map.insert(1160, &[1160]);     // 1160 => [1160]
            map.insert(1161, &[1161]);     // 1161 => [1161]
            map.insert(1162, &[1162]);     // 1162 => [1162]
            map.insert(1163, &[1163]);     // 1163 => [1163]
            map.insert(1164, &[1164]);     // 1164 => [1164]
            map.insert(1165, &[1165]);     // 1165 => [1165]
            map.insert(1166, &[8545]);     // 1166 => [8545]
            map.insert(1167, &[8544]);     // 1167 => [8544]
            map.insert(1168, &[1168]);     // 1168 => [1168]
            map.insert(1169, &[1169]);     // 1169 => [1169]
            map.insert(1170, &[1170]);     // 1170 => [1170]
            map.insert(1171, &[1171]);     // 1171 => [1171]
            map.insert(1172, &[1172]);     // 1172 => [1172]
            map.insert(1173, &[164480]);     // 1173 => [164480]
            map.insert(1174, &[143424]);     // 1174 => [143424]
            map.insert(1175, &[143425]);     // 1175 => [143425]
            map.insert(1176, &[1176]);     // 1176 => [1176]
            map.insert(1177, &[102464]);     // 1177 => [102464]
            map.insert(1178, &[74368]);     // 1178 => [74368]
            map.insert(1179, &[295008]);     // 1179 => [295008]
            map.insert(1180, &[1180]);     // 1180 => [1180]
            map.insert(1181, &[102468]);     // 1181 => [102468]
            map.insert(1182, &[74372]);     // 1182 => [74372]
            map.insert(1183, &[295012]);     // 1183 => [295012]
            map.insert(1184, &[1184]);     // 1184 => [1184]
            map.insert(1185, &[1185]);     // 1185 => [1185]
            map.insert(1186, &[1186]);     // 1186 => [1186]
            map.insert(1187, &[75840]);     // 1187 => [75840]
            map.insert(1188, &[1188]);     // 1188 => [1188]
            map.insert(1189, &[1189]);     // 1189 => [1189]
            map.insert(1190, &[8521]);     // 1190 => [8521]
            map.insert(1191, &[8520]);     // 1191 => [8520]
            map.insert(1192, &[1192]);     // 1192 => [1192]
            map.insert(1193, &[1193]);     // 1193 => [1193]
            map.insert(1194, &[8517]);     // 1194 => [8517]
            map.insert(1195, &[8516]);     // 1195 => [8516]
            map.insert(1196, &[165952]);     // 1196 => [165952]
            map.insert(1197, &[8514]);     // 1197 => [8514]
            map.insert(1198, &[8513]);     // 1198 => [8513]
            map.insert(1199, &[8512]);     // 1199 => [8512]
            map.insert(1200, &[1200]);     // 1200 => [1200]
            map.insert(1201, &[1201]);     // 1201 => [1201]
            map.insert(1202, &[21568]);     // 1202 => [21568]
            map.insert(1203, &[294984]);     // 1203 => [294984]
            map.insert(1204, &[1204]);     // 1204 => [1204]
            map.insert(1205, &[164512]);     // 1205 => [164512]
            map.insert(1206, &[21572]);     // 1206 => [21572]
            map.insert(1207, &[294988]);     // 1207 => [294988]
            map.insert(1208, &[294979]);     // 1208 => [294979]
            map.insert(1209, &[294978]);     // 1209 => [294978]
            map.insert(1210, &[294977]);     // 1210 => [294977]
            map.insert(1211, &[294976]);     // 1211 => [294976]
            map.insert(1212, &[165968]);     // 1212 => [165968]
            map.insert(1213, &[294982]);     // 1213 => [294982]
            map.insert(1214, &[294981]);     // 1214 => [294981]
            map.insert(1215, &[294980]);     // 1215 => [294980]
            map.insert(1216, &[1216]);     // 1216 => [1216]
            map.insert(1217, &[1217]);     // 1217 => [1217]
            map.insert(1218, &[1218]);     // 1218 => [1218]
            map.insert(1219, &[75808]);     // 1219 => [75808]
            map.insert(1220, &[1220]);     // 1220 => [1220]
            map.insert(1221, &[1221]);     // 1221 => [1221]
            map.insert(1222, &[143376]);     // 1222 => [143376]
            map.insert(1223, &[8488]);     // 1223 => [8488]
            map.insert(1224, &[1224]);     // 1224 => [1224]
            map.insert(1225, &[102416]);     // 1225 => [102416]
            map.insert(1226, &[287232]);     // 1226 => [287232]
            map.insert(1227, &[8484]);     // 1227 => [8484]
            map.insert(1228, &[165920]);     // 1228 => [165920]
            map.insert(1229, &[8482]);     // 1229 => [8482]
            map.insert(1230, &[8481]);     // 1230 => [8481]
            map.insert(1231, &[8480]);     // 1231 => [8480]
            map.insert(1232, &[1232]);     // 1232 => [1232]
            map.insert(1233, &[102408]);     // 1233 => [102408]
            map.insert(1234, &[143364]);     // 1234 => [143364]
            map.insert(1235, &[294952]);     // 1235 => [294952]
            map.insert(1236, &[143362]);     // 1236 => [143362]
            map.insert(1237, &[39168]);     // 1237 => [39168]
            map.insert(1238, &[143360]);     // 1238 => [143360]
            map.insert(1239, &[143361]);     // 1239 => [143361]
            map.insert(1240, &[102401]);     // 1240 => [102401]
            map.insert(1241, &[102400]);     // 1241 => [102400]
            map.insert(1242, &[294945]);     // 1242 => [294945]
            map.insert(1243, &[294944]);     // 1243 => [294944]
            map.insert(1244, &[102405]);     // 1244 => [102405]
            map.insert(1245, &[102404]);     // 1245 => [102404]
            map.insert(1246, &[143368]);     // 1246 => [143368]
            map.insert(1247, &[294948]);     // 1247 => [294948]
            map.insert(1248, &[1248]);     // 1248 => [1248]
            map.insert(1249, &[75778]);     // 1249 => [75778]
            map.insert(1250, &[75777]);     // 1250 => [75777]
            map.insert(1251, &[75776]);     // 1251 => [75776]
            map.insert(1252, &[165896]);     // 1252 => [165896]
            map.insert(1253, &[8458]);     // 1253 => [8458]
            map.insert(1254, &[8457]);     // 1254 => [8457]
            map.insert(1255, &[8456]);     // 1255 => [8456]
            map.insert(1256, &[165892]);     // 1256 => [165892]
            map.insert(1257, &[8454]);     // 1257 => [8454]
            map.insert(1258, &[8453]);     // 1258 => [8453]
            map.insert(1259, &[8452]);     // 1259 => [8452]
            map.insert(1260, &[165888]);     // 1260 => [165888]
            map.insert(1261, &[8450]);     // 1261 => [8450]
            map.insert(1262, &[8449]);     // 1262 => [8449]
            map.insert(1263, &[8448]);     // 1263 => [8448]
            map.insert(1264, &[21506]);     // 1264 => [21506]
            map.insert(1265, &[294922]);     // 1265 => [294922]
            map.insert(1266, &[21504]);     // 1266 => [21504]
            map.insert(1267, &[294920]);     // 1267 => [294920]
            map.insert(1268, &[466944]);     // 1268 => [466944]
            map.insert(1269, &[67328]);     // 1269 => [67328]
            map.insert(1270, &[21508]);     // 1270 => [21508]
            map.insert(1271, &[294924]);     // 1271 => [294924]
            map.insert(1272, &[294915]);     // 1272 => [294915]
            map.insert(1273, &[294914]);     // 1273 => [294914]
            map.insert(1274, &[294913]);     // 1274 => [294913]
            map.insert(1275, &[294912]);     // 1275 => [294912]
            map.insert(1276, &[165904]);     // 1276 => [165904]
            map.insert(1277, &[294918]);     // 1277 => [294918]
            map.insert(1278, &[294917]);     // 1278 => [294917]
            map.insert(1279, &[294916]);     // 1279 => [294916]
            map.insert(1280, &[1280]);     // 1280 => [1280]
            map.insert(1281, &[1281]);     // 1281 => [1281]
            map.insert(1282, &[1282]);     // 1282 => [1282]
            map.insert(1283, &[1283]);     // 1283 => [1283]
            map.insert(1284, &[1284]);     // 1284 => [1284]
            map.insert(1285, &[1285]);     // 1285 => [1285]
            map.insert(1286, &[1286]);     // 1286 => [1286]
            map.insert(1287, &[51232]);     // 1287 => [51232]
            map.insert(1288, &[1288]);     // 1288 => [1288]
            map.insert(1289, &[1289]);     // 1289 => [1289]
            map.insert(1290, &[1290]);     // 1290 => [1290]
            map.insert(1291, &[1291]);     // 1291 => [1291]
            map.insert(1292, &[68608]);     // 1292 => [68608]
            map.insert(1293, &[68609]);     // 1293 => [68609]
            map.insert(1294, &[68610]);     // 1294 => [68610]
            map.insert(1295, &[8416]);     // 1295 => [8416]
            map.insert(1296, &[1296]);     // 1296 => [1296]
            map.insert(1297, &[1297]);     // 1297 => [1297]
            map.insert(1298, &[1298]);     // 1298 => [1298]
            map.insert(1299, &[1299]);     // 1299 => [1299]
            map.insert(1300, &[10754]);     // 1300 => [10754]
            map.insert(1301, &[28680]);     // 1301 => [28680]
            map.insert(1302, &[10752]);     // 1302 => [10752]
            map.insert(1303, &[10753]);     // 1303 => [10753]
            map.insert(1304, &[1304]);     // 1304 => [1304]
            map.insert(1305, &[28676]);     // 1305 => [28676]
            map.insert(1306, &[74496]);     // 1306 => [74496]
            map.insert(1307, &[459776]);     // 1307 => [459776]
            map.insert(1308, &[28673]);     // 1308 => [28673]
            map.insert(1309, &[28672]);     // 1309 => [28672]
            map.insert(1310, &[10760]);     // 1310 => [10760]
            map.insert(1311, &[28674]);     // 1311 => [28674]
            map.insert(1312, &[1312]);     // 1312 => [1312]
            map.insert(1313, &[1313]);     // 1313 => [1313]
            map.insert(1314, &[1314]);     // 1314 => [1314]
            map.insert(1315, &[51204]);     // 1315 => [51204]
            map.insert(1316, &[1316]);     // 1316 => [1316]
            map.insert(1317, &[51202]);     // 1317 => [51202]
            map.insert(1318, &[51201]);     // 1318 => [51201]
            map.insert(1319, &[51200]);     // 1319 => [51200]
            map.insert(1320, &[37380]);     // 1320 => [37380]
            map.insert(1321, &[136208]);     // 1321 => [136208]
            map.insert(1322, &[8389]);     // 1322 => [8389]
            map.insert(1323, &[8388]);     // 1323 => [8388]
            map.insert(1324, &[37376]);     // 1324 => [37376]
            map.insert(1325, &[37377]);     // 1325 => [37377]
            map.insert(1326, &[8385]);     // 1326 => [8385]
            map.insert(1327, &[8384]);     // 1327 => [8384]
            map.insert(1328, &[1328]);     // 1328 => [1328]
            map.insert(1329, &[136200]);     // 1329 => [136200]
            map.insert(1330, &[1330]);     // 1330 => [1330]
            map.insert(1331, &[136202]);     // 1331 => [136202]
            map.insert(1332, &[10786]);     // 1332 => [10786]
            map.insert(1333, &[51218]);     // 1333 => [51218]
            map.insert(1334, &[10784]);     // 1334 => [10784]
            map.insert(1335, &[51216]);     // 1335 => [51216]
            map.insert(1336, &[136193]);     // 1336 => [136193]
            map.insert(1337, &[136192]);     // 1337 => [136192]
            map.insert(1338, &[136195]);     // 1338 => [136195]
            map.insert(1339, &[136194]);     // 1339 => [136194]
            map.insert(1340, &[37392]);     // 1340 => [37392]
            map.insert(1341, &[136196]);     // 1341 => [136196]
            map.insert(1342, &[8401]);     // 1342 => [8401]
            map.insert(1343, &[8400]);     // 1343 => [8400]
            map.insert(1344, &[1344]);     // 1344 => [1344]
            map.insert(1345, &[1345]);     // 1345 => [1345]
            map.insert(1346, &[1346]);     // 1346 => [1346]
            map.insert(1347, &[1347]);     // 1347 => [1347]
            map.insert(1348, &[1348]);     // 1348 => [1348]
            map.insert(1349, &[1349]);     // 1349 => [1349]
            map.insert(1350, &[8361]);     // 1350 => [8361]
            map.insert(1351, &[8360]);     // 1351 => [8360]
            map.insert(1352, &[1352]);     // 1352 => [1352]
            map.insert(1353, &[1353]);     // 1353 => [1353]
            map.insert(1354, &[8357]);     // 1354 => [8357]
            map.insert(1355, &[8356]);     // 1355 => [8356]
            map.insert(1356, &[68672]);     // 1356 => [68672]
            map.insert(1357, &[8354]);     // 1357 => [8354]
            map.insert(1358, &[8353]);     // 1358 => [8353]
            map.insert(1359, &[8352]);     // 1359 => [8352]
            map.insert(1360, &[1360]);     // 1360 => [1360]
            map.insert(1361, &[1361]);     // 1361 => [1361]
            map.insert(1362, &[1362]);     // 1362 => [1362]
            map.insert(1363, &[1363]);     // 1363 => [1363]
            map.insert(1364, &[39041]);     // 1364 => [39041]
            map.insert(1365, &[39040]);     // 1365 => [39040]
            map.insert(1366, &[10816]);     // 1366 => [10816]
            map.insert(1367, &[10817]);     // 1367 => [10817]
            map.insert(1368, &[1368]);     // 1368 => [1368]
            map.insert(1369, &[28740]);     // 1369 => [28740]
            map.insert(1370, &[49796]);     // 1370 => [49796]
            map.insert(1371, &[8372]);     // 1371 => [8372]
            map.insert(1372, &[28737]);     // 1372 => [28737]
            map.insert(1373, &[28736]);     // 1373 => [28736]
            map.insert(1374, &[49792]);     // 1374 => [49792]
            map.insert(1375, &[8368]);     // 1375 => [8368]
            map.insert(1376, &[1376]);     // 1376 => [1376]
            map.insert(1377, &[1377]);     // 1377 => [1377]
            map.insert(1378, &[8333]);     // 1378 => [8333]
            map.insert(1379, &[8332]);     // 1379 => [8332]
            map.insert(1380, &[8331]);     // 1380 => [8331]
            map.insert(1381, &[8330]);     // 1381 => [8330]
            map.insert(1382, &[8329]);     // 1382 => [8329]
            map.insert(1383, &[8328]);     // 1383 => [8328]
            map.insert(1384, &[8327]);     // 1384 => [8327]
            map.insert(1385, &[8326]);     // 1385 => [8326]
            map.insert(1386, &[8325]);     // 1386 => [8325]
            map.insert(1387, &[8324]);     // 1387 => [8324]
            map.insert(1388, &[8323]);     // 1388 => [8323]
            map.insert(1389, &[8322]);     // 1389 => [8322]
            map.insert(1390, &[8321]);     // 1390 => [8321]
            map.insert(1391, &[8320]);     // 1391 => [8320]
            map.insert(1392, &[1392]);     // 1392 => [1392]
            map.insert(1393, &[67204]);     // 1393 => [67204]
            map.insert(1394, &[21888]);     // 1394 => [21888]
            map.insert(1395, &[8348]);     // 1395 => [8348]
            map.insert(1396, &[67201]);     // 1396 => [67201]
            map.insert(1397, &[67200]);     // 1397 => [67200]
            map.insert(1398, &[8345]);     // 1398 => [8345]
            map.insert(1399, &[8344]);     // 1399 => [8344]
            map.insert(1400, &[136257]);     // 1400 => [136257]
            map.insert(1401, &[136256]);     // 1401 => [136256]
            map.insert(1402, &[8341]);     // 1402 => [8341]
            map.insert(1403, &[8340]);     // 1403 => [8340]
            map.insert(1404, &[8339]);     // 1404 => [8339]
            map.insert(1405, &[8338]);     // 1405 => [8338]
            map.insert(1406, &[8337]);     // 1406 => [8337]
            map.insert(1407, &[8336]);     // 1407 => [8336]
            map.insert(1408, &[1408]);     // 1408 => [1408]
            map.insert(1409, &[1409]);     // 1409 => [1409]
            map.insert(1410, &[1410]);     // 1410 => [1410]
            map.insert(1411, &[1411]);     // 1411 => [1411]
            map.insert(1412, &[1412]);     // 1412 => [1412]
            map.insert(1413, &[1413]);     // 1413 => [1413]
            map.insert(1414, &[8297]);     // 1414 => [8297]
            map.insert(1415, &[8296]);     // 1415 => [8296]
            map.insert(1416, &[1416]);     // 1416 => [1416]
            map.insert(1417, &[1417]);     // 1417 => [1417]
            map.insert(1418, &[8293]);     // 1418 => [8293]
            map.insert(1419, &[8292]);     // 1419 => [8292]
            map.insert(1420, &[68736]);     // 1420 => [68736]
            map.insert(1421, &[8290]);     // 1421 => [8290]
            map.insert(1422, &[8289]);     // 1422 => [8289]
            map.insert(1423, &[8288]);     // 1423 => [8288]
            map.insert(1424, &[1424]);     // 1424 => [1424]
            map.insert(1425, &[1425]);     // 1425 => [1425]
            map.insert(1426, &[1426]);     // 1426 => [1426]
            map.insert(1427, &[1427]);     // 1427 => [1427]
            map.insert(1428, &[38977]);     // 1428 => [38977]
            map.insert(1429, &[38976]);     // 1429 => [38976]
            map.insert(1430, &[10880]);     // 1430 => [10880]
            map.insert(1431, &[10881]);     // 1431 => [10881]
            map.insert(1432, &[1432]);     // 1432 => [1432]
            map.insert(1433, &[28804]);     // 1433 => [28804]
            map.insert(1434, &[49732]);     // 1434 => [49732]
            map.insert(1435, &[8308]);     // 1435 => [8308]
            map.insert(1436, &[28801]);     // 1436 => [28801]
            map.insert(1437, &[28800]);     // 1437 => [28800]
            map.insert(1438, &[49728]);     // 1438 => [49728]
            map.insert(1439, &[8304]);     // 1439 => [8304]
            map.insert(1440, &[1440]);     // 1440 => [1440]
            map.insert(1441, &[1441]);     // 1441 => [1441]
            map.insert(1442, &[8269]);     // 1442 => [8269]
            map.insert(1443, &[8268]);     // 1443 => [8268]
            map.insert(1444, &[8267]);     // 1444 => [8267]
            map.insert(1445, &[8266]);     // 1445 => [8266]
            map.insert(1446, &[8265]);     // 1446 => [8265]
            map.insert(1447, &[8264]);     // 1447 => [8264]
            map.insert(1448, &[8263]);     // 1448 => [8263]
            map.insert(1449, &[8262]);     // 1449 => [8262]
            map.insert(1450, &[8261]);     // 1450 => [8261]
            map.insert(1451, &[8260]);     // 1451 => [8260]
            map.insert(1452, &[8259]);     // 1452 => [8259]
            map.insert(1453, &[8258]);     // 1453 => [8258]
            map.insert(1454, &[8257]);     // 1454 => [8257]
            map.insert(1455, &[8256]);     // 1455 => [8256]
            map.insert(1456, &[1456]);     // 1456 => [1456]
            map.insert(1457, &[67140]);     // 1457 => [67140]
            map.insert(1458, &[21824]);     // 1458 => [21824]
            map.insert(1459, &[8284]);     // 1459 => [8284]
            map.insert(1460, &[67137]);     // 1460 => [67137]
            map.insert(1461, &[67136]);     // 1461 => [67136]
            map.insert(1462, &[8281]);     // 1462 => [8281]
            map.insert(1463, &[8280]);     // 1463 => [8280]
            map.insert(1464, &[136321]);     // 1464 => [136321]
            map.insert(1465, &[136320]);     // 1465 => [136320]
            map.insert(1466, &[8277]);     // 1466 => [8277]
            map.insert(1467, &[8276]);     // 1467 => [8276]
            map.insert(1468, &[8275]);     // 1468 => [8275]
            map.insert(1469, &[8274]);     // 1469 => [8274]
            map.insert(1470, &[8273]);     // 1470 => [8273]
            map.insert(1471, &[8272]);     // 1471 => [8272]
            map.insert(1472, &[229408]);     // 1472 => [229408]
            map.insert(1473, &[229409]);     // 1473 => [229409]
            map.insert(1474, &[430080]);     // 1474 => [430080]
            map.insert(1475, &[8236]);     // 1475 => [8236]
            map.insert(1476, &[8235]);     // 1476 => [8235]
            map.insert(1477, &[8234]);     // 1477 => [8234]
            map.insert(1478, &[8233]);     // 1478 => [8233]
            map.insert(1479, &[8232]);     // 1479 => [8232]
            map.insert(1480, &[8231]);     // 1480 => [8231]
            map.insert(1481, &[8230]);     // 1481 => [8230]
            map.insert(1482, &[8229]);     // 1482 => [8229]
            map.insert(1483, &[8228]);     // 1483 => [8228]
            map.insert(1484, &[8227]);     // 1484 => [8227]
            map.insert(1485, &[8226]);     // 1485 => [8226]
            map.insert(1486, &[8225]);     // 1486 => [8225]
            map.insert(1487, &[8224]);     // 1487 => [8224]
            map.insert(1488, &[38917]);     // 1488 => [38917]
            map.insert(1489, &[38916]);     // 1489 => [38916]
            map.insert(1490, &[49676]);     // 1490 => [49676]
            map.insert(1491, &[38918]);     // 1491 => [38918]
            map.insert(1492, &[38913]);     // 1492 => [38913]
            map.insert(1493, &[38912]);     // 1493 => [38912]
            map.insert(1494, &[49672]);     // 1494 => [49672]
            map.insert(1495, &[38914]);     // 1495 => [38914]
            map.insert(1496, &[102657]);     // 1496 => [102657]
            map.insert(1497, &[102656]);     // 1497 => [102656]
            map.insert(1498, &[49668]);     // 1498 => [49668]
            map.insert(1499, &[8244]);     // 1499 => [8244]
            map.insert(1500, &[49666]);     // 1500 => [49666]
            map.insert(1501, &[8242]);     // 1501 => [8242]
            map.insert(1502, &[49664]);     // 1502 => [49664]
            map.insert(1503, &[8240]);     // 1503 => [8240]
            map.insert(1504, &[229376]);     // 1504 => [229376]
            map.insert(1505, &[229377]);     // 1505 => [229377]
            map.insert(1506, &[8205]);     // 1506 => [8205]
            map.insert(1507, &[8204]);     // 1507 => [8204]
            map.insert(1508, &[8203]);     // 1508 => [8203]
            map.insert(1509, &[8202]);     // 1509 => [8202]
            map.insert(1510, &[8201]);     // 1510 => [8201]
            map.insert(1511, &[8200]);     // 1511 => [8200]
            map.insert(1512, &[8199]);     // 1512 => [8199]
            map.insert(1513, &[8198]);     // 1513 => [8198]
            map.insert(1514, &[8197]);     // 1514 => [8197]
            map.insert(1515, &[8196]);     // 1515 => [8196]
            map.insert(1516, &[8195]);     // 1516 => [8195]
            map.insert(1517, &[8194]);     // 1517 => [8194]
            map.insert(1518, &[8193]);     // 1518 => [8193]
            map.insert(1519, &[8192]);     // 1519 => [8192]
            map.insert(1520, &[229392]);     // 1520 => [229392]
            map.insert(1521, &[67076]);     // 1521 => [67076]
            map.insert(1522, &[21760]);     // 1522 => [21760]
            map.insert(1523, &[8220]);     // 1523 => [8220]
            map.insert(1524, &[67073]);     // 1524 => [67073]
            map.insert(1525, &[67072]);     // 1525 => [67072]
            map.insert(1526, &[8217]);     // 1526 => [8217]
            map.insert(1527, &[8216]);     // 1527 => [8216]
            map.insert(1528, &[403456]);     // 1528 => [403456]
            map.insert(1529, &[8214]);     // 1529 => [8214]
            map.insert(1530, &[8213]);     // 1530 => [8213]
            map.insert(1531, &[8212]);     // 1531 => [8212]
            map.insert(1532, &[8211]);     // 1532 => [8211]
            map.insert(1533, &[8210]);     // 1533 => [8210]
            map.insert(1534, &[8209]);     // 1534 => [8209]
            map.insert(1535, &[8208]);     // 1535 => [8208]
            map.insert(1536, &[1536]);     // 1536 => [1536]
            map.insert(1537, &[1537]);     // 1537 => [1537]
            map.insert(1538, &[1538]);     // 1538 => [1538]
            map.insert(1539, &[1539]);     // 1539 => [1539]
            map.insert(1540, &[1540]);     // 1540 => [1540]
            map.insert(1541, &[163856]);     // 1541 => [163856]
            map.insert(1542, &[1542]);     // 1542 => [1542]
            map.insert(1543, &[163858]);     // 1543 => [163858]
            map.insert(1544, &[1544]);     // 1544 => [1544]
            map.insert(1545, &[1545]);     // 1545 => [1545]
            map.insert(1546, &[73744]);     // 1546 => [73744]
            map.insert(1547, &[73745]);     // 1547 => [73745]
            map.insert(1548, &[1548]);     // 1548 => [1548]
            map.insert(1549, &[163864]);     // 1549 => [163864]
            map.insert(1550, &[73748]);     // 1550 => [73748]
            map.insert(1551, &[73749]);     // 1551 => [73749]
            map.insert(1552, &[1552]);     // 1552 => [1552]
            map.insert(1553, &[163844]);     // 1553 => [163844]
            map.insert(1554, &[73736]);     // 1554 => [73736]
            map.insert(1555, &[73737]);     // 1555 => [73737]
            map.insert(1556, &[163841]);     // 1556 => [163841]
            map.insert(1557, &[163840]);     // 1557 => [163840]
            map.insert(1558, &[10496]);     // 1558 => [10496]
            map.insert(1559, &[163842]);     // 1559 => [163842]
            map.insert(1560, &[73730]);     // 1560 => [73730]
            map.insert(1561, &[73731]);     // 1561 => [73731]
            map.insert(1562, &[73728]);     // 1562 => [73728]
            map.insert(1563, &[73729]);     // 1563 => [73729]
            map.insert(1564, &[163849]);     // 1564 => [163849]
            map.insert(1565, &[163848]);     // 1565 => [163848]
            map.insert(1566, &[73732]);     // 1566 => [73732]
            map.insert(1567, &[73733]);     // 1567 => [73733]
            map.insert(1568, &[1568]);     // 1568 => [1568]
            map.insert(1569, &[1569]);     // 1569 => [1569]
            map.insert(1570, &[1570]);     // 1570 => [1570]
            map.insert(1571, &[1571]);     // 1571 => [1571]
            map.insert(1572, &[1572]);     // 1572 => [1572]
            map.insert(1573, &[163888]);     // 1573 => [163888]
            map.insert(1574, &[1574]);     // 1574 => [1574]
            map.insert(1575, &[163890]);     // 1575 => [163890]
            map.insert(1576, &[37124]);     // 1576 => [37124]
            map.insert(1577, &[37125]);     // 1577 => [37125]
            map.insert(1578, &[73776]);     // 1578 => [73776]
            map.insert(1579, &[115200]);     // 1579 => [115200]
            map.insert(1580, &[37120]);     // 1580 => [37120]
            map.insert(1581, &[37121]);     // 1581 => [37121]
            map.insert(1582, &[37122]);     // 1582 => [37122]
            map.insert(1583, &[145408]);     // 1583 => [145408]
            map.insert(1584, &[274440]);     // 1584 => [274440]
            map.insert(1585, &[163876]);     // 1585 => [163876]
            map.insert(1586, &[73768]);     // 1586 => [73768]
            map.insert(1587, &[73769]);     // 1587 => [73769]
            map.insert(1588, &[163873]);     // 1588 => [163873]
            map.insert(1589, &[163872]);     // 1589 => [163872]
            map.insert(1590, &[10528]);     // 1590 => [10528]
            map.insert(1591, &[163874]);     // 1591 => [163874]
            map.insert(1592, &[274432]);     // 1592 => [274432]
            map.insert(1593, &[274433]);     // 1593 => [274433]
            map.insert(1594, &[73760]);     // 1594 => [73760]
            map.insert(1595, &[73761]);     // 1595 => [73761]
            map.insert(1596, &[274436]);     // 1596 => [274436]
            map.insert(1597, &[163880]);     // 1597 => [163880]
            map.insert(1598, &[73764]);     // 1598 => [73764]
            map.insert(1599, &[73765]);     // 1599 => [73765]
            map.insert(1600, &[1600]);     // 1600 => [1600]
            map.insert(1601, &[1601]);     // 1601 => [1601]
            map.insert(1602, &[1602]);     // 1602 => [1602]
            map.insert(1603, &[1603]);     // 1603 => [1603]
            map.insert(1604, &[1604]);     // 1604 => [1604]
            map.insert(1605, &[163920]);     // 1605 => [163920]
            map.insert(1606, &[1606]);     // 1606 => [1606]
            map.insert(1607, &[163922]);     // 1607 => [163922]
            map.insert(1608, &[1608]);     // 1608 => [1608]
            map.insert(1609, &[1609]);     // 1609 => [1609]
            map.insert(1610, &[73808]);     // 1610 => [73808]
            map.insert(1611, &[73809]);     // 1611 => [73809]
            map.insert(1612, &[1612]);     // 1612 => [1612]
            map.insert(1613, &[163928]);     // 1613 => [163928]
            map.insert(1614, &[73812]);     // 1614 => [73812]
            map.insert(1615, &[9120]);     // 1615 => [9120]
            map.insert(1616, &[1616]);     // 1616 => [1616]
            map.insert(1617, &[163908]);     // 1617 => [163908]
            map.insert(1618, &[73800]);     // 1618 => [73800]
            map.insert(1619, &[73801]);     // 1619 => [73801]
            map.insert(1620, &[163905]);     // 1620 => [163905]
            map.insert(1621, &[163904]);     // 1621 => [163904]
            map.insert(1622, &[10560]);     // 1622 => [10560]
            map.insert(1623, &[163906]);     // 1623 => [163906]
            map.insert(1624, &[73794]);     // 1624 => [73794]
            map.insert(1625, &[3232]);     // 1625 => [3232]
            map.insert(1626, &[73792]);     // 1626 => [73792]
            map.insert(1627, &[73793]);     // 1627 => [73793]
            map.insert(1628, &[163913]);     // 1628 => [163913]
            map.insert(1629, &[163912]);     // 1629 => [163912]
            map.insert(1630, &[73796]);     // 1630 => [73796]
            map.insert(1631, &[73797]);     // 1631 => [73797]
            map.insert(1632, &[1632]);     // 1632 => [1632]
            map.insert(1633, &[1633]);     // 1633 => [1633]
            map.insert(1634, &[1634]);     // 1634 => [1634]
            map.insert(1635, &[76416]);     // 1635 => [76416]
            map.insert(1636, &[1636]);     // 1636 => [1636]
            map.insert(1637, &[163952]);     // 1637 => [163952]
            map.insert(1638, &[394376]);     // 1638 => [394376]
            map.insert(1639, &[9096]);     // 1639 => [9096]
            map.insert(1640, &[3217]);     // 1640 => [3217]
            map.insert(1641, &[3216]);     // 1641 => [3216]
            map.insert(1642, &[394372]);     // 1642 => [394372]
            map.insert(1643, &[3218]);     // 1643 => [3218]
            map.insert(1644, &[37184]);     // 1644 => [37184]
            map.insert(1645, &[37185]);     // 1645 => [37185]
            map.insert(1646, &[394368]);     // 1646 => [394368]
            map.insert(1647, &[9088]);     // 1647 => [9088]
            map.insert(1648, &[3209]);     // 1648 => [3209]
            map.insert(1649, &[3208]);     // 1649 => [3208]
            map.insert(1650, &[73832]);     // 1650 => [73832]
            map.insert(1651, &[3210]);     // 1651 => [3210]
            map.insert(1652, &[163937]);     // 1652 => [163937]
            map.insert(1653, &[163936]);     // 1653 => [163936]
            map.insert(1654, &[10592]);     // 1654 => [10592]
            map.insert(1655, &[163938]);     // 1655 => [163938]
            map.insert(1656, &[3201]);     // 1656 => [3201]
            map.insert(1657, &[3200]);     // 1657 => [3200]
            map.insert(1658, &[73824]);     // 1658 => [73824]
            map.insert(1659, &[3202]);     // 1659 => [3202]
            map.insert(1660, &[3205]);     // 1660 => [3205]
            map.insert(1661, &[3204]);     // 1661 => [3204]
            map.insert(1662, &[73828]);     // 1662 => [73828]
            map.insert(1663, &[3206]);     // 1663 => [3206]
            map.insert(1664, &[1664]);     // 1664 => [1664]
            map.insert(1665, &[1665]);     // 1665 => [1665]
            map.insert(1666, &[1666]);     // 1666 => [1666]
            map.insert(1667, &[1667]);     // 1667 => [1667]
            map.insert(1668, &[1668]);     // 1668 => [1668]
            map.insert(1669, &[163984]);     // 1669 => [163984]
            map.insert(1670, &[1670]);     // 1670 => [1670]
            map.insert(1671, &[163986]);     // 1671 => [163986]
            map.insert(1672, &[1672]);     // 1672 => [1672]
            map.insert(1673, &[1673]);     // 1673 => [1673]
            map.insert(1674, &[73872]);     // 1674 => [73872]
            map.insert(1675, &[73873]);     // 1675 => [73873]
            map.insert(1676, &[1676]);     // 1676 => [1676]
            map.insert(1677, &[163992]);     // 1677 => [163992]
            map.insert(1678, &[73876]);     // 1678 => [73876]
            map.insert(1679, &[9056]);     // 1679 => [9056]
            map.insert(1680, &[1680]);     // 1680 => [1680]
            map.insert(1681, &[163972]);     // 1681 => [163972]
            map.insert(1682, &[73864]);     // 1682 => [73864]
            map.insert(1683, &[73865]);     // 1683 => [73865]
            map.insert(1684, &[163969]);     // 1684 => [163969]
            map.insert(1685, &[163968]);     // 1685 => [163968]
            map.insert(1686, &[10624]);     // 1686 => [10624]
            map.insert(1687, &[163970]);     // 1687 => [163970]
            map.insert(1688, &[73858]);     // 1688 => [73858]
            map.insert(1689, &[3168]);     // 1689 => [3168]
            map.insert(1690, &[73856]);     // 1690 => [73856]
            map.insert(1691, &[73857]);     // 1691 => [73857]
            map.insert(1692, &[163977]);     // 1692 => [163977]
            map.insert(1693, &[163976]);     // 1693 => [163976]
            map.insert(1694, &[73860]);     // 1694 => [73860]
            map.insert(1695, &[73861]);     // 1695 => [73861]
            map.insert(1696, &[1696]);     // 1696 => [1696]
            map.insert(1697, &[1697]);     // 1697 => [1697]
            map.insert(1698, &[1698]);     // 1698 => [1698]
            map.insert(1699, &[76352]);     // 1699 => [76352]
            map.insert(1700, &[1700]);     // 1700 => [1700]
            map.insert(1701, &[164016]);     // 1701 => [164016]
            map.insert(1702, &[394312]);     // 1702 => [394312]
            map.insert(1703, &[9032]);     // 1703 => [9032]
            map.insert(1704, &[3153]);     // 1704 => [3153]
            map.insert(1705, &[3152]);     // 1705 => [3152]
            map.insert(1706, &[394308]);     // 1706 => [394308]
            map.insert(1707, &[3154]);     // 1707 => [3154]
            map.insert(1708, &[37248]);     // 1708 => [37248]
            map.insert(1709, &[37249]);     // 1709 => [37249]
            map.insert(1710, &[394304]);     // 1710 => [394304]
            map.insert(1711, &[9024]);     // 1711 => [9024]
            map.insert(1712, &[3145]);     // 1712 => [3145]
            map.insert(1713, &[3144]);     // 1713 => [3144]
            map.insert(1714, &[73896]);     // 1714 => [73896]
            map.insert(1715, &[3146]);     // 1715 => [3146]
            map.insert(1716, &[164001]);     // 1716 => [164001]
            map.insert(1717, &[164000]);     // 1717 => [164000]
            map.insert(1718, &[10656]);     // 1718 => [10656]
            map.insert(1719, &[164002]);     // 1719 => [164002]
            map.insert(1720, &[3137]);     // 1720 => [3137]
            map.insert(1721, &[3136]);     // 1721 => [3136]
            map.insert(1722, &[73888]);     // 1722 => [73888]
            map.insert(1723, &[3138]);     // 1723 => [3138]
            map.insert(1724, &[3141]);     // 1724 => [3141]
            map.insert(1725, &[3140]);     // 1725 => [3140]
            map.insert(1726, &[73892]);     // 1726 => [73892]
            map.insert(1727, &[3142]);     // 1727 => [3142]
            map.insert(1728, &[1728]);     // 1728 => [1728]
            map.insert(1729, &[1729]);     // 1729 => [1729]
            map.insert(1730, &[286728]);     // 1730 => [286728]
            map.insert(1731, &[46080]);     // 1731 => [46080]
            map.insert(1732, &[1732]);     // 1732 => [1732]
            map.insert(1733, &[66864]);     // 1733 => [66864]
            map.insert(1734, &[286732]);     // 1734 => [286732]
            map.insert(1735, &[46084]);     // 1735 => [46084]
            map.insert(1736, &[286722]);     // 1736 => [286722]
            map.insert(1737, &[3120]);     // 1737 => [3120]
            map.insert(1738, &[286720]);     // 1738 => [286720]
            map.insert(1739, &[286721]);     // 1739 => [286721]
            map.insert(1740, &[201728]);     // 1740 => [201728]
            map.insert(1741, &[201729]);     // 1741 => [201729]
            map.insert(1742, &[286724]);     // 1742 => [286724]
            map.insert(1743, &[8992]);     // 1743 => [8992]
            map.insert(1744, &[3113]);     // 1744 => [3113]
            map.insert(1745, &[3112]);     // 1745 => [3112]
            map.insert(1746, &[116736]);     // 1746 => [116736]
            map.insert(1747, &[116737]);     // 1747 => [116737]
            map.insert(1748, &[66849]);     // 1748 => [66849]
            map.insert(1749, &[66848]);     // 1749 => [66848]
            map.insert(1750, &[49416]);     // 1750 => [49416]
            map.insert(1751, &[267520]);     // 1751 => [267520]
            map.insert(1752, &[3105]);     // 1752 => [3105]
            map.insert(1753, &[3104]);     // 1753 => [3104]
            map.insert(1754, &[49412]);     // 1754 => [49412]
            map.insert(1755, &[3106]);     // 1755 => [3106]
            map.insert(1756, &[49410]);     // 1756 => [49410]
            map.insert(1757, &[3108]);     // 1757 => [3108]
            map.insert(1758, &[49408]);     // 1758 => [49408]
            map.insert(1759, &[49409]);     // 1759 => [49409]
            map.insert(1760, &[3097]);     // 1760 => [3097]
            map.insert(1761, &[3096]);     // 1761 => [3096]
            map.insert(1762, &[76289]);     // 1762 => [76289]
            map.insert(1763, &[76288]);     // 1763 => [76288]
            map.insert(1764, &[66833]);     // 1764 => [66833]
            map.insert(1765, &[66832]);     // 1765 => [66832]
            map.insert(1766, &[394248]);     // 1766 => [394248]
            map.insert(1767, &[8968]);     // 1767 => [8968]
            map.insert(1768, &[3089]);     // 1768 => [3089]
            map.insert(1769, &[3088]);     // 1769 => [3088]
            map.insert(1770, &[394244]);     // 1770 => [394244]
            map.insert(1771, &[3090]);     // 1771 => [3090]
            map.insert(1772, &[394242]);     // 1772 => [394242]
            map.insert(1773, &[8962]);     // 1773 => [8962]
            map.insert(1774, &[394240]);     // 1774 => [394240]
            map.insert(1775, &[8960]);     // 1775 => [8960]
            map.insert(1776, &[3081]);     // 1776 => [3081]
            map.insert(1777, &[3080]);     // 1777 => [3080]
            map.insert(1778, &[22016]);     // 1778 => [22016]
            map.insert(1779, &[3082]);     // 1779 => [3082]
            map.insert(1780, &[66817]);     // 1780 => [66817]
            map.insert(1781, &[66816]);     // 1781 => [66816]
            map.insert(1782, &[66819]);     // 1782 => [66819]
            map.insert(1783, &[66818]);     // 1783 => [66818]
            map.insert(1784, &[3073]);     // 1784 => [3073]
            map.insert(1785, &[3072]);     // 1785 => [3072]
            map.insert(1786, &[3075]);     // 1786 => [3075]
            map.insert(1787, &[3074]);     // 1787 => [3074]
            map.insert(1788, &[3077]);     // 1788 => [3077]
            map.insert(1789, &[3076]);     // 1789 => [3076]
            map.insert(1790, &[394256]);     // 1790 => [394256]
            map.insert(1791, &[3078]);     // 1791 => [3078]
            map.insert(1792, &[1792]);     // 1792 => [1792]
            map.insert(1793, &[401408]);     // 1793 => [401408]
            map.insert(1794, &[1794]);     // 1794 => [1794]
            map.insert(1795, &[401410]);     // 1795 => [401410]
            map.insert(1796, &[10258]);     // 1796 => [10258]
            map.insert(1797, &[401412]);     // 1797 => [401412]
            map.insert(1798, &[10256]);     // 1798 => [10256]
            map.insert(1799, &[10257]);     // 1799 => [10257]
            map.insert(1800, &[36900]);     // 1800 => [36900]
            map.insert(1801, &[401416]);     // 1801 => [401416]
            map.insert(1802, &[360452]);     // 1802 => [360452]
            map.insert(1803, &[360453]);     // 1803 => [360453]
            map.insert(1804, &[36896]);     // 1804 => [36896]
            map.insert(1805, &[36897]);     // 1805 => [36897]
            map.insert(1806, &[360448]);     // 1806 => [360448]
            map.insert(1807, &[360449]);     // 1807 => [360449]
            map.insert(1808, &[10246]);     // 1808 => [10246]
            map.insert(1809, &[164100]);     // 1809 => [164100]
            map.insert(1810, &[10244]);     // 1810 => [10244]
            map.insert(1811, &[10245]);     // 1811 => [10245]
            map.insert(1812, &[10242]);     // 1812 => [10242]
            map.insert(1813, &[164096]);     // 1813 => [164096]
            map.insert(1814, &[10240]);     // 1814 => [10240]
            map.insert(1815, &[10241]);     // 1815 => [10241]
            map.insert(1816, &[73986]);     // 1816 => [73986]
            map.insert(1817, &[231424]);     // 1817 => [231424]
            map.insert(1818, &[73984]);     // 1818 => [73984]
            map.insert(1819, &[73985]);     // 1819 => [73985]
            map.insert(1820, &[10250]);     // 1820 => [10250]
            map.insert(1821, &[164104]);     // 1821 => [164104]
            map.insert(1822, &[10248]);     // 1822 => [10248]
            map.insert(1823, &[10249]);     // 1823 => [10249]
            map.insert(1824, &[36876]);     // 1824 => [36876]
            map.insert(1825, &[279556]);     // 1825 => [279556]
            map.insert(1826, &[208897]);     // 1826 => [208897]
            map.insert(1827, &[208896]);     // 1827 => [208896]
            map.insert(1828, &[36872]);     // 1828 => [36872]
            map.insert(1829, &[279552]);     // 1829 => [279552]
            map.insert(1830, &[36874]);     // 1830 => [36874]
            map.insert(1831, &[279554]);     // 1831 => [279554]
            map.insert(1832, &[36868]);     // 1832 => [36868]
            map.insert(1833, &[36869]);     // 1833 => [36869]
            map.insert(1834, &[36870]);     // 1834 => [36870]
            map.insert(1835, &[36871]);     // 1835 => [36871]
            map.insert(1836, &[36864]);     // 1836 => [36864]
            map.insert(1837, &[36865]);     // 1837 => [36865]
            map.insert(1838, &[36866]);     // 1838 => [36866]
            map.insert(1839, &[36867]);     // 1839 => [36867]
            map.insert(1840, &[10278]);     // 1840 => [10278]
            map.insert(1841, &[279572]);     // 1841 => [279572]
            map.insert(1842, &[10276]);     // 1842 => [10276]
            map.insert(1843, &[10277]);     // 1843 => [10277]
            map.insert(1844, &[10274]);     // 1844 => [10274]
            map.insert(1845, &[279568]);     // 1845 => [279568]
            map.insert(1846, &[10272]);     // 1846 => [10272]
            map.insert(1847, &[10273]);     // 1847 => [10273]
            map.insert(1848, &[36884]);     // 1848 => [36884]
            map.insert(1849, &[136704]);     // 1849 => [136704]
            map.insert(1850, &[74016]);     // 1850 => [74016]
            map.insert(1851, &[74017]);     // 1851 => [74017]
            map.insert(1852, &[36880]);     // 1852 => [36880]
            map.insert(1853, &[36881]);     // 1853 => [36881]
            map.insert(1854, &[36882]);     // 1854 => [36882]
            map.insert(1855, &[36883]);     // 1855 => [36883]
            map.insert(1856, &[1856]);     // 1856 => [1856]
            map.insert(1857, &[401472]);     // 1857 => [401472]
            map.insert(1858, &[1858]);     // 1858 => [1858]
            map.insert(1859, &[401474]);     // 1859 => [401474]
            map.insert(1860, &[10322]);     // 1860 => [10322]
            map.insert(1861, &[401476]);     // 1861 => [401476]
            map.insert(1862, &[10320]);     // 1862 => [10320]
            map.insert(1863, &[10321]);     // 1863 => [10321]
            map.insert(1864, &[36964]);     // 1864 => [36964]
            map.insert(1865, &[401480]);     // 1865 => [401480]
            map.insert(1866, &[49300]);     // 1866 => [49300]
            map.insert(1867, &[8868]);     // 1867 => [8868]
            map.insert(1868, &[36960]);     // 1868 => [36960]
            map.insert(1869, &[36961]);     // 1869 => [36961]
            map.insert(1870, &[49296]);     // 1870 => [49296]
            map.insert(1871, &[8864]);     // 1871 => [8864]
            map.insert(1872, &[10310]);     // 1872 => [10310]
            map.insert(1873, &[66724]);     // 1873 => [66724]
            map.insert(1874, &[10308]);     // 1874 => [10308]
            map.insert(1875, &[10309]);     // 1875 => [10309]
            map.insert(1876, &[10306]);     // 1876 => [10306]
            map.insert(1877, &[66720]);     // 1877 => [66720]
            map.insert(1878, &[10304]);     // 1878 => [10304]
            map.insert(1879, &[10305]);     // 1879 => [10305]
            map.insert(1880, &[49286]);     // 1880 => [49286]
            map.insert(1881, &[3488]);     // 1881 => [3488]
            map.insert(1882, &[49284]);     // 1882 => [49284]
            map.insert(1883, &[49285]);     // 1883 => [49285]
            map.insert(1884, &[49282]);     // 1884 => [49282]
            map.insert(1885, &[49283]);     // 1885 => [49283]
            map.insert(1886, &[49280]);     // 1886 => [49280]
            map.insert(1887, &[49281]);     // 1887 => [49281]
            map.insert(1888, &[36940]);     // 1888 => [36940]
            map.insert(1889, &[66708]);     // 1889 => [66708]
            map.insert(1890, &[8845]);     // 1890 => [8845]
            map.insert(1891, &[8844]);     // 1891 => [8844]
            map.insert(1892, &[36936]);     // 1892 => [36936]
            map.insert(1893, &[66704]);     // 1893 => [66704]
            map.insert(1894, &[8841]);     // 1894 => [8841]
            map.insert(1895, &[8840]);     // 1895 => [8840]
            map.insert(1896, &[36932]);     // 1896 => [36932]
            map.insert(1897, &[36933]);     // 1897 => [36933]
            map.insert(1898, &[8837]);     // 1898 => [8837]
            map.insert(1899, &[8836]);     // 1899 => [8836]
            map.insert(1900, &[36928]);     // 1900 => [36928]
            map.insert(1901, &[36929]);     // 1901 => [36929]
            map.insert(1902, &[8833]);     // 1902 => [8833]
            map.insert(1903, &[8832]);     // 1903 => [8832]
            map.insert(1904, &[66693]);     // 1904 => [66693]
            map.insert(1905, &[66692]);     // 1905 => [66692]
            map.insert(1906, &[10340]);     // 1906 => [10340]
            map.insert(1907, &[66694]);     // 1907 => [66694]
            map.insert(1908, &[66689]);     // 1908 => [66689]
            map.insert(1909, &[66688]);     // 1909 => [66688]
            map.insert(1910, &[10336]);     // 1910 => [10336]
            map.insert(1911, &[66690]);     // 1911 => [66690]
            map.insert(1912, &[3457]);     // 1912 => [3457]
            map.insert(1913, &[3456]);     // 1913 => [3456]
            map.insert(1914, &[49316]);     // 1914 => [49316]
            map.insert(1915, &[3458]);     // 1915 => [3458]
            map.insert(1916, &[36944]);     // 1916 => [36944]
            map.insert(1917, &[66696]);     // 1917 => [66696]
            map.insert(1918, &[49312]);     // 1918 => [49312]
            map.insert(1919, &[8848]);     // 1919 => [8848]
            map.insert(1920, &[1920]);     // 1920 => [1920]
            map.insert(1921, &[401536]);     // 1921 => [401536]
            map.insert(1922, &[1922]);     // 1922 => [1922]
            map.insert(1923, &[401538]);     // 1923 => [401538]
            map.insert(1924, &[10386]);     // 1924 => [10386]
            map.insert(1925, &[401540]);     // 1925 => [401540]
            map.insert(1926, &[10384]);     // 1926 => [10384]
            map.insert(1927, &[10385]);     // 1927 => [10385]
            map.insert(1928, &[37028]);     // 1928 => [37028]
            map.insert(1929, &[401544]);     // 1929 => [401544]
            map.insert(1930, &[49236]);     // 1930 => [49236]
            map.insert(1931, &[8804]);     // 1931 => [8804]
            map.insert(1932, &[37024]);     // 1932 => [37024]
            map.insert(1933, &[37025]);     // 1933 => [37025]
            map.insert(1934, &[49232]);     // 1934 => [49232]
            map.insert(1935, &[8800]);     // 1935 => [8800]
            map.insert(1936, &[10374]);     // 1936 => [10374]
            map.insert(1937, &[66660]);     // 1937 => [66660]
            map.insert(1938, &[10372]);     // 1938 => [10372]
            map.insert(1939, &[10373]);     // 1939 => [10373]
            map.insert(1940, &[10370]);     // 1940 => [10370]
            map.insert(1941, &[66656]);     // 1941 => [66656]
            map.insert(1942, &[10368]);     // 1942 => [10368]
            map.insert(1943, &[10369]);     // 1943 => [10369]
            map.insert(1944, &[49222]);     // 1944 => [49222]
            map.insert(1945, &[3424]);     // 1945 => [3424]
            map.insert(1946, &[49220]);     // 1946 => [49220]
            map.insert(1947, &[49221]);     // 1947 => [49221]
            map.insert(1948, &[49218]);     // 1948 => [49218]
            map.insert(1949, &[49219]);     // 1949 => [49219]
            map.insert(1950, &[49216]);     // 1950 => [49216]
            map.insert(1951, &[49217]);     // 1951 => [49217]
            map.insert(1952, &[37004]);     // 1952 => [37004]
            map.insert(1953, &[66644]);     // 1953 => [66644]
            map.insert(1954, &[8781]);     // 1954 => [8781]
            map.insert(1955, &[8780]);     // 1955 => [8780]
            map.insert(1956, &[37000]);     // 1956 => [37000]
            map.insert(1957, &[66640]);     // 1957 => [66640]
            map.insert(1958, &[8777]);     // 1958 => [8777]
            map.insert(1959, &[8776]);     // 1959 => [8776]
            map.insert(1960, &[36996]);     // 1960 => [36996]
            map.insert(1961, &[36997]);     // 1961 => [36997]
            map.insert(1962, &[8773]);     // 1962 => [8773]
            map.insert(1963, &[8772]);     // 1963 => [8772]
            map.insert(1964, &[36992]);     // 1964 => [36992]
            map.insert(1965, &[36993]);     // 1965 => [36993]
            map.insert(1966, &[8769]);     // 1966 => [8769]
            map.insert(1967, &[8768]);     // 1967 => [8768]
            map.insert(1968, &[66629]);     // 1968 => [66629]
            map.insert(1969, &[66628]);     // 1969 => [66628]
            map.insert(1970, &[10404]);     // 1970 => [10404]
            map.insert(1971, &[66630]);     // 1971 => [66630]
            map.insert(1972, &[66625]);     // 1972 => [66625]
            map.insert(1973, &[66624]);     // 1973 => [66624]
            map.insert(1974, &[10400]);     // 1974 => [10400]
            map.insert(1975, &[66626]);     // 1975 => [66626]
            map.insert(1976, &[3393]);     // 1976 => [3393]
            map.insert(1977, &[3392]);     // 1977 => [3392]
            map.insert(1978, &[49252]);     // 1978 => [49252]
            map.insert(1979, &[3394]);     // 1979 => [3394]
            map.insert(1980, &[37008]);     // 1980 => [37008]
            map.insert(1981, &[66632]);     // 1981 => [66632]
            map.insert(1982, &[49248]);     // 1982 => [49248]
            map.insert(1983, &[8784]);     // 1983 => [8784]
            map.insert(1984, &[138240]);     // 1984 => [138240]
            map.insert(1985, &[138241]);     // 1985 => [138241]
            map.insert(1986, &[138242]);     // 1986 => [138242]
            map.insert(1987, &[8748]);     // 1987 => [8748]
            map.insert(1988, &[66609]);     // 1988 => [66609]
            map.insert(1989, &[66608]);     // 1989 => [66608]
            map.insert(1990, &[49176]);     // 1990 => [49176]
            map.insert(1991, &[8744]);     // 1991 => [8744]
            map.insert(1992, &[49174]);     // 1992 => [49174]
            map.insert(1993, &[8742]);     // 1993 => [8742]
            map.insert(1994, &[49172]);     // 1994 => [49172]
            map.insert(1995, &[8740]);     // 1995 => [8740]
            map.insert(1996, &[49170]);     // 1996 => [49170]
            map.insert(1997, &[8738]);     // 1997 => [8738]
            map.insert(1998, &[49168]);     // 1998 => [49168]
            map.insert(1999, &[8736]);     // 1999 => [8736]
            map.insert(2000, &[66597]);     // 2000 => [66597]
            map.insert(2001, &[66596]);     // 2001 => [66596]
            map.insert(2002, &[49164]);     // 2002 => [49164]
            map.insert(2003, &[267268]);     // 2003 => [267268]
            map.insert(2004, &[66593]);     // 2004 => [66593]
            map.insert(2005, &[66592]);     // 2005 => [66592]
            map.insert(2006, &[49160]);     // 2006 => [49160]
            map.insert(2007, &[267264]);     // 2007 => [267264]
            map.insert(2008, &[49158]);     // 2008 => [49158]
            map.insert(2009, &[3360]);     // 2009 => [3360]
            map.insert(2010, &[49156]);     // 2010 => [49156]
            map.insert(2011, &[49157]);     // 2011 => [49157]
            map.insert(2012, &[49154]);     // 2012 => [49154]
            map.insert(2013, &[49155]);     // 2013 => [49155]
            map.insert(2014, &[49152]);     // 2014 => [49152]
            map.insert(2015, &[49153]);     // 2015 => [49153]
            map.insert(2016, &[229888]);     // 2016 => [229888]
            map.insert(2017, &[66580]);     // 2017 => [66580]
            map.insert(2018, &[8717]);     // 2018 => [8717]
            map.insert(2019, &[8716]);     // 2019 => [8716]
            map.insert(2020, &[66577]);     // 2020 => [66577]
            map.insert(2021, &[66576]);     // 2021 => [66576]
            map.insert(2022, &[8713]);     // 2022 => [8713]
            map.insert(2023, &[8712]);     // 2023 => [8712]
            map.insert(2024, &[8711]);     // 2024 => [8711]
            map.insert(2025, &[8710]);     // 2025 => [8710]
            map.insert(2026, &[8709]);     // 2026 => [8709]
            map.insert(2027, &[8708]);     // 2027 => [8708]
            map.insert(2028, &[8707]);     // 2028 => [8707]
            map.insert(2029, &[8706]);     // 2029 => [8706]
            map.insert(2030, &[8705]);     // 2030 => [8705]
            map.insert(2031, &[8704]);     // 2031 => [8704]
            map.insert(2032, &[66565]);     // 2032 => [66565]
            map.insert(2033, &[66564]);     // 2033 => [66564]
            map.insert(2034, &[66567]);     // 2034 => [66567]
            map.insert(2035, &[66566]);     // 2035 => [66566]
            map.insert(2036, &[66561]);     // 2036 => [66561]
            map.insert(2037, &[66560]);     // 2037 => [66560]
            map.insert(2038, &[66563]);     // 2038 => [66563]
            map.insert(2039, &[66562]);     // 2039 => [66562]
            map.insert(2040, &[3329]);     // 2040 => [3329]
            map.insert(2041, &[3328]);     // 2041 => [3328]
            map.insert(2042, &[49188]);     // 2042 => [49188]
            map.insert(2043, &[3330]);     // 2043 => [3330]
            map.insert(2044, &[66569]);     // 2044 => [66569]
            map.insert(2045, &[66568]);     // 2045 => [66568]
            map.insert(2046, &[49184]);     // 2046 => [49184]
            map.insert(2047, &[8720]);     // 2047 => [8720]
            map.insert(2048, &[4096]);     // 2048 => [4096]
            map.insert(2049, &[4097]);     // 2049 => [4097]
            map.insert(2050, &[4098]);     // 2050 => [4098]
            map.insert(2051, &[4099]);     // 2051 => [4099]
            map.insert(2052, &[4100]);     // 2052 => [4100]
            map.insert(2053, &[4101]);     // 2053 => [4101]
            map.insert(2054, &[4102]);     // 2054 => [4102]
            map.insert(2055, &[4103]);     // 2055 => [4103]
            map.insert(2056, &[4104]);     // 2056 => [4104]
            map.insert(2057, &[4105]);     // 2057 => [4105]
            map.insert(2058, &[4106]);     // 2058 => [4106]
            map.insert(2059, &[18944]);     // 2059 => [18944]
            map.insert(2060, &[4108]);     // 2060 => [4108]
            map.insert(2061, &[4109]);     // 2061 => [4109]
            map.insert(2062, &[4110]);     // 2062 => [4110]
            map.insert(2063, &[18948]);     // 2063 => [18948]
            map.insert(2064, &[4112]);     // 2064 => [4112]
            map.insert(2065, &[4113]);     // 2065 => [4113]
            map.insert(2066, &[4114]);     // 2066 => [4114]
            map.insert(2067, &[4115]);     // 2067 => [4115]
            map.insert(2068, &[4116]);     // 2068 => [4116]
            map.insert(2069, &[4117]);     // 2069 => [4117]
            map.insert(2070, &[4118]);     // 2070 => [4118]
            map.insert(2071, &[399360]);     // 2071 => [399360]
            map.insert(2072, &[4120]);     // 2072 => [4120]
            map.insert(2073, &[131360]);     // 2073 => [131360]
            map.insert(2074, &[4122]);     // 2074 => [4122]
            map.insert(2075, &[131362]);     // 2075 => [131362]
            map.insert(2076, &[4124]);     // 2076 => [4124]
            map.insert(2077, &[131364]);     // 2077 => [131364]
            map.insert(2078, &[4126]);     // 2078 => [4126]
            map.insert(2079, &[131366]);     // 2079 => [131366]
            map.insert(2080, &[4128]);     // 2080 => [4128]
            map.insert(2081, &[4129]);     // 2081 => [4129]
            map.insert(2082, &[327680]);     // 2082 => [327680]
            map.insert(2083, &[327681]);     // 2083 => [327681]
            map.insert(2084, &[4132]);     // 2084 => [4132]
            map.insert(2085, &[4133]);     // 2085 => [4133]
            map.insert(2086, &[327684]);     // 2086 => [327684]
            map.insert(2087, &[327685]);     // 2087 => [327685]
            map.insert(2088, &[4136]);     // 2088 => [4136]
            map.insert(2089, &[131344]);     // 2089 => [131344]
            map.insert(2090, &[327688]);     // 2090 => [327688]
            map.insert(2091, &[327689]);     // 2091 => [327689]
            map.insert(2092, &[264450]);     // 2092 => [264450]
            map.insert(2093, &[131348]);     // 2093 => [131348]
            map.insert(2094, &[264448]);     // 2094 => [264448]
            map.insert(2095, &[264449]);     // 2095 => [264449]
            map.insert(2096, &[4144]);     // 2096 => [4144]
            map.insert(2097, &[131336]);     // 2097 => [131336]
            map.insert(2098, &[327696]);     // 2098 => [327696]
            map.insert(2099, &[327697]);     // 2099 => [327697]
            map.insert(2100, &[198657]);     // 2100 => [198657]
            map.insert(2101, &[198656]);     // 2101 => [198656]
            map.insert(2102, &[327700]);     // 2102 => [327700]
            map.insert(2103, &[198658]);     // 2103 => [198658]
            map.insert(2104, &[131329]);     // 2104 => [131329]
            map.insert(2105, &[131328]);     // 2105 => [131328]
            map.insert(2106, &[43008]);     // 2106 => [43008]
            map.insert(2107, &[131330]);     // 2107 => [131330]
            map.insert(2108, &[131333]);     // 2108 => [131333]
            map.insert(2109, &[131332]);     // 2109 => [131332]
            map.insert(2110, &[43012]);     // 2110 => [43012]
            map.insert(2111, &[131334]);     // 2111 => [131334]
            map.insert(2112, &[4160]);     // 2112 => [4160]
            map.insert(2113, &[4161]);     // 2113 => [4161]
            map.insert(2114, &[4162]);     // 2114 => [4162]
            map.insert(2115, &[4163]);     // 2115 => [4163]
            map.insert(2116, &[4164]);     // 2116 => [4164]
            map.insert(2117, &[4165]);     // 2117 => [4165]
            map.insert(2118, &[4166]);     // 2118 => [4166]
            map.insert(2119, &[4167]);     // 2119 => [4167]
            map.insert(2120, &[4168]);     // 2120 => [4168]
            map.insert(2121, &[4169]);     // 2121 => [4169]
            map.insert(2122, &[4170]);     // 2122 => [4170]
            map.insert(2123, &[19008]);     // 2123 => [19008]
            map.insert(2124, &[4172]);     // 2124 => [4172]
            map.insert(2125, &[4173]);     // 2125 => [4173]
            map.insert(2126, &[4174]);     // 2126 => [4174]
            map.insert(2127, &[19012]);     // 2127 => [19012]
            map.insert(2128, &[4176]);     // 2128 => [4176]
            map.insert(2129, &[4177]);     // 2129 => [4177]
            map.insert(2130, &[16544]);     // 2130 => [16544]
            map.insert(2131, &[16545]);     // 2131 => [16545]
            map.insert(2132, &[4180]);     // 2132 => [4180]
            map.insert(2133, &[4181]);     // 2133 => [4181]
            map.insert(2134, &[16548]);     // 2134 => [16548]
            map.insert(2135, &[263040]);     // 2135 => [263040]
            map.insert(2136, &[4184]);     // 2136 => [4184]
            map.insert(2137, &[131424]);     // 2137 => [131424]
            map.insert(2138, &[16552]);     // 2138 => [16552]
            map.insert(2139, &[16553]);     // 2139 => [16553]
            map.insert(2140, &[4188]);     // 2140 => [4188]
            map.insert(2141, &[131428]);     // 2141 => [131428]
            map.insert(2142, &[16556]);     // 2142 => [16556]
            map.insert(2143, &[263048]);     // 2143 => [263048]
            map.insert(2144, &[4192]);     // 2144 => [4192]
            map.insert(2145, &[4193]);     // 2145 => [4193]
            map.insert(2146, &[16528]);     // 2146 => [16528]
            map.insert(2147, &[16529]);     // 2147 => [16529]
            map.insert(2148, &[4196]);     // 2148 => [4196]
            map.insert(2149, &[4197]);     // 2149 => [4197]
            map.insert(2150, &[16532]);     // 2150 => [16532]
            map.insert(2151, &[16533]);     // 2151 => [16533]
            map.insert(2152, &[4200]);     // 2152 => [4200]
            map.insert(2153, &[131408]);     // 2153 => [131408]
            map.insert(2154, &[16536]);     // 2154 => [16536]
            map.insert(2155, &[16537]);     // 2155 => [16537]
            map.insert(2156, &[264514]);     // 2156 => [264514]
            map.insert(2157, &[131412]);     // 2157 => [131412]
            map.insert(2158, &[264512]);     // 2158 => [264512]
            map.insert(2159, &[264513]);     // 2159 => [264513]
            map.insert(2160, &[16514]);     // 2160 => [16514]
            map.insert(2161, &[16515]);     // 2161 => [16515]
            map.insert(2162, &[16512]);     // 2162 => [16512]
            map.insert(2163, &[16513]);     // 2163 => [16513]
            map.insert(2164, &[16518]);     // 2164 => [16518]
            map.insert(2165, &[198720]);     // 2165 => [198720]
            map.insert(2166, &[16516]);     // 2166 => [16516]
            map.insert(2167, &[16517]);     // 2167 => [16517]
            map.insert(2168, &[131393]);     // 2168 => [131393]
            map.insert(2169, &[131392]);     // 2169 => [131392]
            map.insert(2170, &[16520]);     // 2170 => [16520]
            map.insert(2171, &[16521]);     // 2171 => [16521]
            map.insert(2172, &[131397]);     // 2172 => [131397]
            map.insert(2173, &[131396]);     // 2173 => [131396]
            map.insert(2174, &[16524]);     // 2174 => [16524]
            map.insert(2175, &[16525]);     // 2175 => [16525]
            map.insert(2176, &[4224]);     // 2176 => [4224]
            map.insert(2177, &[4225]);     // 2177 => [4225]
            map.insert(2178, &[4226]);     // 2178 => [4226]
            map.insert(2179, &[4227]);     // 2179 => [4227]
            map.insert(2180, &[4228]);     // 2180 => [4228]
            map.insert(2181, &[4229]);     // 2181 => [4229]
            map.insert(2182, &[4230]);     // 2182 => [4230]
            map.insert(2183, &[4231]);     // 2183 => [4231]
            map.insert(2184, &[4232]);     // 2184 => [4232]
            map.insert(2185, &[4233]);     // 2185 => [4233]
            map.insert(2186, &[4234]);     // 2186 => [4234]
            map.insert(2187, &[19072]);     // 2187 => [19072]
            map.insert(2188, &[4236]);     // 2188 => [4236]
            map.insert(2189, &[4237]);     // 2189 => [4237]
            map.insert(2190, &[4238]);     // 2190 => [4238]
            map.insert(2191, &[19076]);     // 2191 => [19076]
            map.insert(2192, &[4240]);     // 2192 => [4240]
            map.insert(2193, &[4241]);     // 2193 => [4241]
            map.insert(2194, &[16480]);     // 2194 => [16480]
            map.insert(2195, &[16481]);     // 2195 => [16481]
            map.insert(2196, &[4244]);     // 2196 => [4244]
            map.insert(2197, &[4245]);     // 2197 => [4245]
            map.insert(2198, &[16484]);     // 2198 => [16484]
            map.insert(2199, &[262976]);     // 2199 => [262976]
            map.insert(2200, &[4248]);     // 2200 => [4248]
            map.insert(2201, &[131488]);     // 2201 => [131488]
            map.insert(2202, &[16488]);     // 2202 => [16488]
            map.insert(2203, &[16489]);     // 2203 => [16489]
            map.insert(2204, &[4252]);     // 2204 => [4252]
            map.insert(2205, &[131492]);     // 2205 => [131492]
            map.insert(2206, &[16492]);     // 2206 => [16492]
            map.insert(2207, &[262984]);     // 2207 => [262984]
            map.insert(2208, &[4256]);     // 2208 => [4256]
            map.insert(2209, &[4257]);     // 2209 => [4257]
            map.insert(2210, &[16464]);     // 2210 => [16464]
            map.insert(2211, &[16465]);     // 2211 => [16465]
            map.insert(2212, &[4260]);     // 2212 => [4260]
            map.insert(2213, &[4261]);     // 2213 => [4261]
            map.insert(2214, &[16468]);     // 2214 => [16468]
            map.insert(2215, &[16469]);     // 2215 => [16469]
            map.insert(2216, &[4264]);     // 2216 => [4264]
            map.insert(2217, &[131472]);     // 2217 => [131472]
            map.insert(2218, &[16472]);     // 2218 => [16472]
            map.insert(2219, &[16473]);     // 2219 => [16473]
            map.insert(2220, &[264578]);     // 2220 => [264578]
            map.insert(2221, &[131476]);     // 2221 => [131476]
            map.insert(2222, &[264576]);     // 2222 => [264576]
            map.insert(2223, &[264577]);     // 2223 => [264577]
            map.insert(2224, &[16450]);     // 2224 => [16450]
            map.insert(2225, &[16451]);     // 2225 => [16451]
            map.insert(2226, &[16448]);     // 2226 => [16448]
            map.insert(2227, &[16449]);     // 2227 => [16449]
            map.insert(2228, &[16454]);     // 2228 => [16454]
            map.insert(2229, &[198784]);     // 2229 => [198784]
            map.insert(2230, &[16452]);     // 2230 => [16452]
            map.insert(2231, &[16453]);     // 2231 => [16453]
            map.insert(2232, &[131457]);     // 2232 => [131457]
            map.insert(2233, &[131456]);     // 2233 => [131456]
            map.insert(2234, &[16456]);     // 2234 => [16456]
            map.insert(2235, &[16457]);     // 2235 => [16457]
            map.insert(2236, &[131461]);     // 2236 => [131461]
            map.insert(2237, &[131460]);     // 2237 => [131460]
            map.insert(2238, &[16460]);     // 2238 => [16460]
            map.insert(2239, &[16461]);     // 2239 => [16461]
            map.insert(2240, &[4288]);     // 2240 => [4288]
            map.insert(2241, &[4289]);     // 2241 => [4289]
            map.insert(2242, &[16432]);     // 2242 => [16432]
            map.insert(2243, &[41472]);     // 2243 => [41472]
            map.insert(2244, &[4292]);     // 2244 => [4292]
            map.insert(2245, &[4293]);     // 2245 => [4293]
            map.insert(2246, &[16436]);     // 2246 => [16436]
            map.insert(2247, &[41476]);     // 2247 => [41476]
            map.insert(2248, &[197124]);     // 2248 => [197124]
            map.insert(2249, &[99344]);     // 2249 => [99344]
            map.insert(2250, &[16440]);     // 2250 => [16440]
            map.insert(2251, &[41480]);     // 2251 => [41480]
            map.insert(2252, &[197120]);     // 2252 => [197120]
            map.insert(2253, &[197121]);     // 2253 => [197121]
            map.insert(2254, &[197122]);     // 2254 => [197122]
            map.insert(2255, &[197123]);     // 2255 => [197123]
            map.insert(2256, &[16418]);     // 2256 => [16418]
            map.insert(2257, &[16419]);     // 2257 => [16419]
            map.insert(2258, &[16416]);     // 2258 => [16416]
            map.insert(2259, &[16417]);     // 2259 => [16417]
            map.insert(2260, &[16422]);     // 2260 => [16422]
            map.insert(2261, &[262914]);     // 2261 => [262914]
            map.insert(2262, &[16420]);     // 2262 => [16420]
            map.insert(2263, &[262912]);     // 2263 => [262912]
            map.insert(2264, &[99329]);     // 2264 => [99329]
            map.insert(2265, &[99328]);     // 2265 => [99328]
            map.insert(2266, &[16424]);     // 2266 => [16424]
            map.insert(2267, &[16425]);     // 2267 => [16425]
            map.insert(2268, &[197136]);     // 2268 => [197136]
            map.insert(2269, &[99332]);     // 2269 => [99332]
            map.insert(2270, &[16428]);     // 2270 => [16428]
            map.insert(2271, &[262920]);     // 2271 => [262920]
            map.insert(2272, &[16402]);     // 2272 => [16402]
            map.insert(2273, &[16403]);     // 2273 => [16403]
            map.insert(2274, &[16400]);     // 2274 => [16400]
            map.insert(2275, &[16401]);     // 2275 => [16401]
            map.insert(2276, &[16406]);     // 2276 => [16406]
            map.insert(2277, &[411648]);     // 2277 => [411648]
            map.insert(2278, &[16404]);     // 2278 => [16404]
            map.insert(2279, &[16405]);     // 2279 => [16405]
            map.insert(2280, &[16410]);     // 2280 => [16410]
            map.insert(2281, &[6672]);     // 2281 => [6672]
            map.insert(2282, &[16408]);     // 2282 => [16408]
            map.insert(2283, &[16409]);     // 2283 => [16409]
            map.insert(2284, &[197152]);     // 2284 => [197152]
            map.insert(2285, &[197153]);     // 2285 => [197153]
            map.insert(2286, &[16412]);     // 2286 => [16412]
            map.insert(2287, &[13568]);     // 2287 => [13568]
            map.insert(2288, &[16386]);     // 2288 => [16386]
            map.insert(2289, &[16387]);     // 2289 => [16387]
            map.insert(2290, &[16384]);     // 2290 => [16384]
            map.insert(2291, &[16385]);     // 2291 => [16385]
            map.insert(2292, &[16390]);     // 2292 => [16390]
            map.insert(2293, &[16391]);     // 2293 => [16391]
            map.insert(2294, &[16388]);     // 2294 => [16388]
            map.insert(2295, &[16389]);     // 2295 => [16389]
            map.insert(2296, &[16394]);     // 2296 => [16394]
            map.insert(2297, &[6656]);     // 2297 => [6656]
            map.insert(2298, &[16392]);     // 2298 => [16392]
            map.insert(2299, &[16393]);     // 2299 => [16393]
            map.insert(2300, &[16398]);     // 2300 => [16398]
            map.insert(2301, &[6660]);     // 2301 => [6660]
            map.insert(2302, &[16396]);     // 2302 => [16396]
            map.insert(2303, &[16397]);     // 2303 => [16397]
            map.insert(2304, &[4352]);     // 2304 => [4352]
            map.insert(2305, &[4353]);     // 2305 => [4353]
            map.insert(2306, &[4354]);     // 2306 => [4354]
            map.insert(2307, &[4355]);     // 2307 => [4355]
            map.insert(2308, &[4356]);     // 2308 => [4356]
            map.insert(2309, &[4357]);     // 2309 => [4357]
            map.insert(2310, &[82433]);     // 2310 => [82433]
            map.insert(2311, &[82432]);     // 2311 => [82432]
            map.insert(2312, &[4360]);     // 2312 => [4360]
            map.insert(2313, &[131120]);     // 2313 => [131120]
            map.insert(2314, &[4362]);     // 2314 => [4362]
            map.insert(2315, &[131122]);     // 2315 => [131122]
            map.insert(2316, &[71680]);     // 2316 => [71680]
            map.insert(2317, &[71681]);     // 2317 => [71681]
            map.insert(2318, &[264224]);     // 2318 => [264224]
            map.insert(2319, &[264225]);     // 2319 => [264225]
            map.insert(2320, &[4368]);     // 2320 => [4368]
            map.insert(2321, &[131112]);     // 2321 => [131112]
            map.insert(2322, &[4370]);     // 2322 => [4370]
            map.insert(2323, &[131114]);     // 2323 => [131114]
            map.insert(2324, &[4372]);     // 2324 => [4372]
            map.insert(2325, &[131116]);     // 2325 => [131116]
            map.insert(2326, &[106528]);     // 2326 => [106528]
            map.insert(2327, &[82448]);     // 2327 => [82448]
            map.insert(2328, &[131105]);     // 2328 => [131105]
            map.insert(2329, &[131104]);     // 2329 => [131104]
            map.insert(2330, &[131107]);     // 2330 => [131107]
            map.insert(2331, &[131106]);     // 2331 => [131106]
            map.insert(2332, &[131109]);     // 2332 => [131109]
            map.insert(2333, &[131108]);     // 2333 => [131108]
            map.insert(2334, &[264240]);     // 2334 => [264240]
            map.insert(2335, &[131110]);     // 2335 => [131110]
            map.insert(2336, &[4384]);     // 2336 => [4384]
            map.insert(2337, &[131096]);     // 2337 => [131096]
            map.insert(2338, &[327936]);     // 2338 => [327936]
            map.insert(2339, &[327937]);     // 2339 => [327937]
            map.insert(2340, &[264202]);     // 2340 => [264202]
            map.insert(2341, &[131100]);     // 2341 => [131100]
            map.insert(2342, &[264200]);     // 2342 => [264200]
            map.insert(2343, &[264201]);     // 2343 => [264201]
            map.insert(2344, &[131089]);     // 2344 => [131089]
            map.insert(2345, &[131088]);     // 2345 => [131088]
            map.insert(2346, &[264196]);     // 2346 => [264196]
            map.insert(2347, &[131090]);     // 2347 => [131090]
            map.insert(2348, &[264194]);     // 2348 => [264194]
            map.insert(2349, &[131092]);     // 2349 => [131092]
            map.insert(2350, &[264192]);     // 2350 => [264192]
            map.insert(2351, &[264193]);     // 2351 => [264193]
            map.insert(2352, &[131081]);     // 2352 => [131081]
            map.insert(2353, &[131080]);     // 2353 => [131080]
            map.insert(2354, &[131083]);     // 2354 => [131083]
            map.insert(2355, &[131082]);     // 2355 => [131082]
            map.insert(2356, &[131085]);     // 2356 => [131085]
            map.insert(2357, &[131084]);     // 2357 => [131084]
            map.insert(2358, &[106496]);     // 2358 => [106496]
            map.insert(2359, &[106497]);     // 2359 => [106497]
            map.insert(2360, &[131073]);     // 2360 => [131073]
            map.insert(2361, &[131072]);     // 2361 => [131072]
            map.insert(2362, &[131075]);     // 2362 => [131075]
            map.insert(2363, &[131074]);     // 2363 => [131074]
            map.insert(2364, &[131077]);     // 2364 => [131077]
            map.insert(2365, &[131076]);     // 2365 => [131076]
            map.insert(2366, &[264208]);     // 2366 => [264208]
            map.insert(2367, &[131078]);     // 2367 => [131078]
            map.insert(2368, &[4416]);     // 2368 => [4416]
            map.insert(2369, &[4417]);     // 2369 => [4417]
            map.insert(2370, &[4418]);     // 2370 => [4418]
            map.insert(2371, &[4419]);     // 2371 => [4419]
            map.insert(2372, &[4420]);     // 2372 => [4420]
            map.insert(2373, &[4421]);     // 2373 => [4421]
            map.insert(2374, &[262801]);     // 2374 => [262801]
            map.insert(2375, &[262800]);     // 2375 => [262800]
            map.insert(2376, &[4424]);     // 2376 => [4424]
            map.insert(2377, &[131184]);     // 2377 => [131184]
            map.insert(2378, &[151681]);     // 2378 => [151681]
            map.insert(2379, &[151680]);     // 2379 => [151680]
            map.insert(2380, &[71744]);     // 2380 => [71744]
            map.insert(2381, &[71745]);     // 2381 => [71745]
            map.insert(2382, &[264288]);     // 2382 => [264288]
            map.insert(2383, &[264289]);     // 2383 => [264289]
            map.insert(2384, &[4432]);     // 2384 => [4432]
            map.insert(2385, &[131176]);     // 2385 => [131176]
            map.insert(2386, &[16800]);     // 2386 => [16800]
            map.insert(2387, &[262788]);     // 2387 => [262788]
            map.insert(2388, &[262787]);     // 2388 => [262787]
            map.insert(2389, &[262786]);     // 2389 => [262786]
            map.insert(2390, &[262785]);     // 2390 => [262785]
            map.insert(2391, &[262784]);     // 2391 => [262784]
            map.insert(2392, &[131169]);     // 2392 => [131169]
            map.insert(2393, &[131168]);     // 2393 => [131168]
            map.insert(2394, &[131171]);     // 2394 => [131171]
            map.insert(2395, &[131170]);     // 2395 => [131170]
            map.insert(2396, &[131173]);     // 2396 => [131173]
            map.insert(2397, &[131172]);     // 2397 => [131172]
            map.insert(2398, &[262793]);     // 2398 => [262793]
            map.insert(2399, &[262792]);     // 2399 => [262792]
            map.insert(2400, &[4448]);     // 2400 => [4448]
            map.insert(2401, &[131160]);     // 2401 => [131160]
            map.insert(2402, &[16784]);     // 2402 => [16784]
            map.insert(2403, &[16785]);     // 2403 => [16785]
            map.insert(2404, &[264266]);     // 2404 => [264266]
            map.insert(2405, &[131164]);     // 2405 => [131164]
            map.insert(2406, &[264264]);     // 2406 => [264264]
            map.insert(2407, &[264265]);     // 2407 => [264265]
            map.insert(2408, &[131153]);     // 2408 => [131153]
            map.insert(2409, &[131152]);     // 2409 => [131152]
            map.insert(2410, &[264260]);     // 2410 => [264260]
            map.insert(2411, &[131154]);     // 2411 => [131154]
            map.insert(2412, &[264258]);     // 2412 => [264258]
            map.insert(2413, &[131156]);     // 2413 => [131156]
            map.insert(2414, &[264256]);     // 2414 => [264256]
            map.insert(2415, &[264257]);     // 2415 => [264257]
            map.insert(2416, &[131145]);     // 2416 => [131145]
            map.insert(2417, &[131144]);     // 2417 => [131144]
            map.insert(2418, &[16768]);     // 2418 => [16768]
            map.insert(2419, &[16769]);     // 2419 => [16769]
            map.insert(2420, &[131149]);     // 2420 => [131149]
            map.insert(2421, &[131148]);     // 2421 => [131148]
            map.insert(2422, &[16772]);     // 2422 => [16772]
            map.insert(2423, &[262816]);     // 2423 => [262816]
            map.insert(2424, &[131137]);     // 2424 => [131137]
            map.insert(2425, &[131136]);     // 2425 => [131136]
            map.insert(2426, &[131139]);     // 2426 => [131139]
            map.insert(2427, &[131138]);     // 2427 => [131138]
            map.insert(2428, &[131141]);     // 2428 => [131141]
            map.insert(2429, &[131140]);     // 2429 => [131140]
            map.insert(2430, &[264272]);     // 2430 => [264272]
            map.insert(2431, &[131142]);     // 2431 => [131142]
            map.insert(2432, &[4480]);     // 2432 => [4480]
            map.insert(2433, &[4481]);     // 2433 => [4481]
            map.insert(2434, &[4482]);     // 2434 => [4482]
            map.insert(2435, &[4483]);     // 2435 => [4483]
            map.insert(2436, &[4484]);     // 2436 => [4484]
            map.insert(2437, &[4485]);     // 2437 => [4485]
            map.insert(2438, &[262737]);     // 2438 => [262737]
            map.insert(2439, &[262736]);     // 2439 => [262736]
            map.insert(2440, &[4488]);     // 2440 => [4488]
            map.insert(2441, &[131248]);     // 2441 => [131248]
            map.insert(2442, &[151617]);     // 2442 => [151617]
            map.insert(2443, &[151616]);     // 2443 => [151616]
            map.insert(2444, &[71808]);     // 2444 => [71808]
            map.insert(2445, &[71809]);     // 2445 => [71809]
            map.insert(2446, &[264352]);     // 2446 => [264352]
            map.insert(2447, &[264353]);     // 2447 => [264353]
            map.insert(2448, &[4496]);     // 2448 => [4496]
            map.insert(2449, &[131240]);     // 2449 => [131240]
            map.insert(2450, &[16736]);     // 2450 => [16736]
            map.insert(2451, &[262724]);     // 2451 => [262724]
            map.insert(2452, &[262723]);     // 2452 => [262723]
            map.insert(2453, &[262722]);     // 2453 => [262722]
            map.insert(2454, &[262721]);     // 2454 => [262721]
            map.insert(2455, &[262720]);     // 2455 => [262720]
            map.insert(2456, &[131233]);     // 2456 => [131233]
            map.insert(2457, &[131232]);     // 2457 => [131232]
            map.insert(2458, &[131235]);     // 2458 => [131235]
            map.insert(2459, &[131234]);     // 2459 => [131234]
            map.insert(2460, &[131237]);     // 2460 => [131237]
            map.insert(2461, &[131236]);     // 2461 => [131236]
            map.insert(2462, &[262729]);     // 2462 => [262729]
            map.insert(2463, &[262728]);     // 2463 => [262728]
            map.insert(2464, &[4512]);     // 2464 => [4512]
            map.insert(2465, &[131224]);     // 2465 => [131224]
            map.insert(2466, &[16720]);     // 2466 => [16720]
            map.insert(2467, &[16721]);     // 2467 => [16721]
            map.insert(2468, &[264330]);     // 2468 => [264330]
            map.insert(2469, &[131228]);     // 2469 => [131228]
            map.insert(2470, &[264328]);     // 2470 => [264328]
            map.insert(2471, &[264329]);     // 2471 => [264329]
            map.insert(2472, &[131217]);     // 2472 => [131217]
            map.insert(2473, &[131216]);     // 2473 => [131216]
            map.insert(2474, &[264324]);     // 2474 => [264324]
            map.insert(2475, &[131218]);     // 2475 => [131218]
            map.insert(2476, &[264322]);     // 2476 => [264322]
            map.insert(2477, &[131220]);     // 2477 => [131220]
            map.insert(2478, &[264320]);     // 2478 => [264320]
            map.insert(2479, &[264321]);     // 2479 => [264321]
            map.insert(2480, &[131209]);     // 2480 => [131209]
            map.insert(2481, &[131208]);     // 2481 => [131208]
            map.insert(2482, &[16704]);     // 2482 => [16704]
            map.insert(2483, &[16705]);     // 2483 => [16705]
            map.insert(2484, &[131213]);     // 2484 => [131213]
            map.insert(2485, &[131212]);     // 2485 => [131212]
            map.insert(2486, &[16708]);     // 2486 => [16708]
            map.insert(2487, &[262752]);     // 2487 => [262752]
            map.insert(2488, &[131201]);     // 2488 => [131201]
            map.insert(2489, &[131200]);     // 2489 => [131200]
            map.insert(2490, &[131203]);     // 2490 => [131203]
            map.insert(2491, &[131202]);     // 2491 => [131202]
            map.insert(2492, &[131205]);     // 2492 => [131205]
            map.insert(2493, &[131204]);     // 2493 => [131204]
            map.insert(2494, &[264336]);     // 2494 => [264336]
            map.insert(2495, &[131206]);     // 2495 => [131206]
            map.insert(2496, &[133632]);     // 2496 => [133632]
            map.insert(2497, &[133633]);     // 2497 => [133633]
            map.insert(2498, &[133634]);     // 2498 => [133634]
            map.insert(2499, &[262676]);     // 2499 => [262676]
            map.insert(2500, &[133636]);     // 2500 => [133636]
            map.insert(2501, &[262674]);     // 2501 => [262674]
            map.insert(2502, &[262673]);     // 2502 => [262673]
            map.insert(2503, &[262672]);     // 2503 => [262672]
            map.insert(2504, &[133640]);     // 2504 => [133640]
            map.insert(2505, &[151554]);     // 2505 => [151554]
            map.insert(2506, &[151553]);     // 2506 => [151553]
            map.insert(2507, &[151552]);     // 2507 => [151552]
            map.insert(2508, &[197376]);     // 2508 => [197376]
            map.insert(2509, &[336896]);     // 2509 => [336896]
            map.insert(2510, &[151557]);     // 2510 => [151557]
            map.insert(2511, &[151556]);     // 2511 => [151556]
            map.insert(2512, &[16674]);     // 2512 => [16674]
            map.insert(2513, &[262662]);     // 2513 => [262662]
            map.insert(2514, &[16672]);     // 2514 => [16672]
            map.insert(2515, &[262660]);     // 2515 => [262660]
            map.insert(2516, &[262659]);     // 2516 => [262659]
            map.insert(2517, &[262658]);     // 2517 => [262658]
            map.insert(2518, &[262657]);     // 2518 => [262657]
            map.insert(2519, &[262656]);     // 2519 => [262656]
            map.insert(2520, &[131297]);     // 2520 => [131297]
            map.insert(2521, &[131296]);     // 2521 => [131296]
            map.insert(2522, &[16680]);     // 2522 => [16680]
            map.insert(2523, &[262668]);     // 2523 => [262668]
            map.insert(2524, &[284672]);     // 2524 => [284672]
            map.insert(2525, &[262666]);     // 2525 => [262666]
            map.insert(2526, &[262665]);     // 2526 => [262665]
            map.insert(2527, &[262664]);     // 2527 => [262664]
            map.insert(2528, &[16658]);     // 2528 => [16658]
            map.insert(2529, &[16659]);     // 2529 => [16659]
            map.insert(2530, &[16656]);     // 2530 => [16656]
            map.insert(2531, &[16657]);     // 2531 => [16657]
            map.insert(2532, &[70161]);     // 2532 => [70161]
            map.insert(2533, &[70160]);     // 2533 => [70160]
            map.insert(2534, &[16660]);     // 2534 => [16660]
            map.insert(2535, &[13320]);     // 2535 => [13320]
            map.insert(2536, &[131281]);     // 2536 => [131281]
            map.insert(2537, &[131280]);     // 2537 => [131280]
            map.insert(2538, &[16664]);     // 2538 => [16664]
            map.insert(2539, &[13316]);     // 2539 => [13316]
            map.insert(2540, &[13315]);     // 2540 => [13315]
            map.insert(2541, &[13314]);     // 2541 => [13314]
            map.insert(2542, &[13313]);     // 2542 => [13313]
            map.insert(2543, &[13312]);     // 2543 => [13312]
            map.insert(2544, &[16642]);     // 2544 => [16642]
            map.insert(2545, &[16643]);     // 2545 => [16643]
            map.insert(2546, &[16640]);     // 2546 => [16640]
            map.insert(2547, &[16641]);     // 2547 => [16641]
            map.insert(2548, &[70145]);     // 2548 => [70145]
            map.insert(2549, &[70144]);     // 2549 => [70144]
            map.insert(2550, &[16644]);     // 2550 => [16644]
            map.insert(2551, &[262688]);     // 2551 => [262688]
            map.insert(2552, &[131265]);     // 2552 => [131265]
            map.insert(2553, &[131264]);     // 2553 => [131264]
            map.insert(2554, &[16648]);     // 2554 => [16648]
            map.insert(2555, &[16649]);     // 2555 => [16649]
            map.insert(2556, &[83970]);     // 2556 => [83970]
            map.insert(2557, &[131268]);     // 2557 => [131268]
            map.insert(2558, &[83968]);     // 2558 => [83968]
            map.insert(2559, &[83969]);     // 2559 => [83969]
            map.insert(2560, &[4608]);     // 2560 => [4608]
            map.insert(2561, &[4609]);     // 2561 => [4609]
            map.insert(2562, &[4610]);     // 2562 => [4610]
            map.insert(2563, &[18440]);     // 2563 => [18440]
            map.insert(2564, &[4612]);     // 2564 => [4612]
            map.insert(2565, &[4613]);     // 2565 => [4613]
            map.insert(2566, &[82177]);     // 2566 => [82177]
            map.insert(2567, &[82176]);     // 2567 => [82176]
            map.insert(2568, &[4616]);     // 2568 => [4616]
            map.insert(2569, &[18434]);     // 2569 => [18434]
            map.insert(2570, &[18433]);     // 2570 => [18433]
            map.insert(2571, &[18432]);     // 2571 => [18432]
            map.insert(2572, &[4620]);     // 2572 => [4620]
            map.insert(2573, &[18438]);     // 2573 => [18438]
            map.insert(2574, &[18437]);     // 2574 => [18437]
            map.insert(2575, &[18436]);     // 2575 => [18436]
            map.insert(2576, &[4624]);     // 2576 => [4624]
            map.insert(2577, &[4625]);     // 2577 => [4625]
            map.insert(2578, &[4626]);     // 2578 => [4626]
            map.insert(2579, &[18456]);     // 2579 => [18456]
            map.insert(2580, &[4628]);     // 2580 => [4628]
            map.insert(2581, &[168960]);     // 2581 => [168960]
            map.insert(2582, &[82193]);     // 2582 => [82193]
            map.insert(2583, &[82192]);     // 2583 => [82192]
            map.insert(2584, &[409604]);     // 2584 => [409604]
            map.insert(2585, &[18450]);     // 2585 => [18450]
            map.insert(2586, &[18449]);     // 2586 => [18449]
            map.insert(2587, &[18448]);     // 2587 => [18448]
            map.insert(2588, &[409600]);     // 2588 => [409600]
            map.insert(2589, &[409601]);     // 2589 => [409601]
            map.insert(2590, &[409602]);     // 2590 => [409602]
            map.insert(2591, &[18452]);     // 2591 => [18452]
            map.insert(2592, &[4640]);     // 2592 => [4640]
            map.insert(2593, &[4641]);     // 2593 => [4641]
            map.insert(2594, &[328192]);     // 2594 => [328192]
            map.insert(2595, &[328193]);     // 2595 => [328193]
            map.insert(2596, &[4644]);     // 2596 => [4644]
            map.insert(2597, &[282880]);     // 2597 => [282880]
            map.insert(2598, &[328196]);     // 2598 => [328196]
            map.insert(2599, &[82208]);     // 2599 => [82208]
            map.insert(2600, &[34052]);     // 2600 => [34052]
            map.insert(2601, &[18466]);     // 2601 => [18466]
            map.insert(2602, &[18465]);     // 2602 => [18465]
            map.insert(2603, &[18464]);     // 2603 => [18464]
            map.insert(2604, &[34048]);     // 2604 => [34048]
            map.insert(2605, &[34049]);     // 2605 => [34049]
            map.insert(2606, &[34050]);     // 2606 => [34050]
            map.insert(2607, &[18468]);     // 2607 => [18468]
            map.insert(2608, &[271368]);     // 2608 => [271368]
            map.insert(2609, &[131848]);     // 2609 => [131848]
            map.insert(2610, &[328208]);     // 2610 => [328208]
            map.insert(2611, &[328209]);     // 2611 => [328209]
            map.insert(2612, &[199169]);     // 2612 => [199169]
            map.insert(2613, &[199168]);     // 2613 => [199168]
            map.insert(2614, &[328212]);     // 2614 => [328212]
            map.insert(2615, &[199170]);     // 2615 => [199170]
            map.insert(2616, &[271360]);     // 2616 => [271360]
            map.insert(2617, &[131840]);     // 2617 => [131840]
            map.insert(2618, &[271362]);     // 2618 => [271362]
            map.insert(2619, &[131842]);     // 2619 => [131842]
            map.insert(2620, &[271364]);     // 2620 => [271364]
            map.insert(2621, &[131844]);     // 2621 => [131844]
            map.insert(2622, &[217088]);     // 2622 => [217088]
            map.insert(2623, &[217089]);     // 2623 => [217089]
            map.insert(2624, &[4672]);     // 2624 => [4672]
            map.insert(2625, &[4673]);     // 2625 => [4673]
            map.insert(2626, &[41089]);     // 2626 => [41089]
            map.insert(2627, &[41088]);     // 2627 => [41088]
            map.insert(2628, &[4676]);     // 2628 => [4676]
            map.insert(2629, &[4677]);     // 2629 => [4677]
            map.insert(2630, &[41093]);     // 2630 => [41093]
            map.insert(2631, &[41092]);     // 2631 => [41092]
            map.insert(2632, &[196740]);     // 2632 => [196740]
            map.insert(2633, &[18498]);     // 2633 => [18498]
            map.insert(2634, &[18497]);     // 2634 => [18497]
            map.insert(2635, &[18496]);     // 2635 => [18496]
            map.insert(2636, &[196736]);     // 2636 => [196736]
            map.insert(2637, &[196737]);     // 2637 => [196737]
            map.insert(2638, &[196738]);     // 2638 => [196738]
            map.insert(2639, &[18500]);     // 2639 => [18500]
            map.insert(2640, &[4688]);     // 2640 => [4688]
            map.insert(2641, &[4689]);     // 2641 => [4689]
            map.insert(2642, &[17056]);     // 2642 => [17056]
            map.insert(2643, &[262532]);     // 2643 => [262532]
            map.insert(2644, &[262531]);     // 2644 => [262531]
            map.insert(2645, &[262530]);     // 2645 => [262530]
            map.insert(2646, &[262529]);     // 2646 => [262529]
            map.insert(2647, &[262528]);     // 2647 => [262528]
            map.insert(2648, &[6305]);     // 2648 => [6305]
            map.insert(2649, &[6304]);     // 2649 => [6304]
            map.insert(2650, &[18513]);     // 2650 => [18513]
            map.insert(2651, &[18512]);     // 2651 => [18512]
            map.insert(2652, &[196752]);     // 2652 => [196752]
            map.insert(2653, &[196753]);     // 2653 => [196753]
            map.insert(2654, &[262537]);     // 2654 => [262537]
            map.insert(2655, &[262536]);     // 2655 => [262536]
            map.insert(2656, &[4704]);     // 2656 => [4704]
            map.insert(2657, &[4705]);     // 2657 => [4705]
            map.insert(2658, &[17040]);     // 2658 => [17040]
            map.insert(2659, &[41120]);     // 2659 => [41120]
            map.insert(2660, &[4708]);     // 2660 => [4708]
            map.insert(2661, &[70032]);     // 2661 => [70032]
            map.insert(2662, &[17044]);     // 2662 => [17044]
            map.insert(2663, &[41124]);     // 2663 => [41124]
            map.insert(2664, &[6289]);     // 2664 => [6289]
            map.insert(2665, &[6288]);     // 2665 => [6288]
            map.insert(2666, &[18529]);     // 2666 => [18529]
            map.insert(2667, &[18528]);     // 2667 => [18528]
            map.insert(2668, &[196768]);     // 2668 => [196768]
            map.insert(2669, &[196769]);     // 2669 => [196769]
            map.insert(2670, &[397440]);     // 2670 => [397440]
            map.insert(2671, &[397441]);     // 2671 => [397441]
            map.insert(2672, &[17026]);     // 2672 => [17026]
            map.insert(2673, &[6280]);     // 2673 => [6280]
            map.insert(2674, &[17024]);     // 2674 => [17024]
            map.insert(2675, &[17025]);     // 2675 => [17025]
            map.insert(2676, &[70017]);     // 2676 => [70017]
            map.insert(2677, &[70016]);     // 2677 => [70016]
            map.insert(2678, &[17028]);     // 2678 => [17028]
            map.insert(2679, &[262560]);     // 2679 => [262560]
            map.insert(2680, &[6273]);     // 2680 => [6273]
            map.insert(2681, &[6272]);     // 2681 => [6272]
            map.insert(2682, &[17032]);     // 2682 => [17032]
            map.insert(2683, &[6274]);     // 2683 => [6274]
            map.insert(2684, &[6277]);     // 2684 => [6277]
            map.insert(2685, &[6276]);     // 2685 => [6276]
            map.insert(2686, &[17036]);     // 2686 => [17036]
            map.insert(2687, &[6278]);     // 2687 => [6278]
            map.insert(2688, &[4736]);     // 2688 => [4736]
            map.insert(2689, &[4737]);     // 2689 => [4737]
            map.insert(2690, &[41025]);     // 2690 => [41025]
            map.insert(2691, &[41024]);     // 2691 => [41024]
            map.insert(2692, &[4740]);     // 2692 => [4740]
            map.insert(2693, &[4741]);     // 2693 => [4741]
            map.insert(2694, &[41029]);     // 2694 => [41029]
            map.insert(2695, &[41028]);     // 2695 => [41028]
            map.insert(2696, &[196676]);     // 2696 => [196676]
            map.insert(2697, &[18562]);     // 2697 => [18562]
            map.insert(2698, &[18561]);     // 2698 => [18561]
            map.insert(2699, &[18560]);     // 2699 => [18560]
            map.insert(2700, &[196672]);     // 2700 => [196672]
            map.insert(2701, &[196673]);     // 2701 => [196673]
            map.insert(2702, &[196674]);     // 2702 => [196674]
            map.insert(2703, &[18564]);     // 2703 => [18564]
            map.insert(2704, &[4752]);     // 2704 => [4752]
            map.insert(2705, &[4753]);     // 2705 => [4753]
            map.insert(2706, &[16992]);     // 2706 => [16992]
            map.insert(2707, &[262468]);     // 2707 => [262468]
            map.insert(2708, &[262467]);     // 2708 => [262467]
            map.insert(2709, &[262466]);     // 2709 => [262466]
            map.insert(2710, &[262465]);     // 2710 => [262465]
            map.insert(2711, &[262464]);     // 2711 => [262464]
            map.insert(2712, &[6241]);     // 2712 => [6241]
            map.insert(2713, &[6240]);     // 2713 => [6240]
            map.insert(2714, &[18577]);     // 2714 => [18577]
            map.insert(2715, &[18576]);     // 2715 => [18576]
            map.insert(2716, &[196688]);     // 2716 => [196688]
            map.insert(2717, &[196689]);     // 2717 => [196689]
            map.insert(2718, &[262473]);     // 2718 => [262473]
            map.insert(2719, &[262472]);     // 2719 => [262472]
            map.insert(2720, &[4768]);     // 2720 => [4768]
            map.insert(2721, &[4769]);     // 2721 => [4769]
            map.insert(2722, &[16976]);     // 2722 => [16976]
            map.insert(2723, &[41056]);     // 2723 => [41056]
            map.insert(2724, &[4772]);     // 2724 => [4772]
            map.insert(2725, &[69968]);     // 2725 => [69968]
            map.insert(2726, &[16980]);     // 2726 => [16980]
            map.insert(2727, &[41060]);     // 2727 => [41060]
            map.insert(2728, &[6225]);     // 2728 => [6225]
            map.insert(2729, &[6224]);     // 2729 => [6224]
            map.insert(2730, &[18593]);     // 2730 => [18593]
            map.insert(2731, &[18592]);     // 2731 => [18592]
            map.insert(2732, &[196704]);     // 2732 => [196704]
            map.insert(2733, &[196705]);     // 2733 => [196705]
            map.insert(2734, &[397376]);     // 2734 => [397376]
            map.insert(2735, &[397377]);     // 2735 => [397377]
            map.insert(2736, &[16962]);     // 2736 => [16962]
            map.insert(2737, &[6216]);     // 2737 => [6216]
            map.insert(2738, &[16960]);     // 2738 => [16960]
            map.insert(2739, &[16961]);     // 2739 => [16961]
            map.insert(2740, &[69953]);     // 2740 => [69953]
            map.insert(2741, &[69952]);     // 2741 => [69952]
            map.insert(2742, &[16964]);     // 2742 => [16964]
            map.insert(2743, &[262496]);     // 2743 => [262496]
            map.insert(2744, &[6209]);     // 2744 => [6209]
            map.insert(2745, &[6208]);     // 2745 => [6208]
            map.insert(2746, &[16968]);     // 2746 => [16968]
            map.insert(2747, &[6210]);     // 2747 => [6210]
            map.insert(2748, &[6213]);     // 2748 => [6213]
            map.insert(2749, &[6212]);     // 2749 => [6212]
            map.insert(2750, &[16972]);     // 2750 => [16972]
            map.insert(2751, &[6214]);     // 2751 => [6214]
            map.insert(2752, &[133376]);     // 2752 => [133376]
            map.insert(2753, &[40962]);     // 2753 => [40962]
            map.insert(2754, &[40961]);     // 2754 => [40961]
            map.insert(2755, &[40960]);     // 2755 => [40960]
            map.insert(2756, &[196616]);     // 2756 => [196616]
            map.insert(2757, &[196617]);     // 2757 => [196617]
            map.insert(2758, &[40965]);     // 2758 => [40965]
            map.insert(2759, &[40964]);     // 2759 => [40964]
            map.insert(2760, &[196612]);     // 2760 => [196612]
            map.insert(2761, &[196613]);     // 2761 => [196613]
            map.insert(2762, &[40969]);     // 2762 => [40969]
            map.insert(2763, &[40968]);     // 2763 => [40968]
            map.insert(2764, &[196608]);     // 2764 => [196608]
            map.insert(2765, &[196609]);     // 2765 => [196609]
            map.insert(2766, &[196610]);     // 2766 => [196610]
            map.insert(2767, &[196611]);     // 2767 => [196611]
            map.insert(2768, &[16930]);     // 2768 => [16930]
            map.insert(2769, &[262406]);     // 2769 => [262406]
            map.insert(2770, &[16928]);     // 2770 => [16928]
            map.insert(2771, &[262404]);     // 2771 => [262404]
            map.insert(2772, &[262403]);     // 2772 => [262403]
            map.insert(2773, &[262402]);     // 2773 => [262402]
            map.insert(2774, &[262401]);     // 2774 => [262401]
            map.insert(2775, &[262400]);     // 2775 => [262400]
            map.insert(2776, &[6177]);     // 2776 => [6177]
            map.insert(2777, &[6176]);     // 2777 => [6176]
            map.insert(2778, &[329729]);     // 2778 => [329729]
            map.insert(2779, &[329728]);     // 2779 => [329728]
            map.insert(2780, &[196624]);     // 2780 => [196624]
            map.insert(2781, &[196625]);     // 2781 => [196625]
            map.insert(2782, &[262409]);     // 2782 => [262409]
            map.insert(2783, &[262408]);     // 2783 => [262408]
            map.insert(2784, &[16914]);     // 2784 => [16914]
            map.insert(2785, &[40994]);     // 2785 => [40994]
            map.insert(2786, &[16912]);     // 2786 => [16912]
            map.insert(2787, &[40992]);     // 2787 => [40992]
            map.insert(2788, &[196648]);     // 2788 => [196648]
            map.insert(2789, &[69904]);     // 2789 => [69904]
            map.insert(2790, &[16916]);     // 2790 => [16916]
            map.insert(2791, &[40996]);     // 2791 => [40996]
            map.insert(2792, &[6161]);     // 2792 => [6161]
            map.insert(2793, &[6160]);     // 2793 => [6160]
            map.insert(2794, &[397316]);     // 2794 => [397316]
            map.insert(2795, &[6162]);     // 2795 => [6162]
            map.insert(2796, &[196640]);     // 2796 => [196640]
            map.insert(2797, &[196641]);     // 2797 => [196641]
            map.insert(2798, &[397312]);     // 2798 => [397312]
            map.insert(2799, &[397313]);     // 2799 => [397313]
            map.insert(2800, &[16898]);     // 2800 => [16898]
            map.insert(2801, &[6152]);     // 2801 => [6152]
            map.insert(2802, &[16896]);     // 2802 => [16896]
            map.insert(2803, &[16897]);     // 2803 => [16897]
            map.insert(2804, &[69889]);     // 2804 => [69889]
            map.insert(2805, &[69888]);     // 2805 => [69888]
            map.insert(2806, &[16900]);     // 2806 => [16900]
            map.insert(2807, &[262432]);     // 2807 => [262432]
            map.insert(2808, &[6145]);     // 2808 => [6145]
            map.insert(2809, &[6144]);     // 2809 => [6144]
            map.insert(2810, &[16904]);     // 2810 => [16904]
            map.insert(2811, &[6146]);     // 2811 => [6146]
            map.insert(2812, &[6149]);     // 2812 => [6149]
            map.insert(2813, &[6148]);     // 2813 => [6148]
            map.insert(2814, &[16908]);     // 2814 => [16908]
            map.insert(2815, &[6150]);     // 2815 => [6150]
            map.insert(2816, &[4864]);     // 2816 => [4864]
            map.insert(2817, &[4865]);     // 2817 => [4865]
            map.insert(2818, &[81925]);     // 2818 => [81925]
            map.insert(2819, &[81924]);     // 2819 => [81924]
            map.insert(2820, &[81923]);     // 2820 => [81923]
            map.insert(2821, &[81922]);     // 2821 => [81922]
            map.insert(2822, &[81921]);     // 2822 => [81921]
            map.insert(2823, &[81920]);     // 2823 => [81920]
            map.insert(2824, &[33828]);     // 2824 => [33828]
            map.insert(2825, &[18690]);     // 2825 => [18690]
            map.insert(2826, &[18689]);     // 2826 => [18689]
            map.insert(2827, &[18688]);     // 2827 => [18688]
            map.insert(2828, &[33824]);     // 2828 => [33824]
            map.insert(2829, &[33825]);     // 2829 => [33825]
            map.insert(2830, &[81929]);     // 2830 => [81929]
            map.insert(2831, &[81928]);     // 2831 => [81928]
            map.insert(2832, &[4880]);     // 2832 => [4880]
            map.insert(2833, &[131624]);     // 2833 => [131624]
            map.insert(2834, &[81941]);     // 2834 => [81941]
            map.insert(2835, &[81940]);     // 2835 => [81940]
            map.insert(2836, &[81939]);     // 2836 => [81939]
            map.insert(2837, &[81938]);     // 2837 => [81938]
            map.insert(2838, &[81937]);     // 2838 => [81937]
            map.insert(2839, &[81936]);     // 2839 => [81936]
            map.insert(2840, &[131617]);     // 2840 => [131617]
            map.insert(2841, &[131616]);     // 2841 => [131616]
            map.insert(2842, &[131619]);     // 2842 => [131619]
            map.insert(2843, &[131618]);     // 2843 => [131618]
            map.insert(2844, &[33840]);     // 2844 => [33840]
            map.insert(2845, &[131620]);     // 2845 => [131620]
            map.insert(2846, &[81945]);     // 2846 => [81945]
            map.insert(2847, &[81944]);     // 2847 => [81944]
            map.insert(2848, &[33804]);     // 2848 => [33804]
            map.insert(2849, &[282628]);     // 2849 => [282628]
            map.insert(2850, &[328448]);     // 2850 => [328448]
            map.insert(2851, &[81956]);     // 2851 => [81956]
            map.insert(2852, &[33800]);     // 2852 => [33800]
            map.insert(2853, &[282624]);     // 2853 => [282624]
            map.insert(2854, &[81953]);     // 2854 => [81953]
            map.insert(2855, &[81952]);     // 2855 => [81952]
            map.insert(2856, &[33796]);     // 2856 => [33796]
            map.insert(2857, &[131600]);     // 2857 => [131600]
            map.insert(2858, &[33798]);     // 2858 => [33798]
            map.insert(2859, &[131602]);     // 2859 => [131602]
            map.insert(2860, &[33792]);     // 2860 => [33792]
            map.insert(2861, &[33793]);     // 2861 => [33793]
            map.insert(2862, &[33794]);     // 2862 => [33794]
            map.insert(2863, &[33795]);     // 2863 => [33795]
            map.insert(2864, &[131593]);     // 2864 => [131593]
            map.insert(2865, &[131592]);     // 2865 => [131592]
            map.insert(2866, &[153600]);     // 2866 => [153600]
            map.insert(2867, &[131594]);     // 2867 => [131594]
            map.insert(2868, &[33816]);     // 2868 => [33816]
            map.insert(2869, &[131596]);     // 2869 => [131596]
            map.insert(2870, &[107008]);     // 2870 => [107008]
            map.insert(2871, &[81968]);     // 2871 => [81968]
            map.insert(2872, &[131585]);     // 2872 => [131585]
            map.insert(2873, &[131584]);     // 2873 => [131584]
            map.insert(2874, &[131587]);     // 2874 => [131587]
            map.insert(2875, &[131586]);     // 2875 => [131586]
            map.insert(2876, &[33808]);     // 2876 => [33808]
            map.insert(2877, &[131588]);     // 2877 => [131588]
            map.insert(2878, &[33810]);     // 2878 => [33810]
            map.insert(2879, &[131590]);     // 2879 => [131590]
            map.insert(2880, &[133248]);     // 2880 => [133248]
            map.insert(2881, &[133249]);     // 2881 => [133249]
            map.insert(2882, &[133250]);     // 2882 => [133250]
            map.insert(2883, &[262292]);     // 2883 => [262292]
            map.insert(2884, &[133252]);     // 2884 => [133252]
            map.insert(2885, &[262290]);     // 2885 => [262290]
            map.insert(2886, &[262289]);     // 2886 => [262289]
            map.insert(2887, &[262288]);     // 2887 => [262288]
            map.insert(2888, &[133256]);     // 2888 => [133256]
            map.insert(2889, &[133257]);     // 2889 => [133257]
            map.insert(2890, &[18753]);     // 2890 => [18753]
            map.insert(2891, &[18752]);     // 2891 => [18752]
            map.insert(2892, &[33888]);     // 2892 => [33888]
            map.insert(2893, &[33889]);     // 2893 => [33889]
            map.insert(2894, &[262297]);     // 2894 => [262297]
            map.insert(2895, &[262296]);     // 2895 => [262296]
            map.insert(2896, &[133264]);     // 2896 => [133264]
            map.insert(2897, &[262278]);     // 2897 => [262278]
            map.insert(2898, &[262277]);     // 2898 => [262277]
            map.insert(2899, &[262276]);     // 2899 => [262276]
            map.insert(2900, &[262275]);     // 2900 => [262275]
            map.insert(2901, &[262274]);     // 2901 => [262274]
            map.insert(2902, &[262273]);     // 2902 => [262273]
            map.insert(2903, &[262272]);     // 2903 => [262272]
            map.insert(2904, &[131681]);     // 2904 => [131681]
            map.insert(2905, &[131680]);     // 2905 => [131680]
            map.insert(2906, &[262285]);     // 2906 => [262285]
            map.insert(2907, &[262284]);     // 2907 => [262284]
            map.insert(2908, &[262283]);     // 2908 => [262283]
            map.insert(2909, &[262282]);     // 2909 => [262282]
            map.insert(2910, &[262281]);     // 2910 => [262281]
            map.insert(2911, &[262280]);     // 2911 => [262280]
            map.insert(2912, &[133280]);     // 2912 => [133280]
            map.insert(2913, &[133281]);     // 2913 => [133281]
            map.insert(2914, &[133282]);     // 2914 => [133282]
            map.insert(2915, &[262324]);     // 2915 => [262324]
            map.insert(2916, &[33864]);     // 2916 => [33864]
            map.insert(2917, &[69776]);     // 2917 => [69776]
            map.insert(2918, &[262321]);     // 2918 => [262321]
            map.insert(2919, &[262320]);     // 2919 => [262320]
            map.insert(2920, &[33860]);     // 2920 => [33860]
            map.insert(2921, &[131664]);     // 2921 => [131664]
            map.insert(2922, &[33862]);     // 2922 => [33862]
            map.insert(2923, &[131666]);     // 2923 => [131666]
            map.insert(2924, &[33856]);     // 2924 => [33856]
            map.insert(2925, &[33857]);     // 2925 => [33857]
            map.insert(2926, &[33858]);     // 2926 => [33858]
            map.insert(2927, &[33859]);     // 2927 => [33859]
            map.insert(2928, &[69765]);     // 2928 => [69765]
            map.insert(2929, &[69764]);     // 2929 => [69764]
            map.insert(2930, &[17280]);     // 2930 => [17280]
            map.insert(2931, &[262308]);     // 2931 => [262308]
            map.insert(2932, &[69761]);     // 2932 => [69761]
            map.insert(2933, &[69760]);     // 2933 => [69760]
            map.insert(2934, &[262305]);     // 2934 => [262305]
            map.insert(2935, &[262304]);     // 2935 => [262304]
            map.insert(2936, &[131649]);     // 2936 => [131649]
            map.insert(2937, &[131648]);     // 2937 => [131648]
            map.insert(2938, &[131651]);     // 2938 => [131651]
            map.insert(2939, &[131650]);     // 2939 => [131650]
            map.insert(2940, &[33872]);     // 2940 => [33872]
            map.insert(2941, &[131652]);     // 2941 => [131652]
            map.insert(2942, &[262313]);     // 2942 => [262313]
            map.insert(2943, &[262312]);     // 2943 => [262312]
            map.insert(2944, &[133184]);     // 2944 => [133184]
            map.insert(2945, &[133185]);     // 2945 => [133185]
            map.insert(2946, &[133186]);     // 2946 => [133186]
            map.insert(2947, &[262228]);     // 2947 => [262228]
            map.insert(2948, &[133188]);     // 2948 => [133188]
            map.insert(2949, &[262226]);     // 2949 => [262226]
            map.insert(2950, &[262225]);     // 2950 => [262225]
            map.insert(2951, &[262224]);     // 2951 => [262224]
            map.insert(2952, &[133192]);     // 2952 => [133192]
            map.insert(2953, &[133193]);     // 2953 => [133193]
            map.insert(2954, &[18817]);     // 2954 => [18817]
            map.insert(2955, &[18816]);     // 2955 => [18816]
            map.insert(2956, &[33952]);     // 2956 => [33952]
            map.insert(2957, &[33953]);     // 2957 => [33953]
            map.insert(2958, &[262233]);     // 2958 => [262233]
            map.insert(2959, &[262232]);     // 2959 => [262232]
            map.insert(2960, &[133200]);     // 2960 => [133200]
            map.insert(2961, &[262214]);     // 2961 => [262214]
            map.insert(2962, &[262213]);     // 2962 => [262213]
            map.insert(2963, &[262212]);     // 2963 => [262212]
            map.insert(2964, &[262211]);     // 2964 => [262211]
            map.insert(2965, &[262210]);     // 2965 => [262210]
            map.insert(2966, &[262209]);     // 2966 => [262209]
            map.insert(2967, &[262208]);     // 2967 => [262208]
            map.insert(2968, &[131745]);     // 2968 => [131745]
            map.insert(2969, &[131744]);     // 2969 => [131744]
            map.insert(2970, &[262221]);     // 2970 => [262221]
            map.insert(2971, &[262220]);     // 2971 => [262220]
            map.insert(2972, &[262219]);     // 2972 => [262219]
            map.insert(2973, &[262218]);     // 2973 => [262218]
            map.insert(2974, &[262217]);     // 2974 => [262217]
            map.insert(2975, &[262216]);     // 2975 => [262216]
            map.insert(2976, &[133216]);     // 2976 => [133216]
            map.insert(2977, &[133217]);     // 2977 => [133217]
            map.insert(2978, &[133218]);     // 2978 => [133218]
            map.insert(2979, &[262260]);     // 2979 => [262260]
            map.insert(2980, &[33928]);     // 2980 => [33928]
            map.insert(2981, &[69712]);     // 2981 => [69712]
            map.insert(2982, &[262257]);     // 2982 => [262257]
            map.insert(2983, &[262256]);     // 2983 => [262256]
            map.insert(2984, &[33924]);     // 2984 => [33924]
            map.insert(2985, &[131728]);     // 2985 => [131728]
            map.insert(2986, &[33926]);     // 2986 => [33926]
            map.insert(2987, &[131730]);     // 2987 => [131730]
            map.insert(2988, &[33920]);     // 2988 => [33920]
            map.insert(2989, &[33921]);     // 2989 => [33921]
            map.insert(2990, &[33922]);     // 2990 => [33922]
            map.insert(2991, &[33923]);     // 2991 => [33923]
            map.insert(2992, &[69701]);     // 2992 => [69701]
            map.insert(2993, &[69700]);     // 2993 => [69700]
            map.insert(2994, &[17216]);     // 2994 => [17216]
            map.insert(2995, &[262244]);     // 2995 => [262244]
            map.insert(2996, &[69697]);     // 2996 => [69697]
            map.insert(2997, &[69696]);     // 2997 => [69696]
            map.insert(2998, &[262241]);     // 2998 => [262241]
            map.insert(2999, &[262240]);     // 2999 => [262240]
            map.insert(3000, &[131713]);     // 3000 => [131713]
            map.insert(3001, &[131712]);     // 3001 => [131712]
            map.insert(3002, &[131715]);     // 3002 => [131715]
            map.insert(3003, &[131714]);     // 3003 => [131714]
            map.insert(3004, &[33936]);     // 3004 => [33936]
            map.insert(3005, &[131716]);     // 3005 => [131716]
            map.insert(3006, &[262249]);     // 3006 => [262249]
            map.insert(3007, &[262248]);     // 3007 => [262248]
            map.insert(3008, &[133120]);     // 3008 => [133120]
            map.insert(3009, &[133121]);     // 3009 => [133121]
            map.insert(3010, &[133122]);     // 3010 => [133122]
            map.insert(3011, &[262164]);     // 3011 => [262164]
            map.insert(3012, &[133124]);     // 3012 => [133124]
            map.insert(3013, &[262162]);     // 3013 => [262162]
            map.insert(3014, &[262161]);     // 3014 => [262161]
            map.insert(3015, &[262160]);     // 3015 => [262160]
            map.insert(3016, &[133128]);     // 3016 => [133128]
            map.insert(3017, &[133129]);     // 3017 => [133129]
            map.insert(3018, &[133130]);     // 3018 => [133130]
            map.insert(3019, &[262172]);     // 3019 => [262172]
            map.insert(3020, &[196864]);     // 3020 => [196864]
            map.insert(3021, &[196865]);     // 3021 => [196865]
            map.insert(3022, &[262169]);     // 3022 => [262169]
            map.insert(3023, &[262168]);     // 3023 => [262168]
            map.insert(3024, &[133136]);     // 3024 => [133136]
            map.insert(3025, &[262150]);     // 3025 => [262150]
            map.insert(3026, &[262149]);     // 3026 => [262149]
            map.insert(3027, &[262148]);     // 3027 => [262148]
            map.insert(3028, &[262147]);     // 3028 => [262147]
            map.insert(3029, &[262146]);     // 3029 => [262146]
            map.insert(3030, &[262145]);     // 3030 => [262145]
            map.insert(3031, &[262144]);     // 3031 => [262144]
            map.insert(3032, &[133144]);     // 3032 => [133144]
            map.insert(3033, &[262158]);     // 3033 => [262158]
            map.insert(3034, &[262157]);     // 3034 => [262157]
            map.insert(3035, &[262156]);     // 3035 => [262156]
            map.insert(3036, &[262155]);     // 3036 => [262155]
            map.insert(3037, &[262154]);     // 3037 => [262154]
            map.insert(3038, &[262153]);     // 3038 => [262153]
            map.insert(3039, &[262152]);     // 3039 => [262152]
            map.insert(3040, &[133152]);     // 3040 => [133152]
            map.insert(3041, &[133153]);     // 3041 => [133153]
            map.insert(3042, &[133154]);     // 3042 => [133154]
            map.insert(3043, &[262196]);     // 3043 => [262196]
            map.insert(3044, &[69649]);     // 3044 => [69649]
            map.insert(3045, &[69648]);     // 3045 => [69648]
            map.insert(3046, &[262193]);     // 3046 => [262193]
            map.insert(3047, &[262192]);     // 3047 => [262192]
            map.insert(3048, &[133160]);     // 3048 => [133160]
            map.insert(3049, &[6416]);     // 3049 => [6416]
            map.insert(3050, &[133162]);     // 3050 => [133162]
            map.insert(3051, &[6418]);     // 3051 => [6418]
            map.insert(3052, &[196896]);     // 3052 => [196896]
            map.insert(3053, &[69656]);     // 3053 => [69656]
            map.insert(3054, &[397568]);     // 3054 => [397568]
            map.insert(3055, &[262200]);     // 3055 => [262200]
            map.insert(3056, &[69637]);     // 3056 => [69637]
            map.insert(3057, &[69636]);     // 3057 => [69636]
            map.insert(3058, &[17152]);     // 3058 => [17152]
            map.insert(3059, &[262180]);     // 3059 => [262180]
            map.insert(3060, &[69633]);     // 3060 => [69633]
            map.insert(3061, &[69632]);     // 3061 => [69632]
            map.insert(3062, &[262177]);     // 3062 => [262177]
            map.insert(3063, &[262176]);     // 3063 => [262176]
            map.insert(3064, &[6401]);     // 3064 => [6401]
            map.insert(3065, &[6400]);     // 3065 => [6400]
            map.insert(3066, &[17160]);     // 3066 => [17160]
            map.insert(3067, &[6402]);     // 3067 => [6402]
            map.insert(3068, &[69641]);     // 3068 => [69641]
            map.insert(3069, &[69640]);     // 3069 => [69640]
            map.insert(3070, &[262185]);     // 3070 => [262185]
            map.insert(3071, &[262184]);     // 3071 => [262184]
            map.insert(3072, &[5120]);     // 3072 => [5120]
            map.insert(3073, &[5121]);     // 3073 => [5121]
            map.insert(3074, &[5122]);     // 3074 => [5122]
            map.insert(3075, &[5123]);     // 3075 => [5123]
            map.insert(3076, &[5124]);     // 3076 => [5124]
            map.insert(3077, &[5125]);     // 3077 => [5125]
            map.insert(3078, &[5126]);     // 3078 => [5126]
            map.insert(3079, &[5127]);     // 3079 => [5127]
            map.insert(3080, &[5128]);     // 3080 => [5128]
            map.insert(3081, &[311296]);     // 3081 => [311296]
            map.insert(3082, &[5130]);     // 3082 => [5130]
            map.insert(3083, &[311298]);     // 3083 => [311298]
            map.insert(3084, &[5132]);     // 3084 => [5132]
            map.insert(3085, &[311300]);     // 3085 => [311300]
            map.insert(3086, &[5134]);     // 3086 => [5134]
            map.insert(3087, &[311302]);     // 3087 => [311302]
            map.insert(3088, &[5136]);     // 3088 => [5136]
            map.insert(3089, &[5137]);     // 3089 => [5137]
            map.insert(3090, &[5138]);     // 3090 => [5138]
            map.insert(3091, &[5139]);     // 3091 => [5139]
            map.insert(3092, &[5140]);     // 3092 => [5140]
            map.insert(3093, &[24840]);     // 3093 => [24840]
            map.insert(3094, &[139456]);     // 3094 => [139456]
            map.insert(3095, &[139457]);     // 3095 => [139457]
            map.insert(3096, &[5144]);     // 3096 => [5144]
            map.insert(3097, &[24836]);     // 3097 => [24836]
            map.insert(3098, &[78336]);     // 3098 => [78336]
            map.insert(3099, &[78337]);     // 3099 => [78337]
            map.insert(3100, &[24833]);     // 3100 => [24833]
            map.insert(3101, &[24832]);     // 3101 => [24832]
            map.insert(3102, &[182272]);     // 3102 => [182272]
            map.insert(3103, &[24834]);     // 3103 => [24834]
            map.insert(3104, &[5152]);     // 3104 => [5152]
            map.insert(3105, &[5153]);     // 3105 => [5153]
            map.insert(3106, &[328704]);     // 3106 => [328704]
            map.insert(3107, &[328705]);     // 3107 => [328705]
            map.insert(3108, &[5156]);     // 3108 => [5156]
            map.insert(3109, &[5157]);     // 3109 => [5157]
            map.insert(3110, &[328708]);     // 3110 => [328708]
            map.insert(3111, &[328709]);     // 3111 => [328709]
            map.insert(3112, &[33540]);     // 3112 => [33540]
            map.insert(3113, &[132368]);     // 3113 => [132368]
            map.insert(3114, &[328712]);     // 3114 => [328712]
            map.insert(3115, &[118784]);     // 3115 => [118784]
            map.insert(3116, &[33536]);     // 3116 => [33536]
            map.insert(3117, &[33537]);     // 3117 => [33537]
            map.insert(3118, &[33538]);     // 3118 => [33538]
            map.insert(3119, &[141824]);     // 3119 => [141824]
            map.insert(3120, &[270856]);     // 3120 => [270856]
            map.insert(3121, &[132360]);     // 3121 => [132360]
            map.insert(3122, &[328720]);     // 3122 => [328720]
            map.insert(3123, &[328721]);     // 3123 => [328721]
            map.insert(3124, &[199681]);     // 3124 => [199681]
            map.insert(3125, &[199680]);     // 3125 => [199680]
            map.insert(3126, &[328724]);     // 3126 => [328724]
            map.insert(3127, &[199682]);     // 3127 => [199682]
            map.insert(3128, &[270848]);     // 3128 => [270848]
            map.insert(3129, &[132352]);     // 3129 => [132352]
            map.insert(3130, &[270850]);     // 3130 => [270850]
            map.insert(3131, &[132354]);     // 3131 => [132354]
            map.insert(3132, &[270852]);     // 3132 => [270852]
            map.insert(3133, &[132356]);     // 3133 => [132356]
            map.insert(3134, &[270854]);     // 3134 => [270854]
            map.insert(3135, &[132358]);     // 3135 => [132358]
            map.insert(3136, &[5184]);     // 3136 => [5184]
            map.insert(3137, &[5185]);     // 3137 => [5185]
            map.insert(3138, &[5186]);     // 3138 => [5186]
            map.insert(3139, &[5187]);     // 3139 => [5187]
            map.insert(3140, &[5188]);     // 3140 => [5188]
            map.insert(3141, &[5189]);     // 3141 => [5189]
            map.insert(3142, &[139408]);     // 3142 => [139408]
            map.insert(3143, &[139409]);     // 3143 => [139409]
            map.insert(3144, &[5192]);     // 3144 => [5192]
            map.insert(3145, &[98448]);     // 3145 => [98448]
            map.insert(3146, &[5194]);     // 3146 => [5194]
            map.insert(3147, &[98450]);     // 3147 => [98450]
            map.insert(3148, &[5196]);     // 3148 => [5196]
            map.insert(3149, &[98452]);     // 3149 => [98452]
            map.insert(3150, &[139416]);     // 3150 => [139416]
            map.insert(3151, &[12704]);     // 3151 => [12704]
            map.insert(3152, &[5200]);     // 3152 => [5200]
            map.insert(3153, &[98440]);     // 3153 => [98440]
            map.insert(3154, &[139396]);     // 3154 => [139396]
            map.insert(3155, &[139397]);     // 3155 => [139397]
            map.insert(3156, &[139394]);     // 3156 => [139394]
            map.insert(3157, &[35200]);     // 3157 => [35200]
            map.insert(3158, &[139392]);     // 3158 => [139392]
            map.insert(3159, &[139393]);     // 3159 => [139393]
            map.insert(3160, &[98433]);     // 3160 => [98433]
            map.insert(3161, &[98432]);     // 3161 => [98432]
            map.insert(3162, &[98435]);     // 3162 => [98435]
            map.insert(3163, &[98434]);     // 3163 => [98434]
            map.insert(3164, &[98437]);     // 3164 => [98437]
            map.insert(3165, &[98436]);     // 3165 => [98436]
            map.insert(3166, &[139400]);     // 3166 => [139400]
            map.insert(3167, &[139401]);     // 3167 => [139401]
            map.insert(3168, &[5216]);     // 3168 => [5216]
            map.insert(3169, &[5217]);     // 3169 => [5217]
            map.insert(3170, &[17552]);     // 3170 => [17552]
            map.insert(3171, &[17553]);     // 3171 => [17553]
            map.insert(3172, &[5220]);     // 3172 => [5220]
            map.insert(3173, &[5221]);     // 3173 => [5221]
            map.insert(3174, &[17556]);     // 3174 => [17556]
            map.insert(3175, &[12680]);     // 3175 => [12680]
            map.insert(3176, &[33604]);     // 3176 => [33604]
            map.insert(3177, &[98480]);     // 3177 => [98480]
            map.insert(3178, &[17560]);     // 3178 => [17560]
            map.insert(3179, &[12676]);     // 3179 => [12676]
            map.insert(3180, &[33600]);     // 3180 => [33600]
            map.insert(3181, &[33601]);     // 3181 => [33601]
            map.insert(3182, &[12673]);     // 3182 => [12673]
            map.insert(3183, &[12672]);     // 3183 => [12672]
            map.insert(3184, &[17538]);     // 3184 => [17538]
            map.insert(3185, &[17539]);     // 3185 => [17539]
            map.insert(3186, &[17536]);     // 3186 => [17536]
            map.insert(3187, &[17537]);     // 3187 => [17537]
            map.insert(3188, &[17542]);     // 3188 => [17542]
            map.insert(3189, &[35232]);     // 3189 => [35232]
            map.insert(3190, &[17540]);     // 3190 => [17540]
            map.insert(3191, &[17541]);     // 3191 => [17541]
            map.insert(3192, &[270912]);     // 3192 => [270912]
            map.insert(3193, &[98464]);     // 3193 => [98464]
            map.insert(3194, &[17544]);     // 3194 => [17544]
            map.insert(3195, &[299136]);     // 3195 => [299136]
            map.insert(3196, &[270916]);     // 3196 => [270916]
            map.insert(3197, &[98468]);     // 3197 => [98468]
            map.insert(3198, &[17548]);     // 3198 => [17548]
            map.insert(3199, &[299140]);     // 3199 => [299140]
            map.insert(3200, &[5248]);     // 3200 => [5248]
            map.insert(3201, &[5249]);     // 3201 => [5249]
            map.insert(3202, &[5250]);     // 3202 => [5250]
            map.insert(3203, &[5251]);     // 3203 => [5251]
            map.insert(3204, &[5252]);     // 3204 => [5252]
            map.insert(3205, &[5253]);     // 3205 => [5253]
            map.insert(3206, &[139344]);     // 3206 => [139344]
            map.insert(3207, &[139345]);     // 3207 => [139345]
            map.insert(3208, &[5256]);     // 3208 => [5256]
            map.insert(3209, &[98384]);     // 3209 => [98384]
            map.insert(3210, &[5258]);     // 3210 => [5258]
            map.insert(3211, &[98386]);     // 3211 => [98386]
            map.insert(3212, &[5260]);     // 3212 => [5260]
            map.insert(3213, &[98388]);     // 3213 => [98388]
            map.insert(3214, &[139352]);     // 3214 => [139352]
            map.insert(3215, &[12640]);     // 3215 => [12640]
            map.insert(3216, &[5264]);     // 3216 => [5264]
            map.insert(3217, &[98376]);     // 3217 => [98376]
            map.insert(3218, &[139332]);     // 3218 => [139332]
            map.insert(3219, &[139333]);     // 3219 => [139333]
            map.insert(3220, &[139330]);     // 3220 => [139330]
            map.insert(3221, &[35136]);     // 3221 => [35136]
            map.insert(3222, &[139328]);     // 3222 => [139328]
            map.insert(3223, &[139329]);     // 3223 => [139329]
            map.insert(3224, &[98369]);     // 3224 => [98369]
            map.insert(3225, &[98368]);     // 3225 => [98368]
            map.insert(3226, &[98371]);     // 3226 => [98371]
            map.insert(3227, &[98370]);     // 3227 => [98370]
            map.insert(3228, &[98373]);     // 3228 => [98373]
            map.insert(3229, &[98372]);     // 3229 => [98372]
            map.insert(3230, &[139336]);     // 3230 => [139336]
            map.insert(3231, &[139337]);     // 3231 => [139337]
            map.insert(3232, &[5280]);     // 3232 => [5280]
            map.insert(3233, &[5281]);     // 3233 => [5281]
            map.insert(3234, &[17488]);     // 3234 => [17488]
            map.insert(3235, &[17489]);     // 3235 => [17489]
            map.insert(3236, &[5284]);     // 3236 => [5284]
            map.insert(3237, &[5285]);     // 3237 => [5285]
            map.insert(3238, &[17492]);     // 3238 => [17492]
            map.insert(3239, &[12616]);     // 3239 => [12616]
            map.insert(3240, &[33668]);     // 3240 => [33668]
            map.insert(3241, &[98416]);     // 3241 => [98416]
            map.insert(3242, &[17496]);     // 3242 => [17496]
            map.insert(3243, &[12612]);     // 3243 => [12612]
            map.insert(3244, &[33664]);     // 3244 => [33664]
            map.insert(3245, &[33665]);     // 3245 => [33665]
            map.insert(3246, &[12609]);     // 3246 => [12609]
            map.insert(3247, &[12608]);     // 3247 => [12608]
            map.insert(3248, &[17474]);     // 3248 => [17474]
            map.insert(3249, &[17475]);     // 3249 => [17475]
            map.insert(3250, &[17472]);     // 3250 => [17472]
            map.insert(3251, &[17473]);     // 3251 => [17473]
            map.insert(3252, &[17478]);     // 3252 => [17478]
            map.insert(3253, &[35168]);     // 3253 => [35168]
            map.insert(3254, &[17476]);     // 3254 => [17476]
            map.insert(3255, &[17477]);     // 3255 => [17477]
            map.insert(3256, &[270976]);     // 3256 => [270976]
            map.insert(3257, &[98400]);     // 3257 => [98400]
            map.insert(3258, &[17480]);     // 3258 => [17480]
            map.insert(3259, &[299072]);     // 3259 => [299072]
            map.insert(3260, &[270980]);     // 3260 => [270980]
            map.insert(3261, &[98404]);     // 3261 => [98404]
            map.insert(3262, &[17484]);     // 3262 => [17484]
            map.insert(3263, &[299076]);     // 3263 => [299076]
            map.insert(3264, &[272385]);     // 3264 => [272385]
            map.insert(3265, &[272384]);     // 3265 => [272384]
            map.insert(3266, &[139284]);     // 3266 => [139284]
            map.insert(3267, &[272386]);     // 3267 => [272386]
            map.insert(3268, &[139282]);     // 3268 => [139282]
            map.insert(3269, &[272388]);     // 3269 => [272388]
            map.insert(3270, &[139280]);     // 3270 => [139280]
            map.insert(3271, &[139281]);     // 3271 => [139281]
            map.insert(3272, &[98321]);     // 3272 => [98321]
            map.insert(3273, &[98320]);     // 3273 => [98320]
            map.insert(3274, &[98323]);     // 3274 => [98323]
            map.insert(3275, &[98322]);     // 3275 => [98322]
            map.insert(3276, &[198144]);     // 3276 => [198144]
            map.insert(3277, &[98324]);     // 3277 => [98324]
            map.insert(3278, &[139288]);     // 3278 => [139288]
            map.insert(3279, &[12576]);     // 3279 => [12576]
            map.insert(3280, &[98313]);     // 3280 => [98313]
            map.insert(3281, &[98312]);     // 3281 => [98312]
            map.insert(3282, &[139268]);     // 3282 => [139268]
            map.insert(3283, &[139269]);     // 3283 => [139269]
            map.insert(3284, &[139266]);     // 3284 => [139266]
            map.insert(3285, &[35072]);     // 3285 => [35072]
            map.insert(3286, &[139264]);     // 3286 => [139264]
            map.insert(3287, &[139265]);     // 3287 => [139265]
            map.insert(3288, &[98305]);     // 3288 => [98305]
            map.insert(3289, &[98304]);     // 3289 => [98304]
            map.insert(3290, &[98307]);     // 3290 => [98307]
            map.insert(3291, &[98306]);     // 3291 => [98306]
            map.insert(3292, &[98309]);     // 3292 => [98309]
            map.insert(3293, &[98308]);     // 3293 => [98308]
            map.insert(3294, &[139272]);     // 3294 => [139272]
            map.insert(3295, &[139273]);     // 3295 => [139273]
            map.insert(3296, &[17426]);     // 3296 => [17426]
            map.insert(3297, &[272416]);     // 3297 => [272416]
            map.insert(3298, &[17424]);     // 3298 => [17424]
            map.insert(3299, &[17425]);     // 3299 => [17425]
            map.insert(3300, &[17430]);     // 3300 => [17430]
            map.insert(3301, &[12554]);     // 3301 => [12554]
            map.insert(3302, &[17428]);     // 3302 => [17428]
            map.insert(3303, &[12552]);     // 3303 => [12552]
            map.insert(3304, &[90624]);     // 3304 => [90624]
            map.insert(3305, &[98352]);     // 3305 => [98352]
            map.insert(3306, &[17432]);     // 3306 => [17432]
            map.insert(3307, &[12548]);     // 3307 => [12548]
            map.insert(3308, &[169984]);     // 3308 => [169984]
            map.insert(3309, &[12546]);     // 3309 => [12546]
            map.insert(3310, &[12545]);     // 3310 => [12545]
            map.insert(3311, &[12544]);     // 3311 => [12544]
            map.insert(3312, &[17410]);     // 3312 => [17410]
            map.insert(3313, &[17411]);     // 3313 => [17411]
            map.insert(3314, &[17408]);     // 3314 => [17408]
            map.insert(3315, &[17409]);     // 3315 => [17409]
            map.insert(3316, &[17414]);     // 3316 => [17414]
            map.insert(3317, &[35104]);     // 3317 => [35104]
            map.insert(3318, &[17412]);     // 3318 => [17412]
            map.insert(3319, &[17413]);     // 3319 => [17413]
            map.insert(3320, &[98337]);     // 3320 => [98337]
            map.insert(3321, &[98336]);     // 3321 => [98336]
            map.insert(3322, &[17416]);     // 3322 => [17416]
            map.insert(3323, &[299008]);     // 3323 => [299008]
            map.insert(3324, &[98341]);     // 3324 => [98341]
            map.insert(3325, &[98340]);     // 3325 => [98340]
            map.insert(3326, &[17420]);     // 3326 => [17420]
            map.insert(3327, &[299012]);     // 3327 => [299012]
            map.insert(3328, &[5376]);     // 3328 => [5376]
            map.insert(3329, &[5377]);     // 3329 => [5377]
            map.insert(3330, &[5378]);     // 3330 => [5378]
            map.insert(3331, &[5379]);     // 3331 => [5379]
            map.insert(3332, &[5380]);     // 3332 => [5380]
            map.insert(3333, &[24600]);     // 3333 => [24600]
            map.insert(3334, &[83457]);     // 3334 => [83457]
            map.insert(3335, &[83456]);     // 3335 => [83456]
            map.insert(3336, &[33316]);     // 3336 => [33316]
            map.insert(3337, &[24596]);     // 3337 => [24596]
            map.insert(3338, &[33318]);     // 3338 => [33318]
            map.insert(3339, &[24598]);     // 3339 => [24598]
            map.insert(3340, &[33312]);     // 3340 => [33312]
            map.insert(3341, &[24592]);     // 3341 => [24592]
            map.insert(3342, &[33314]);     // 3342 => [33314]
            map.insert(3343, &[24594]);     // 3343 => [24594]
            map.insert(3344, &[5392]);     // 3344 => [5392]
            map.insert(3345, &[24588]);     // 3345 => [24588]
            map.insert(3346, &[245760]);     // 3346 => [245760]
            map.insert(3347, &[245761]);     // 3347 => [245761]
            map.insert(3348, &[24585]);     // 3348 => [24585]
            map.insert(3349, &[24584]);     // 3349 => [24584]
            map.insert(3350, &[14848]);     // 3350 => [14848]
            map.insert(3351, &[24586]);     // 3351 => [24586]
            map.insert(3352, &[24581]);     // 3352 => [24581]
            map.insert(3353, &[24580]);     // 3353 => [24580]
            map.insert(3354, &[24583]);     // 3354 => [24583]
            map.insert(3355, &[24582]);     // 3355 => [24582]
            map.insert(3356, &[24577]);     // 3356 => [24577]
            map.insert(3357, &[24576]);     // 3357 => [24576]
            map.insert(3358, &[24579]);     // 3358 => [24579]
            map.insert(3359, &[24578]);     // 3359 => [24578]
            map.insert(3360, &[33292]);     // 3360 => [33292]
            map.insert(3361, &[132120]);     // 3361 => [132120]
            map.insert(3362, &[328960]);     // 3362 => [328960]
            map.insert(3363, &[205312]);     // 3363 => [205312]
            map.insert(3364, &[33288]);     // 3364 => [33288]
            map.insert(3365, &[33289]);     // 3365 => [33289]
            map.insert(3366, &[33290]);     // 3366 => [33290]
            map.insert(3367, &[55296]);     // 3367 => [55296]
            map.insert(3368, &[33284]);     // 3368 => [33284]
            map.insert(3369, &[132112]);     // 3369 => [132112]
            map.insert(3370, &[33286]);     // 3370 => [33286]
            map.insert(3371, &[132114]);     // 3371 => [132114]
            map.insert(3372, &[33280]);     // 3372 => [33280]
            map.insert(3373, &[33281]);     // 3373 => [33281]
            map.insert(3374, &[33282]);     // 3374 => [33282]
            map.insert(3375, &[33283]);     // 3375 => [33283]
            map.insert(3376, &[132105]);     // 3376 => [132105]
            map.insert(3377, &[132104]);     // 3377 => [132104]
            map.insert(3378, &[132107]);     // 3378 => [132107]
            map.insert(3379, &[132106]);     // 3379 => [132106]
            map.insert(3380, &[33304]);     // 3380 => [33304]
            map.insert(3381, &[132108]);     // 3381 => [132108]
            map.insert(3382, &[107520]);     // 3382 => [107520]
            map.insert(3383, &[107521]);     // 3383 => [107521]
            map.insert(3384, &[132097]);     // 3384 => [132097]
            map.insert(3385, &[132096]);     // 3385 => [132096]
            map.insert(3386, &[132099]);     // 3386 => [132099]
            map.insert(3387, &[132098]);     // 3387 => [132098]
            map.insert(3388, &[33296]);     // 3388 => [33296]
            map.insert(3389, &[132100]);     // 3389 => [132100]
            map.insert(3390, &[33298]);     // 3390 => [33298]
            map.insert(3391, &[132102]);     // 3391 => [132102]
            map.insert(3392, &[5440]);     // 3392 => [5440]
            map.insert(3393, &[5441]);     // 3393 => [5441]
            map.insert(3394, &[426112]);     // 3394 => [426112]
            map.insert(3395, &[426113]);     // 3395 => [426113]
            map.insert(3396, &[34961]);     // 3396 => [34961]
            map.insert(3397, &[34960]);     // 3397 => [34960]
            map.insert(3398, &[426116]);     // 3398 => [426116]
            map.insert(3399, &[34962]);     // 3399 => [34962]
            map.insert(3400, &[33380]);     // 3400 => [33380]
            map.insert(3401, &[24660]);     // 3401 => [24660]
            map.insert(3402, &[426120]);     // 3402 => [426120]
            map.insert(3403, &[12452]);     // 3403 => [12452]
            map.insert(3404, &[33376]);     // 3404 => [33376]
            map.insert(3405, &[24656]);     // 3405 => [24656]
            map.insert(3406, &[12449]);     // 3406 => [12449]
            map.insert(3407, &[12448]);     // 3407 => [12448]
            map.insert(3408, &[34949]);     // 3408 => [34949]
            map.insert(3409, &[34948]);     // 3409 => [34948]
            map.insert(3410, &[139652]);     // 3410 => [139652]
            map.insert(3411, &[34950]);     // 3411 => [34950]
            map.insert(3412, &[34945]);     // 3412 => [34945]
            map.insert(3413, &[34944]);     // 3413 => [34944]
            map.insert(3414, &[139648]);     // 3414 => [139648]
            map.insert(3415, &[34946]);     // 3415 => [34946]
            map.insert(3416, &[24645]);     // 3416 => [24645]
            map.insert(3417, &[24644]);     // 3417 => [24644]
            map.insert(3418, &[206976]);     // 3418 => [206976]
            map.insert(3419, &[24646]);     // 3419 => [24646]
            map.insert(3420, &[24641]);     // 3420 => [24641]
            map.insert(3421, &[24640]);     // 3421 => [24640]
            map.insert(3422, &[24643]);     // 3422 => [24643]
            map.insert(3423, &[24642]);     // 3423 => [24642]
            map.insert(3424, &[33356]);     // 3424 => [33356]
            map.insert(3425, &[132184]);     // 3425 => [132184]
            map.insert(3426, &[17808]);     // 3426 => [17808]
            map.insert(3427, &[12428]);     // 3427 => [12428]
            map.insert(3428, &[33352]);     // 3428 => [33352]
            map.insert(3429, &[33353]);     // 3429 => [33353]
            map.insert(3430, &[12425]);     // 3430 => [12425]
            map.insert(3431, &[12424]);     // 3431 => [12424]
            map.insert(3432, &[33348]);     // 3432 => [33348]
            map.insert(3433, &[132176]);     // 3433 => [132176]
            map.insert(3434, &[12421]);     // 3434 => [12421]
            map.insert(3435, &[12420]);     // 3435 => [12420]
            map.insert(3436, &[33344]);     // 3436 => [33344]
            map.insert(3437, &[33345]);     // 3437 => [33345]
            map.insert(3438, &[12417]);     // 3438 => [12417]
            map.insert(3439, &[12416]);     // 3439 => [12416]
            map.insert(3440, &[132169]);     // 3440 => [132169]
            map.insert(3441, &[132168]);     // 3441 => [132168]
            map.insert(3442, &[17792]);     // 3442 => [17792]
            map.insert(3443, &[17793]);     // 3443 => [17793]
            map.insert(3444, &[34977]);     // 3444 => [34977]
            map.insert(3445, &[34976]);     // 3445 => [34976]
            map.insert(3446, &[17796]);     // 3446 => [17796]
            map.insert(3447, &[34978]);     // 3447 => [34978]
            map.insert(3448, &[132161]);     // 3448 => [132161]
            map.insert(3449, &[132160]);     // 3449 => [132160]
            map.insert(3450, &[132163]);     // 3450 => [132163]
            map.insert(3451, &[132162]);     // 3451 => [132162]
            map.insert(3452, &[33360]);     // 3452 => [33360]
            map.insert(3453, &[132164]);     // 3453 => [132164]
            map.insert(3454, &[12433]);     // 3454 => [12433]
            map.insert(3455, &[12432]);     // 3455 => [12432]
            map.insert(3456, &[5504]);     // 3456 => [5504]
            map.insert(3457, &[5505]);     // 3457 => [5505]
            map.insert(3458, &[426048]);     // 3458 => [426048]
            map.insert(3459, &[426049]);     // 3459 => [426049]
            map.insert(3460, &[34897]);     // 3460 => [34897]
            map.insert(3461, &[34896]);     // 3461 => [34896]
            map.insert(3462, &[426052]);     // 3462 => [426052]
            map.insert(3463, &[34898]);     // 3463 => [34898]
            map.insert(3464, &[33444]);     // 3464 => [33444]
            map.insert(3465, &[24724]);     // 3465 => [24724]
            map.insert(3466, &[426056]);     // 3466 => [426056]
            map.insert(3467, &[12388]);     // 3467 => [12388]
            map.insert(3468, &[33440]);     // 3468 => [33440]
            map.insert(3469, &[24720]);     // 3469 => [24720]
            map.insert(3470, &[12385]);     // 3470 => [12385]
            map.insert(3471, &[12384]);     // 3471 => [12384]
            map.insert(3472, &[34885]);     // 3472 => [34885]
            map.insert(3473, &[34884]);     // 3473 => [34884]
            map.insert(3474, &[139588]);     // 3474 => [139588]
            map.insert(3475, &[34886]);     // 3475 => [34886]
            map.insert(3476, &[34881]);     // 3476 => [34881]
            map.insert(3477, &[34880]);     // 3477 => [34880]
            map.insert(3478, &[139584]);     // 3478 => [139584]
            map.insert(3479, &[34882]);     // 3479 => [34882]
            map.insert(3480, &[24709]);     // 3480 => [24709]
            map.insert(3481, &[24708]);     // 3481 => [24708]
            map.insert(3482, &[206912]);     // 3482 => [206912]
            map.insert(3483, &[24710]);     // 3483 => [24710]
            map.insert(3484, &[24705]);     // 3484 => [24705]
            map.insert(3485, &[24704]);     // 3485 => [24704]
            map.insert(3486, &[24707]);     // 3486 => [24707]
            map.insert(3487, &[24706]);     // 3487 => [24706]
            map.insert(3488, &[33420]);     // 3488 => [33420]
            map.insert(3489, &[132248]);     // 3489 => [132248]
            map.insert(3490, &[17744]);     // 3490 => [17744]
            map.insert(3491, &[12364]);     // 3491 => [12364]
            map.insert(3492, &[33416]);     // 3492 => [33416]
            map.insert(3493, &[33417]);     // 3493 => [33417]
            map.insert(3494, &[12361]);     // 3494 => [12361]
            map.insert(3495, &[12360]);     // 3495 => [12360]
            map.insert(3496, &[33412]);     // 3496 => [33412]
            map.insert(3497, &[132240]);     // 3497 => [132240]
            map.insert(3498, &[12357]);     // 3498 => [12357]
            map.insert(3499, &[12356]);     // 3499 => [12356]
            map.insert(3500, &[33408]);     // 3500 => [33408]
            map.insert(3501, &[33409]);     // 3501 => [33409]
            map.insert(3502, &[12353]);     // 3502 => [12353]
            map.insert(3503, &[12352]);     // 3503 => [12352]
            map.insert(3504, &[132233]);     // 3504 => [132233]
            map.insert(3505, &[132232]);     // 3505 => [132232]
            map.insert(3506, &[17728]);     // 3506 => [17728]
            map.insert(3507, &[17729]);     // 3507 => [17729]
            map.insert(3508, &[34913]);     // 3508 => [34913]
            map.insert(3509, &[34912]);     // 3509 => [34912]
            map.insert(3510, &[17732]);     // 3510 => [17732]
            map.insert(3511, &[34914]);     // 3511 => [34914]
            map.insert(3512, &[132225]);     // 3512 => [132225]
            map.insert(3513, &[132224]);     // 3513 => [132224]
            map.insert(3514, &[132227]);     // 3514 => [132227]
            map.insert(3515, &[132226]);     // 3515 => [132226]
            map.insert(3516, &[33424]);     // 3516 => [33424]
            map.insert(3517, &[132228]);     // 3517 => [132228]
            map.insert(3518, &[12369]);     // 3518 => [12369]
            map.insert(3519, &[12368]);     // 3519 => [12368]
            map.insert(3520, &[425986]);     // 3520 => [425986]
            map.insert(3521, &[34836]);     // 3521 => [34836]
            map.insert(3522, &[425984]);     // 3522 => [425984]
            map.insert(3523, &[425985]);     // 3523 => [425985]
            map.insert(3524, &[34833]);     // 3524 => [34833]
            map.insert(3525, &[34832]);     // 3525 => [34832]
            map.insert(3526, &[425988]);     // 3526 => [425988]
            map.insert(3527, &[34834]);     // 3527 => [34834]
            map.insert(3528, &[335877]);     // 3528 => [335877]
            map.insert(3529, &[335876]);     // 3529 => [335876]
            map.insert(3530, &[425992]);     // 3530 => [425992]
            map.insert(3531, &[12324]);     // 3531 => [12324]
            map.insert(3532, &[335873]);     // 3532 => [335873]
            map.insert(3533, &[335872]);     // 3533 => [335872]
            map.insert(3534, &[12321]);     // 3534 => [12321]
            map.insert(3535, &[12320]);     // 3535 => [12320]
            map.insert(3536, &[34821]);     // 3536 => [34821]
            map.insert(3537, &[34820]);     // 3537 => [34820]
            map.insert(3538, &[139524]);     // 3538 => [139524]
            map.insert(3539, &[34822]);     // 3539 => [34822]
            map.insert(3540, &[34817]);     // 3540 => [34817]
            map.insert(3541, &[34816]);     // 3541 => [34816]
            map.insert(3542, &[139520]);     // 3542 => [139520]
            map.insert(3543, &[34818]);     // 3543 => [34818]
            map.insert(3544, &[98561]);     // 3544 => [98561]
            map.insert(3545, &[98560]);     // 3545 => [98560]
            map.insert(3546, &[206848]);     // 3546 => [206848]
            map.insert(3547, &[98562]);     // 3547 => [98562]
            map.insert(3548, &[34825]);     // 3548 => [34825]
            map.insert(3549, &[34824]);     // 3549 => [34824]
            map.insert(3550, &[139528]);     // 3550 => [139528]
            map.insert(3551, &[34826]);     // 3551 => [34826]
            map.insert(3552, &[233472]);     // 3552 => [233472]
            map.insert(3553, &[233473]);     // 3553 => [233473]
            map.insert(3554, &[17680]);     // 3554 => [17680]
            map.insert(3555, &[12300]);     // 3555 => [12300]
            map.insert(3556, &[27136]);     // 3556 => [27136]
            map.insert(3557, &[12298]);     // 3557 => [12298]
            map.insert(3558, &[12297]);     // 3558 => [12297]
            map.insert(3559, &[12296]);     // 3559 => [12296]
            map.insert(3560, &[12295]);     // 3560 => [12295]
            map.insert(3561, &[12294]);     // 3561 => [12294]
            map.insert(3562, &[12293]);     // 3562 => [12293]
            map.insert(3563, &[12292]);     // 3563 => [12292]
            map.insert(3564, &[12291]);     // 3564 => [12291]
            map.insert(3565, &[12290]);     // 3565 => [12290]
            map.insert(3566, &[12289]);     // 3566 => [12289]
            map.insert(3567, &[12288]);     // 3567 => [12288]
            map.insert(3568, &[17666]);     // 3568 => [17666]
            map.insert(3569, &[34852]);     // 3569 => [34852]
            map.insert(3570, &[17664]);     // 3570 => [17664]
            map.insert(3571, &[17665]);     // 3571 => [17665]
            map.insert(3572, &[34849]);     // 3572 => [34849]
            map.insert(3573, &[34848]);     // 3573 => [34848]
            map.insert(3574, &[17668]);     // 3574 => [17668]
            map.insert(3575, &[34850]);     // 3575 => [34850]
            map.insert(3576, &[98593]);     // 3576 => [98593]
            map.insert(3577, &[98592]);     // 3577 => [98592]
            map.insert(3578, &[17672]);     // 3578 => [17672]
            map.insert(3579, &[12308]);     // 3579 => [12308]
            map.insert(3580, &[12307]);     // 3580 => [12307]
            map.insert(3581, &[12306]);     // 3581 => [12306]
            map.insert(3582, &[12305]);     // 3582 => [12305]
            map.insert(3583, &[12304]);     // 3583 => [12304]
            map.insert(3584, &[5632]);     // 3584 => [5632]
            map.insert(3585, &[5633]);     // 3585 => [5633]
            map.insert(3586, &[5634]);     // 3586 => [5634]
            map.insert(3587, &[19464]);     // 3587 => [19464]
            map.insert(3588, &[5636]);     // 3588 => [5636]
            map.insert(3589, &[167952]);     // 3589 => [167952]
            map.insert(3590, &[83201]);     // 3590 => [83201]
            map.insert(3591, &[83200]);     // 3591 => [83200]
            map.insert(3592, &[33060]);     // 3592 => [33060]
            map.insert(3593, &[19458]);     // 3593 => [19458]
            map.insert(3594, &[19457]);     // 3594 => [19457]
            map.insert(3595, &[19456]);     // 3595 => [19456]
            map.insert(3596, &[33056]);     // 3596 => [33056]
            map.insert(3597, &[33057]);     // 3597 => [33057]
            map.insert(3598, &[33058]);     // 3598 => [33058]
            map.insert(3599, &[19460]);     // 3599 => [19460]
            map.insert(3600, &[270376]);     // 3600 => [270376]
            map.insert(3601, &[167940]);     // 3601 => [167940]
            map.insert(3602, &[77832]);     // 3602 => [77832]
            map.insert(3603, &[77833]);     // 3603 => [77833]
            map.insert(3604, &[167937]);     // 3604 => [167937]
            map.insert(3605, &[167936]);     // 3605 => [167936]
            map.insert(3606, &[14592]);     // 3606 => [14592]
            map.insert(3607, &[167938]);     // 3607 => [167938]
            map.insert(3608, &[270368]);     // 3608 => [270368]
            map.insert(3609, &[270369]);     // 3609 => [270369]
            map.insert(3610, &[77824]);     // 3610 => [77824]
            map.insert(3611, &[77825]);     // 3611 => [77825]
            map.insert(3612, &[270372]);     // 3612 => [270372]
            map.insert(3613, &[167944]);     // 3613 => [167944]
            map.insert(3614, &[77828]);     // 3614 => [77828]
            map.insert(3615, &[77829]);     // 3615 => [77829]
            map.insert(3616, &[100352]);     // 3616 => [100352]
            map.insert(3617, &[100353]);     // 3617 => [100353]
            map.insert(3618, &[100354]);     // 3618 => [100354]
            map.insert(3619, &[205056]);     // 3619 => [205056]
            map.insert(3620, &[33032]);     // 3620 => [33032]
            map.insert(3621, &[33033]);     // 3621 => [33033]
            map.insert(3622, &[33034]);     // 3622 => [33034]
            map.insert(3623, &[141320]);     // 3623 => [141320]
            map.insert(3624, &[33028]);     // 3624 => [33028]
            map.insert(3625, &[33029]);     // 3625 => [33029]
            map.insert(3626, &[33030]);     // 3626 => [33030]
            map.insert(3627, &[141316]);     // 3627 => [141316]
            map.insert(3628, &[33024]);     // 3628 => [33024]
            map.insert(3629, &[33025]);     // 3629 => [33025]
            map.insert(3630, &[33026]);     // 3630 => [33026]
            map.insert(3631, &[141312]);     // 3631 => [141312]
            map.insert(3632, &[270344]);     // 3632 => [270344]
            map.insert(3633, &[270345]);     // 3633 => [270345]
            map.insert(3634, &[270346]);     // 3634 => [270346]
            map.insert(3635, &[270347]);     // 3635 => [270347]
            map.insert(3636, &[270348]);     // 3636 => [270348]
            map.insert(3637, &[167968]);     // 3637 => [167968]
            map.insert(3638, &[491521]);     // 3638 => [491521]
            map.insert(3639, &[491520]);     // 3639 => [491520]
            map.insert(3640, &[270336]);     // 3640 => [270336]
            map.insert(3641, &[270337]);     // 3641 => [270337]
            map.insert(3642, &[270338]);     // 3642 => [270338]
            map.insert(3643, &[270339]);     // 3643 => [270339]
            map.insert(3644, &[270340]);     // 3644 => [270340]
            map.insert(3645, &[270341]);     // 3645 => [270341]
            map.insert(3646, &[270342]);     // 3646 => [270342]
            map.insert(3647, &[141328]);     // 3647 => [141328]
            map.insert(3648, &[5696]);     // 3648 => [5696]
            map.insert(3649, &[5697]);     // 3649 => [5697]
            map.insert(3650, &[42113]);     // 3650 => [42113]
            map.insert(3651, &[42112]);     // 3651 => [42112]
            map.insert(3652, &[5700]);     // 3652 => [5700]
            map.insert(3653, &[168016]);     // 3653 => [168016]
            map.insert(3654, &[139920]);     // 3654 => [139920]
            map.insert(3655, &[42116]);     // 3655 => [42116]
            map.insert(3656, &[33124]);     // 3656 => [33124]
            map.insert(3657, &[19522]);     // 3657 => [19522]
            map.insert(3658, &[19521]);     // 3658 => [19521]
            map.insert(3659, &[19520]);     // 3659 => [19520]
            map.insert(3660, &[33120]);     // 3660 => [33120]
            map.insert(3661, &[33121]);     // 3661 => [33121]
            map.insert(3662, &[33122]);     // 3662 => [33122]
            map.insert(3663, &[19524]);     // 3663 => [19524]
            map.insert(3664, &[270440]);     // 3664 => [270440]
            map.insert(3665, &[168004]);     // 3665 => [168004]
            map.insert(3666, &[139908]);     // 3666 => [139908]
            map.insert(3667, &[263556]);     // 3667 => [263556]
            map.insert(3668, &[168001]);     // 3668 => [168001]
            map.insert(3669, &[168000]);     // 3669 => [168000]
            map.insert(3670, &[139904]);     // 3670 => [139904]
            map.insert(3671, &[263552]);     // 3671 => [263552]
            map.insert(3672, &[270432]);     // 3672 => [270432]
            map.insert(3673, &[98944]);     // 3673 => [98944]
            map.insert(3674, &[77888]);     // 3674 => [77888]
            map.insert(3675, &[77889]);     // 3675 => [77889]
            map.insert(3676, &[270436]);     // 3676 => [270436]
            map.insert(3677, &[98948]);     // 3677 => [98948]
            map.insert(3678, &[77892]);     // 3678 => [77892]
            map.insert(3679, &[263560]);     // 3679 => [263560]
            map.insert(3680, &[100416]);     // 3680 => [100416]
            map.insert(3681, &[100417]);     // 3681 => [100417]
            map.insert(3682, &[100418]);     // 3682 => [100418]
            map.insert(3683, &[180356]);     // 3683 => [180356]
            map.insert(3684, &[33096]);     // 3684 => [33096]
            map.insert(3685, &[33097]);     // 3685 => [33097]
            map.insert(3686, &[180353]);     // 3686 => [180353]
            map.insert(3687, &[180352]);     // 3687 => [180352]
            map.insert(3688, &[33092]);     // 3688 => [33092]
            map.insert(3689, &[33093]);     // 3689 => [33093]
            map.insert(3690, &[33094]);     // 3690 => [33094]
            map.insert(3691, &[141380]);     // 3691 => [141380]
            map.insert(3692, &[33088]);     // 3692 => [33088]
            map.insert(3693, &[33089]);     // 3693 => [33089]
            map.insert(3694, &[33090]);     // 3694 => [33090]
            map.insert(3695, &[141376]);     // 3695 => [141376]
            map.insert(3696, &[270408]);     // 3696 => [270408]
            map.insert(3697, &[270409]);     // 3697 => [270409]
            map.insert(3698, &[18048]);     // 3698 => [18048]
            map.insert(3699, &[18049]);     // 3699 => [18049]
            map.insert(3700, &[270412]);     // 3700 => [270412]
            map.insert(3701, &[168032]);     // 3701 => [168032]
            map.insert(3702, &[18052]);     // 3702 => [18052]
            map.insert(3703, &[180368]);     // 3703 => [180368]
            map.insert(3704, &[270400]);     // 3704 => [270400]
            map.insert(3705, &[270401]);     // 3705 => [270401]
            map.insert(3706, &[270402]);     // 3706 => [270402]
            map.insert(3707, &[270403]);     // 3707 => [270403]
            map.insert(3708, &[270404]);     // 3708 => [270404]
            map.insert(3709, &[270405]);     // 3709 => [270405]
            map.insert(3710, &[270406]);     // 3710 => [270406]
            map.insert(3711, &[141392]);     // 3711 => [141392]
            map.insert(3712, &[5760]);     // 3712 => [5760]
            map.insert(3713, &[5761]);     // 3713 => [5761]
            map.insert(3714, &[42049]);     // 3714 => [42049]
            map.insert(3715, &[42048]);     // 3715 => [42048]
            map.insert(3716, &[5764]);     // 3716 => [5764]
            map.insert(3717, &[168080]);     // 3717 => [168080]
            map.insert(3718, &[139856]);     // 3718 => [139856]
            map.insert(3719, &[42052]);     // 3719 => [42052]
            map.insert(3720, &[33188]);     // 3720 => [33188]
            map.insert(3721, &[19586]);     // 3721 => [19586]
            map.insert(3722, &[19585]);     // 3722 => [19585]
            map.insert(3723, &[19584]);     // 3723 => [19584]
            map.insert(3724, &[33184]);     // 3724 => [33184]
            map.insert(3725, &[33185]);     // 3725 => [33185]
            map.insert(3726, &[33186]);     // 3726 => [33186]
            map.insert(3727, &[19588]);     // 3727 => [19588]
            map.insert(3728, &[270504]);     // 3728 => [270504]
            map.insert(3729, &[168068]);     // 3729 => [168068]
            map.insert(3730, &[139844]);     // 3730 => [139844]
            map.insert(3731, &[263492]);     // 3731 => [263492]
            map.insert(3732, &[168065]);     // 3732 => [168065]
            map.insert(3733, &[168064]);     // 3733 => [168064]
            map.insert(3734, &[139840]);     // 3734 => [139840]
            map.insert(3735, &[263488]);     // 3735 => [263488]
            map.insert(3736, &[270496]);     // 3736 => [270496]
            map.insert(3737, &[98880]);     // 3737 => [98880]
            map.insert(3738, &[77952]);     // 3738 => [77952]
            map.insert(3739, &[77953]);     // 3739 => [77953]
            map.insert(3740, &[270500]);     // 3740 => [270500]
            map.insert(3741, &[98884]);     // 3741 => [98884]
            map.insert(3742, &[77956]);     // 3742 => [77956]
            map.insert(3743, &[263496]);     // 3743 => [263496]
            map.insert(3744, &[100480]);     // 3744 => [100480]
            map.insert(3745, &[100481]);     // 3745 => [100481]
            map.insert(3746, &[100482]);     // 3746 => [100482]
            map.insert(3747, &[180292]);     // 3747 => [180292]
            map.insert(3748, &[33160]);     // 3748 => [33160]
            map.insert(3749, &[33161]);     // 3749 => [33161]
            map.insert(3750, &[180289]);     // 3750 => [180289]
            map.insert(3751, &[180288]);     // 3751 => [180288]
            map.insert(3752, &[33156]);     // 3752 => [33156]
            map.insert(3753, &[33157]);     // 3753 => [33157]
            map.insert(3754, &[33158]);     // 3754 => [33158]
            map.insert(3755, &[141444]);     // 3755 => [141444]
            map.insert(3756, &[33152]);     // 3756 => [33152]
            map.insert(3757, &[33153]);     // 3757 => [33153]
            map.insert(3758, &[33154]);     // 3758 => [33154]
            map.insert(3759, &[141440]);     // 3759 => [141440]
            map.insert(3760, &[270472]);     // 3760 => [270472]
            map.insert(3761, &[270473]);     // 3761 => [270473]
            map.insert(3762, &[17984]);     // 3762 => [17984]
            map.insert(3763, &[17985]);     // 3763 => [17985]
            map.insert(3764, &[270476]);     // 3764 => [270476]
            map.insert(3765, &[168096]);     // 3765 => [168096]
            map.insert(3766, &[17988]);     // 3766 => [17988]
            map.insert(3767, &[180304]);     // 3767 => [180304]
            map.insert(3768, &[270464]);     // 3768 => [270464]
            map.insert(3769, &[270465]);     // 3769 => [270465]
            map.insert(3770, &[270466]);     // 3770 => [270466]
            map.insert(3771, &[270467]);     // 3771 => [270467]
            map.insert(3772, &[270468]);     // 3772 => [270468]
            map.insert(3773, &[270469]);     // 3773 => [270469]
            map.insert(3774, &[270470]);     // 3774 => [270470]
            map.insert(3775, &[141456]);     // 3775 => [141456]
            map.insert(3776, &[134400]);     // 3776 => [134400]
            map.insert(3777, &[41986]);     // 3777 => [41986]
            map.insert(3778, &[41985]);     // 3778 => [41985]
            map.insert(3779, &[41984]);     // 3779 => [41984]
            map.insert(3780, &[197640]);     // 3780 => [197640]
            map.insert(3781, &[197641]);     // 3781 => [197641]
            map.insert(3782, &[139792]);     // 3782 => [139792]
            map.insert(3783, &[41988]);     // 3783 => [41988]
            map.insert(3784, &[197636]);     // 3784 => [197636]
            map.insert(3785, &[98832]);     // 3785 => [98832]
            map.insert(3786, &[290816]);     // 3786 => [290816]
            map.insert(3787, &[41992]);     // 3787 => [41992]
            map.insert(3788, &[197632]);     // 3788 => [197632]
            map.insert(3789, &[197633]);     // 3789 => [197633]
            map.insert(3790, &[197634]);     // 3790 => [197634]
            map.insert(3791, &[197635]);     // 3791 => [197635]
            map.insert(3792, &[98825]);     // 3792 => [98825]
            map.insert(3793, &[98824]);     // 3793 => [98824]
            map.insert(3794, &[139780]);     // 3794 => [139780]
            map.insert(3795, &[263428]);     // 3795 => [263428]
            map.insert(3796, &[139778]);     // 3796 => [139778]
            map.insert(3797, &[263426]);     // 3797 => [263426]
            map.insert(3798, &[139776]);     // 3798 => [139776]
            map.insert(3799, &[263424]);     // 3799 => [263424]
            map.insert(3800, &[98817]);     // 3800 => [98817]
            map.insert(3801, &[98816]);     // 3801 => [98816]
            map.insert(3802, &[98819]);     // 3802 => [98819]
            map.insert(3803, &[98818]);     // 3803 => [98818]
            map.insert(3804, &[197648]);     // 3804 => [197648]
            map.insert(3805, &[98820]);     // 3805 => [98820]
            map.insert(3806, &[139784]);     // 3806 => [139784]
            map.insert(3807, &[263432]);     // 3807 => [263432]
            map.insert(3808, &[90120]);     // 3808 => [90120]
            map.insert(3809, &[90121]);     // 3809 => [90121]
            map.insert(3810, &[17936]);     // 3810 => [17936]
            map.insert(3811, &[180228]);     // 3811 => [180228]
            map.insert(3812, &[26880]);     // 3812 => [26880]
            map.insert(3813, &[180226]);     // 3813 => [180226]
            map.insert(3814, &[180225]);     // 3814 => [180225]
            map.insert(3815, &[180224]);     // 3815 => [180224]
            map.insert(3816, &[90112]);     // 3816 => [90112]
            map.insert(3817, &[90113]);     // 3817 => [90113]
            map.insert(3818, &[90114]);     // 3818 => [90114]
            map.insert(3819, &[90115]);     // 3819 => [90115]
            map.insert(3820, &[90116]);     // 3820 => [90116]
            map.insert(3821, &[90117]);     // 3821 => [90117]
            map.insert(3822, &[398336]);     // 3822 => [398336]
            map.insert(3823, &[180232]);     // 3823 => [180232]
            map.insert(3824, &[17922]);     // 3824 => [17922]
            map.insert(3825, &[7176]);     // 3825 => [7176]
            map.insert(3826, &[17920]);     // 3826 => [17920]
            map.insert(3827, &[17921]);     // 3827 => [17921]
            map.insert(3828, &[70913]);     // 3828 => [70913]
            map.insert(3829, &[70912]);     // 3829 => [70912]
            map.insert(3830, &[17924]);     // 3830 => [17924]
            map.insert(3831, &[180240]);     // 3831 => [180240]
            map.insert(3832, &[7169]);     // 3832 => [7169]
            map.insert(3833, &[7168]);     // 3833 => [7168]
            map.insert(3834, &[17928]);     // 3834 => [17928]
            map.insert(3835, &[7170]);     // 3835 => [7170]
            map.insert(3836, &[7173]);     // 3836 => [7173]
            map.insert(3837, &[7172]);     // 3837 => [7172]
            map.insert(3838, &[17932]);     // 3838 => [17932]
            map.insert(3839, &[7174]);     // 3839 => [7174]
            map.insert(3840, &[32812]);     // 3840 => [32812]
            map.insert(3841, &[405504]);     // 3841 => [405504]
            map.insert(3842, &[82949]);     // 3842 => [82949]
            map.insert(3843, &[82948]);     // 3843 => [82948]
            map.insert(3844, &[32808]);     // 3844 => [32808]
            map.insert(3845, &[32809]);     // 3845 => [32809]
            map.insert(3846, &[82945]);     // 3846 => [82945]
            map.insert(3847, &[82944]);     // 3847 => [82944]
            map.insert(3848, &[32804]);     // 3848 => [32804]
            map.insert(3849, &[32805]);     // 3849 => [32805]
            map.insert(3850, &[32806]);     // 3850 => [32806]
            map.insert(3851, &[19712]);     // 3851 => [19712]
            map.insert(3852, &[32800]);     // 3852 => [32800]
            map.insert(3853, &[32801]);     // 3853 => [32801]
            map.insert(3854, &[32802]);     // 3854 => [32802]
            map.insert(3855, &[32803]);     // 3855 => [32803]
            map.insert(3856, &[14342]);     // 3856 => [14342]
            map.insert(3857, &[25100]);     // 3857 => [25100]
            map.insert(3858, &[14340]);     // 3858 => [14340]
            map.insert(3859, &[14341]);     // 3859 => [14341]
            map.insert(3860, &[14338]);     // 3860 => [14338]
            map.insert(3861, &[25096]);     // 3861 => [25096]
            map.insert(3862, &[14336]);     // 3862 => [14336]
            map.insert(3863, &[14337]);     // 3863 => [14337]
            map.insert(3864, &[32820]);     // 3864 => [32820]
            map.insert(3865, &[25092]);     // 3865 => [25092]
            map.insert(3866, &[78080]);     // 3866 => [78080]
            map.insert(3867, &[78081]);     // 3867 => [78081]
            map.insert(3868, &[32816]);     // 3868 => [32816]
            map.insert(3869, &[25088]);     // 3869 => [25088]
            map.insert(3870, &[32818]);     // 3870 => [32818]
            map.insert(3871, &[25090]);     // 3871 => [25090]
            map.insert(3872, &[32780]);     // 3872 => [32780]
            map.insert(3873, &[32781]);     // 3873 => [32781]
            map.insert(3874, &[204801]);     // 3874 => [204801]
            map.insert(3875, &[204800]);     // 3875 => [204800]
            map.insert(3876, &[32776]);     // 3876 => [32776]
            map.insert(3877, &[32777]);     // 3877 => [32777]
            map.insert(3878, &[32778]);     // 3878 => [32778]
            map.insert(3879, &[32779]);     // 3879 => [32779]
            map.insert(3880, &[32772]);     // 3880 => [32772]
            map.insert(3881, &[32773]);     // 3881 => [32773]
            map.insert(3882, &[32774]);     // 3882 => [32774]
            map.insert(3883, &[32775]);     // 3883 => [32775]
            map.insert(3884, &[32768]);     // 3884 => [32768]
            map.insert(3885, &[32769]);     // 3885 => [32769]
            map.insert(3886, &[32770]);     // 3886 => [32770]
            map.insert(3887, &[32771]);     // 3887 => [32771]
            map.insert(3888, &[32796]);     // 3888 => [32796]
            map.insert(3889, &[132616]);     // 3889 => [132616]
            map.insert(3890, &[204817]);     // 3890 => [204817]
            map.insert(3891, &[204816]);     // 3891 => [204816]
            map.insert(3892, &[32792]);     // 3892 => [32792]
            map.insert(3893, &[32793]);     // 3893 => [32793]
            map.insert(3894, &[32794]);     // 3894 => [32794]
            map.insert(3895, &[32795]);     // 3895 => [32795]
            map.insert(3896, &[32788]);     // 3896 => [32788]
            map.insert(3897, &[132608]);     // 3897 => [132608]
            map.insert(3898, &[32790]);     // 3898 => [32790]
            map.insert(3899, &[132610]);     // 3899 => [132610]
            map.insert(3900, &[32784]);     // 3900 => [32784]
            map.insert(3901, &[32785]);     // 3901 => [32785]
            map.insert(3902, &[32786]);     // 3902 => [32786]
            map.insert(3903, &[32787]);     // 3903 => [32787]
            map.insert(3904, &[134272]);     // 3904 => [134272]
            map.insert(3905, &[134273]);     // 3905 => [134273]
            map.insert(3906, &[134274]);     // 3906 => [134274]
            map.insert(3907, &[263316]);     // 3907 => [263316]
            map.insert(3908, &[32872]);     // 3908 => [32872]
            map.insert(3909, &[32873]);     // 3909 => [32873]
            map.insert(3910, &[263313]);     // 3910 => [263313]
            map.insert(3911, &[263312]);     // 3911 => [263312]
            map.insert(3912, &[32868]);     // 3912 => [32868]
            map.insert(3913, &[32869]);     // 3913 => [32869]
            map.insert(3914, &[32870]);     // 3914 => [32870]
            map.insert(3915, &[19776]);     // 3915 => [19776]
            map.insert(3916, &[32864]);     // 3916 => [32864]
            map.insert(3917, &[32865]);     // 3917 => [32865]
            map.insert(3918, &[32866]);     // 3918 => [32866]
            map.insert(3919, &[32867]);     // 3919 => [32867]
            map.insert(3920, &[134288]);     // 3920 => [134288]
            map.insert(3921, &[263302]);     // 3921 => [263302]
            map.insert(3922, &[263301]);     // 3922 => [263301]
            map.insert(3923, &[263300]);     // 3923 => [263300]
            map.insert(3924, &[263299]);     // 3924 => [263299]
            map.insert(3925, &[263298]);     // 3925 => [263298]
            map.insert(3926, &[263297]);     // 3926 => [263297]
            map.insert(3927, &[263296]);     // 3927 => [263296]
            map.insert(3928, &[32884]);     // 3928 => [32884]
            map.insert(3929, &[25156]);     // 3929 => [25156]
            map.insert(3930, &[53380]);     // 3930 => [53380]
            map.insert(3931, &[263308]);     // 3931 => [263308]
            map.insert(3932, &[32880]);     // 3932 => [32880]
            map.insert(3933, &[25152]);     // 3933 => [25152]
            map.insert(3934, &[53376]);     // 3934 => [53376]
            map.insert(3935, &[263304]);     // 3935 => [263304]
            map.insert(3936, &[32844]);     // 3936 => [32844]
            map.insert(3937, &[32845]);     // 3937 => [32845]
            map.insert(3938, &[204865]);     // 3938 => [204865]
            map.insert(3939, &[204864]);     // 3939 => [204864]
            map.insert(3940, &[32840]);     // 3940 => [32840]
            map.insert(3941, &[32841]);     // 3941 => [32841]
            map.insert(3942, &[32842]);     // 3942 => [32842]
            map.insert(3943, &[32843]);     // 3943 => [32843]
            map.insert(3944, &[32836]);     // 3944 => [32836]
            map.insert(3945, &[32837]);     // 3945 => [32837]
            map.insert(3946, &[32838]);     // 3946 => [32838]
            map.insert(3947, &[32839]);     // 3947 => [32839]
            map.insert(3948, &[32832]);     // 3948 => [32832]
            map.insert(3949, &[32833]);     // 3949 => [32833]
            map.insert(3950, &[32834]);     // 3950 => [32834]
            map.insert(3951, &[32835]);     // 3951 => [32835]
            map.insert(3952, &[32860]);     // 3952 => [32860]
            map.insert(3953, &[70788]);     // 3953 => [70788]
            map.insert(3954, &[18304]);     // 3954 => [18304]
            map.insert(3955, &[263332]);     // 3955 => [263332]
            map.insert(3956, &[32856]);     // 3956 => [32856]
            map.insert(3957, &[70784]);     // 3957 => [70784]
            map.insert(3958, &[263329]);     // 3958 => [263329]
            map.insert(3959, &[263328]);     // 3959 => [263328]
            map.insert(3960, &[32852]);     // 3960 => [32852]
            map.insert(3961, &[132672]);     // 3961 => [132672]
            map.insert(3962, &[32854]);     // 3962 => [32854]
            map.insert(3963, &[132674]);     // 3963 => [132674]
            map.insert(3964, &[32848]);     // 3964 => [32848]
            map.insert(3965, &[32849]);     // 3965 => [32849]
            map.insert(3966, &[32850]);     // 3966 => [32850]
            map.insert(3967, &[32851]);     // 3967 => [32851]
            map.insert(3968, &[134208]);     // 3968 => [134208]
            map.insert(3969, &[134209]);     // 3969 => [134209]
            map.insert(3970, &[134210]);     // 3970 => [134210]
            map.insert(3971, &[263252]);     // 3971 => [263252]
            map.insert(3972, &[32936]);     // 3972 => [32936]
            map.insert(3973, &[32937]);     // 3973 => [32937]
            map.insert(3974, &[263249]);     // 3974 => [263249]
            map.insert(3975, &[263248]);     // 3975 => [263248]
            map.insert(3976, &[32932]);     // 3976 => [32932]
            map.insert(3977, &[32933]);     // 3977 => [32933]
            map.insert(3978, &[32934]);     // 3978 => [32934]
            map.insert(3979, &[19840]);     // 3979 => [19840]
            map.insert(3980, &[32928]);     // 3980 => [32928]
            map.insert(3981, &[32929]);     // 3981 => [32929]
            map.insert(3982, &[32930]);     // 3982 => [32930]
            map.insert(3983, &[32931]);     // 3983 => [32931]
            map.insert(3984, &[134224]);     // 3984 => [134224]
            map.insert(3985, &[263238]);     // 3985 => [263238]
            map.insert(3986, &[263237]);     // 3986 => [263237]
            map.insert(3987, &[263236]);     // 3987 => [263236]
            map.insert(3988, &[263235]);     // 3988 => [263235]
            map.insert(3989, &[263234]);     // 3989 => [263234]
            map.insert(3990, &[263233]);     // 3990 => [263233]
            map.insert(3991, &[263232]);     // 3991 => [263232]
            map.insert(3992, &[32948]);     // 3992 => [32948]
            map.insert(3993, &[25220]);     // 3993 => [25220]
            map.insert(3994, &[53316]);     // 3994 => [53316]
            map.insert(3995, &[263244]);     // 3995 => [263244]
            map.insert(3996, &[32944]);     // 3996 => [32944]
            map.insert(3997, &[25216]);     // 3997 => [25216]
            map.insert(3998, &[53312]);     // 3998 => [53312]
            map.insert(3999, &[263240]);     // 3999 => [263240]
            map.insert(4000, &[32908]);     // 4000 => [32908]
            map.insert(4001, &[32909]);     // 4001 => [32909]
            map.insert(4002, &[204929]);     // 4002 => [204929]
            map.insert(4003, &[204928]);     // 4003 => [204928]
            map.insert(4004, &[32904]);     // 4004 => [32904]
            map.insert(4005, &[32905]);     // 4005 => [32905]
            map.insert(4006, &[32906]);     // 4006 => [32906]
            map.insert(4007, &[32907]);     // 4007 => [32907]
            map.insert(4008, &[32900]);     // 4008 => [32900]
            map.insert(4009, &[32901]);     // 4009 => [32901]
            map.insert(4010, &[32902]);     // 4010 => [32902]
            map.insert(4011, &[32903]);     // 4011 => [32903]
            map.insert(4012, &[32896]);     // 4012 => [32896]
            map.insert(4013, &[32897]);     // 4013 => [32897]
            map.insert(4014, &[32898]);     // 4014 => [32898]
            map.insert(4015, &[32899]);     // 4015 => [32899]
            map.insert(4016, &[32924]);     // 4016 => [32924]
            map.insert(4017, &[70724]);     // 4017 => [70724]
            map.insert(4018, &[18240]);     // 4018 => [18240]
            map.insert(4019, &[263268]);     // 4019 => [263268]
            map.insert(4020, &[32920]);     // 4020 => [32920]
            map.insert(4021, &[70720]);     // 4021 => [70720]
            map.insert(4022, &[263265]);     // 4022 => [263265]
            map.insert(4023, &[263264]);     // 4023 => [263264]
            map.insert(4024, &[32916]);     // 4024 => [32916]
            map.insert(4025, &[132736]);     // 4025 => [132736]
            map.insert(4026, &[32918]);     // 4026 => [32918]
            map.insert(4027, &[132738]);     // 4027 => [132738]
            map.insert(4028, &[32912]);     // 4028 => [32912]
            map.insert(4029, &[32913]);     // 4029 => [32913]
            map.insert(4030, &[32914]);     // 4030 => [32914]
            map.insert(4031, &[32915]);     // 4031 => [32915]
            map.insert(4032, &[134144]);     // 4032 => [134144]
            map.insert(4033, &[134145]);     // 4033 => [134145]
            map.insert(4034, &[134146]);     // 4034 => [134146]
            map.insert(4035, &[263188]);     // 4035 => [263188]
            map.insert(4036, &[134148]);     // 4036 => [134148]
            map.insert(4037, &[263186]);     // 4037 => [263186]
            map.insert(4038, &[263185]);     // 4038 => [263185]
            map.insert(4039, &[263184]);     // 4039 => [263184]
            map.insert(4040, &[134152]);     // 4040 => [134152]
            map.insert(4041, &[134153]);     // 4041 => [134153]
            map.insert(4042, &[134154]);     // 4042 => [134154]
            map.insert(4043, &[263196]);     // 4043 => [263196]
            map.insert(4044, &[32992]);     // 4044 => [32992]
            map.insert(4045, &[336384]);     // 4045 => [336384]
            map.insert(4046, &[53264]);     // 4046 => [53264]
            map.insert(4047, &[263192]);     // 4047 => [263192]
            map.insert(4048, &[134160]);     // 4048 => [134160]
            map.insert(4049, &[263174]);     // 4049 => [263174]
            map.insert(4050, &[263173]);     // 4050 => [263173]
            map.insert(4051, &[263172]);     // 4051 => [263172]
            map.insert(4052, &[263171]);     // 4052 => [263171]
            map.insert(4053, &[263170]);     // 4053 => [263170]
            map.insert(4054, &[263169]);     // 4054 => [263169]
            map.insert(4055, &[263168]);     // 4055 => [263168]
            map.insert(4056, &[99073]);     // 4056 => [99073]
            map.insert(4057, &[99072]);     // 4057 => [99072]
            map.insert(4058, &[53252]);     // 4058 => [53252]
            map.insert(4059, &[263180]);     // 4059 => [263180]
            map.insert(4060, &[53250]);     // 4060 => [53250]
            map.insert(4061, &[263178]);     // 4061 => [263178]
            map.insert(4062, &[53248]);     // 4062 => [53248]
            map.insert(4063, &[263176]);     // 4063 => [263176]
            map.insert(4064, &[26628]);     // 4064 => [26628]
            map.insert(4065, &[26629]);     // 4065 => [26629]
            map.insert(4066, &[26630]);     // 4066 => [26630]
            map.insert(4067, &[12812]);     // 4067 => [12812]
            map.insert(4068, &[26624]);     // 4068 => [26624]
            map.insert(4069, &[26625]);     // 4069 => [26625]
            map.insert(4070, &[26626]);     // 4070 => [26626]
            map.insert(4071, &[12808]);     // 4071 => [12808]
            map.insert(4072, &[32964]);     // 4072 => [32964]
            map.insert(4073, &[32965]);     // 4073 => [32965]
            map.insert(4074, &[12805]);     // 4074 => [12805]
            map.insert(4075, &[12804]);     // 4075 => [12804]
            map.insert(4076, &[32960]);     // 4076 => [32960]
            map.insert(4077, &[32961]);     // 4077 => [32961]
            map.insert(4078, &[12801]);     // 4078 => [12801]
            map.insert(4079, &[12800]);     // 4079 => [12800]
            map.insert(4080, &[70661]);     // 4080 => [70661]
            map.insert(4081, &[70660]);     // 4081 => [70660]
            map.insert(4082, &[18176]);     // 4082 => [18176]
            map.insert(4083, &[263204]);     // 4083 => [263204]
            map.insert(4084, &[70657]);     // 4084 => [70657]
            map.insert(4085, &[70656]);     // 4085 => [70656]
            map.insert(4086, &[263201]);     // 4086 => [263201]
            map.insert(4087, &[263200]);     // 4087 => [263200]
            map.insert(4088, &[7425]);     // 4088 => [7425]
            map.insert(4089, &[7424]);     // 4089 => [7424]
            map.insert(4090, &[53284]);     // 4090 => [53284]
            map.insert(4091, &[7426]);     // 4091 => [7426]
            map.insert(4092, &[32976]);     // 4092 => [32976]
            map.insert(4093, &[70664]);     // 4093 => [70664]
            map.insert(4094, &[53280]);     // 4094 => [53280]
            map.insert(4095, &[263208]);     // 4095 => [263208]
            
            SYNDROME_MAP = Box::into_raw(map);
        }
    });
}

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

impl BinaryCode for BogosrndCode19_7 {
    fn name(&self) -> String {
        "[19, 7] Bogosrnd code".to_owned()
    }

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

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

    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(19);
        let stor = unsafe { error.get_storage_mut() };
        let errbytes = map[&he.as_u64()];
        debug_assert_eq!(errbytes.len(), 19 / 64 + if 19 % 64 != 0 { 1 } else { 0 });
        stor.clear();
        stor.extend_from_slice(&errbytes[..]);
        unsafe { error.set_len(19) };
        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(7);
        Ok(codeword)
        
    }

    fn decode_slice(&self, c: &mut [u64]) {
        init();
        
        debug_assert_eq!(c[19 / 64] & !((1 << 19) - 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 = BogosrndCode19_7.generator_matrix();
        assert_eq!(code.ncols(), 19);
        assert_eq!(code.nrows(), 7);
    }

    #[test]
    fn test_decode_sample() {
        let code = BogosrndCode19_7;
        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 = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, false, true, true, true, true, false, false, true, false, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, true, true, true, true, false, false, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, true, false, true, false, false, true, false, true, false, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, true, false, false, false, false, true, true, false, false, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, false, true, true, true, true, true, false, true, false, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, true, true, false, true, true, false, true, true, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, false, false, true, true, false, false, false, false, false, true, 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, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, true, false, false, false, false, false, true, false, true, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, true, false, false, false, false, false, false, true, false, true, false, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, true, true, true, false, false, true, true, false, true, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, true, true, true, false, false, false, false, true, true, true, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, false, false, false, true, false, true, false, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, false, false, true, true, false, false, true, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, false, true, true, false, true, false, true, false, false, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, false, true, true, false, true, false, true, true, false, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, false, false, false, false, true, false, true, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, true, false, false, false, true, false, true, false, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, false, false, true, false, true, false, true, true, false, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, false, false, false, false, true, false, false, true, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, true, true, false, true, false, true, false, false, true, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, true, true, true, true, false, true, false, false, false, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, true, false, false, true, true, false, true, false, false, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, false, false, true, true, false, true, false, false, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, false, true, true, true, false, false, true, true, false, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, true, true, true, true, false, false, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, true, false, false, false, true, false, true, false, true, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, true, false, false, false, true, false, true, false, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, false, false, false, false, true, true, false, false, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, false, false, false, false, true, true, false, false, false, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, true, false, true, true, true, false, true, false, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, true, true, true, true, true, true, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, true, false, false, false, true, false, true, false, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, false, false, false, true, true, true, false, false, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, true, false, false, false, true, true, false, false, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, 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 = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, true, false, false, false, true, true, false, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, 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 = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, true, false, false, true, false, false, true, false, true, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, false, false, true, false, false, true, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, false, true, true, true, false, false, false, true, false, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, true, true, true, false, true, false, true, false, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, true, false, false, true, false, false, false, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, false, true, true, false, false, false, false, false, false, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, true, true, true, true, false, true, true, false, false, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, true, false, false, true, false, true, true, false, false, true, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, false, true, false, false, true, true, false, false, true, true, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, false, true, true, false, true, true, false, false, false, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, false, false, true, false, true, false, false, true, false, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, false, true, true, false, true, false, false, true, false, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, false, true, false, false, true, true, false, false, true, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, false, false, false, false, true, true, false, false, false, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, false, true, false, true, false, true, true, true, false, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, false, false, false, true, false, true, true, true, false, true, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, false, true, false, true, false, true, false, true, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, true, true, true, true, false, true, false, true, false, true, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, true, false, true, true, false, true, true, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, false, false, false, true, true, false, false, true, false, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, false, false, false, false, true, false, true, true, false, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, false, true, true, false, false, true, true, true, false, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, true, true, false, false, true, true, false, false, false, false, true, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, false, false, false, true, false, false, false, false, true, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, true, true, false, true, false, false, true, false, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, false, true, true, true, false, false, true, false, true, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, true, true, false, true, false, false, false, false, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, true, true, false, false, false, false, true, false, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, false, false, true, true, true, false, false, false, true, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, false, true, true, false, true, false, false, true, true, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, false, false, true, true, false, true, true, false, false, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, false, false, false, true, true, false, true, true, false, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, true, false, false, true, false, true, false, true, false, false, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, true, false, false, true, false, true, false, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, true, true, true, false, false, true, true, true, false, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, false, true, true, false, false, false, true, false, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, true, true, true, false, false, false, true, false, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, true, false, false, true, false, true, false, false, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, true, true, true, false, true, false, false, false, true, false, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, true, true, true, true, true, false, true, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, true, true, true, true, false, false, true, true, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, true, false, false, true, false, false, true, true, false, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, false, true, true, false, true, false, false, true, true, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, false, false, false, true, false, true, true, false, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, false, false, false, true, false, true, false, true, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, false, true, false, false, false, true, true, false, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, false, true, true, false, true, true, true, false, false, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, false, true, true, true, false, false, true, true, true, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, false, true, true, true, false, false, true, false, true, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, false, false, true, false, false, false, false, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, false, false, false, false, true, false, true, true, true, true, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, true, true, false, true, false, true, true, false, false, false, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, true, true, true, true, true, false, false, true, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, false, true, false, false, false, false, false, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, false, false, false, true, true, false, false, true, false, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, true, false, false, true, true, false, false, false, false, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, false, false, true, true, false, true, false, false, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, true, false, true, true, true, false, true, false, false, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, true, true, true, true, true, false, true, false, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, true, true, true, true, true, true, false, true, false, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, true, true, true, true, false, false, false, true, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, false, false, true, false, false, false, true, true, false, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, true, true, false, false, false, true, false, true, true, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, true, true, true, true, false, true, false, true, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, true, true, true, true, true, true, false, true, false, true, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, false, true, false, true, false, true, true, false, false, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, false, false, false, false, false, true, true, true, false, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, false, true, true, true, true, true, false, false, false, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, false, false, false, true, true, true, false, false, false, false, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, false, true, true, false, true, true, true, true, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, false, true, true, true, false, false, true, false, true, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, true, false, true, false, true, false, false, false, false, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, false, false, false, true, false, false, false, false, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, true, true, false, false, false, false, false, true, false, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, false, false, false, true, false, false, false, false, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, true, false, true, true, true, false, false, true, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, true, true, true, true, true, false, true, true, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, false, true, false, true, true, false, true, false, true, true, false, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, false, false, true, true, false, false, true, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, false, true, true, true, true, true, true, true, true, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, false, true, true, true, false, true, true, true, false, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, false, false, true, true, false, true, false, true, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, false, true, true, false, false, true, false, true, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, true, false, true, true, false, true, true, false, true, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, true, true, true, true, true, false, true, true, false, true, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, false, true, true, false, false, false, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, true, true, true, true, false, false, true, true, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, true, false, false, true, true, true, true, false, false, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, true, false, false, false, true, true, true, true, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, false, false, false, false, false, true, true, true, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, false, false, false, false, true, true, false, true, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, false, false, false, true, true, false, true, true, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, false, true, true, true, true, false, true, true, true, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, true, true, false, false, true, false, false, true, true, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, true, true, false, false, false, false, true, false, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, false, false, false, false, true, true, true, false, true, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, false, false, false, false, true, true, true, false, true, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, false, false, true, true, true, true, false, true, false, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, true, true, true, false, true, false, true, false, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, true, false, false, true, true, true, true, true, false, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, false, false, true, false, false, true, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, false, true, true, false, true, false, true, true, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, true, true, true, true, true, true, true, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, true, true, false, true, true, true, false, false, true, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, false, true, true, false, true, true, false, false, false, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, true, false, true, true, false, false, false, false, true, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, true, false, false, true, true, false, false, false, false, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, true, false, false, true, true, true, false, false, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, true, false, false, true, false, true, false, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, true, false, true, false, true, true, true, true, false, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, true, false, false, false, true, true, true, true, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, true, true, true, false, true, false, true, false, true, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, true, true, false, false, true, true, false, true, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, false, false, true, false, false, false, false, true, true, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, false, false, false, false, false, false, false, false, true, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, true, true, true, true, false, true, true, true, false, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, false, false, true, false, false, true, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, false, true, true, false, false, false, true, false, false, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, false, true, true, false, false, false, false, false, false, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, false, false, false, false, false, false, true, false, false, false, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, true, false, false, false, false, false, false, true, false, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, true, true, false, false, true, false, true, true, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, false, true, true, true, false, false, true, false, true, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, false, true, true, true, false, true, false, false, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, false, false, false, false, false, true, false, true, true, false, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, true, true, true, true, false, false, true, false, false, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, true, true, true, true, false, true, true, false, false, false, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, false, true, true, true, false, false, true, false, false, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, false, false, false, true, false, false, true, false, false, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, false, false, true, false, false, true, true, true, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, true, false, false, true, false, false, true, true, true, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, false, false, true, true, true, true, false, false, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, false, false, true, true, false, true, false, false, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, true, true, true, true, true, true, true, false, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, true, true, true, true, true, true, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, true, false, true, false, true, false, false, false, true, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, false, true, true, false, true, true, false, false, false, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, false, true, true, false, false, false, true, true, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, true, false, false, false, false, false, true, true, false, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, true, true, true, false, false, true, true, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, true, true, true, false, false, false, true, true, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, false, false, true, false, false, false, true, false, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, false, false, false, true, false, false, false, false, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, false, true, false, false, false, false, true, true, false, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, false, false, false, false, false, true, true, true, false, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, false, true, true, false, false, false, true, false, false, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, false, true, true, false, true, false, true, true, true, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, true, true, false, false, true, true, true, false, true, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, true, true, true, true, false, true, false, true, false, true, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, false, false, true, false, true, false, true, true, false, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, true, false, false, false, true, false, true, false, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, true, true, false, true, true, true, true, false, true, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, true, false, false, true, true, true, true, true, true, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, false, false, true, true, false, false, true, false, false, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, false, false, false, true, false, false, false, false, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, true, true, true, true, false, false, false, true, false, false, false, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, true, true, true, false, false, true, false, false, false, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, true, true, true, true, true, false, false, true, false, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, true, true, false, true, true, false, true, true, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, false, false, false, true, true, true, false, false, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, false, false, false, true, false, true, false, false, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, true, false, false, false, false, false, false, false, false, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, true, false, false, false, false, false, false, true, true, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, true, false, false, false, true, true, true, true, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, false, false, false, false, false, true, true, true, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, false, false, true, false, true, false, true, false, true, true, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, true, false, false, false, false, false, false, true, false, true, false, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, false, false, false, false, true, true, true, true, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, 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 = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, true, true, false, false, false, false, false, true, true, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, false, false, false, false, false, false, false, false, true, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, false, true, false, false, true, false, false, true, true, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, false, false, true, true, true, false, true, true, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, true, false, true, true, true, false, true, false, true, false, true, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, true, true, false, true, false, false, false, false, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, false, true, false, false, true, true, true, true, true, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, true, false, false, false, true, true, true, true, true, false, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, true, true, true, true, false, false, false, true, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, true, true, true, true, false, false, true, true, false, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, false, false, true, false, true, true, false, false, false, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, false, true, true, false, true, true, false, false, false, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, true, false, false, false, true, true, true, true, true, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, false, false, true, true, true, false, true, true, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, true, true, false, false, true, true, false, true, false, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, true, true, false, false, true, true, false, true, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, true, false, true, false, true, true, true, false, true, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, false, false, false, false, true, true, false, true, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, true, false, true, false, false, true, true, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, true, true, true, true, true, false, false, true, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, true, true, true, true, false, true, false, true, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, false, true, true, true, true, false, true, true, true, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, false, false, true, false, true, false, false, false, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, true, false, false, true, true, false, false, false, false, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, false, true, false, false, false, false, false, false, true, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, false, true, true, false, false, false, false, false, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, false, false, true, false, false, true, true, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, false, false, true, false, false, true, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, true, true, false, false, false, true, false, true, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, true, false, false, true, false, true, false, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, false, true, false, true, true, true, true, false, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, true, true, true, true, true, true, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, false, true, false, true, true, false, false, true, true, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, false, false, false, false, true, false, false, true, false, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, false, true, true, true, false, true, true, false, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, false, false, true, true, false, true, false, false, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, true, false, false, true, true, false, true, false, false, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, true, false, false, true, true, false, true, false, true, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, true, true, false, true, true, false, true, true, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, false, false, true, false, false, true, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, true, true, false, false, false, false, false, false, true, 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, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, true, true, true, false, true, true, false, false, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, true, true, false, true, false, false, false, false, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, true, true, false, false, false, false, false, true, true, false, false, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, false, false, false, false, false, true, true, true, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, false, false, false, true, false, false, false, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, false, false, false, false, true, true, false, false, false, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, false, false, false, false, true, true, true, false, true, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, false, false, false, true, true, true, false, false, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, false, false, true, false, true, false, false, true, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, true, false, false, true, false, true, false, false, true, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, false, true, true, false, false, false, false, true, false, true, true, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, true, true, false, false, false, true, true, false, true, true, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, true, false, false, true, false, false, false, true, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, false, false, false, true, false, true, false, true, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, false, false, true, true, false, false, false, true, true, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, false, false, false, true, false, false, false, false, true, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, false, true, false, true, true, true, false, false, false, false, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, false, false, true, true, true, false, false, false, false, false, true, false, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, false, true, true, true, false, false, false, true, false, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, false, false, false, true, true, true, false, true, false, true, false, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, true, true, false, true, false, false, true, true, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, true, false, false, true, false, true, true, false, false, true, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, true, false, false, false, false, false, false, true, true, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, false, false, false, false, false, true, true, true, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, true, true, true, true, true, true, false, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, false, true, true, true, true, false, false, true, false, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, true, true, true, true, false, true, false, false, false, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, false, true, true, true, true, true, true, true, false, true, true, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, false, false, true, false, false, false, false, false, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, true, false, false, true, false, true, false, false, false, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, false, true, false, true, true, true, false, true, false, true, true, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, false, false, true, false, false, true, true, false, false, false, false, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, false, true, true, false, true, false, true, true, false, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, false, true, true, false, true, false, true, true, false, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, false, false, false, true, false, false, false, false, false, false, false, true, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, false, false, false, true, false, false, true, false, false, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, false, false, true, false, false, true, true, false, true, false, true, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, false, false, false, false, true, false, true, true, true, true, true, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, true, false, false, true, true, false, true, true, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, true, true, true, true, true, true, true, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, false, true, true, false, false, true, true, true, true, true, true, true, true, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, 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 = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, false, true, false, false, false, true, false, false, true, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, false, true, true, false, false, false, false, false, true, true, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, false, false, false, true, false, true, false, false, true, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, false, false, false, true, false, false, false, false, false, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, true, true, true, false, true, false, false, false, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, true, true, true, true, true, false, false, false, false, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, false, true, false, true, true, true, false, false, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, false, false, true, true, false, false, true, true, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, false, true, true, true, true, true, false, true, true, true, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, true, true, true, true, true, true, true, true, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, false, false, true, false, false, false, true, false, true, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, false, false, false, false, false, false, false, false, false, true, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, true, false, true, true, true, true, true, false, false, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, false, false, true, false, true, true, false, true, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, false, true, true, false, true, false, false, false, true, false, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, true, false, false, true, true, true, false, true, false, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, true, true, true, false, false, false, true, true, true, false, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, true, true, true, false, true, true, true, true, false, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, true, true, false, true, false, true, true, true, false, true, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, false, false, true, false, false, false, false, false, true, true, true, true, true, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, false, true, false, true, false, true, true, true, true, false, false, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, false, true, true, false, false, true, true, true, true, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, true, true, false, false, true, true, false, true, false, true, true, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, false, false, true, true, true, false, true, true, false, true, false, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, true, true, true, true, false, false, false, false, true, false, false, true, false, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, true, true, true, false, false, false, false, true, false, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, true, false, true, true, true, false, true, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, false, true, true, false, false, true, true, true, true, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, false, false, false, false, false, false, true, true, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, true, false, false, false, false, false, true, true, true, false, true, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, true, true, false, false, true, true, true, false, false, true, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, true, true, false, false, true, true, true, true, true, true, false, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, true, false, false, false, false, false, true, true, false, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, false, false, false, false, false, true, true, true, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, false, true, false, false, false, true, false, false, true, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, false, true, true, false, false, true, true, true, true, false, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, true, true, true, false, false, false, true, true, true, true, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, false, true, true, true, false, false, false, true, true, true, true, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, true, true, false, false, true, true, false, true, false, true, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, false, false, false, true, false, true, false, true, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, true, false, true, true, true, true, true, true, true, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, false, false, false, true, true, true, true, true, true, false, true, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, false, false, false, false, false, false, true, true, true, false, true, false, true, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, true, false, false, false, true, true, true, true, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, false, false, false, false, false, true, false, false, true, true, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, true, false, false, false, false, false, false, true, true, false, true, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, true, true, false, false, true, true, false, false, false, true, false, false, true, true, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, true, false, true, true, true, true, false, false, true, true, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, true, false, false, true, true, false, false, false, false, false, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, true, false, true, true, true, false, false, true, false, false, true, false, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, true, true, false, true, false, true, false, true, false, true, false, false, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, false, false, false, true, false, true, false, true, true, true, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, true, true, true, true, false, false, false, true, false, true, true, true, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, true, true, false, false, false, false, false, true, true, true, false, true, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, true, false, true, true, true, false, true, true, true, true, false, false, false, false]);
            let codeword = BinVector::from_bools(&[true, true, true, true, true, false, false, false, true, true, false, true, true, true, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, true, false, false, true, false, true, true, false, false, false, true, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, true, false, false, true, false, true, true, false, true, true, true, false, false, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, true, false, true, true, true, true, true, false, true, true, false, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, true, true, true, false, false, false, true, false, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, true, true, false, false, false, true, true, true, false, false, false, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, false, false, false, true, true, true, true, false, false, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, true, true, false, false, false, true, true, false, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, true, true, true, false, false, true, true, false, false, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, true, false, false, true, true, false, true, false, false, false, true, true, true, false]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, false, false, false, true, true, true, true, false, false, false, true, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, true, false, true, true, false, true, false, false, true, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, true, false, false, true, false, true, true, false, true, true, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, false, false, true, true, false, true, true, true, true, true, false, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[false, false, false, false, false, true, false, false, false, true, true, true, true, false, false, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, false, false, false, true, true, false, false, true, true, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, false, false, false, true, true, true, false, false, true, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, true, false, false, false, true, false, true, true, true, true, false, false, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, false, false, false, true, true, true, false, false, false, false, true, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, true, true, false, false, false, true, false, true, false, false, true, false, true, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, true, false, false, false, true, false, true, false, false, true, false, true, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, false, false, true, true, true, true, false, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[true, true, true, false, true, true, false, false, false, true, true, false, true, false, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, true, false, false, true, true, false, true, false, true, false, true, false, true, true]);
            let codeword = BinVector::from_bools(&[true, false, false, false, false, true, false, false, true, false, false, true, true, true, false, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, false, false, true, false, true, true, false, true, true, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, false, false, false, false, false, false, true, false, true, false, true, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, false, true, true, true, false, false, true, true, false, false, true, true, false, true, true]);
            let codeword = BinVector::from_bools(&[false, false, true, true, false, true, true, true, false, false, true, true, false, false, false, true, false, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, true, false, false, false, false, false, true, false, true, false, true, false, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, false, false, false, false, false, true, true, true, false, true, false, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, false, false, true, true, false, false, true, false, false, false, true, true, false, true, false, true, true, true]);
            let codeword = BinVector::from_bools(&[false, false, false, false, true, false, false, false, true, true, false, true, true, false, true, false, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, true, true, false, true, true, false, false, false, false, true, false, false, true, false, false, true]);
            let codeword = BinVector::from_bools(&[true, true, false, true, true, true, true, true, false, false, true, false, false, false, false, true, false, false, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, true, true, true, true, true, false, true, false, false, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[true, false, false, true, true, true, true, true, false, true, false, true, false, false, false, false, false, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, false, false, false, false, true, true, false, false, true, true, false, false, true, false, false, true, false]);
            let codeword = BinVector::from_bools(&[true, true, true, 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 = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, false, false, true, true, false, true, true, true, false, false, true, false, true, true, true, true]);
            let codeword = BinVector::from_bools(&[false, true, false, true, false, true, false, false, true, true, false, false, false, true, true, true, true, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, true, true, true, false, false, true, true, true, true, true, false, true, true, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, true, true, true, false, false, true, true, false, true, false, true, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, true, true, false, false, false, false, true, true, false, true, false, true, true, false, false, true, true, false]);
            let codeword = BinVector::from_bools(&[true, true, false, false, false, true, false, false, true, true, true, false, true, true, false, false, true, true, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, true, true, false, false, true, false, false, false, true, false, false, false, false, true]);
            let codeword = BinVector::from_bools(&[false, true, true, true, false, true, true, true, false, true, false, false, false, false, false, false, false, true, true]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, true, false, false, false, true, true, true, false, false, false, true, true, true, true, false, true, false]);
            let codeword = BinVector::from_bools(&[false, false, true, false, false, false, true, true, true, false, false, false, false, true, true, true, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[true, false, false, false, true, false, true, false, true, true, false, false, false, false, false, false, true, false, false]);
            let codeword = BinVector::from_bools(&[true, false, true, false, true, true, true, true, true, true, false, false, false, false, false, false, true, false, false]);
            assert_eq!(code.decode_to_code(&randvec), Ok(codeword));
        }
        
        {
            let code = BogosrndCode19_7;
            let randvec = BinVector::from_bools(&[false, true, false, true, false, false, false, true, false, false, false, true, false, false, true, true, false, false, true]);
            let codeword = BinVector::from_bools(&[false, false, false, true, false, false, true, true, false, false, false, true, false, true, true, true, false, false, 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, true, true, true, false, false, true, false, false, false, true, true ]);
        assert_eq!(vector, first_row.as_vector());
    }

}