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;

/// ``[30, 20]`` Wagner code
///
/// Decodes using Syndrome decoding
#[derive(Clone, Serialize)]
pub struct WagnerCode30_20;

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(&[
                &[ 715128833 ],
                &[ 357564418 ],
                &[ 1069547524 ],
                &[ 1060110344 ],
                &[ 1022361616 ],
                &[ 871366688 ],
                &[ 267386944 ],
                &[ 24117376 ],
                &[ 78643456 ],
                &[ 305136128 ],
                &[ 674235392 ],
                &[ 147851264 ],
                &[ 810553344 ],
                &[ 48242688 ],
                &[ 641744896 ],
                &[ 192970752 ],
                &[ 462487552 ],
                &[ 454164480 ],
                &[ 505675776 ],
                &[ 664272896 ],
                
            ], 30));
            GENERATOR_MATRIX = Box::into_raw(matrix);

            let matrix = Box::new(BinMatrix::from_slices(&[
                &[ 430346241 ],
                &[ 642813954 ],
                &[ 283829316 ],
                &[ 326905928 ],
                &[ 771682384 ],
                &[ 398909536 ],
                &[ 856368256 ],
                &[ 204797184 ],
                &[ 267994624 ],
                &[ 1070151680 ],
                
            ], 30));
            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(1024, 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, &[3145728]);     // 7 => [3145728]
            map.insert(8, &[8]);     // 8 => [8]
            map.insert(9, &[9]);     // 9 => [9]
            map.insert(10, &[10]);     // 10 => [10]
            map.insert(11, &[12582912]);     // 11 => [12582912]
            map.insert(12, &[12]);     // 12 => [12]
            map.insert(13, &[13]);     // 13 => [13]
            map.insert(14, &[294912]);     // 14 => [294912]
            map.insert(15, &[294913]);     // 15 => [294913]
            map.insert(16, &[16]);     // 16 => [16]
            map.insert(17, &[17]);     // 17 => [17]
            map.insert(18, &[18]);     // 18 => [18]
            map.insert(19, &[50331648]);     // 19 => [50331648]
            map.insert(20, &[20]);     // 20 => [20]
            map.insert(21, &[21]);     // 21 => [21]
            map.insert(22, &[22]);     // 22 => [22]
            map.insert(23, &[50331652]);     // 23 => [50331652]
            map.insert(24, &[24]);     // 24 => [24]
            map.insert(25, &[25]);     // 25 => [25]
            map.insert(26, &[26]);     // 26 => [26]
            map.insert(27, &[50331656]);     // 27 => [50331656]
            map.insert(28, &[96]);     // 28 => [96]
            map.insert(29, &[97]);     // 29 => [97]
            map.insert(30, &[98]);     // 30 => [98]
            map.insert(31, &[805306400]);     // 31 => [805306400]
            map.insert(32, &[32]);     // 32 => [32]
            map.insert(33, &[33]);     // 33 => [33]
            map.insert(34, &[34]);     // 34 => [34]
            map.insert(35, &[201326592]);     // 35 => [201326592]
            map.insert(36, &[36]);     // 36 => [36]
            map.insert(37, &[17301504]);     // 37 => [17301504]
            map.insert(38, &[38]);     // 38 => [38]
            map.insert(39, &[17301506]);     // 39 => [17301506]
            map.insert(40, &[40]);     // 40 => [40]
            map.insert(41, &[2113536]);     // 41 => [2113536]
            map.insert(42, &[33619968]);     // 42 => [33619968]
            map.insert(43, &[33619969]);     // 43 => [33619969]
            map.insert(44, &[80]);     // 44 => [80]
            map.insert(45, &[81]);     // 45 => [81]
            map.insert(46, &[1064960]);     // 46 => [1064960]
            map.insert(47, &[1064961]);     // 47 => [1064961]
            map.insert(48, &[48]);     // 48 => [48]
            map.insert(49, &[49]);     // 49 => [49]
            map.insert(50, &[50]);     // 50 => [50]
            map.insert(51, &[33028]);     // 51 => [33028]
            map.insert(52, &[72]);     // 52 => [72]
            map.insert(53, &[131200]);     // 53 => [131200]
            map.insert(54, &[34078720]);     // 54 => [34078720]
            map.insert(55, &[33024]);     // 55 => [33024]
            map.insert(56, &[68]);     // 56 => [68]
            map.insert(57, &[262400]);     // 57 => [262400]
            map.insert(58, &[70]);     // 58 => [70]
            map.insert(59, &[262402]);     // 59 => [262402]
            map.insert(60, &[64]);     // 60 => [64]
            map.insert(61, &[65]);     // 61 => [65]
            map.insert(62, &[66]);     // 62 => [66]
            map.insert(63, &[805306368]);     // 63 => [805306368]
            map.insert(64, &[128]);     // 64 => [128]
            map.insert(65, &[129]);     // 65 => [129]
            map.insert(66, &[130]);     // 66 => [130]
            map.insert(67, &[131]);     // 67 => [131]
            map.insert(68, &[132]);     // 68 => [132]
            map.insert(69, &[133]);     // 69 => [133]
            map.insert(70, &[20971521]);     // 70 => [20971521]
            map.insert(71, &[20971520]);     // 71 => [20971520]
            map.insert(72, &[136]);     // 72 => [136]
            map.insert(73, &[131136]);     // 73 => [131136]
            map.insert(74, &[138]);     // 74 => [138]
            map.insert(75, &[131138]);     // 75 => [131138]
            map.insert(76, &[25165824]);     // 76 => [25165824]
            map.insert(77, &[25165825]);     // 77 => [25165825]
            map.insert(78, &[25165826]);     // 78 => [25165826]
            map.insert(79, &[20971528]);     // 79 => [20971528]
            map.insert(80, &[144]);     // 80 => [144]
            map.insert(81, &[145]);     // 81 => [145]
            map.insert(82, &[536872960]);     // 82 => [536872960]
            map.insert(83, &[536872961]);     // 83 => [536872961]
            map.insert(84, &[37748736]);     // 84 => [37748736]
            map.insert(85, &[131104]);     // 85 => [131104]
            map.insert(86, &[37748738]);     // 86 => [37748738]
            map.insert(87, &[131106]);     // 87 => [131106]
            map.insert(88, &[2098177]);     // 88 => [2098177]
            map.insert(89, &[2098176]);     // 89 => [2098176]
            map.insert(90, &[1049604]);     // 90 => [1049604]
            map.insert(91, &[2098178]);     // 91 => [2098178]
            map.insert(92, &[1049602]);     // 92 => [1049602]
            map.insert(93, &[41943042]);     // 93 => [41943042]
            map.insert(94, &[1049600]);     // 94 => [1049600]
            map.insert(95, &[41943040]);     // 95 => [41943040]
            map.insert(96, &[160]);     // 96 => [160]
            map.insert(97, &[161]);     // 97 => [161]
            map.insert(98, &[4718592]);     // 98 => [4718592]
            map.insert(99, &[4718593]);     // 99 => [4718593]
            map.insert(100, &[131089]);     // 100 => [131089]
            map.insert(101, &[131088]);     // 101 => [131088]
            map.insert(102, &[12289]);     // 102 => [12289]
            map.insert(103, &[12288]);     // 103 => [12288]
            map.insert(104, &[8912897]);     // 104 => [8912897]
            map.insert(105, &[8912896]);     // 105 => [8912896]
            map.insert(106, &[4718600]);     // 106 => [4718600]
            map.insert(107, &[8912898]);     // 107 => [8912898]
            map.insert(108, &[268437505]);     // 108 => [268437505]
            map.insert(109, &[268437504]);     // 109 => [268437504]
            map.insert(110, &[4259856]);     // 110 => [4259856]
            map.insert(111, &[268437506]);     // 111 => [268437506]
            map.insert(112, &[17408]);     // 112 => [17408]
            map.insert(113, &[131076]);     // 113 => [131076]
            map.insert(114, &[17410]);     // 114 => [17410]
            map.insert(115, &[131078]);     // 115 => [131078]
            map.insert(116, &[131073]);     // 116 => [131073]
            map.insert(117, &[131072]);     // 117 => [131072]
            map.insert(118, &[131075]);     // 118 => [131075]
            map.insert(119, &[131074]);     // 119 => [131074]
            map.insert(120, &[196]);     // 120 => [196]
            map.insert(121, &[131084]);     // 121 => [131084]
            map.insert(122, &[4259844]);     // 122 => [4259844]
            map.insert(123, &[20971584]);     // 123 => [20971584]
            map.insert(124, &[192]);     // 124 => [192]
            map.insert(125, &[131080]);     // 125 => [131080]
            map.insert(126, &[4259840]);     // 126 => [4259840]
            map.insert(127, &[4259841]);     // 127 => [4259841]
            map.insert(128, &[256]);     // 128 => [256]
            map.insert(129, &[257]);     // 129 => [257]
            map.insert(130, &[258]);     // 130 => [258]
            map.insert(131, &[259]);     // 131 => [259]
            map.insert(132, &[260]);     // 132 => [260]
            map.insert(133, &[262208]);     // 133 => [262208]
            map.insert(134, &[75497473]);     // 134 => [75497473]
            map.insert(135, &[75497472]);     // 135 => [75497472]
            map.insert(136, &[264]);     // 136 => [264]
            map.insert(137, &[265]);     // 137 => [265]
            map.insert(138, &[32833]);     // 138 => [32833]
            map.insert(139, &[32832]);     // 139 => [32832]
            map.insert(140, &[71303168]);     // 140 => [71303168]
            map.insert(141, &[71303169]);     // 141 => [71303169]
            map.insert(142, &[71303170]);     // 142 => [71303170]
            map.insert(143, &[32836]);     // 143 => [32836]
            map.insert(144, &[272]);     // 144 => [272]
            map.insert(145, &[268443648]);     // 145 => [268443648]
            map.insert(146, &[274]);     // 146 => [274]
            map.insert(147, &[268443650]);     // 147 => [268443650]
            map.insert(148, &[276]);     // 148 => [276]
            map.insert(149, &[32802]);     // 149 => [32802]
            map.insert(150, &[32801]);     // 150 => [32801]
            map.insert(151, &[32800]);     // 151 => [32800]
            map.insert(152, &[262177]);     // 152 => [262177]
            map.insert(153, &[262176]);     // 153 => [262176]
            map.insert(154, &[1049088]);     // 154 => [1049088]
            map.insert(155, &[6144]);     // 155 => [6144]
            map.insert(156, &[2097665]);     // 156 => [2097665]
            map.insert(157, &[2097664]);     // 157 => [2097664]
            map.insert(158, &[1049092]);     // 158 => [1049092]
            map.insert(159, &[2097666]);     // 159 => [2097666]
            map.insert(160, &[288]);     // 160 => [288]
            map.insert(161, &[289]);     // 161 => [289]
            map.insert(162, &[290]);     // 162 => [290]
            map.insert(163, &[32788]);     // 163 => [32788]
            map.insert(164, &[142606336]);     // 164 => [142606336]
            map.insert(165, &[142606337]);     // 165 => [142606337]
            map.insert(166, &[32785]);     // 166 => [32785]
            map.insert(167, &[32784]);     // 167 => [32784]
            map.insert(168, &[262161]);     // 168 => [262161]
            map.insert(169, &[262160]);     // 169 => [262160]
            map.insert(170, &[536879108]);     // 170 => [536879108]
            map.insert(171, &[262162]);     // 171 => [262162]
            map.insert(172, &[536879106]);     // 172 => [536879106]
            map.insert(173, &[138412034]);     // 173 => [138412034]
            map.insert(174, &[536879104]);     // 174 => [536879104]
            map.insert(175, &[138412032]);     // 175 => [138412032]
            map.insert(176, &[262153]);     // 176 => [262153]
            map.insert(177, &[262152]);     // 177 => [262152]
            map.insert(178, &[32773]);     // 178 => [32773]
            map.insert(179, &[32772]);     // 179 => [32772]
            map.insert(180, &[16896]);     // 180 => [16896]
            map.insert(181, &[32770]);     // 181 => [32770]
            map.insert(182, &[32769]);     // 182 => [32769]
            map.insert(183, &[32768]);     // 183 => [32768]
            map.insert(184, &[262145]);     // 184 => [262145]
            map.insert(185, &[262144]);     // 185 => [262144]
            map.insert(186, &[262147]);     // 186 => [262147]
            map.insert(187, &[262146]);     // 187 => [262146]
            map.insert(188, &[320]);     // 188 => [320]
            map.insert(189, &[262148]);     // 189 => [262148]
            map.insert(190, &[32777]);     // 190 => [32777]
            map.insert(191, &[32776]);     // 191 => [32776]
            map.insert(192, &[384]);     // 192 => [384]
            map.insert(193, &[385]);     // 193 => [385]
            map.insert(194, &[163840]);     // 194 => [163840]
            map.insert(195, &[163841]);     // 195 => [163841]
            map.insert(196, &[1536]);     // 196 => [1536]
            map.insert(197, &[1537]);     // 197 => [1537]
            map.insert(198, &[1538]);     // 198 => [1538]
            map.insert(199, &[167772224]);     // 199 => [167772224]
            map.insert(200, &[536875009]);     // 200 => [536875009]
            map.insert(201, &[536875008]);     // 201 => [536875008]
            map.insert(202, &[83886081]);     // 202 => [83886081]
            map.insert(203, &[83886080]);     // 203 => [83886080]
            map.insert(204, &[393216]);     // 204 => [393216]
            map.insert(205, &[134742016]);     // 205 => [134742016]
            map.insert(206, &[393218]);     // 206 => [393218]
            map.insert(207, &[134742018]);     // 207 => [134742018]
            map.insert(208, &[134283265]);     // 208 => [134283265]
            map.insert(209, &[134283264]);     // 209 => [134283264]
            map.insert(210, &[163856]);     // 210 => [163856]
            map.insert(211, &[134283266]);     // 211 => [134283266]
            map.insert(212, &[1552]);     // 212 => [1552]
            map.insert(213, &[134283268]);     // 213 => [134283268]
            map.insert(214, &[268439584]);     // 214 => [268439584]
            map.insert(215, &[32928]);     // 215 => [32928]
            map.insert(216, &[100663296]);     // 216 => [100663296]
            map.insert(217, &[100663297]);     // 217 => [100663297]
            map.insert(218, &[100663298]);     // 218 => [100663298]
            map.insert(219, &[83886096]);     // 219 => [83886096]
            map.insert(220, &[100663300]);     // 220 => [100663300]
            map.insert(221, &[134742032]);     // 221 => [134742032]
            map.insert(222, &[1049856]);     // 222 => [1049856]
            map.insert(223, &[41943296]);     // 223 => [41943296]
            map.insert(224, &[150994952]);     // 224 => [150994952]
            map.insert(225, &[150994953]);     // 225 => [150994953]
            map.insert(226, &[67174416]);     // 226 => [67174416]
            map.insert(227, &[17827840]);     // 227 => [17827840]
            map.insert(228, &[1568]);     // 228 => [1568]
            map.insert(229, &[131344]);     // 229 => [131344]
            map.insert(230, &[67633160]);     // 230 => [67633160]
            map.insert(231, &[32912]);     // 231 => [32912]
            map.insert(232, &[150994944]);     // 232 => [150994944]
            map.insert(233, &[150994945]);     // 233 => [150994945]
            map.insert(234, &[150994946]);     // 234 => [150994946]
            map.insert(235, &[167772176]);     // 235 => [167772176]
            map.insert(236, &[67633154]);     // 236 => [67633154]
            map.insert(237, &[134742048]);     // 237 => [134742048]
            map.insert(238, &[67633152]);     // 238 => [67633152]
            map.insert(239, &[67633153]);     // 239 => [67633153]
            map.insert(240, &[67174402]);     // 240 => [67174402]
            map.insert(241, &[131332]);     // 241 => [131332]
            map.insert(242, &[67174400]);     // 242 => [67174400]
            map.insert(243, &[67174401]);     // 243 => [67174401]
            map.insert(244, &[131329]);     // 244 => [131329]
            map.insert(245, &[131328]);     // 245 => [131328]
            map.insert(246, &[268439552]);     // 246 => [268439552]
            map.insert(247, &[32896]);     // 247 => [32896]
            map.insert(248, &[262273]);     // 248 => [262273]
            map.insert(249, &[262272]);     // 249 => [262272]
            map.insert(250, &[167772161]);     // 250 => [167772161]
            map.insert(251, &[167772160]);     // 251 => [167772160]
            map.insert(252, &[10240]);     // 252 => [10240]
            map.insert(253, &[10241]);     // 253 => [10241]
            map.insert(254, &[10242]);     // 254 => [10242]
            map.insert(255, &[167772164]);     // 255 => [167772164]
            map.insert(256, &[512]);     // 256 => [512]
            map.insert(257, &[513]);     // 257 => [513]
            map.insert(258, &[514]);     // 258 => [514]
            map.insert(259, &[49152]);     // 259 => [49152]
            map.insert(260, &[516]);     // 260 => [516]
            map.insert(261, &[517]);     // 261 => [517]
            map.insert(262, &[301989889]);     // 262 => [301989889]
            map.insert(263, &[301989888]);     // 263 => [301989888]
            map.insert(264, &[520]);     // 264 => [520]
            map.insert(265, &[521]);     // 265 => [521]
            map.insert(266, &[134221824]);     // 266 => [134221824]
            map.insert(267, &[134221825]);     // 267 => [134221825]
            map.insert(268, &[278529]);     // 268 => [278529]
            map.insert(269, &[278528]);     // 269 => [278528]
            map.insert(270, &[537395200]);     // 270 => [537395200]
            map.insert(271, &[537395201]);     // 271 => [537395201]
            map.insert(272, &[528]);     // 272 => [528]
            map.insert(273, &[529]);     // 273 => [529]
            map.insert(274, &[536936448]);     // 274 => [536936448]
            map.insert(275, &[536936449]);     // 275 => [536936449]
            map.insert(276, &[285212672]);     // 276 => [285212672]
            map.insert(277, &[285212673]);     // 277 => [285212673]
            map.insert(278, &[285212674]);     // 278 => [285212674]
            map.insert(279, &[301989904]);     // 279 => [301989904]
            map.insert(280, &[1048834]);     // 280 => [1048834]
            map.insert(281, &[2097412]);     // 281 => [2097412]
            map.insert(282, &[1048832]);     // 282 => [1048832]
            map.insert(283, &[1048833]);     // 283 => [1048833]
            map.insert(284, &[2097409]);     // 284 => [2097409]
            map.insert(285, &[2097408]);     // 285 => [2097408]
            map.insert(286, &[1048836]);     // 286 => [1048836]
            map.insert(287, &[2097410]);     // 287 => [2097410]
            map.insert(288, &[544]);     // 288 => [544]
            map.insert(289, &[545]);     // 289 => [545]
            map.insert(290, &[1310721]);     // 290 => [1310721]
            map.insert(291, &[1310720]);     // 291 => [1310720]
            map.insert(292, &[2359296]);     // 292 => [2359296]
            map.insert(293, &[2359297]);     // 293 => [2359297]
            map.insert(294, &[2359298]);     // 294 => [2359298]
            map.insert(295, &[1310724]);     // 295 => [1310724]
            map.insert(296, &[67112961]);     // 296 => [67112961]
            map.insert(297, &[67112960]);     // 297 => [67112960]
            map.insert(298, &[2129920]);     // 298 => [2129920]
            map.insert(299, &[553648128]);     // 299 => [553648128]
            map.insert(300, &[1081345]);     // 300 => [1081345]
            map.insert(301, &[1081344]);     // 301 => [1081344]
            map.insert(302, &[2129924]);     // 302 => [2129924]
            map.insert(303, &[1081346]);     // 303 => [1081346]
            map.insert(304, &[268959745]);     // 304 => [268959745]
            map.insert(305, &[268959744]);     // 305 => [268959744]
            map.insert(306, &[536936480]);     // 306 => [536936480]
            map.insert(307, &[268959746]);     // 307 => [268959746]
            map.insert(308, &[16640]);     // 308 => [16640]
            map.insert(309, &[8390656]);     // 309 => [8390656]
            map.insert(310, &[16642]);     // 310 => [16642]
            map.insert(311, &[8390658]);     // 311 => [8390658]
            map.insert(312, &[570425344]);     // 312 => [570425344]
            map.insert(313, &[570425345]);     // 313 => [570425345]
            map.insert(314, &[570425346]);     // 314 => [570425346]
            map.insert(315, &[553648144]);     // 315 => [553648144]
            map.insert(316, &[576]);     // 316 => [576]
            map.insert(317, &[577]);     // 317 => [577]
            map.insert(318, &[4196352]);     // 318 => [4196352]
            map.insert(319, &[4196353]);     // 319 => [4196353]
            map.insert(320, &[640]);     // 320 => [640]
            map.insert(321, &[641]);     // 321 => [641]
            map.insert(322, &[642]);     // 322 => [642]
            map.insert(323, &[272629776]);     // 323 => [272629776]
            map.insert(324, &[1280]);     // 324 => [1280]
            map.insert(325, &[1281]);     // 325 => [1281]
            map.insert(326, &[1282]);     // 326 => [1282]
            map.insert(327, &[545259552]);     // 327 => [545259552]
            map.insert(328, &[648]);     // 328 => [648]
            map.insert(329, &[131648]);     // 329 => [131648]
            map.insert(330, &[67117060]);     // 330 => [67117060]
            map.insert(331, &[4327424]);     // 331 => [4327424]
            map.insert(332, &[67117058]);     // 332 => [67117058]
            map.insert(333, &[134225952]);     // 333 => [134225952]
            map.insert(334, &[67117056]);     // 334 => [67117056]
            map.insert(335, &[67117057]);     // 335 => [67117057]
            map.insert(336, &[276824072]);     // 336 => [276824072]
            map.insert(337, &[272629762]);     // 337 => [272629762]
            map.insert(338, &[272629761]);     // 338 => [272629761]
            map.insert(339, &[272629760]);     // 339 => [272629760]
            map.insert(340, &[526344]);     // 340 => [526344]
            map.insert(341, &[131616]);     // 341 => [131616]
            map.insert(342, &[33556544]);     // 342 => [33556544]
            map.insert(343, &[272629764]);     // 343 => [272629764]
            map.insert(344, &[276824064]);     // 344 => [276824064]
            map.insert(345, &[276824065]);     // 345 => [276824065]
            map.insert(346, &[276824066]);     // 346 => [276824066]
            map.insert(347, &[272629768]);     // 347 => [272629768]
            map.insert(348, &[526336]);     // 348 => [526336]
            map.insert(349, &[526337]);     // 349 => [526337]
            map.insert(350, &[526338]);     // 350 => [526338]
            map.insert(351, &[335544576]);     // 351 => [335544576]
            map.insert(352, &[672]);     // 352 => [672]
            map.insert(353, &[2107392]);     // 353 => [2107392]
            map.insert(354, &[33556488]);     // 354 => [33556488]
            map.insert(355, &[545259524]);     // 355 => [545259524]
            map.insert(356, &[541065224]);     // 356 => [541065224]
            map.insert(357, &[545259522]);     // 357 => [545259522]
            map.insert(358, &[545259521]);     // 358 => [545259521]
            map.insert(359, &[545259520]);     // 359 => [545259520]
            map.insert(360, &[33556482]);     // 360 => [33556482]
            map.insert(361, &[134225924]);     // 361 => [134225924]
            map.insert(362, &[33556480]);     // 362 => [33556480]
            map.insert(363, &[33556481]);     // 363 => [33556481]
            map.insert(364, &[541065216]);     // 364 => [541065216]
            map.insert(365, &[134225920]);     // 365 => [134225920]
            map.insert(366, &[541065218]);     // 366 => [541065218]
            map.insert(367, &[134225922]);     // 367 => [134225922]
            map.insert(368, &[17920]);     // 368 => [17920]
            map.insert(369, &[33794]);     // 369 => [33794]
            map.insert(370, &[33793]);     // 370 => [33793]
            map.insert(371, &[33792]);     // 371 => [33792]
            map.insert(372, &[131585]);     // 372 => [131585]
            map.insert(373, &[131584]);     // 373 => [131584]
            map.insert(374, &[180224]);     // 374 => [180224]
            map.insert(375, &[131586]);     // 375 => [131586]
            map.insert(376, &[16779265]);     // 376 => [16779265]
            map.insert(377, &[16779264]);     // 377 => [16779264]
            map.insert(378, &[33556496]);     // 378 => [33556496]
            map.insert(379, &[16779266]);     // 379 => [16779266]
            map.insert(380, &[263169]);     // 380 => [263169]
            map.insert(381, &[263168]);     // 381 => [263168]
            map.insert(382, &[4196480]);     // 382 => [4196480]
            map.insert(383, &[263170]);     // 383 => [263170]
            map.insert(384, &[768]);     // 384 => [768]
            map.insert(385, &[769]);     // 385 => [769]
            map.insert(386, &[770]);     // 386 => [770]
            map.insert(387, &[671088768]);     // 387 => [671088768]
            map.insert(388, &[1152]);     // 388 => [1152]
            map.insert(389, &[16785408]);     // 389 => [16785408]
            map.insert(390, &[1154]);     // 390 => [1154]
            map.insert(391, &[16785410]);     // 391 => [16785410]
            map.insert(392, &[16448]);     // 392 => [16448]
            map.insert(393, &[16449]);     // 393 => [16449]
            map.insert(394, &[1048592]);     // 394 => [1048592]
            map.insert(395, &[1048593]);     // 395 => [1048593]
            map.insert(396, &[2097169]);     // 396 => [2097169]
            map.insert(397, &[2097168]);     // 397 => [2097168]
            map.insert(398, &[1048596]);     // 398 => [1048596]
            map.insert(399, &[2097170]);     // 399 => [2097170]
            map.insert(400, &[134219777]);     // 400 => [134219777]
            map.insert(401, &[134219776]);     // 401 => [134219776]
            map.insert(402, &[1048584]);     // 402 => [1048584]
            map.insert(403, &[1048585]);     // 403 => [1048585]
            map.insert(404, &[16416]);     // 404 => [16416]
            map.insert(405, &[2097160]);     // 405 => [2097160]
            map.insert(406, &[33562624]);     // 406 => [33562624]
            map.insert(407, &[33562625]);     // 407 => [33562625]
            map.insert(408, &[1048578]);     // 408 => [1048578]
            map.insert(409, &[2097156]);     // 409 => [2097156]
            map.insert(410, &[1048576]);     // 410 => [1048576]
            map.insert(411, &[1048577]);     // 411 => [1048577]
            map.insert(412, &[2097153]);     // 412 => [2097153]
            map.insert(413, &[2097152]);     // 413 => [2097152]
            map.insert(414, &[1048580]);     // 414 => [1048580]
            map.insert(415, &[2097154]);     // 415 => [2097154]
            map.insert(416, &[532480]);     // 416 => [532480]
            map.insert(417, &[2097216]);     // 417 => [2097216]
            map.insert(418, &[532482]);     // 418 => [532482]
            map.insert(419, &[2097218]);     // 419 => [2097218]
            map.insert(420, &[16400]);     // 420 => [16400]
            map.insert(421, &[4198400]);     // 421 => [4198400]
            map.insert(422, &[1048640]);     // 422 => [1048640]
            map.insert(423, &[1048641]);     // 423 => [1048641]
            map.insert(424, &[532488]);     // 424 => [532488]
            map.insert(425, &[2097224]);     // 425 => [2097224]
            map.insert(426, &[8392708]);     // 426 => [8392708]
            map.insert(427, &[553648384]);     // 427 => [553648384]
            map.insert(428, &[8392706]);     // 428 => [8392706]
            map.insert(429, &[4198408]);     // 429 => [4198408]
            map.insert(430, &[8392704]);     // 430 => [8392704]
            map.insert(431, &[8392705]);     // 431 => [8392705]
            map.insert(432, &[16388]);     // 432 => [16388]
            map.insert(433, &[132096]);     // 433 => [132096]
            map.insert(434, &[67110912]);     // 434 => [67110912]
            map.insert(435, &[67110913]);     // 435 => [67110913]
            map.insert(436, &[16384]);     // 436 => [16384]
            map.insert(437, &[16385]);     // 437 => [16385]
            map.insert(438, &[16386]);     // 438 => [16386]
            map.insert(439, &[33280]);     // 439 => [33280]
            map.insert(440, &[262657]);     // 440 => [262657]
            map.insert(441, &[262656]);     // 441 => [262656]
            map.insert(442, &[1048608]);     // 442 => [1048608]
            map.insert(443, &[1048609]);     // 443 => [1048609]
            map.insert(444, &[16392]);     // 444 => [16392]
            map.insert(445, &[2097184]);     // 445 => [2097184]
            map.insert(446, &[16394]);     // 446 => [16394]
            map.insert(447, &[2097186]);     // 447 => [2097186]
            map.insert(448, &[1028]);     // 448 => [1028]
            map.insert(449, &[147456]);     // 449 => [147456]
            map.insert(450, &[4202496]);     // 450 => [4202496]
            map.insert(451, &[671088640]);     // 451 => [671088640]
            map.insert(452, &[1024]);     // 452 => [1024]
            map.insert(453, &[1025]);     // 453 => [1025]
            map.insert(454, &[1026]);     // 454 => [1026]
            map.insert(455, &[528384]);     // 455 => [528384]
            map.insert(456, &[8396801]);     // 456 => [8396801]
            map.insert(457, &[8396800]);     // 457 => [8396800]
            map.insert(458, &[4202504]);     // 458 => [4202504]
            map.insert(459, &[8396802]);     // 459 => [8396802]
            map.insert(460, &[1032]);     // 460 => [1032]
            map.insert(461, &[1033]);     // 461 => [1033]
            map.insert(462, &[1034]);     // 462 => [1034]
            map.insert(463, &[528392]);     // 463 => [528392]
            map.insert(464, &[1044]);     // 464 => [1044]
            map.insert(465, &[147472]);     // 465 => [147472]
            map.insert(466, &[1048712]);     // 466 => [1048712]
            map.insert(467, &[69640]);     // 467 => [69640]
            map.insert(468, &[1040]);     // 468 => [1040]
            map.insert(469, &[1041]);     // 469 => [1041]
            map.insert(470, &[1042]);     // 470 => [1042]
            map.insert(471, &[335544328]);     // 471 => [335544328]
            map.insert(472, &[1048706]);     // 472 => [1048706]
            map.insert(473, &[69634]);     // 473 => [69634]
            map.insert(474, &[1048704]);     // 474 => [1048704]
            map.insert(475, &[69632]);     // 475 => [69632]
            map.insert(476, &[2097281]);     // 476 => [2097281]
            map.insert(477, &[2097280]);     // 477 => [2097280]
            map.insert(478, &[335544321]);     // 478 => [335544321]
            map.insert(479, &[335544320]);     // 479 => [335544320]
            map.insert(480, &[603979776]);     // 480 => [603979776]
            map.insert(481, &[603979777]);     // 481 => [603979777]
            map.insert(482, &[16781312]);     // 482 => [16781312]
            map.insert(483, &[16781313]);     // 483 => [16781313]
            map.insert(484, &[1056]);     // 484 => [1056]
            map.insert(485, &[1057]);     // 485 => [1057]
            map.insert(486, &[1058]);     // 486 => [1058]
            map.insert(487, &[1179656]);     // 487 => [1179656]
            map.insert(488, &[2228224]);     // 488 => [2228224]
            map.insert(489, &[2228225]);     // 489 => [2228225]
            map.insert(490, &[2228226]);     // 490 => [2228226]
            map.insert(491, &[1179652]);     // 491 => [1179652]
            map.insert(492, &[2228228]);     // 492 => [2228228]
            map.insert(493, &[1179650]);     // 493 => [1179650]
            map.insert(494, &[1179649]);     // 494 => [1179649]
            map.insert(495, &[1179648]);     // 495 => [1179648]
            map.insert(496, &[33558529]);     // 496 => [33558529]
            map.insert(497, &[33558528]);     // 497 => [33558528]
            map.insert(498, &[16781328]);     // 498 => [16781328]
            map.insert(499, &[33558530]);     // 499 => [33558530]
            map.insert(500, &[16512]);     // 500 => [16512]
            map.insert(501, &[16513]);     // 501 => [16513]
            map.insert(502, &[16514]);     // 502 => [16514]
            map.insert(503, &[33408]);     // 503 => [33408]
            map.insert(504, &[1088]);     // 504 => [1088]
            map.insert(505, &[1089]);     // 505 => [1089]
            map.insert(506, &[1090]);     // 506 => [1090]
            map.insert(507, &[69664]);     // 507 => [69664]
            map.insert(508, &[402653184]);     // 508 => [402653184]
            map.insert(509, &[402653185]);     // 509 => [402653185]
            map.insert(510, &[402653186]);     // 510 => [402653186]
            map.insert(511, &[1179664]);     // 511 => [1179664]
            map.insert(512, &[2048]);     // 512 => [2048]
            map.insert(513, &[2049]);     // 513 => [2049]
            map.insert(514, &[2050]);     // 514 => [2050]
            map.insert(515, &[2051]);     // 515 => [2051]
            map.insert(516, &[2052]);     // 516 => [2052]
            map.insert(517, &[2053]);     // 517 => [2053]
            map.insert(518, &[67125248]);     // 518 => [67125248]
            map.insert(519, &[67125249]);     // 519 => [67125249]
            map.insert(520, &[2056]);     // 520 => [2056]
            map.insert(521, &[2057]);     // 521 => [2057]
            map.insert(522, &[135266305]);     // 522 => [135266305]
            map.insert(523, &[135266304]);     // 523 => [135266304]
            map.insert(524, &[136314880]);     // 524 => [136314880]
            map.insert(525, &[136314881]);     // 525 => [136314881]
            map.insert(526, &[136314882]);     // 526 => [136314882]
            map.insert(527, &[135266308]);     // 527 => [135266308]
            map.insert(528, &[2064]);     // 528 => [2064]
            map.insert(529, &[2065]);     // 529 => [2065]
            map.insert(530, &[536871040]);     // 530 => [536871040]
            map.insert(531, &[536871041]);     // 531 => [536871041]
            map.insert(532, &[2068]);     // 532 => [2068]
            map.insert(533, &[8389152]);     // 533 => [8389152]
            map.insert(534, &[536871044]);     // 534 => [536871044]
            map.insert(535, &[33817600]);     // 535 => [33817600]
            map.insert(536, &[268566528]);     // 536 => [268566528]
            map.insert(537, &[268566529]);     // 537 => [268566529]
            map.insert(538, &[4353]);     // 538 => [4353]
            map.insert(539, &[4352]);     // 539 => [4352]
            map.insert(540, &[268566532]);     // 540 => [268566532]
            map.insert(541, &[268452864]);     // 541 => [268452864]
            map.insert(542, &[4194848]);     // 542 => [4194848]
            map.insert(543, &[4356]);     // 543 => [4356]
            map.insert(544, &[2080]);     // 544 => [2080]
            map.insert(545, &[2081]);     // 545 => [2081]
            map.insert(546, &[266240]);     // 546 => [266240]
            map.insert(547, &[266241]);     // 547 => [266241]
            map.insert(548, &[134234113]);     // 548 => [134234113]
            map.insert(549, &[134234112]);     // 549 => [134234112]
            map.insert(550, &[537001985]);     // 550 => [537001985]
            map.insert(551, &[537001984]);     // 551 => [537001984]
            map.insert(552, &[68157440]);     // 552 => [68157440]
            map.insert(553, &[68157441]);     // 553 => [68157441]
            map.insert(554, &[68157442]);     // 554 => [68157442]
            map.insert(555, &[69206020]);     // 555 => [69206020]
            map.insert(556, &[36864]);     // 556 => [36864]
            map.insert(557, &[268435584]);     // 557 => [268435584]
            map.insert(558, &[69206017]);     // 558 => [69206017]
            map.insert(559, &[69206016]);     // 559 => [69206016]
            map.insert(560, &[2096]);     // 560 => [2096]
            map.insert(561, &[8389124]);     // 561 => [8389124]
            map.insert(562, &[266256]);     // 562 => [266256]
            map.insert(563, &[99328]);     // 563 => [99328]
            map.insert(564, &[8389121]);     // 564 => [8389121]
            map.insert(565, &[8389120]);     // 565 => [8389120]
            map.insert(566, &[4194824]);     // 566 => [4194824]
            map.insert(567, &[8389122]);     // 567 => [8389122]
            map.insert(568, &[2116]);     // 568 => [2116]
            map.insert(569, &[16777856]);     // 569 => [16777856]
            map.insert(570, &[4194820]);     // 570 => [4194820]
            map.insert(571, &[4384]);     // 571 => [4384]
            map.insert(572, &[2112]);     // 572 => [2112]
            map.insert(573, &[2113]);     // 573 => [2113]
            map.insert(574, &[4194816]);     // 574 => [4194816]
            map.insert(575, &[4194817]);     // 575 => [4194817]
            map.insert(576, &[2176]);     // 576 => [2176]
            map.insert(577, &[2177]);     // 577 => [2177]
            map.insert(578, &[536870928]);     // 578 => [536870928]
            map.insert(579, &[536870929]);     // 579 => [536870929]
            map.insert(580, &[270337]);     // 580 => [270337]
            map.insert(581, &[270336]);     // 581 => [270336]
            map.insert(582, &[536870932]);     // 582 => [536870932]
            map.insert(583, &[270338]);     // 583 => [270338]
            map.insert(584, &[2184]);     // 584 => [2184]
            map.insert(585, &[40962]);     // 585 => [40962]
            map.insert(586, &[40961]);     // 586 => [40961]
            map.insert(587, &[40960]);     // 587 => [40960]
            map.insert(588, &[268435489]);     // 588 => [268435489]
            map.insert(589, &[268435488]);     // 589 => [268435488]
            map.insert(590, &[536871008]);     // 590 => [536871008]
            map.insert(591, &[268435490]);     // 591 => [268435490]
            map.insert(592, &[536870914]);     // 592 => [536870914]
            map.insert(593, &[268435520]);     // 593 => [268435520]
            map.insert(594, &[536870912]);     // 594 => [536870912]
            map.insert(595, &[536870913]);     // 595 => [536870913]
            map.insert(596, &[134218753]);     // 596 => [134218753]
            map.insert(597, &[134218752]);     // 597 => [134218752]
            map.insert(598, &[536870916]);     // 598 => [536870916]
            map.insert(599, &[536870917]);     // 599 => [536870917]
            map.insert(600, &[536870922]);     // 600 => [536870922]
            map.insert(601, &[268435528]);     // 601 => [268435528]
            map.insert(602, &[536870920]);     // 602 => [536870920]
            map.insert(603, &[536870921]);     // 603 => [536870921]
            map.insert(604, &[524800]);     // 604 => [524800]
            map.insert(605, &[524801]);     // 605 => [524801]
            map.insert(606, &[524802]);     // 606 => [524802]
            map.insert(607, &[5632]);     // 607 => [5632]
            map.insert(608, &[2208]);     // 608 => [2208]
            map.insert(609, &[268435468]);     // 609 => [268435468]
            map.insert(610, &[33554952]);     // 610 => [33554952]
            map.insert(611, &[17826048]);     // 611 => [17826048]
            map.insert(612, &[268435465]);     // 612 => [268435465]
            map.insert(613, &[268435464]);     // 613 => [268435464]
            map.insert(614, &[536870984]);     // 614 => [536870984]
            map.insert(615, &[268435466]);     // 615 => [268435466]
            map.insert(616, &[268435461]);     // 616 => [268435461]
            map.insert(617, &[268435460]);     // 617 => [268435460]
            map.insert(618, &[33554944]);     // 618 => [33554944]
            map.insert(619, &[33554945]);     // 619 => [33554945]
            map.insert(620, &[268435457]);     // 620 => [268435457]
            map.insert(621, &[268435456]);     // 621 => [268435456]
            map.insert(622, &[536870976]);     // 622 => [536870976]
            map.insert(623, &[268435458]);     // 623 => [268435458]
            map.insert(624, &[536870946]);     // 624 => [536870946]
            map.insert(625, &[133124]);     // 625 => [133124]
            map.insert(626, &[536870944]);     // 626 => [536870944]
            map.insert(627, &[536870945]);     // 627 => [536870945]
            map.insert(628, &[133121]);     // 628 => [133121]
            map.insert(629, &[133120]);     // 629 => [133120]
            map.insert(630, &[67109888]);     // 630 => [67109888]
            map.insert(631, &[67109889]);     // 631 => [67109889]
            map.insert(632, &[16777729]);     // 632 => [16777729]
            map.insert(633, &[16777728]);     // 633 => [16777728]
            map.insert(634, &[536870952]);     // 634 => [536870952]
            map.insert(635, &[16777730]);     // 635 => [16777730]
            map.insert(636, &[8448]);     // 636 => [8448]
            map.insert(637, &[268435472]);     // 637 => [268435472]
            map.insert(638, &[8450]);     // 638 => [8450]
            map.insert(639, &[268435474]);     // 639 => [268435474]
            map.insert(640, &[2304]);     // 640 => [2304]
            map.insert(641, &[8404992]);     // 641 => [8404992]
            map.insert(642, &[2306]);     // 642 => [2306]
            map.insert(643, &[8404994]);     // 643 => [8404994]
            map.insert(644, &[66560]);     // 644 => [66560]
            map.insert(645, &[66561]);     // 645 => [66561]
            map.insert(646, &[66562]);     // 646 => [66562]
            map.insert(647, &[4192]);     // 647 => [4192]
            map.insert(648, &[139265]);     // 648 => [139265]
            map.insert(649, &[139264]);     // 649 => [139264]
            map.insert(650, &[4210688]);     // 650 => [4210688]
            map.insert(651, &[4112]);     // 651 => [4112]
            map.insert(652, &[66568]);     // 652 => [66568]
            map.insert(653, &[139268]);     // 653 => [139268]
            map.insert(654, &[4210692]);     // 654 => [4210692]
            map.insert(655, &[4116]);     // 655 => [4116]
            map.insert(656, &[134218241]);     // 656 => [134218241]
            map.insert(657, &[134218240]);     // 657 => [134218240]
            map.insert(658, &[4105]);     // 658 => [4105]
            map.insert(659, &[4104]);     // 659 => [4104]
            map.insert(660, &[66576]);     // 660 => [66576]
            map.insert(661, &[134218244]);     // 661 => [134218244]
            map.insert(662, &[536872448]);     // 662 => [536872448]
            map.insert(663, &[4108]);     // 663 => [4108]
            map.insert(664, &[525312]);     // 664 => [525312]
            map.insert(665, &[4098]);     // 665 => [4098]
            map.insert(666, &[4097]);     // 666 => [4097]
            map.insert(667, &[4096]);     // 667 => [4096]
            map.insert(668, &[525316]);     // 668 => [525316]
            map.insert(669, &[4102]);     // 669 => [4102]
            map.insert(670, &[4101]);     // 670 => [4101]
            map.insert(671, &[4100]);     // 671 => [4100]
            map.insert(672, &[5242884]);     // 672 => [5242884]
            map.insert(673, &[6291458]);     // 673 => [6291458]
            map.insert(674, &[6291457]);     // 674 => [6291457]
            map.insert(675, &[6291456]);     // 675 => [6291456]
            map.insert(676, &[5242880]);     // 676 => [5242880]
            map.insert(677, &[5242881]);     // 677 => [5242881]
            map.insert(678, &[4161]);     // 678 => [4161]
            map.insert(679, &[4160]);     // 679 => [4160]
            map.insert(680, &[10485760]);     // 680 => [10485760]
            map.insert(681, &[10485761]);     // 681 => [10485761]
            map.insert(682, &[10485762]);     // 682 => [10485762]
            map.insert(683, &[9437188]);     // 683 => [9437188]
            map.insert(684, &[33555458]);     // 684 => [33555458]
            map.insert(685, &[9437186]);     // 685 => [9437186]
            map.insert(686, &[33555456]);     // 686 => [33555456]
            map.insert(687, &[9437184]);     // 687 => [9437184]
            map.insert(688, &[67109378]);     // 688 => [67109378]
            map.insert(689, &[264200]);     // 689 => [264200]
            map.insert(690, &[67109376]);     // 690 => [67109376]
            map.insert(691, &[67109377]);     // 691 => [67109377]
            map.insert(692, &[8328]);     // 692 => [8328]
            map.insert(693, &[34818]);     // 693 => [34818]
            map.insert(694, &[34817]);     // 694 => [34817]
            map.insert(695, &[34816]);     // 695 => [34816]
            map.insert(696, &[264193]);     // 696 => [264193]
            map.insert(697, &[264192]);     // 697 => [264192]
            map.insert(698, &[4129]);     // 698 => [4129]
            map.insert(699, &[4128]);     // 699 => [4128]
            map.insert(700, &[8320]);     // 700 => [8320]
            map.insert(701, &[16778240]);     // 701 => [16778240]
            map.insert(702, &[8322]);     // 702 => [8322]
            map.insert(703, &[16778242]);     // 703 => [16778242]
            map.insert(704, &[8256]);     // 704 => [8256]
            map.insert(705, &[2621440]);     // 705 => [2621440]
            map.insert(706, &[8258]);     // 706 => [8258]
            map.insert(707, &[2621442]);     // 707 => [2621442]
            map.insert(708, &[1572866]);     // 708 => [1572866]
            map.insert(709, &[2621444]);     // 709 => [2621444]
            map.insert(710, &[1572864]);     // 710 => [1572864]
            map.insert(711, &[1572865]);     // 711 => [1572865]
            map.insert(712, &[8264]);     // 712 => [8264]
            map.insert(713, &[16793604]);     // 713 => [16793604]
            map.insert(714, &[268468240]);     // 714 => [268468240]
            map.insert(715, &[4240]);     // 715 => [4240]
            map.insert(716, &[16793601]);     // 716 => [16793601]
            map.insert(717, &[16793600]);     // 717 => [16793600]
            map.insert(718, &[1572872]);     // 718 => [1572872]
            map.insert(719, &[16793602]);     // 719 => [16793602]
            map.insert(720, &[536871170]);     // 720 => [536871170]
            map.insert(721, &[2621456]);     // 721 => [2621456]
            map.insert(722, &[536871168]);     // 722 => [536871168]
            map.insert(723, &[536871169]);     // 723 => [536871169]
            map.insert(724, &[268697600]);     // 724 => [268697600]
            map.insert(725, &[268697601]);     // 725 => [268697601]
            map.insert(726, &[268697602]);     // 726 => [268697602]
            map.insert(727, &[35651616]);     // 727 => [35651616]
            map.insert(728, &[268468226]);     // 728 => [268468226]
            map.insert(729, &[4226]);     // 729 => [4226]
            map.insert(730, &[268468224]);     // 730 => [268468224]
            map.insert(731, &[4224]);     // 731 => [4224]
            map.insert(732, &[8224]);     // 732 => [8224]
            map.insert(733, &[2162688]);     // 733 => [2162688]
            map.insert(734, &[33570816]);     // 734 => [33570816]
            map.insert(735, &[33570817]);     // 735 => [33570817]
            map.insert(736, &[18874372]);     // 736 => [18874372]
            map.insert(737, &[17825794]);     // 737 => [17825794]
            map.insert(738, &[17825793]);     // 738 => [17825793]
            map.insert(739, &[17825792]);     // 739 => [17825792]
            map.insert(740, &[18874368]);     // 740 => [18874368]
            map.insert(741, &[536903680]);     // 741 => [536903680]
            map.insert(742, &[18874370]);     // 742 => [18874370]
            map.insert(743, &[536903682]);     // 743 => [536903682]
            map.insert(744, &[540672]);     // 744 => [540672]
            map.insert(745, &[540673]);     // 745 => [540673]
            map.insert(746, &[537133057]);     // 746 => [537133057]
            map.insert(747, &[537133056]);     // 747 => [537133056]
            map.insert(748, &[8208]);     // 748 => [8208]
            map.insert(749, &[268435712]);     // 749 => [268435712]
            map.insert(750, &[135168]);     // 750 => [135168]
            map.insert(751, &[135169]);     // 751 => [135169]
            map.insert(752, &[34603008]);     // 752 => [34603008]
            map.insert(753, &[8389632]);     // 753 => [8389632]
            map.insert(754, &[34603010]);     // 754 => [34603010]
            map.insert(755, &[8389634]);     // 755 => [8389634]
            map.insert(756, &[8200]);     // 756 => [8200]
            map.insert(757, &[8201]);     // 757 => [8201]
            map.insert(758, &[35651585]);     // 758 => [35651585]
            map.insert(759, &[35651584]);     // 759 => [35651584]
            map.insert(760, &[8196]);     // 760 => [8196]
            map.insert(761, &[8197]);     // 761 => [8197]
            map.insert(762, &[4195328]);     // 762 => [4195328]
            map.insert(763, &[4195329]);     // 763 => [4195329]
            map.insert(764, &[8192]);     // 764 => [8192]
            map.insert(765, &[8193]);     // 765 => [8193]
            map.insert(766, &[8194]);     // 766 => [8194]
            map.insert(767, &[8195]);     // 767 => [8195]
            map.insert(768, &[65664]);     // 768 => [65664]
            map.insert(769, &[1052672]);     // 769 => [1052672]
            map.insert(770, &[4194368]);     // 770 => [4194368]
            map.insert(771, &[4194369]);     // 771 => [4194369]
            map.insert(772, &[67141633]);     // 772 => [67141633]
            map.insert(773, &[67141632]);     // 773 => [67141632]
            map.insert(774, &[2101248]);     // 774 => [2101248]
            map.insert(775, &[2101249]);     // 775 => [2101249]
            map.insert(776, &[8388673]);     // 776 => [8388673]
            map.insert(777, &[8388672]);     // 777 => [8388672]
            map.insert(778, &[67371009]);     // 778 => [67371009]
            map.insert(779, &[67371008]);     // 779 => [67371008]
            map.insert(780, &[16908288]);     // 780 => [16908288]
            map.insert(781, &[16908289]);     // 781 => [16908289]
            map.insert(782, &[16908290]);     // 782 => [16908290]
            map.insert(783, &[67371012]);     // 783 => [67371012]
            map.insert(784, &[134217985]);     // 784 => [134217985]
            map.insert(785, &[134217984]);     // 785 => [134217984]
            map.insert(786, &[4194384]);     // 786 => [4194384]
            map.insert(787, &[134217986]);     // 787 => [134217986]
            map.insert(788, &[8388641]);     // 788 => [8388641]
            map.insert(789, &[8388640]);     // 789 => [8388640]
            map.insert(790, &[4194344]);     // 790 => [4194344]
            map.insert(791, &[8388642]);     // 791 => [8388642]
            map.insert(792, &[524420]);     // 792 => [524420]
            map.insert(793, &[134217992]);     // 793 => [134217992]
            map.insert(794, &[4194340]);     // 794 => [4194340]
            map.insert(795, &[33685508]);     // 795 => [33685508]
            map.insert(796, &[524416]);     // 796 => [524416]
            map.insert(797, &[524417]);     // 797 => [524417]
            map.insert(798, &[4194336]);     // 798 => [4194336]
            map.insert(799, &[33685504]);     // 799 => [33685504]
            map.insert(800, &[134479880]);     // 800 => [134479880]
            map.insert(801, &[8388628]);     // 801 => [8388628]
            map.insert(802, &[134250500]);     // 802 => [134250500]
            map.insert(803, &[33685568]);     // 803 => [33685568]
            map.insert(804, &[8388625]);     // 804 => [8388625]
            map.insert(805, &[8388624]);     // 805 => [8388624]
            map.insert(806, &[134250496]);     // 806 => [134250496]
            map.insert(807, &[134250497]);     // 807 => [134250497]
            map.insert(808, &[134479872]);     // 808 => [134479872]
            map.insert(809, &[655360]);     // 809 => [655360]
            map.insert(810, &[33554560]);     // 810 => [33554560]
            map.insert(811, &[33554561]);     // 811 => [33554561]
            map.insert(812, &[4194322]);     // 812 => [4194322]
            map.insert(813, &[20482]);     // 813 => [20482]
            map.insert(814, &[4194320]);     // 814 => [4194320]
            map.insert(815, &[20480]);     // 815 => [20480]
            map.insert(816, &[8388613]);     // 816 => [8388613]
            map.insert(817, &[8388612]);     // 817 => [8388612]
            map.insert(818, &[67109120]);     // 818 => [67109120]
            map.insert(819, &[67109121]);     // 819 => [67109121]
            map.insert(820, &[8388609]);     // 820 => [8388609]
            map.insert(821, &[8388608]);     // 821 => [8388608]
            map.insert(822, &[4194312]);     // 822 => [4194312]
            map.insert(823, &[8388610]);     // 823 => [8388610]
            map.insert(824, &[9216]);     // 824 => [9216]
            map.insert(825, &[16777344]);     // 825 => [16777344]
            map.insert(826, &[4194308]);     // 826 => [4194308]
            map.insert(827, &[4194309]);     // 827 => [4194309]
            map.insert(828, &[4194306]);     // 828 => [4194306]
            map.insert(829, &[8388616]);     // 829 => [8388616]
            map.insert(830, &[4194304]);     // 830 => [4194304]
            map.insert(831, &[4194305]);     // 831 => [4194305]
            map.insert(832, &[65536]);     // 832 => [65536]
            map.insert(833, &[65537]);     // 833 => [65537]
            map.insert(834, &[65538]);     // 834 => [65538]
            map.insert(835, &[65539]);     // 835 => [65539]
            map.insert(836, &[65540]);     // 836 => [65540]
            map.insert(837, &[16777280]);     // 837 => [16777280]
            map.insert(838, &[65542]);     // 838 => [65542]
            map.insert(839, &[16777282]);     // 839 => [16777282]
            map.insert(840, &[65544]);     // 840 => [65544]
            map.insert(841, &[65545]);     // 841 => [65545]
            map.insert(842, &[33554464]);     // 842 => [33554464]
            map.insert(843, &[4325376]);     // 843 => [4325376]
            map.insert(844, &[524304]);     // 844 => [524304]
            map.insert(845, &[524305]);     // 845 => [524305]
            map.insert(846, &[524306]);     // 846 => [524306]
            map.insert(847, &[4325380]);     // 847 => [4325380]
            map.insert(848, &[65552]);     // 848 => [65552]
            map.insert(849, &[65553]);     // 849 => [65553]
            map.insert(850, &[536871424]);     // 850 => [536871424]
            map.insert(851, &[536871425]);     // 851 => [536871425]
            map.insert(852, &[524296]);     // 852 => [524296]
            map.insert(853, &[524297]);     // 853 => [524297]
            map.insert(854, &[33554496]);     // 854 => [33554496]
            map.insert(855, &[33554497]);     // 855 => [33554497]
            map.insert(856, &[524292]);     // 856 => [524292]
            map.insert(857, &[16777248]);     // 857 => [16777248]
            map.insert(858, &[524294]);     // 858 => [524294]
            map.insert(859, &[16777250]);     // 859 => [16777250]
            map.insert(860, &[524288]);     // 860 => [524288]
            map.insert(861, &[524289]);     // 861 => [524289]
            map.insert(862, &[524290]);     // 862 => [524290]
            map.insert(863, &[5120]);     // 863 => [5120]
            map.insert(864, &[65568]);     // 864 => [65568]
            map.insert(865, &[2105344]);     // 865 => [2105344]
            map.insert(866, &[33554440]);     // 866 => [33554440]
            map.insert(867, &[33554441]);     // 867 => [33554441]
            map.insert(868, &[1056770]);     // 868 => [1056770]
            map.insert(869, &[2105348]);     // 869 => [2105348]
            map.insert(870, &[1056768]);     // 870 => [1056768]
            map.insert(871, &[1056769]);     // 871 => [1056769]
            map.insert(872, &[33554434]);     // 872 => [33554434]
            map.insert(873, &[16777232]);     // 873 => [16777232]
            map.insert(874, &[33554432]);     // 874 => [33554432]
            map.insert(875, &[33554433]);     // 875 => [33554433]
            map.insert(876, &[268435969]);     // 876 => [268435969]
            map.insert(877, &[268435968]);     // 877 => [268435968]
            map.insert(878, &[33554436]);     // 878 => [33554436]
            map.insert(879, &[33554437]);     // 879 => [33554437]
            map.insert(880, &[16777225]);     // 880 => [16777225]
            map.insert(881, &[16777224]);     // 881 => [16777224]
            map.insert(882, &[33554456]);     // 882 => [33554456]
            map.insert(883, &[16777226]);     // 883 => [16777226]
            map.insert(884, &[8388737]);     // 884 => [8388737]
            map.insert(885, &[8388736]);     // 885 => [8388736]
            map.insert(886, &[4194440]);     // 886 => [4194440]
            map.insert(887, &[8388738]);     // 887 => [8388738]
            map.insert(888, &[16777217]);     // 888 => [16777217]
            map.insert(889, &[16777216]);     // 889 => [16777216]
            map.insert(890, &[33554448]);     // 890 => [33554448]
            map.insert(891, &[16777218]);     // 891 => [16777218]
            map.insert(892, &[524320]);     // 892 => [524320]
            map.insert(893, &[16777220]);     // 893 => [16777220]
            map.insert(894, &[4194432]);     // 894 => [4194432]
            map.insert(895, &[4194433]);     // 895 => [4194433]
            map.insert(896, &[134217745]);     // 896 => [134217745]
            map.insert(897, &[134217744]);     // 897 => [134217744]
            map.insert(898, &[8421376]);     // 898 => [8421376]
            map.insert(899, &[8421377]);     // 899 => [8421377]
            map.insert(900, &[8650760]);     // 900 => [8650760]
            map.insert(901, &[4456450]);     // 901 => [4456450]
            map.insert(902, &[4456449]);     // 902 => [4456449]
            map.insert(903, &[4456448]);     // 903 => [4456448]
            map.insert(904, &[4227073]);     // 904 => [4227073]
            map.insert(905, &[4227072]);     // 905 => [4227072]
            map.insert(906, &[67108932]);     // 906 => [67108932]
            map.insert(907, &[4227074]);     // 907 => [4227074]
            map.insert(908, &[8650752]);     // 908 => [8650752]
            map.insert(909, &[8650753]);     // 909 => [8650753]
            map.insert(910, &[67108928]);     // 910 => [67108928]
            map.insert(911, &[67108929]);     // 911 => [67108929]
            map.insert(912, &[134217729]);     // 912 => [134217729]
            map.insert(913, &[134217728]);     // 913 => [134217728]
            map.insert(914, &[67108896]);     // 914 => [67108896]
            map.insert(915, &[134217730]);     // 915 => [134217730]
            map.insert(916, &[134217733]);     // 916 => [134217733]
            map.insert(917, &[134217732]);     // 917 => [134217732]
            map.insert(918, &[536871936]);     // 918 => [536871936]
            map.insert(919, &[536871937]);     // 919 => [536871937]
            map.insert(920, &[134217737]);     // 920 => [134217737]
            map.insert(921, &[134217736]);     // 921 => [134217736]
            map.insert(922, &[1050624]);     // 922 => [1050624]
            map.insert(923, &[4608]);     // 923 => [4608]
            map.insert(924, &[2099201]);     // 924 => [2099201]
            map.insert(925, &[2099200]);     // 925 => [2099200]
            map.insert(926, &[1050628]);     // 926 => [1050628]
            map.insert(927, &[2099202]);     // 927 => [2099202]
            map.insert(928, &[67108882]);     // 928 => [67108882]
            map.insert(929, &[268436488]);     // 929 => [268436488]
            map.insert(930, &[67108880]);     // 930 => [67108880]
            map.insert(931, &[67108881]);     // 931 => [67108881]
            map.insert(932, &[18448]);     // 932 => [18448]
            map.insert(933, &[134217800]);     // 933 => [134217800]
            map.insert(934, &[67108884]);     // 934 => [67108884]
            map.insert(935, &[4456480]);     // 935 => [4456480]
            map.insert(936, &[268436481]);     // 936 => [268436481]
            map.insert(937, &[268436480]);     // 937 => [268436480]
            map.insert(938, &[67108888]);     // 938 => [67108888]
            map.insert(939, &[268436482]);     // 939 => [268436482]
            map.insert(940, &[134217793]);     // 940 => [134217793]
            map.insert(941, &[134217792]);     // 941 => [134217792]
            map.insert(942, &[4194576]);     // 942 => [4194576]
            map.insert(943, &[134217794]);     // 943 => [134217794]
            map.insert(944, &[67108866]);     // 944 => [67108866]
            map.insert(945, &[134217760]);     // 945 => [134217760]
            map.insert(946, &[67108864]);     // 946 => [67108864]
            map.insert(947, &[67108865]);     // 947 => [67108865]
            map.insert(948, &[18432]);     // 948 => [18432]
            map.insert(949, &[8388864]);     // 949 => [8388864]
            map.insert(950, &[67108868]);     // 950 => [67108868]
            map.insert(951, &[67108869]);     // 951 => [67108869]
            map.insert(952, &[67108874]);     // 952 => [67108874]
            map.insert(953, &[134217768]);     // 953 => [134217768]
            map.insert(954, &[67108872]);     // 954 => [67108872]
            map.insert(955, &[67108873]);     // 955 => [67108873]
            map.insert(956, &[4194562]);     // 956 => [4194562]
            map.insert(957, &[8388872]);     // 957 => [8388872]
            map.insert(958, &[4194560]);     // 958 => [4194560]
            map.insert(959, &[4194561]);     // 959 => [4194561]
            map.insert(960, &[65792]);     // 960 => [65792]
            map.insert(961, &[65793]);     // 961 => [65793]
            map.insert(962, &[65794]);     // 962 => [65794]
            map.insert(963, &[67239940]);     // 963 => [67239940]
            map.insert(964, &[3072]);     // 964 => [3072]
            map.insert(965, &[3073]);     // 965 => [3073]
            map.insert(966, &[67239937]);     // 966 => [67239937]
            map.insert(967, &[67239936]);     // 967 => [67239936]
            map.insert(968, &[537919488]);     // 968 => [537919488]
            map.insert(969, &[537919489]);     // 969 => [537919489]
            map.insert(970, &[537919490]);     // 970 => [537919490]
            map.insert(971, &[538968068]);     // 971 => [538968068]
            map.insert(972, &[16809986]);     // 972 => [16809986]
            map.insert(973, &[538968066]);     // 973 => [538968066]
            map.insert(974, &[16809984]);     // 974 => [16809984]
            map.insert(975, &[538968064]);     // 975 => [538968064]
            map.insert(976, &[134217857]);     // 976 => [134217857]
            map.insert(977, &[134217856]);     // 977 => [134217856]
            map.insert(978, &[33816577]);     // 978 => [33816577]
            map.insert(979, &[33816576]);     // 979 => [33816576]
            map.insert(980, &[524552]);     // 980 => [524552]
            map.insert(981, &[134217860]);     // 981 => [134217860]
            map.insert(982, &[33554752]);     // 982 => [33554752]
            map.insert(983, &[33816580]);     // 983 => [33816580]
            map.insert(984, &[268451841]);     // 984 => [268451841]
            map.insert(985, &[268451840]);     // 985 => [268451840]
            map.insert(986, &[536887360]);     // 986 => [536887360]
            map.insert(987, &[268451842]);     // 987 => [268451842]
            map.insert(988, &[524544]);     // 988 => [524544]
            map.insert(989, &[33587200]);     // 989 => [33587200]
            map.insert(990, &[524546]);     // 990 => [524546]
            map.insert(991, &[33587202]);     // 991 => [33587202]
            map.insert(992, &[134348804]);     // 992 => [134348804]
            map.insert(993, &[786436]);     // 993 => [786436]
            map.insert(994, &[536887300]);     // 994 => [536887300]
            map.insert(995, &[557064]);     // 995 => [557064]
            map.insert(996, &[134348800]);     // 996 => [134348800]
            map.insert(997, &[786432]);     // 997 => [786432]
            map.insert(998, &[536887296]);     // 998 => [536887296]
            map.insert(999, &[536887297]);     // 999 => [536887297]
            map.insert(1000, &[33554690]);     // 1000 => [33554690]
            map.insert(1001, &[557058]);     // 1001 => [557058]
            map.insert(1002, &[33554688]);     // 1002 => [33554688]
            map.insert(1003, &[557056]);     // 1003 => [557056]
            map.insert(1004, &[134348808]);     // 1004 => [134348808]
            map.insert(1005, &[786440]);     // 1005 => [786440]
            map.insert(1006, &[33554692]);     // 1006 => [33554692]
            map.insert(1007, &[557060]);     // 1007 => [557060]
            map.insert(1008, &[270532608]);     // 1008 => [270532608]
            map.insert(1009, &[270532609]);     // 1009 => [270532609]
            map.insert(1010, &[67108992]);     // 1010 => [67108992]
            map.insert(1011, &[67108993]);     // 1011 => [67108993]
            map.insert(1012, &[270532612]);     // 1012 => [270532612]
            map.insert(1013, &[98306]);     // 1013 => [98306]
            map.insert(1014, &[98305]);     // 1014 => [98305]
            map.insert(1015, &[98304]);     // 1015 => [98304]
            map.insert(1016, &[16777473]);     // 1016 => [16777473]
            map.insert(1017, &[16777472]);     // 1017 => [16777472]
            map.insert(1018, &[67109000]);     // 1018 => [67109000]
            map.insert(1019, &[16777474]);     // 1019 => [16777474]
            map.insert(1020, &[8704]);     // 1020 => [8704]
            map.insert(1021, &[8705]);     // 1021 => [8705]
            map.insert(1022, &[8706]);     // 1022 => [8706]
            map.insert(1023, &[98312]);     // 1023 => [98312]
            
            SYNDROME_MAP = Box::into_raw(map);
        }
    });
}

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

impl BinaryCode for WagnerCode30_20 {
    fn name(&self) -> String {
        "[30, 20] Wagner code".to_owned()
    }

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

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

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

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

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

}