lora-irrigation/blinkled/encdec8b10b/encdec8b10b/core.py

# https://en.wikipedia.org/wiki/8b/10b_encoding

import re

class ControlSymbol(int):
    def __repr__(self):
        return 'ControlSymbol(%#x)' % self

class EncDec8B10B(object):
    # Table 36-3 of 802.3-2018 has symbols for 1000Base-X coding

    COMMA = ControlSymbol(0xbc)
    COMMA_ALTA = ControlSymbol(0x3c)
    COMMA_ALTB = ControlSymbol(0xfc)
    K_28_0 = ControlSymbol(0x1c)
    K_28_2 = ControlSymbol(0x5c)
    K_28_3 = ControlSymbol(0x7c)
    K_28_4 = ControlSymbol(0x9c)
    K_28_6 = ControlSymbol(0xdc)
    K_23_7 = ControlSymbol(0xf7)
    K_27_7 = ControlSymbol(0xfb)
    K_29_7 = ControlSymbol(0xfd)
    K_30_7 = ControlSymbol(0xfe)

    # Where disparity of 0 means more 0's, 1 means more 1's
    #
    # index of lookup strings:
    #    <ctrl><disparity><data>
    #
    # data is lowest/rightmost bit maps to A, and high bit is H
    #
    # format of data:
    #    <newdisparity><data>
    # data is lowest/rightmost bit transmitted first
    #
    # comment of each line is:
    #    # "<data bitstring>" <start disp><encoding><ending> [<dec val>]
    enc_lookup = [
        "00010111001",    # "00000000" -D00.0- [0]
        "00010101110",    # "00000001" -D01.0- [1]
        "00010101101",    # "00000010" -D02.0- [2]
        "11101100011",    # "00000011" -D03.0+ [3]
        "00010101011",    # "00000100" -D04.0- [4]
        "11101100101",    # "00000101" -D05.0+ [5]
        "11101100110",    # "00000110" -D06.0+ [6]
        "11101000111",    # "00000111" -D07.0+ [7]
        "00010100111",    # "00001000" -D08.0- [8]
        "11101101001",    # "00001001" -D09.0+ [9]
        "11101101010",    # "00001010" -D10.0+ [10]
        "11101001011",    # "00001011" -D11.0+ [11]
        "11101101100",    # "00001100" -D12.0+ [12]
        "11101001101",    # "00001101" -D13.0+ [13]
        "11101001110",    # "00001110" -D14.0+ [14]
        "00010111010",    # "00001111" -D15.0- [15]
        "00010110110",    # "00010000" -D16.0- [16]
        "11101110001",    # "00010001" -D17.0+ [17]
        "11101110010",    # "00010010" -D18.0+ [18]
        "11101010011",    # "00010011" -D19.0+ [19]
        "11101110100",    # "00010100" -D20.0+ [20]
        "11101010101",    # "00010101" -D21.0+ [21]
        "11101010110",    # "00010110" -D22.0+ [22]
        "00010010111",    # "00010111" -D23.0- [23]
        "00010110011",    # "00011000" -D24.0- [24]
        "11101011001",    # "00011001" -D25.0+ [25]
        "11101011010",    # "00011010" -D26.0+ [26]
        "00010011011",    # "00011011" -D27.0- [27]
        "11101011100",    # "00011100" -D28.0+ [28]
        "00010011101",    # "00011101" -D29.0- [29]
        "00010011110",    # "00011110" -D30.0- [30]
        "00010110101",    # "00011111" -D31.0- [31]
        "11001111001",    # "00100000" -D00.1+ [32]
        "11001101110",    # "00100001" -D01.1+ [33]
        "11001101101",    # "00100010" -D02.1+ [34]
        "01001100011",    # "00100011" -D03.1- [35]
        "11001101011",    # "00100100" -D04.1+ [36]
        "01001100101",    # "00100101" -D05.1- [37]
        "01001100110",    # "00100110" -D06.1- [38]
        "01001000111",    # "00100111" -D07.1- [39]
        "11001100111",    # "00101000" -D08.1+ [40]
        "01001101001",    # "00101001" -D09.1- [41]
        "01001101010",    # "00101010" -D10.1- [42]
        "01001001011",    # "00101011" -D11.1- [43]
        "01001101100",    # "00101100" -D12.1- [44]
        "01001001101",    # "00101101" -D13.1- [45]
        "01001001110",    # "00101110" -D14.1- [46]
        "11001111010",    # "00101111" -D15.1+ [47]
        "11001110110",    # "00110000" -D16.1+ [48]
        "01001110001",    # "00110001" -D17.1- [49]
        "01001110010",    # "00110010" -D18.1- [50]
        "01001010011",    # "00110011" -D19.1- [51]
        "01001110100",    # "00110100" -D20.1- [52]
        "01001010101",    # "00110101" -D21.1- [53]
        "01001010110",    # "00110110" -D22.1- [54]
        "11001010111",    # "00110111" -D23.1+ [55]
        "11001110011",    # "00111000" -D24.1+ [56]
        "01001011001",    # "00111001" -D25.1- [57]
        "01001011010",    # "00111010" -D26.1- [58]
        "11001011011",    # "00111011" -D27.1+ [59]
        "01001011100",    # "00111100" -D28.1- [60]
        "11001011101",    # "00111101" -D29.1+ [61]
        "11001011110",    # "00111110" -D30.1+ [62]
        "11001110101",    # "00111111" -D31.1+ [63]
        "11010111001",    # "01000000" -D00.2+ [64]
        "11010101110",    # "01000001" -D01.2+ [65]
        "11010101101",    # "01000010" -D02.2+ [66]
        "01010100011",    # "01000011" -D03.2- [67]
        "11010101011",    # "01000100" -D04.2+ [68]
        "01010100101",    # "01000101" -D05.2- [69]
        "01010100110",    # "01000110" -D06.2- [70]
        "01010000111",    # "01000111" -D07.2- [71]
        "11010100111",    # "01001000" -D08.2+ [72]
        "01010101001",    # "01001001" -D09.2- [73]
        "01010101010",    # "01001010" -D10.2- [74]
        "01010001011",    # "01001011" -D11.2- [75]
        "01010101100",    # "01001100" -D12.2- [76]
        "01010001101",    # "01001101" -D13.2- [77]
        "01010001110",    # "01001110" -D14.2- [78]
        "11010111010",    # "01001111" -D15.2+ [79]
        "11010110110",    # "01010000" -D16.2+ [80]
        "01010110001",    # "01010001" -D17.2- [81]
        "01010110010",    # "01010010" -D18.2- [82]
        "01010010011",    # "01010011" -D19.2- [83]
        "01010110100",    # "01010100" -D20.2- [84]
        "01010010101",    # "01010101" -D21.2- [85]
        "01010010110",    # "01010110" -D22.2- [86]
        "11010010111",    # "01010111" -D23.2+ [87]
        "11010110011",    # "01011000" -D24.2+ [88]
        "01010011001",    # "01011001" -D25.2- [89]
        "01010011010",    # "01011010" -D26.2- [90]
        "11010011011",    # "01011011" -D27.2+ [91]
        "01010011100",    # "01011100" -D28.2- [92]
        "11010011101",    # "01011101" -D29.2+ [93]
        "11010011110",    # "01011110" -D30.2+ [94]
        "11010110101",    # "01011111" -D31.2+ [95]
        "11100111001",    # "01100000" -D00.3+ [96]
        "11100101110",    # "01100001" -D01.3+ [97]
        "11100101101",    # "01100010" -D02.3+ [98]
        "00011100011",    # "01100011" -D03.3- [99]
        "11100101011",    # "01100100" -D04.3+ [100]
        "00011100101",    # "01100101" -D05.3- [101]
        "00011100110",    # "01100110" -D06.3- [102]
        "00011000111",    # "01100111" -D07.3- [103]
        "11100100111",    # "01101000" -D08.3+ [104]
        "00011101001",    # "01101001" -D09.3- [105]
        "00011101010",    # "01101010" -D10.3- [106]
        "00011001011",    # "01101011" -D11.3- [107]
        "00011101100",    # "01101100" -D12.3- [108]
        "00011001101",    # "01101101" -D13.3- [109]
        "00011001110",    # "01101110" -D14.3- [110]
        "11100111010",    # "01101111" -D15.3+ [111]
        "11100110110",    # "01110000" -D16.3+ [112]
        "00011110001",    # "01110001" -D17.3- [113]
        "00011110010",    # "01110010" -D18.3- [114]
        "00011010011",    # "01110011" -D19.3- [115]
        "00011110100",    # "01110100" -D20.3- [116]
        "00011010101",    # "01110101" -D21.3- [117]
        "00011010110",    # "01110110" -D22.3- [118]
        "11100010111",    # "01110111" -D23.3+ [119]
        "11100110011",    # "01111000" -D24.3+ [120]
        "00011011001",    # "01111001" -D25.3- [121]
        "00011011010",    # "01111010" -D26.3- [122]
        "11100011011",    # "01111011" -D27.3+ [123]
        "00011011100",    # "01111100" -D28.3- [124]
        "11100011101",    # "01111101" -D29.3+ [125]
        "11100011110",    # "01111110" -D30.3+ [126]
        "11100110101",    # "01111111" -D31.3+ [127]
        "00100111001",    # "10000000" -D00.4- [128]
        "00100101110",    # "10000001" -D01.4- [129]
        "00100101101",    # "10000010" -D02.4- [130]
        "11011100011",    # "10000011" -D03.4+ [131]
        "00100101011",    # "10000100" -D04.4- [132]
        "11011100101",    # "10000101" -D05.4+ [133]
        "11011100110",    # "10000110" -D06.4+ [134]
        "11011000111",    # "10000111" -D07.4+ [135]
        "00100100111",    # "10001000" -D08.4- [136]
        "11011101001",    # "10001001" -D09.4+ [137]
        "11011101010",    # "10001010" -D10.4+ [138]
        "11011001011",    # "10001011" -D11.4+ [139]
        "11011101100",    # "10001100" -D12.4+ [140]
        "11011001101",    # "10001101" -D13.4+ [141]
        "11011001110",    # "10001110" -D14.4+ [142]
        "00100111010",    # "10001111" -D15.4- [143]
        "00100110110",    # "10010000" -D16.4- [144]
        "11011110001",    # "10010001" -D17.4+ [145]
        "11011110010",    # "10010010" -D18.4+ [146]
        "11011010011",    # "10010011" -D19.4+ [147]
        "11011110100",    # "10010100" -D20.4+ [148]
        "11011010101",    # "10010101" -D21.4+ [149]
        "11011010110",    # "10010110" -D22.4+ [150]
        "00100010111",    # "10010111" -D23.4- [151]
        "00100110011",    # "10011000" -D24.4- [152]
        "11011011001",    # "10011001" -D25.4+ [153]
        "11011011010",    # "10011010" -D26.4+ [154]
        "00100011011",    # "10011011" -D27.4- [155]
        "11011011100",    # "10011100" -D28.4+ [156]
        "00100011101",    # "10011101" -D29.4- [157]
        "00100011110",    # "10011110" -D30.4- [158]
        "00100110101",    # "10011111" -D31.4- [159]
        "10101111001",    # "10100000" -D00.5+ [160]
        "10101101110",    # "10100001" -D01.5+ [161]
        "10101101101",    # "10100010" -D02.5+ [162]
        "00101100011",    # "10100011" -D03.5- [163]
        "10101101011",    # "10100100" -D04.5+ [164]
        "00101100101",    # "10100101" -D05.5- [165]
        "00101100110",    # "10100110" -D06.5- [166]
        "00101000111",    # "10100111" -D07.5- [167]
        "10101100111",    # "10101000" -D08.5+ [168]
        "00101101001",    # "10101001" -D09.5- [169]
        "00101101010",    # "10101010" -D10.5- [170]
        "00101001011",    # "10101011" -D11.5- [171]
        "00101101100",    # "10101100" -D12.5- [172]
        "00101001101",    # "10101101" -D13.5- [173]
        "00101001110",    # "10101110" -D14.5- [174]
        "10101111010",    # "10101111" -D15.5+ [175]
        "10101110110",    # "10110000" -D16.5+ [176]
        "00101110001",    # "10110001" -D17.5- [177]
        "00101110010",    # "10110010" -D18.5- [178]
        "00101010011",    # "10110011" -D19.5- [179]
        "00101110100",    # "10110100" -D20.5- [180]
        "00101010101",    # "10110101" -D21.5- [181]
        "00101010110",    # "10110110" -D22.5- [182]
        "10101010111",    # "10110111" -D23.5+ [183]
        "10101110011",    # "10111000" -D24.5+ [184]
        "00101011001",    # "10111001" -D25.5- [185]
        "00101011010",    # "10111010" -D26.5- [186]
        "10101011011",    # "10111011" -D27.5+ [187]
        "00101011100",    # "10111100" -D28.5- [188]
        "10101011101",    # "10111101" -D29.5+ [189]
        "10101011110",    # "10111110" -D30.5+ [190]
        "10101110101",    # "10111111" -D31.5+ [191]
        "10110111001",    # "11000000" -D00.6+ [192]
        "10110101110",    # "11000001" -D01.6+ [193]
        "10110101101",    # "11000010" -D02.6+ [194]
        "00110100011",    # "11000011" -D03.6- [195]
        "10110101011",    # "11000100" -D04.6+ [196]
        "00110100101",    # "11000101" -D05.6- [197]
        "00110100110",    # "11000110" -D06.6- [198]
        "00110000111",    # "11000111" -D07.6- [199]
        "10110100111",    # "11001000" -D08.6+ [200]
        "00110101001",    # "11001001" -D09.6- [201]
        "00110101010",    # "11001010" -D10.6- [202]
        "00110001011",    # "11001011" -D11.6- [203]
        "00110101100",    # "11001100" -D12.6- [204]
        "00110001101",    # "11001101" -D13.6- [205]
        "00110001110",    # "11001110" -D14.6- [206]
        "10110111010",    # "11001111" -D15.6+ [207]
        "10110110110",    # "11010000" -D16.6+ [208]
        "00110110001",    # "11010001" -D17.6- [209]
        "00110110010",    # "11010010" -D18.6- [210]
        "00110010011",    # "11010011" -D19.6- [211]
        "00110110100",    # "11010100" -D20.6- [212]
        "00110010101",    # "11010101" -D21.6- [213]
        "00110010110",    # "11010110" -D22.6- [214]
        "10110010111",    # "11010111" -D23.6+ [215]
        "10110110011",    # "11011000" -D24.6+ [216]
        "00110011001",    # "11011001" -D25.6- [217]
        "00110011010",    # "11011010" -D26.6- [218]
        "10110011011",    # "11011011" -D27.6+ [219]
        "00110011100",    # "11011100" -D28.6- [220]
        "10110011101",    # "11011101" -D29.6+ [221]
        "10110011110",    # "11011110" -D30.6+ [222]
        "10110110101",    # "11011111" -D31.6+ [223]
        "01000111001",    # "11100000" -D00.7- [224]
        "01000101110",    # "11100001" -D01.7- [225]
        "01000101101",    # "11100010" -D02.7- [226]
        "10111100011",    # "11100011" -D03.7+ [227]
        "01000101011",    # "11100100" -D04.7- [228]
        "10111100101",    # "11100101" -D05.7+ [229]
        "10111100110",    # "11100110" -D06.7+ [230]
        "10111000111",    # "11100111" -D07.7+ [231]
        "01000100111",    # "11101000" -D08.7- [232]
        "10111101001",    # "11101001" -D09.7+ [233]
        "10111101010",    # "11101010" -D10.7+ [234]
        "10111001011",    # "11101011" -D11.7+ [235]
        "10111101100",    # "11101100" -D12.7+ [236]
        "10111001101",    # "11101101" -D13.7+ [237]
        "10111001110",    # "11101110" -D14.7+ [238]
        "01000111010",    # "11101111" -D15.7- [239]
        "01000110110",    # "11110000" -D16.7- [240]
        "11110110001",    # "11110001" -D17.7+ [241]
        "11110110010",    # "11110010" -D18.7+ [242]
        "10111010011",    # "11110011" -D19.7+ [243]
        "11110110100",    # "11110100" -D20.7+ [244]
        "10111010101",    # "11110101" -D21.7+ [245]
        "10111010110",    # "11110110" -D22.7+ [246]
        "01000010111",    # "11110111" -D23.7- [247]
        "01000110011",    # "11111000" -D24.7- [248]
        "10111011001",    # "11111001" -D25.7+ [249]
        "10111011010",    # "11111010" -D26.7+ [250]
        "01000011011",    # "11111011" -D27.7- [251]
        "10111011100",    # "11111100" -D28.7+ [252]
        "01000011101",    # "11111101" -D29.7- [253]
        "01000011110",    # "11111110" -D30.7- [254]
        "01000110101",    # "11111111" -D31.7- [255]
        "11101000110",    # "00000000" +D00.0+ [256]
        "11101010001",    # "00000001" +D01.0+ [257]
        "11101010010",    # "00000010" +D02.0+ [258]
        "00010100011",    # "00000011" +D03.0- [259]
        "11101010100",    # "00000100" +D04.0+ [260]
        "00010100101",    # "00000101" +D05.0- [261]
        "00010100110",    # "00000110" +D06.0- [262]
        "00010111000",    # "00000111" +D07.0- [263]
        "11101011000",    # "00001000" +D08.0+ [264]
        "00010101001",    # "00001001" +D09.0- [265]
        "00010101010",    # "00001010" +D10.0- [266]
        "00010001011",    # "00001011" +D11.0- [267]
        "00010101100",    # "00001100" +D12.0- [268]
        "00010001101",    # "00001101" +D13.0- [269]
        "00010001110",    # "00001110" +D14.0- [270]
        "11101000101",    # "00001111" +D15.0+ [271]
        "11101001001",    # "00010000" +D16.0+ [272]
        "00010110001",    # "00010001" +D17.0- [273]
        "00010110010",    # "00010010" +D18.0- [274]
        "00010010011",    # "00010011" +D19.0- [275]
        "00010110100",    # "00010100" +D20.0- [276]
        "00010010101",    # "00010101" +D21.0- [277]
        "00010010110",    # "00010110" +D22.0- [278]
        "11101101000",    # "00010111" +D23.0+ [279]
        "11101001100",    # "00011000" +D24.0+ [280]
        "00010011001",    # "00011001" +D25.0- [281]
        "00010011010",    # "00011010" +D26.0- [282]
        "11101100100",    # "00011011" +D27.0+ [283]
        "00010011100",    # "00011100" +D28.0- [284]
        "11101100010",    # "00011101" +D29.0+ [285]
        "11101100001",    # "00011110" +D30.0+ [286]
        "11101001010",    # "00011111" +D31.0+ [287]
        "01001000110",    # "00100000" +D00.1- [288]
        "01001010001",    # "00100001" +D01.1- [289]
        "01001010010",    # "00100010" +D02.1- [290]
        "11001100011",    # "00100011" +D03.1+ [291]
        "01001010100",    # "00100100" +D04.1- [292]
        "11001100101",    # "00100101" +D05.1+ [293]
        "11001100110",    # "00100110" +D06.1+ [294]
        "11001111000",    # "00100111" +D07.1+ [295]
        "01001011000",    # "00101000" +D08.1- [296]
        "11001101001",    # "00101001" +D09.1+ [297]
        "11001101010",    # "00101010" +D10.1+ [298]
        "11001001011",    # "00101011" +D11.1+ [299]
        "11001101100",    # "00101100" +D12.1+ [300]
        "11001001101",    # "00101101" +D13.1+ [301]
        "11001001110",    # "00101110" +D14.1+ [302]
        "01001000101",    # "00101111" +D15.1- [303]
        "01001001001",    # "00110000" +D16.1- [304]
        "11001110001",    # "00110001" +D17.1+ [305]
        "11001110010",    # "00110010" +D18.1+ [306]
        "11001010011",    # "00110011" +D19.1+ [307]
        "11001110100",    # "00110100" +D20.1+ [308]
        "11001010101",    # "00110101" +D21.1+ [309]
        "11001010110",    # "00110110" +D22.1+ [310]
        "01001101000",    # "00110111" +D23.1- [311]
        "01001001100",    # "00111000" +D24.1- [312]
        "11001011001",    # "00111001" +D25.1+ [313]
        "11001011010",    # "00111010" +D26.1+ [314]
        "01001100100",    # "00111011" +D27.1- [315]
        "11001011100",    # "00111100" +D28.1+ [316]
        "01001100010",    # "00111101" +D29.1- [317]
        "01001100001",    # "00111110" +D30.1- [318]
        "01001001010",    # "00111111" +D31.1- [319]
        "01010000110",    # "01000000" +D00.2- [320]
        "01010010001",    # "01000001" +D01.2- [321]
        "01010010010",    # "01000010" +D02.2- [322]
        "11010100011",    # "01000011" +D03.2+ [323]
        "01010010100",    # "01000100" +D04.2- [324]
        "11010100101",    # "01000101" +D05.2+ [325]
        "11010100110",    # "01000110" +D06.2+ [326]
        "11010111000",    # "01000111" +D07.2+ [327]
        "01010011000",    # "01001000" +D08.2- [328]
        "11010101001",    # "01001001" +D09.2+ [329]
        "11010101010",    # "01001010" +D10.2+ [330]
        "11010001011",    # "01001011" +D11.2+ [331]
        "11010101100",    # "01001100" +D12.2+ [332]
        "11010001101",    # "01001101" +D13.2+ [333]
        "11010001110",    # "01001110" +D14.2+ [334]
        "01010000101",    # "01001111" +D15.2- [335]
        "01010001001",    # "01010000" +D16.2- [336]
        "11010110001",    # "01010001" +D17.2+ [337]
        "11010110010",    # "01010010" +D18.2+ [338]
        "11010010011",    # "01010011" +D19.2+ [339]
        "11010110100",    # "01010100" +D20.2+ [340]
        "11010010101",    # "01010101" +D21.2+ [341]
        "11010010110",    # "01010110" +D22.2+ [342]
        "01010101000",    # "01010111" +D23.2- [343]
        "01010001100",    # "01011000" +D24.2- [344]
        "11010011001",    # "01011001" +D25.2+ [345]
        "11010011010",    # "01011010" +D26.2+ [346]
        "01010100100",    # "01011011" +D27.2- [347]
        "11010011100",    # "01011100" +D28.2+ [348]
        "01010100010",    # "01011101" +D29.2- [349]
        "01010100001",    # "01011110" +D30.2- [350]
        "01010001010",    # "01011111" +D31.2- [351]
        "00011000110",    # "01100000" +D00.3- [352]
        "00011010001",    # "01100001" +D01.3- [353]
        "00011010010",    # "01100010" +D02.3- [354]
        "11100100011",    # "01100011" +D03.3+ [355]
        "00011010100",    # "01100100" +D04.3- [356]
        "11100100101",    # "01100101" +D05.3+ [357]
        "11100100110",    # "01100110" +D06.3+ [358]
        "11100111000",    # "01100111" +D07.3+ [359]
        "00011011000",    # "01101000" +D08.3- [360]
        "11100101001",    # "01101001" +D09.3+ [361]
        "11100101010",    # "01101010" +D10.3+ [362]
        "11100001011",    # "01101011" +D11.3+ [363]
        "11100101100",    # "01101100" +D12.3+ [364]
        "11100001101",    # "01101101" +D13.3+ [365]
        "11100001110",    # "01101110" +D14.3+ [366]
        "00011000101",    # "01101111" +D15.3- [367]
        "00011001001",    # "01110000" +D16.3- [368]
        "11100110001",    # "01110001" +D17.3+ [369]
        "11100110010",    # "01110010" +D18.3+ [370]
        "11100010011",    # "01110011" +D19.3+ [371]
        "11100110100",    # "01110100" +D20.3+ [372]
        "11100010101",    # "01110101" +D21.3+ [373]
        "11100010110",    # "01110110" +D22.3+ [374]
        "00011101000",    # "01110111" +D23.3- [375]
        "00011001100",    # "01111000" +D24.3- [376]
        "11100011001",    # "01111001" +D25.3+ [377]
        "11100011010",    # "01111010" +D26.3+ [378]
        "00011100100",    # "01111011" +D27.3- [379]
        "11100011100",    # "01111100" +D28.3+ [380]
        "00011100010",    # "01111101" +D29.3- [381]
        "00011100001",    # "01111110" +D30.3- [382]
        "00011001010",    # "01111111" +D31.3- [383]
        "11011000110",    # "10000000" +D00.4+ [384]
        "11011010001",    # "10000001" +D01.4+ [385]
        "11011010010",    # "10000010" +D02.4+ [386]
        "00100100011",    # "10000011" +D03.4- [387]
        "11011010100",    # "10000100" +D04.4+ [388]
        "00100100101",    # "10000101" +D05.4- [389]
        "00100100110",    # "10000110" +D06.4- [390]
        "00100111000",    # "10000111" +D07.4- [391]
        "11011011000",    # "10001000" +D08.4+ [392]
        "00100101001",    # "10001001" +D09.4- [393]
        "00100101010",    # "10001010" +D10.4- [394]
        "00100001011",    # "10001011" +D11.4- [395]
        "00100101100",    # "10001100" +D12.4- [396]
        "00100001101",    # "10001101" +D13.4- [397]
        "00100001110",    # "10001110" +D14.4- [398]
        "11011000101",    # "10001111" +D15.4+ [399]
        "11011001001",    # "10010000" +D16.4+ [400]
        "00100110001",    # "10010001" +D17.4- [401]
        "00100110010",    # "10010010" +D18.4- [402]
        "00100010011",    # "10010011" +D19.4- [403]
        "00100110100",    # "10010100" +D20.4- [404]
        "00100010101",    # "10010101" +D21.4- [405]
        "00100010110",    # "10010110" +D22.4- [406]
        "11011101000",    # "10010111" +D23.4+ [407]
        "11011001100",    # "10011000" +D24.4+ [408]
        "00100011001",    # "10011001" +D25.4- [409]
        "00100011010",    # "10011010" +D26.4- [410]
        "11011100100",    # "10011011" +D27.4+ [411]
        "00100011100",    # "10011100" +D28.4- [412]
        "11011100010",    # "10011101" +D29.4+ [413]
        "11011100001",    # "10011110" +D30.4+ [414]
        "11011001010",    # "10011111" +D31.4+ [415]
        "00101000110",    # "10100000" +D00.5- [416]
        "00101010001",    # "10100001" +D01.5- [417]
        "00101010010",    # "10100010" +D02.5- [418]
        "10101100011",    # "10100011" +D03.5+ [419]
        "00101010100",    # "10100100" +D04.5- [420]
        "10101100101",    # "10100101" +D05.5+ [421]
        "10101100110",    # "10100110" +D06.5+ [422]
        "10101111000",    # "10100111" +D07.5+ [423]
        "00101011000",    # "10101000" +D08.5- [424]
        "10101101001",    # "10101001" +D09.5+ [425]
        "10101101010",    # "10101010" +D10.5+ [426]
        "10101001011",    # "10101011" +D11.5+ [427]
        "10101101100",    # "10101100" +D12.5+ [428]
        "10101001101",    # "10101101" +D13.5+ [429]
        "10101001110",    # "10101110" +D14.5+ [430]
        "00101000101",    # "10101111" +D15.5- [431]
        "00101001001",    # "10110000" +D16.5- [432]
        "10101110001",    # "10110001" +D17.5+ [433]
        "10101110010",    # "10110010" +D18.5+ [434]
        "10101010011",    # "10110011" +D19.5+ [435]
        "10101110100",    # "10110100" +D20.5+ [436]
        "10101010101",    # "10110101" +D21.5+ [437]
        "10101010110",    # "10110110" +D22.5+ [438]
        "00101101000",    # "10110111" +D23.5- [439]
        "00101001100",    # "10111000" +D24.5- [440]
        "10101011001",    # "10111001" +D25.5+ [441]
        "10101011010",    # "10111010" +D26.5+ [442]
        "00101100100",    # "10111011" +D27.5- [443]
        "10101011100",    # "10111100" +D28.5+ [444]
        "00101100010",    # "10111101" +D29.5- [445]
        "00101100001",    # "10111110" +D30.5- [446]
        "00101001010",    # "10111111" +D31.5- [447]
        "00110000110",    # "11000000" +D00.6- [448]
        "00110010001",    # "11000001" +D01.6- [449]
        "00110010010",    # "11000010" +D02.6- [450]
        "10110100011",    # "11000011" +D03.6+ [451]
        "00110010100",    # "11000100" +D04.6- [452]
        "10110100101",    # "11000101" +D05.6+ [453]
        "10110100110",    # "11000110" +D06.6+ [454]
        "10110111000",    # "11000111" +D07.6+ [455]
        "00110011000",    # "11001000" +D08.6- [456]
        "10110101001",    # "11001001" +D09.6+ [457]
        "10110101010",    # "11001010" +D10.6+ [458]
        "10110001011",    # "11001011" +D11.6+ [459]
        "10110101100",    # "11001100" +D12.6+ [460]
        "10110001101",    # "11001101" +D13.6+ [461]
        "10110001110",    # "11001110" +D14.6+ [462]
        "00110000101",    # "11001111" +D15.6- [463]
        "00110001001",    # "11010000" +D16.6- [464]
        "10110110001",    # "11010001" +D17.6+ [465]
        "10110110010",    # "11010010" +D18.6+ [466]
        "10110010011",    # "11010011" +D19.6+ [467]
        "10110110100",    # "11010100" +D20.6+ [468]
        "10110010101",    # "11010101" +D21.6+ [469]
        "10110010110",    # "11010110" +D22.6+ [470]
        "00110101000",    # "11010111" +D23.6- [471]
        "00110001100",    # "11011000" +D24.6- [472]
        "10110011001",    # "11011001" +D25.6+ [473]
        "10110011010",    # "11011010" +D26.6+ [474]
        "00110100100",    # "11011011" +D27.6- [475]
        "10110011100",    # "11011100" +D28.6+ [476]
        "00110100010",    # "11011101" +D29.6- [477]
        "00110100001",    # "11011110" +D30.6- [478]
        "00110001010",    # "11011111" +D31.6- [479]
        "10111000110",    # "11100000" +D00.7+ [480]
        "10111010001",    # "11100001" +D01.7+ [481]
        "10111010010",    # "11100010" +D02.7+ [482]
        "01000100011",    # "11100011" +D03.7- [483]
        "10111010100",    # "11100100" +D04.7+ [484]
        "01000100101",    # "11100101" +D05.7- [485]
        "01000100110",    # "11100110" +D06.7- [486]
        "01000111000",    # "11100111" +D07.7- [487]
        "10111011000",    # "11101000" +D08.7+ [488]
        "01000101001",    # "11101001" +D09.7- [489]
        "01000101010",    # "11101010" +D10.7- [490]
        "00001001011",    # "11101011" +D11.7- [491]
        "01000101100",    # "11101100" +D12.7- [492]
        "00001001101",    # "11101101" +D13.7- [493]
        "00001001110",    # "11101110" +D14.7- [494]
        "10111000101",    # "11101111" +D15.7+ [495]
        "10111001001",    # "11110000" +D16.7+ [496]
        "01000110001",    # "11110001" +D17.7- [497]
        "01000110010",    # "11110010" +D18.7- [498]
        "01000010011",    # "11110011" +D19.7- [499]
        "01000110100",    # "11110100" +D20.7- [500]
        "01000010101",    # "11110101" +D21.7- [501]
        "01000010110",    # "11110110" +D22.7- [502]
        "10111101000",    # "11110111" +D23.7+ [503]
        "10111001100",    # "11111000" +D24.7+ [504]
        "01000011001",    # "11111001" +D25.7- [505]
        "01000011010",    # "11111010" +D26.7- [506]
        "10111100100",    # "11111011" +D27.7+ [507]
        "01000011100",    # "11111100" +D28.7- [508]
        "10111100010",    # "11111101" +D29.7+ [509]
        "10111100001",    # "11111110" +D30.7+ [510]
        "10111001010",    # "11111111" +D31.7+ [511]
        "00010111001",    # "00000000" -K00.0- [512]
        "00010101110",    # "00000001" -K01.0- [513]
        "00010101101",    # "00000010" -K02.0- [514]
        "11101100011",    # "00000011" -K03.0+ [515]
        "00010101011",    # "00000100" -K04.0- [516]
        "11101100101",    # "00000101" -K05.0+ [517]
        "11101100110",    # "00000110" -K06.0+ [518]
        "11101000111",    # "00000111" -K07.0+ [519]
        "00010100111",    # "00001000" -K08.0- [520]
        "11101101001",    # "00001001" -K09.0+ [521]
        "11101101010",    # "00001010" -K10.0+ [522]
        "11101001011",    # "00001011" -K11.0+ [523]
        "11101101100",    # "00001100" -K12.0+ [524]
        "11101001101",    # "00001101" -K13.0+ [525]
        "11101001110",    # "00001110" -K14.0+ [526]
        "00010111010",    # "00001111" -K15.0- [527]
        "00010110110",    # "00010000" -K16.0- [528]
        "11101110001",    # "00010001" -K17.0+ [529]
        "11101110010",    # "00010010" -K18.0+ [530]
        "11101010011",    # "00010011" -K19.0+ [531]
        "11101110100",    # "00010100" -K20.0+ [532]
        "11101010101",    # "00010101" -K21.0+ [533]
        "11101010110",    # "00010110" -K22.0+ [534]
        "00010010111",    # "00010111" -K23.0- [535]
        "00010110011",    # "00011000" -K24.0- [536]
        "11101011001",    # "00011001" -K25.0+ [537]
        "11101011010",    # "00011010" -K26.0+ [538]
        "00010011011",    # "00011011" -K27.0- [539]
        "00010111100",    # "00011100" -K28.0- [540]
        "00010011101",    # "00011101" -K29.0- [541]
        "00010011110",    # "00011110" -K30.0- [542]
        "00010110101",    # "00011111" -K31.0- [543]
        "11001111001",    # "00100000" -K00.1+ [544]
        "11001101110",    # "00100001" -K01.1+ [545]
        "11001101101",    # "00100010" -K02.1+ [546]
        "00110100011",    # "00100011" -K03.1- [547]
        "11001101011",    # "00100100" -K04.1+ [548]
        "00110100101",    # "00100101" -K05.1- [549]
        "00110100110",    # "00100110" -K06.1- [550]
        "00110000111",    # "00100111" -K07.1- [551]
        "11001100111",    # "00101000" -K08.1+ [552]
        "00110101001",    # "00101001" -K09.1- [553]
        "00110101010",    # "00101010" -K10.1- [554]
        "00110001011",    # "00101011" -K11.1- [555]
        "00110101100",    # "00101100" -K12.1- [556]
        "00110001101",    # "00101101" -K13.1- [557]
        "00110001110",    # "00101110" -K14.1- [558]
        "11001111010",    # "00101111" -K15.1+ [559]
        "11001110110",    # "00110000" -K16.1+ [560]
        "00110110001",    # "00110001" -K17.1- [561]
        "00110110010",    # "00110010" -K18.1- [562]
        "00110010011",    # "00110011" -K19.1- [563]
        "00110110100",    # "00110100" -K20.1- [564]
        "00110010101",    # "00110101" -K21.1- [565]
        "00110010110",    # "00110110" -K22.1- [566]
        "11001010111",    # "00110111" -K23.1+ [567]
        "11001110011",    # "00111000" -K24.1+ [568]
        "00110011001",    # "00111001" -K25.1- [569]
        "00110011010",    # "00111010" -K26.1- [570]
        "11001011011",    # "00111011" -K27.1+ [571]
        "11001111100",    # "00111100" -K28.1+ [572]
        "11001011101",    # "00111101" -K29.1+ [573]
        "11001011110",    # "00111110" -K30.1+ [574]
        "11001110101",    # "00111111" -K31.1+ [575]
        "11010111001",    # "01000000" -K00.2+ [576]
        "11010101110",    # "01000001" -K01.2+ [577]
        "11010101101",    # "01000010" -K02.2+ [578]
        "00101100011",    # "01000011" -K03.2- [579]
        "11010101011",    # "01000100" -K04.2+ [580]
        "00101100101",    # "01000101" -K05.2- [581]
        "00101100110",    # "01000110" -K06.2- [582]
        "00101000111",    # "01000111" -K07.2- [583]
        "11010100111",    # "01001000" -K08.2+ [584]
        "00101101001",    # "01001001" -K09.2- [585]
        "00101101010",    # "01001010" -K10.2- [586]
        "00101001011",    # "01001011" -K11.2- [587]
        "00101101100",    # "01001100" -K12.2- [588]
        "00101001101",    # "01001101" -K13.2- [589]
        "00101001110",    # "01001110" -K14.2- [590]
        "11010111010",    # "01001111" -K15.2+ [591]
        "11010110110",    # "01010000" -K16.2+ [592]
        "00101110001",    # "01010001" -K17.2- [593]
        "00101110010",    # "01010010" -K18.2- [594]
        "00101010011",    # "01010011" -K19.2- [595]
        "00101110100",    # "01010100" -K20.2- [596]
        "00101010101",    # "01010101" -K21.2- [597]
        "00101010110",    # "01010110" -K22.2- [598]
        "11010010111",    # "01010111" -K23.2+ [599]
        "11010110011",    # "01011000" -K24.2+ [600]
        "00101011001",    # "01011001" -K25.2- [601]
        "00101011010",    # "01011010" -K26.2- [602]
        "11010011011",    # "01011011" -K27.2+ [603]
        "11010111100",    # "01011100" -K28.2+ [604]
        "11010011101",    # "01011101" -K29.2+ [605]
        "11010011110",    # "01011110" -K30.2+ [606]
        "11010110101",    # "01011111" -K31.2+ [607]
        "11100111001",    # "01100000" -K00.3+ [608]
        "11100101110",    # "01100001" -K01.3+ [609]
        "11100101101",    # "01100010" -K02.3+ [610]
        "00011100011",    # "01100011" -K03.3- [611]
        "11100101011",    # "01100100" -K04.3+ [612]
        "00011100101",    # "01100101" -K05.3- [613]
        "00011100110",    # "01100110" -K06.3- [614]
        "00011000111",    # "01100111" -K07.3- [615]
        "11100100111",    # "01101000" -K08.3+ [616]
        "00011101001",    # "01101001" -K09.3- [617]
        "00011101010",    # "01101010" -K10.3- [618]
        "00011001011",    # "01101011" -K11.3- [619]
        "00011101100",    # "01101100" -K12.3- [620]
        "00011001101",    # "01101101" -K13.3- [621]
        "00011001110",    # "01101110" -K14.3- [622]
        "11100111010",    # "01101111" -K15.3+ [623]
        "11100110110",    # "01110000" -K16.3+ [624]
        "00011110001",    # "01110001" -K17.3- [625]
        "00011110010",    # "01110010" -K18.3- [626]
        "00011010011",    # "01110011" -K19.3- [627]
        "00011110100",    # "01110100" -K20.3- [628]
        "00011010101",    # "01110101" -K21.3- [629]
        "00011010110",    # "01110110" -K22.3- [630]
        "11100010111",    # "01110111" -K23.3+ [631]
        "11100110011",    # "01111000" -K24.3+ [632]
        "00011011001",    # "01111001" -K25.3- [633]
        "00011011010",    # "01111010" -K26.3- [634]
        "11100011011",    # "01111011" -K27.3+ [635]
        "11100111100",    # "01111100" -K28.3+ [636]
        "11100011101",    # "01111101" -K29.3+ [637]
        "11100011110",    # "01111110" -K30.3+ [638]
        "11100110101",    # "01111111" -K31.3+ [639]
        "00100111001",    # "10000000" -K00.4- [640]
        "00100101110",    # "10000001" -K01.4- [641]
        "00100101101",    # "10000010" -K02.4- [642]
        "11011100011",    # "10000011" -K03.4+ [643]
        "00100101011",    # "10000100" -K04.4- [644]
        "11011100101",    # "10000101" -K05.4+ [645]
        "11011100110",    # "10000110" -K06.4+ [646]
        "11011000111",    # "10000111" -K07.4+ [647]
        "00100100111",    # "10001000" -K08.4- [648]
        "11011101001",    # "10001001" -K09.4+ [649]
        "11011101010",    # "10001010" -K10.4+ [650]
        "11011001011",    # "10001011" -K11.4+ [651]
        "11011101100",    # "10001100" -K12.4+ [652]
        "11011001101",    # "10001101" -K13.4+ [653]
        "11011001110",    # "10001110" -K14.4+ [654]
        "00100111010",    # "10001111" -K15.4- [655]
        "00100110110",    # "10010000" -K16.4- [656]
        "11011110001",    # "10010001" -K17.4+ [657]
        "11011110010",    # "10010010" -K18.4+ [658]
        "11011010011",    # "10010011" -K19.4+ [659]
        "11011110100",    # "10010100" -K20.4+ [660]
        "11011010101",    # "10010101" -K21.4+ [661]
        "11011010110",    # "10010110" -K22.4+ [662]
        "00100010111",    # "10010111" -K23.4- [663]
        "00100110011",    # "10011000" -K24.4- [664]
        "11011011001",    # "10011001" -K25.4+ [665]
        "11011011010",    # "10011010" -K26.4+ [666]
        "00100011011",    # "10011011" -K27.4- [667]
        "00100111100",    # "10011100" -K28.4- [668]
        "00100011101",    # "10011101" -K29.4- [669]
        "00100011110",    # "10011110" -K30.4- [670]
        "00100110101",    # "10011111" -K31.4- [671]
        "10101111001",    # "10100000" -K00.5+ [672]
        "10101101110",    # "10100001" -K01.5+ [673]
        "10101101101",    # "10100010" -K02.5+ [674]
        "01010100011",    # "10100011" -K03.5- [675]
        "10101101011",    # "10100100" -K04.5+ [676]
        "01010100101",    # "10100101" -K05.5- [677]
        "01010100110",    # "10100110" -K06.5- [678]
        "01010000111",    # "10100111" -K07.5- [679]
        "10101100111",    # "10101000" -K08.5+ [680]
        "01010101001",    # "10101001" -K09.5- [681]
        "01010101010",    # "10101010" -K10.5- [682]
        "01010001011",    # "10101011" -K11.5- [683]
        "01010101100",    # "10101100" -K12.5- [684]
        "01010001101",    # "10101101" -K13.5- [685]
        "01010001110",    # "10101110" -K14.5- [686]
        "10101111010",    # "10101111" -K15.5+ [687]
        "10101110110",    # "10110000" -K16.5+ [688]
        "01010110001",    # "10110001" -K17.5- [689]
        "01010110010",    # "10110010" -K18.5- [690]
        "01010010011",    # "10110011" -K19.5- [691]
        "01010110100",    # "10110100" -K20.5- [692]
        "01010010101",    # "10110101" -K21.5- [693]
        "01010010110",    # "10110110" -K22.5- [694]
        "10101010111",    # "10110111" -K23.5+ [695]
        "10101110011",    # "10111000" -K24.5+ [696]
        "01010011001",    # "10111001" -K25.5- [697]
        "01010011010",    # "10111010" -K26.5- [698]
        "10101011011",    # "10111011" -K27.5+ [699]
        "10101111100",    # "10111100" -K28.5+ [700]
        "10101011101",    # "10111101" -K29.5+ [701]
        "10101011110",    # "10111110" -K30.5+ [702]
        "10101110101",    # "10111111" -K31.5+ [703]
        "10110111001",    # "11000000" -K00.6+ [704]
        "10110101110",    # "11000001" -K01.6+ [705]
        "10110101101",    # "11000010" -K02.6+ [706]
        "01001100011",    # "11000011" -K03.6- [707]
        "10110101011",    # "11000100" -K04.6+ [708]
        "01001100101",    # "11000101" -K05.6- [709]
        "01001100110",    # "11000110" -K06.6- [710]
        "01001000111",    # "11000111" -K07.6- [711]
        "10110100111",    # "11001000" -K08.6+ [712]
        "01001101001",    # "11001001" -K09.6- [713]
        "01001101010",    # "11001010" -K10.6- [714]
        "01001001011",    # "11001011" -K11.6- [715]
        "01001101100",    # "11001100" -K12.6- [716]
        "01001001101",    # "11001101" -K13.6- [717]
        "01001001110",    # "11001110" -K14.6- [718]
        "10110111010",    # "11001111" -K15.6+ [719]
        "10110110110",    # "11010000" -K16.6+ [720]
        "01001110001",    # "11010001" -K17.6- [721]
        "01001110010",    # "11010010" -K18.6- [722]
        "01001010011",    # "11010011" -K19.6- [723]
        "01001110100",    # "11010100" -K20.6- [724]
        "01001010101",    # "11010101" -K21.6- [725]
        "01001010110",    # "11010110" -K22.6- [726]
        "10110010111",    # "11010111" -K23.6+ [727]
        "10110110011",    # "11011000" -K24.6+ [728]
        "01001011001",    # "11011001" -K25.6- [729]
        "01001011010",    # "11011010" -K26.6- [730]
        "10110011011",    # "11011011" -K27.6+ [731]
        "10110111100",    # "11011100" -K28.6+ [732]
        "10110011101",    # "11011101" -K29.6+ [733]
        "10110011110",    # "11011110" -K30.6+ [734]
        "10110110101",    # "11011111" -K31.6+ [735]
        "00001111001",    # "11100000" -K00.7- [736]
        "00001101110",    # "11100001" -K01.7- [737]
        "00001101101",    # "11100010" -K02.7- [738]
        "11110100011",    # "11100011" -K03.7+ [739]
        "00001101011",    # "11100100" -K04.7- [740]
        "11110100101",    # "11100101" -K05.7+ [741]
        "11110100110",    # "11100110" -K06.7+ [742]
        "11110000111",    # "11100111" -K07.7+ [743]
        "00001100111",    # "11101000" -K08.7- [744]
        "11110101001",    # "11101001" -K09.7+ [745]
        "11110101010",    # "11101010" -K10.7+ [746]
        "11110001011",    # "11101011" -K11.7+ [747]
        "11110101100",    # "11101100" -K12.7+ [748]
        "11110001101",    # "11101101" -K13.7+ [749]
        "11110001110",    # "11101110" -K14.7+ [750]
        "00001111010",    # "11101111" -K15.7- [751]
        "00001110110",    # "11110000" -K16.7- [752]
        "11110110001",    # "11110001" -K17.7+ [753]
        "11110110010",    # "11110010" -K18.7+ [754]
        "11110010011",    # "11110011" -K19.7+ [755]
        "11110110100",    # "11110100" -K20.7+ [756]
        "11110010101",    # "11110101" -K21.7+ [757]
        "11110010110",    # "11110110" -K22.7+ [758]
        "00001010111",    # "11110111" -K23.7- [759]
        "00001110011",    # "11111000" -K24.7- [760]
        "11110011001",    # "11111001" -K25.7+ [761]
        "11110011010",    # "11111010" -K26.7+ [762]
        "00001011011",    # "11111011" -K27.7- [763]
        "00001111100",    # "11111100" -K28.7- [764]
        "00001011101",    # "11111101" -K29.7- [765]
        "00001011110",    # "11111110" -K30.7- [766]
        "00001110101",    # "11111111" -K31.7- [767]
        "11101000110",    # "00000000" +K00.0+ [768]
        "11101010001",    # "00000001" +K01.0+ [769]
        "11101010010",    # "00000010" +K02.0+ [770]
        "00010100011",    # "00000011" +K03.0- [771]
        "11101010100",    # "00000100" +K04.0+ [772]
        "00010100101",    # "00000101" +K05.0- [773]
        "00010100110",    # "00000110" +K06.0- [774]
        "00010111000",    # "00000111" +K07.0- [775]
        "11101011000",    # "00001000" +K08.0+ [776]
        "00010101001",    # "00001001" +K09.0- [777]
        "00010101010",    # "00001010" +K10.0- [778]
        "00010001011",    # "00001011" +K11.0- [779]
        "00010101100",    # "00001100" +K12.0- [780]
        "00010001101",    # "00001101" +K13.0- [781]
        "00010001110",    # "00001110" +K14.0- [782]
        "11101000101",    # "00001111" +K15.0+ [783]
        "11101001001",    # "00010000" +K16.0+ [784]
        "00010110001",    # "00010001" +K17.0- [785]
        "00010110010",    # "00010010" +K18.0- [786]
        "00010010011",    # "00010011" +K19.0- [787]
        "00010110100",    # "00010100" +K20.0- [788]
        "00010010101",    # "00010101" +K21.0- [789]
        "00010010110",    # "00010110" +K22.0- [790]
        "11101101000",    # "00010111" +K23.0+ [791]
        "11101001100",    # "00011000" +K24.0+ [792]
        "00010011001",    # "00011001" +K25.0- [793]
        "00010011010",    # "00011010" +K26.0- [794]
        "11101100100",    # "00011011" +K27.0+ [795]
        "11101000011",    # "00011100" +K28.0+ [796]
        "11101100010",    # "00011101" +K29.0+ [797]
        "11101100001",    # "00011110" +K30.0+ [798]
        "11101001010",    # "00011111" +K31.0+ [799]
        "00110000110",    # "00100000" +K00.1- [800]
        "00110010001",    # "00100001" +K01.1- [801]
        "00110010010",    # "00100010" +K02.1- [802]
        "11001100011",    # "00100011" +K03.1+ [803]
        "00110010100",    # "00100100" +K04.1- [804]
        "11001100101",    # "00100101" +K05.1+ [805]
        "11001100110",    # "00100110" +K06.1+ [806]
        "11001111000",    # "00100111" +K07.1+ [807]
        "00110011000",    # "00101000" +K08.1- [808]
        "11001101001",    # "00101001" +K09.1+ [809]
        "11001101010",    # "00101010" +K10.1+ [810]
        "11001001011",    # "00101011" +K11.1+ [811]
        "11001101100",    # "00101100" +K12.1+ [812]
        "11001001101",    # "00101101" +K13.1+ [813]
        "11001001110",    # "00101110" +K14.1+ [814]
        "00110000101",    # "00101111" +K15.1- [815]
        "00110001001",    # "00110000" +K16.1- [816]
        "11001110001",    # "00110001" +K17.1+ [817]
        "11001110010",    # "00110010" +K18.1+ [818]
        "11001010011",    # "00110011" +K19.1+ [819]
        "11001110100",    # "00110100" +K20.1+ [820]
        "11001010101",    # "00110101" +K21.1+ [821]
        "11001010110",    # "00110110" +K22.1+ [822]
        "00110101000",    # "00110111" +K23.1- [823]
        "00110001100",    # "00111000" +K24.1- [824]
        "11001011001",    # "00111001" +K25.1+ [825]
        "11001011010",    # "00111010" +K26.1+ [826]
        "00110100100",    # "00111011" +K27.1- [827]
        "00110000011",    # "00111100" +K28.1- [828]
        "00110100010",    # "00111101" +K29.1- [829]
        "00110100001",    # "00111110" +K30.1- [830]
        "00110001010",    # "00111111" +K31.1- [831]
        "00101000110",    # "01000000" +K00.2- [832]
        "00101010001",    # "01000001" +K01.2- [833]
        "00101010010",    # "01000010" +K02.2- [834]
        "11010100011",    # "01000011" +K03.2+ [835]
        "00101010100",    # "01000100" +K04.2- [836]
        "11010100101",    # "01000101" +K05.2+ [837]
        "11010100110",    # "01000110" +K06.2+ [838]
        "11010111000",    # "01000111" +K07.2+ [839]
        "00101011000",    # "01001000" +K08.2- [840]
        "11010101001",    # "01001001" +K09.2+ [841]
        "11010101010",    # "01001010" +K10.2+ [842]
        "11010001011",    # "01001011" +K11.2+ [843]
        "11010101100",    # "01001100" +K12.2+ [844]
        "11010001101",    # "01001101" +K13.2+ [845]
        "11010001110",    # "01001110" +K14.2+ [846]
        "00101000101",    # "01001111" +K15.2- [847]
        "00101001001",    # "01010000" +K16.2- [848]
        "11010110001",    # "01010001" +K17.2+ [849]
        "11010110010",    # "01010010" +K18.2+ [850]
        "11010010011",    # "01010011" +K19.2+ [851]
        "11010110100",    # "01010100" +K20.2+ [852]
        "11010010101",    # "01010101" +K21.2+ [853]
        "11010010110",    # "01010110" +K22.2+ [854]
        "00101101000",    # "01010111" +K23.2- [855]
        "00101001100",    # "01011000" +K24.2- [856]
        "11010011001",    # "01011001" +K25.2+ [857]
        "11010011010",    # "01011010" +K26.2+ [858]
        "00101100100",    # "01011011" +K27.2- [859]
        "00101000011",    # "01011100" +K28.2- [860]
        "00101100010",    # "01011101" +K29.2- [861]
        "00101100001",    # "01011110" +K30.2- [862]
        "00101001010",    # "01011111" +K31.2- [863]
        "00011000110",    # "01100000" +K00.3- [864]
        "00011010001",    # "01100001" +K01.3- [865]
        "00011010010",    # "01100010" +K02.3- [866]
        "11100100011",    # "01100011" +K03.3+ [867]
        "00011010100",    # "01100100" +K04.3- [868]
        "11100100101",    # "01100101" +K05.3+ [869]
        "11100100110",    # "01100110" +K06.3+ [870]
        "11100111000",    # "01100111" +K07.3+ [871]
        "00011011000",    # "01101000" +K08.3- [872]
        "11100101001",    # "01101001" +K09.3+ [873]
        "11100101010",    # "01101010" +K10.3+ [874]
        "11100001011",    # "01101011" +K11.3+ [875]
        "11100101100",    # "01101100" +K12.3+ [876]
        "11100001101",    # "01101101" +K13.3+ [877]
        "11100001110",    # "01101110" +K14.3+ [878]
        "00011000101",    # "01101111" +K15.3- [879]
        "00011001001",    # "01110000" +K16.3- [880]
        "11100110001",    # "01110001" +K17.3+ [881]
        "11100110010",    # "01110010" +K18.3+ [882]
        "11100010011",    # "01110011" +K19.3+ [883]
        "11100110100",    # "01110100" +K20.3+ [884]
        "11100010101",    # "01110101" +K21.3+ [885]
        "11100010110",    # "01110110" +K22.3+ [886]
        "00011101000",    # "01110111" +K23.3- [887]
        "00011001100",    # "01111000" +K24.3- [888]
        "11100011001",    # "01111001" +K25.3+ [889]
        "11100011010",    # "01111010" +K26.3+ [890]
        "00011100100",    # "01111011" +K27.3- [891]
        "00011000011",    # "01111100" +K28.3- [892]
        "00011100010",    # "01111101" +K29.3- [893]
        "00011100001",    # "01111110" +K30.3- [894]
        "00011001010",    # "01111111" +K31.3- [895]
        "11011000110",    # "10000000" +K00.4+ [896]
        "11011010001",    # "10000001" +K01.4+ [897]
        "11011010010",    # "10000010" +K02.4+ [898]
        "00100100011",    # "10000011" +K03.4- [899]
        "11011010100",    # "10000100" +K04.4+ [900]
        "00100100101",    # "10000101" +K05.4- [901]
        "00100100110",    # "10000110" +K06.4- [902]
        "00100111000",    # "10000111" +K07.4- [903]
        "11011011000",    # "10001000" +K08.4+ [904]
        "00100101001",    # "10001001" +K09.4- [905]
        "00100101010",    # "10001010" +K10.4- [906]
        "00100001011",    # "10001011" +K11.4- [907]
        "00100101100",    # "10001100" +K12.4- [908]
        "00100001101",    # "10001101" +K13.4- [909]
        "00100001110",    # "10001110" +K14.4- [910]
        "11011000101",    # "10001111" +K15.4+ [911]
        "11011001001",    # "10010000" +K16.4+ [912]
        "00100110001",    # "10010001" +K17.4- [913]
        "00100110010",    # "10010010" +K18.4- [914]
        "00100010011",    # "10010011" +K19.4- [915]
        "00100110100",    # "10010100" +K20.4- [916]
        "00100010101",    # "10010101" +K21.4- [917]
        "00100010110",    # "10010110" +K22.4- [918]
        "11011101000",    # "10010111" +K23.4+ [919]
        "11011001100",    # "10011000" +K24.4+ [920]
        "00100011001",    # "10011001" +K25.4- [921]
        "00100011010",    # "10011010" +K26.4- [922]
        "11011100100",    # "10011011" +K27.4+ [923]
        "11011000011",    # "10011100" +K28.4+ [924]
        "11011100010",    # "10011101" +K29.4+ [925]
        "11011100001",    # "10011110" +K30.4+ [926]
        "11011001010",    # "10011111" +K31.4+ [927]
        "01010000110",    # "10100000" +K00.5- [928]
        "01010010001",    # "10100001" +K01.5- [929]
        "01010010010",    # "10100010" +K02.5- [930]
        "10101100011",    # "10100011" +K03.5+ [931]
        "01010010100",    # "10100100" +K04.5- [932]
        "10101100101",    # "10100101" +K05.5+ [933]
        "10101100110",    # "10100110" +K06.5+ [934]
        "10101111000",    # "10100111" +K07.5+ [935]
        "01010011000",    # "10101000" +K08.5- [936]
        "10101101001",    # "10101001" +K09.5+ [937]
        "10101101010",    # "10101010" +K10.5+ [938]
        "10101001011",    # "10101011" +K11.5+ [939]
        "10101101100",    # "10101100" +K12.5+ [940]
        "10101001101",    # "10101101" +K13.5+ [941]
        "10101001110",    # "10101110" +K14.5+ [942]
        "01010000101",    # "10101111" +K15.5- [943]
        "01010001001",    # "10110000" +K16.5- [944]
        "10101110001",    # "10110001" +K17.5+ [945]
        "10101110010",    # "10110010" +K18.5+ [946]
        "10101010011",    # "10110011" +K19.5+ [947]
        "10101110100",    # "10110100" +K20.5+ [948]
        "10101010101",    # "10110101" +K21.5+ [949]
        "10101010110",    # "10110110" +K22.5+ [950]
        "01010101000",    # "10110111" +K23.5- [951]
        "01010001100",    # "10111000" +K24.5- [952]
        "10101011001",    # "10111001" +K25.5+ [953]
        "10101011010",    # "10111010" +K26.5+ [954]
        "01010100100",    # "10111011" +K27.5- [955]
        "01010000011",    # "10111100" +K28.5- [956]
        "01010100010",    # "10111101" +K29.5- [957]
        "01010100001",    # "10111110" +K30.5- [958]
        "01010001010",    # "10111111" +K31.5- [959]
        "01001000110",    # "11000000" +K00.6- [960]
        "01001010001",    # "11000001" +K01.6- [961]
        "01001010010",    # "11000010" +K02.6- [962]
        "10110100011",    # "11000011" +K03.6+ [963]
        "01001010100",    # "11000100" +K04.6- [964]
        "10110100101",    # "11000101" +K05.6+ [965]
        "10110100110",    # "11000110" +K06.6+ [966]
        "10110111000",    # "11000111" +K07.6+ [967]
        "01001011000",    # "11001000" +K08.6- [968]
        "10110101001",    # "11001001" +K09.6+ [969]
        "10110101010",    # "11001010" +K10.6+ [970]
        "10110001011",    # "11001011" +K11.6+ [971]
        "10110101100",    # "11001100" +K12.6+ [972]
        "10110001101",    # "11001101" +K13.6+ [973]
        "10110001110",    # "11001110" +K14.6+ [974]
        "01001000101",    # "11001111" +K15.6- [975]
        "01001001001",    # "11010000" +K16.6- [976]
        "10110110001",    # "11010001" +K17.6+ [977]
        "10110110010",    # "11010010" +K18.6+ [978]
        "10110010011",    # "11010011" +K19.6+ [979]
        "10110110100",    # "11010100" +K20.6+ [980]
        "10110010101",    # "11010101" +K21.6+ [981]
        "10110010110",    # "11010110" +K22.6+ [982]
        "01001101000",    # "11010111" +K23.6- [983]
        "01001001100",    # "11011000" +K24.6- [984]
        "10110011001",    # "11011001" +K25.6+ [985]
        "10110011010",    # "11011010" +K26.6+ [986]
        "01001100100",    # "11011011" +K27.6- [987]
        "01001000011",    # "11011100" +K28.6- [988]
        "01001100010",    # "11011101" +K29.6- [989]
        "01001100001",    # "11011110" +K30.6- [990]
        "01001001010",    # "11011111" +K31.6- [991]
        "11110000110",    # "11100000" +K00.7+ [992]
        "11110010001",    # "11100001" +K01.7+ [993]
        "11110010010",    # "11100010" +K02.7+ [994]
        "00001100011",    # "11100011" +K03.7- [995]
        "11110010100",    # "11100100" +K04.7+ [996]
        "00001100101",    # "11100101" +K05.7- [997]
        "00001100110",    # "11100110" +K06.7- [998]
        "00001111000",    # "11100111" +K07.7- [999]
        "11110011000",    # "11101000" +K08.7+ [1000]
        "00001101001",    # "11101001" +K09.7- [1001]
        "00001101010",    # "11101010" +K10.7- [1002]
        "00001001011",    # "11101011" +K11.7- [1003]
        "00001101100",    # "11101100" +K12.7- [1004]
        "00001001101",    # "11101101" +K13.7- [1005]
        "00001001110",    # "11101110" +K14.7- [1006]
        "11110000101",    # "11101111" +K15.7+ [1007]
        "11110001001",    # "11110000" +K16.7+ [1008]
        "00001110001",    # "11110001" +K17.7- [1009]
        "00001110010",    # "11110010" +K18.7- [1010]
        "00001010011",    # "11110011" +K19.7- [1011]
        "00001110100",    # "11110100" +K20.7- [1012]
        "00001010101",    # "11110101" +K21.7- [1013]
        "00001010110",    # "11110110" +K22.7- [1014]
        "11110101000",    # "11110111" +K23.7+ [1015]
        "11110001100",    # "11111000" +K24.7+ [1016]
        "00001011001",    # "11111001" +K25.7- [1017]
        "00001011010",    # "11111010" +K26.7- [1018]
        "11110100100",    # "11111011" +K27.7+ [1019]
        "11110000011",    # "11111100" +K28.7+ [1020]
        "11110100010",    # "11111101" +K29.7+ [1021]
        "11110100001",    # "11111110" +K30.7+ [1022]
        "11110001010"      # "11111111" +K31.7+ [1023]
    ]

    dec_lookup = [
        "DEC8b10bERR",  # "0000000000"
        "DEC8b10bERR",  # "0000000001"
        "DEC8b10bERR",  # "0000000010"
        "DEC8b10bERR",  # "0000000011"
        "DEC8b10bERR",  # "0000000100"
        "DEC8b10bERR",  # "0000000101"
        "DEC8b10bERR",  # "0000000110"
        "DEC8b10bERR",  # "0000000111"
        "DEC8b10bERR",  # "0000001000"
        "DEC8b10bERR",  # "0000001001"
        "DEC8b10bERR",  # "0000001010"
        "DEC8b10bERR",  # "0000001011"
        "DEC8b10bERR",  # "0000001100"
        "DEC8b10bERR",  # "0000001101"
        "DEC8b10bERR",  # "0000001110"
        "DEC8b10bERR",  # "0000001111"
        "DEC8b10bERR",  # "0000010000"
        "DEC8b10bERR",  # "0000010001"
        "DEC8b10bERR",  # "0000010010"
        "DEC8b10bERR",  # "0000010011"
        "DEC8b10bERR",  # "0000010100"
        "DEC8b10bERR",  # "0000010101"
        "DEC8b10bERR",  # "0000010110"
        "DEC8b10bERR",  # "0000010111"
        "DEC8b10bERR",  # "0000011000"
        "DEC8b10bERR",  # "0000011001"
        "DEC8b10bERR",  # "0000011010"
        "DEC8b10bERR",  # "0000011011"
        "DEC8b10bERR",  # "0000011100"
        "DEC8b10bERR",  # "0000011101"
        "DEC8b10bERR",  # "0000011110"
        "DEC8b10bERR",  # "0000011111"
        "DEC8b10bERR",  # "0000100000"
        "DEC8b10bERR",  # "0000100001"
        "DEC8b10bERR",  # "0000100010"
        "DEC8b10bERR",  # "0000100011"
        "DEC8b10bERR",  # "0000100100"
        "DEC8b10bERR",  # "0000100101"
        "DEC8b10bERR",  # "0000100110"
        "DEC8b10bERR",  # "0000100111"
        "DEC8b10bERR",  # "0000101000"
        "DEC8b10bERR",  # "0000101001"
        "DEC8b10bERR",  # "0000101010"
        "DEC8b10bERR",  # "0000101011"
        "DEC8b10bERR",  # "0000101100"
        "DEC8b10bERR",  # "0000101101"
        "DEC8b10bERR",  # "0000101110"
        "DEC8b10bERR",  # "0000101111"
        "DEC8b10bERR",  # "0000110000"
        "DEC8b10bERR",  # "0000110001"
        "DEC8b10bERR",  # "0000110010"
        "DEC8b10bERR",  # "0000110011"
        "DEC8b10bERR",  # "0000110100"
        "DEC8b10bERR",  # "0000110101"
        "DEC8b10bERR",  # "0000110110"
        "DEC8b10bERR",  # "0000110111"
        "DEC8b10bERR",  # "0000111000"
        "DEC8b10bERR",  # "0000111001"
        "DEC8b10bERR",  # "0000111010"
        "DEC8b10bERR",  # "0000111011"
        "DEC8b10bERR",  # "0000111100"
        "DEC8b10bERR",  # "0000111101"
        "DEC8b10bERR",  # "0000111110"
        "DEC8b10bERR",  # "0000111111"
        "DEC8b10bERR",  # "0001000000"
        "DEC8b10bERR",  # "0001000001"
        "DEC8b10bERR",  # "0001000010"
        "DEC8b10bERR",  # "0001000011"
        "DEC8b10bERR",  # "0001000100"
        "DEC8b10bERR",  # "0001000101"
        "DEC8b10bERR",  # "0001000110"
        "DEC8b10bERR",  # "0001000111"
        "DEC8b10bERR",  # "0001001000"
        "DEC8b10bERR",  # "0001001001"
        "DEC8b10bERR",  # "0001001010"
        "011101011",    # "0001001011", -D11.7+, [1,1]
        "DEC8b10bERR",  # "0001001100"
        "011101101",    # "0001001101", -D13.7+, [2,2]
        "011101110",    # "0001001110", -D14.7+, [3,3]
        "DEC8b10bERR",  # "0001001111"
        "DEC8b10bERR",  # "0001010000"
        "DEC8b10bERR",  # "0001010001"
        "DEC8b10bERR",  # "0001010010"
        "111110011",    # "0001010011", -K19.7+, [4,1]
        "DEC8b10bERR",  # "0001010100"
        "111110101",    # "0001010101", -K21.7+, [5,2]
        "111110110",    # "0001010110", -K22.7+, [6,3]
        "111110111",    # "0001010111", +K23.7+, [7,4]
        "DEC8b10bERR",  # "0001011000"
        "111111001",    # "0001011001", -K25.7+, [8,5]
        "111111010",    # "0001011010", -K26.7+, [9,6]
        "111111011",    # "0001011011", +K27.7+, [10,7]
        "DEC8b10bERR",  # "0001011100"
        "111111101",    # "0001011101", +K29.7+, [11,8]
        "111111110",    # "0001011110", +K30.7+, [12,9]
        "DEC8b10bERR",  # "0001011111"
        "DEC8b10bERR",  # "0001100000"
        "DEC8b10bERR",  # "0001100001"
        "DEC8b10bERR",  # "0001100010"
        "111100011",    # "0001100011", -K3.7+, [13,10]
        "DEC8b10bERR",  # "0001100100"
        "111100101",    # "0001100101", -K5.7+, [14,11]
        "111100110",    # "0001100110", -K6.7+, [15,12]
        "111101000",    # "0001100111", +K8.7+, [16,13]
        "DEC8b10bERR",  # "0001101000"
        "111101001",    # "0001101001", -K9.7+, [17,14]
        "111101010",    # "0001101010", -K10.7+, [18,15]
        "111100100",    # "0001101011", +K4.7+, [19,16]
        "111101100",    # "0001101100", -K12.7+, [20,17]
        "111100010",    # "0001101101", +K2.7+, [21,18]
        "111100001",    # "0001101110", +K1.7+, [22,19]
        "DEC8b10bERR",  # "0001101111"
        "DEC8b10bERR",  # "0001110000"
        "111110001",    # "0001110001", -K17.7+, [23,20]
        "111110010",    # "0001110010", -K18.7+, [24,21]
        "111111000",    # "0001110011", +K24.7+, [25,22]
        "111110100",    # "0001110100", -K20.7+, [26,23]
        "111111111",    # "0001110101", +K31.7+, [27,24]
        "111110000",    # "0001110110", +K16.7+, [28,25]
        "DEC8b10bERR",  # "0001110111"
        "111100111",    # "0001111000", -K7.7+, [29,26]
        "111100000",    # "0001111001", +K0.7+, [30,27]
        "111101111",    # "0001111010", +K15.7+, [31,28]
        "DEC8b10bERR",  # "0001111011"
        "111111100",    # "0001111100", +K28.7+, [32,29]
        "DEC8b10bERR",  # "0001111101"
        "DEC8b10bERR",  # "0001111110"
        "DEC8b10bERR",  # "0001111111"
        "DEC8b10bERR",  # "0010000000"
        "DEC8b10bERR",  # "0010000001"
        "DEC8b10bERR",  # "0010000010"
        "DEC8b10bERR",  # "0010000011"
        "DEC8b10bERR",  # "0010000100"
        "DEC8b10bERR",  # "0010000101"
        "DEC8b10bERR",  # "0010000110"
        "DEC8b10bERR",  # "0010000111"
        "DEC8b10bERR",  # "0010001000"
        "DEC8b10bERR",  # "0010001001"
        "DEC8b10bERR",  # "0010001010"
        "000001011",    # "0010001011", -D11.0+, [33,4]
        "DEC8b10bERR",  # "0010001100"
        "000001101",    # "0010001101", -D13.0+, [34,5]
        "000001110",    # "0010001110", -D14.0+, [35,6]
        "DEC8b10bERR",  # "0010001111"
        "DEC8b10bERR",  # "0010010000"
        "DEC8b10bERR",  # "0010010001"
        "DEC8b10bERR",  # "0010010010"
        "000010011",    # "0010010011", -D19.0+, [36,7]
        "DEC8b10bERR",  # "0010010100"
        "000010101",    # "0010010101", -D21.0+, [37,8]
        "000010110",    # "0010010110", -D22.0+, [38,9]
        "000010111",    # "0010010111", +D23.0+, [39,10]
        "DEC8b10bERR",  # "0010011000"
        "000011001",    # "0010011001", -D25.0+, [40,11]
        "000011010",    # "0010011010", -D26.0+, [41,12]
        "000011011",    # "0010011011", +D27.0+, [42,13]
        "000011100",    # "0010011100", -D28.0+, [43,14]
        "000011101",    # "0010011101", +D29.0+, [44,15]
        "000011110",    # "0010011110", +D30.0+, [45,16]
        "DEC8b10bERR",  # "0010011111"
        "DEC8b10bERR",  # "0010100000"
        "DEC8b10bERR",  # "0010100001"
        "DEC8b10bERR",  # "0010100010"
        "000000011",    # "0010100011", -D3.0+, [46,17]
        "DEC8b10bERR",  # "0010100100"
        "000000101",    # "0010100101", -D5.0+, [47,18]
        "000000110",    # "0010100110", -D6.0+, [48,19]
        "000001000",    # "0010100111", +D8.0+, [49,20]
        "DEC8b10bERR",  # "0010101000"
        "000001001",    # "0010101001", -D9.0+, [50,21]
        "000001010",    # "0010101010", -D10.0+, [51,22]
        "000000100",    # "0010101011", +D4.0+, [52,23]
        "000001100",    # "0010101100", -D12.0+, [53,24]
        "000000010",    # "0010101101", +D2.0+, [54,25]
        "000000001",    # "0010101110", +D1.0+, [55,26]
        "DEC8b10bERR",  # "0010101111"
        "DEC8b10bERR",  # "0010110000"
        "000010001",    # "0010110001", -D17.0+, [56,27]
        "000010010",    # "0010110010", -D18.0+, [57,28]
        "000011000",    # "0010110011", +D24.0+, [58,29]
        "000010100",    # "0010110100", -D20.0+, [59,30]
        "000011111",    # "0010110101", +D31.0+, [60,31]
        "000010000",    # "0010110110", +D16.0+, [61,32]
        "DEC8b10bERR",  # "0010110111"
        "000000111",    # "0010111000", -D7.0+, [62,33]
        "000000000",    # "0010111001", +D0.0+, [63,34]
        "000001111",    # "0010111010", +D15.0+, [64,35]
        "DEC8b10bERR",  # "0010111011"
        "100011100",    # "0010111100", +K28.0+, [65,30]
        "DEC8b10bERR",  # "0010111101"
        "DEC8b10bERR",  # "0010111110"
        "DEC8b10bERR",  # "0010111111"
        "DEC8b10bERR",  # "0011000000"
        "DEC8b10bERR",  # "0011000001"
        "DEC8b10bERR",  # "0011000010"
        "101111100",    # "0011000011", -K28.3+, [66,31]
        "DEC8b10bERR",  # "0011000100"
        "001101111",    # "0011000101", -D15.3+, [67,36]
        "001100000",    # "0011000110", -D0.3+, [68,37]
        "001100111",    # "0011000111", +D7.3+, [69,38]
        "DEC8b10bERR",  # "0011001000"
        "001110000",    # "0011001001", -D16.3+, [70,39]
        "001111111",    # "0011001010", -D31.3+, [71,40]
        "001101011",    # "0011001011", +D11.3+, [72,41]
        "001111000",    # "0011001100", -D24.3+, [73,42]
        "001101101",    # "0011001101", +D13.3+, [74,43]
        "001101110",    # "0011001110", +D14.3+, [75,44]
        "DEC8b10bERR",  # "0011001111"
        "DEC8b10bERR",  # "0011010000"
        "001100001",    # "0011010001", -D1.3+, [76,45]
        "001100010",    # "0011010010", -D2.3+, [77,46]
        "001110011",    # "0011010011", +D19.3+, [78,47]
        "001100100",    # "0011010100", -D4.3+, [79,48]
        "001110101",    # "0011010101", +D21.3+, [80,49]
        "001110110",    # "0011010110", +D22.3+, [81,50]
        "DEC8b10bERR",  # "0011010111"
        "001101000",    # "0011011000", -D8.3+, [82,51]
        "001111001",    # "0011011001", +D25.3+, [83,52]
        "001111010",    # "0011011010", +D26.3+, [84,53]
        "DEC8b10bERR",  # "0011011011"
        "001111100",    # "0011011100", +D28.3+, [85,54]
        "DEC8b10bERR",  # "0011011101"
        "DEC8b10bERR",  # "0011011110"
        "DEC8b10bERR",  # "0011011111"
        "DEC8b10bERR",  # "0011100000"
        "001111110",    # "0011100001", -D30.3+, [86,55]
        "001111101",    # "0011100010", -D29.3+, [87,56]
        "001100011",    # "0011100011", +D3.3+, [88,57]
        "001111011",    # "0011100100", -D27.3+, [89,58]
        "001100101",    # "0011100101", +D5.3+, [90,59]
        "001100110",    # "0011100110", +D6.3+, [91,60]
        "DEC8b10bERR",  # "0011100111"
        "001110111",    # "0011101000", -D23.3+, [92,61]
        "001101001",    # "0011101001", +D9.3+, [93,62]
        "001101010",    # "0011101010", +D10.3+, [94,63]
        "DEC8b10bERR",  # "0011101011"
        "001101100",    # "0011101100", +D12.3+, [95,64]
        "DEC8b10bERR",  # "0011101101"
        "DEC8b10bERR",  # "0011101110"
        "DEC8b10bERR",  # "0011101111"
        "DEC8b10bERR",  # "0011110000"
        "001110001",    # "0011110001", +D17.3+, [96,65]
        "001110010",    # "0011110010", +D18.3+, [97,66]
        "DEC8b10bERR",  # "0011110011"
        "001110100",    # "0011110100", +D20.3+, [98,67]
        "DEC8b10bERR",  # "0011110101"
        "DEC8b10bERR",  # "0011110110"
        "DEC8b10bERR",  # "0011110111"
        "DEC8b10bERR",  # "0011111000"
        "DEC8b10bERR",  # "0011111001"
        "DEC8b10bERR",  # "0011111010"
        "DEC8b10bERR",  # "0011111011"
        "DEC8b10bERR",  # "0011111100"
        "DEC8b10bERR",  # "0011111101"
        "DEC8b10bERR",  # "0011111110"
        "DEC8b10bERR",  # "0011111111"
        "DEC8b10bERR",  # "0100000000"
        "DEC8b10bERR",  # "0100000001"
        "DEC8b10bERR",  # "0100000010"
        "DEC8b10bERR",  # "0100000011"
        "DEC8b10bERR",  # "0100000100"
        "DEC8b10bERR",  # "0100000101"
        "DEC8b10bERR",  # "0100000110"
        "DEC8b10bERR",  # "0100000111"
        "DEC8b10bERR",  # "0100001000"
        "DEC8b10bERR",  # "0100001001"
        "DEC8b10bERR",  # "0100001010"
        "010001011",    # "0100001011", -D11.4+, [99,68]
        "DEC8b10bERR",  # "0100001100"
        "010001101",    # "0100001101", -D13.4+, [100,69]
        "010001110",    # "0100001110", -D14.4+, [101,70]
        "DEC8b10bERR",  # "0100001111"
        "DEC8b10bERR",  # "0100010000"
        "DEC8b10bERR",  # "0100010001"
        "DEC8b10bERR",  # "0100010010"
        "010010011",    # "0100010011", -D19.4+, [102,71]
        "DEC8b10bERR",  # "0100010100"
        "010010101",    # "0100010101", -D21.4+, [103,72]
        "010010110",    # "0100010110", -D22.4+, [104,73]
        "010010111",    # "0100010111", +D23.4+, [105,74]
        "DEC8b10bERR",  # "0100011000"
        "010011001",    # "0100011001", -D25.4+, [106,75]
        "010011010",    # "0100011010", -D26.4+, [107,76]
        "010011011",    # "0100011011", +D27.4+, [108,77]
        "010011100",    # "0100011100", -D28.4+, [109,78]
        "010011101",    # "0100011101", +D29.4+, [110,79]
        "010011110",    # "0100011110", +D30.4+, [111,80]
        "DEC8b10bERR",  # "0100011111"
        "DEC8b10bERR",  # "0100100000"
        "DEC8b10bERR",  # "0100100001"
        "DEC8b10bERR",  # "0100100010"
        "010000011",    # "0100100011", -D3.4+, [112,81]
        "DEC8b10bERR",  # "0100100100"
        "010000101",    # "0100100101", -D5.4+, [113,82]
        "010000110",    # "0100100110", -D6.4+, [114,83]
        "010001000",    # "0100100111", +D8.4+, [115,84]
        "DEC8b10bERR",  # "0100101000"
        "010001001",    # "0100101001", -D9.4+, [116,85]
        "010001010",    # "0100101010", -D10.4+, [117,86]
        "010000100",    # "0100101011", +D4.4+, [118,87]
        "010001100",    # "0100101100", -D12.4+, [119,88]
        "010000010",    # "0100101101", +D2.4+, [120,89]
        "010000001",    # "0100101110", +D1.4+, [121,90]
        "DEC8b10bERR",  # "0100101111"
        "DEC8b10bERR",  # "0100110000"
        "010010001",    # "0100110001", -D17.4+, [122,91]
        "010010010",    # "0100110010", -D18.4+, [123,92]
        "010011000",    # "0100110011", +D24.4+, [124,93]
        "010010100",    # "0100110100", -D20.4+, [125,94]
        "010011111",    # "0100110101", +D31.4+, [126,95]
        "010010000",    # "0100110110", +D16.4+, [127,96]
        "DEC8b10bERR",  # "0100110111"
        "010000111",    # "0100111000", -D7.4+, [128,97]
        "010000000",    # "0100111001", +D0.4+, [129,98]
        "010001111",    # "0100111010", +D15.4+, [130,99]
        "DEC8b10bERR",  # "0100111011"
        "110011100",    # "0100111100", +K28.4+, [131,32]
        "DEC8b10bERR",  # "0100111101"
        "DEC8b10bERR",  # "0100111110"
        "DEC8b10bERR",  # "0100111111"
        "DEC8b10bERR",  # "0101000000"
        "DEC8b10bERR",  # "0101000001"
        "DEC8b10bERR",  # "0101000010"
        "101011100",    # "0101000011", -K28.2+, [132,33]
        "DEC8b10bERR",  # "0101000100"
        "010101111",    # "0101000101", -D15.5+, [133,100]
        "010100000",    # "0101000110", -D0.5+, [134,101]
        "010100111",    # "0101000111", +D7.5+, [135,102]
        "DEC8b10bERR",  # "0101001000"
        "010110000",    # "0101001001", -D16.5+, [136,103]
        "010111111",    # "0101001010", -D31.5+, [137,104]
        "010101011",    # "0101001011", +D11.5+, [138,105]
        "010111000",    # "0101001100", -D24.5+, [139,106]
        "010101101",    # "0101001101", +D13.5+, [140,107]
        "010101110",    # "0101001110", +D14.5+, [141,108]
        "DEC8b10bERR",  # "0101001111"
        "DEC8b10bERR",  # "0101010000"
        "010100001",    # "0101010001", -D1.5+, [142,109]
        "010100010",    # "0101010010", -D2.5+, [143,110]
        "010110011",    # "0101010011", +D19.5+, [144,111]
        "010100100",    # "0101010100", -D4.5+, [145,112]
        "010110101",    # "0101010101", +D21.5+, [146,113]
        "010110110",    # "0101010110", +D22.5+, [147,114]
        "010110111",    # "0101010111", +D23.5-, [148,115]
        "010101000",    # "0101011000", -D8.5+, [149,116]
        "010111001",    # "0101011001", +D25.5+, [150,117]
        "010111010",    # "0101011010", +D26.5+, [151,118]
        "010111011",    # "0101011011", +D27.5-, [152,119]
        "010111100",    # "0101011100", +D28.5+, [153,120]
        "010111101",    # "0101011101", +D29.5-, [154,121]
        "010111110",    # "0101011110", +D30.5-, [155,122]
        "DEC8b10bERR",  # "0101011111"
        "DEC8b10bERR",  # "0101100000"
        "010111110",    # "0101100001", -D30.5+, [156,123]
        "010111101",    # "0101100010", -D29.5+, [157,124]
        "010100011",    # "0101100011", +D3.5+, [158,125]
        "010111011",    # "0101100100", -D27.5+, [159,126]
        "010100101",    # "0101100101", +D5.5+, [160,127]
        "010100110",    # "0101100110", +D6.5+, [161,128]
        "010101000",    # "0101100111", +D8.5-, [162,129]
        "010110111",    # "0101101000", -D23.5+, [163,130]
        "010101001",    # "0101101001", +D9.5+, [164,131]
        "010101010",    # "0101101010", +D10.5+, [165,132]
        "010100100",    # "0101101011", +D4.5-, [166,133]
        "010101100",    # "0101101100", +D12.5+, [167,134]
        "010100010",    # "0101101101", +D2.5-, [168,135]
        "010100001",    # "0101101110", +D1.5-, [169,136]
        "DEC8b10bERR",  # "0101101111"
        "DEC8b10bERR",  # "0101110000"
        "010110001",    # "0101110001", +D17.5+, [170,137]
        "010110010",    # "0101110010", +D18.5+, [171,138]
        "010111000",    # "0101110011", +D24.5-, [172,139]
        "010110100",    # "0101110100", +D20.5+, [173,140]
        "010111111",    # "0101110101", +D31.5-, [174,141]
        "010110000",    # "0101110110", +D16.5-, [175,142]
        "DEC8b10bERR",  # "0101110111"
        "010100111",    # "0101111000", -D7.5-, [176,143]
        "010100000",    # "0101111001", +D0.5-, [177,144]
        "010101111",    # "0101111010", +D15.5-, [178,145]
        "DEC8b10bERR",  # "0101111011"
        "110111100",    # "0101111100", +K28.5-, [179,34]
        "DEC8b10bERR",  # "0101111101"
        "DEC8b10bERR",  # "0101111110"
        "DEC8b10bERR",  # "0101111111"
        "DEC8b10bERR",  # "0110000000"
        "DEC8b10bERR",  # "0110000001"
        "DEC8b10bERR",  # "0110000010"
        "100111100",    # "0110000011", -K28.1+, [180,35]
        "DEC8b10bERR",  # "0110000100"
        "011001111",    # "0110000101", -D15.6+, [181,146]
        "011000000",    # "0110000110", -D0.6+, [182,147]
        "011000111",    # "0110000111", +D7.6+, [183,148]
        "DEC8b10bERR",  # "0110001000"
        "011010000",    # "0110001001", -D16.6+, [184,149]
        "011011111",    # "0110001010", -D31.6+, [185,150]
        "011001011",    # "0110001011", +D11.6+, [186,151]
        "011011000",    # "0110001100", -D24.6+, [187,152]
        "011001101",    # "0110001101", +D13.6+, [188,153]
        "011001110",    # "0110001110", +D14.6+, [189,154]
        "DEC8b10bERR",  # "0110001111"
        "DEC8b10bERR",  # "0110010000"
        "011000001",    # "0110010001", -D1.6+, [190,155]
        "011000010",    # "0110010010", -D2.6+, [191,156]
        "011010011",    # "0110010011", +D19.6+, [192,157]
        "011000100",    # "0110010100", -D4.6+, [193,158]
        "011010101",    # "0110010101", +D21.6+, [194,159]
        "011010110",    # "0110010110", +D22.6+, [195,160]
        "011010111",    # "0110010111", +D23.6-, [196,161]
        "011001000",    # "0110011000", -D8.6+, [197,162]
        "011011001",    # "0110011001", +D25.6+, [198,163]
        "011011010",    # "0110011010", +D26.6+, [199,164]
        "011011011",    # "0110011011", +D27.6-, [200,165]
        "011011100",    # "0110011100", +D28.6+, [201,166]
        "011011101",    # "0110011101", +D29.6-, [202,167]
        "011011110",    # "0110011110", +D30.6-, [203,168]
        "DEC8b10bERR",  # "0110011111"
        "DEC8b10bERR",  # "0110100000"
        "011011110",    # "0110100001", -D30.6+, [204,169]
        "011011101",    # "0110100010", -D29.6+, [205,170]
        "011000011",    # "0110100011", +D3.6+, [206,171]
        "011011011",    # "0110100100", -D27.6+, [207,172]
        "011000101",    # "0110100101", +D5.6+, [208,173]
        "011000110",    # "0110100110", +D6.6+, [209,174]
        "011001000",    # "0110100111", +D8.6-, [210,175]
        "011010111",    # "0110101000", -D23.6+, [211,176]
        "011001001",    # "0110101001", +D9.6+, [212,177]
        "011001010",    # "0110101010", +D10.6+, [213,178]
        "011000100",    # "0110101011", +D4.6-, [214,179]
        "011001100",    # "0110101100", +D12.6+, [215,180]
        "011000010",    # "0110101101", +D2.6-, [216,181]
        "011000001",    # "0110101110", +D1.6-, [217,182]
        "DEC8b10bERR",  # "0110101111"
        "DEC8b10bERR",  # "0110110000"
        "011010001",    # "0110110001", +D17.6+, [218,183]
        "011010010",    # "0110110010", +D18.6+, [219,184]
        "011011000",    # "0110110011", +D24.6-, [220,185]
        "011010100",    # "0110110100", +D20.6+, [221,186]
        "011011111",    # "0110110101", +D31.6-, [222,187]
        "011010000",    # "0110110110", +D16.6-, [223,188]
        "DEC8b10bERR",  # "0110110111"
        "011000111",    # "0110111000", -D7.6-, [224,189]
        "011000000",    # "0110111001", +D0.6-, [225,190]
        "011001111",    # "0110111010", +D15.6-, [226,191]
        "DEC8b10bERR",  # "0110111011"
        "111011100",    # "0110111100", +K28.6-, [227,36]
        "DEC8b10bERR",  # "0110111101"
        "DEC8b10bERR",  # "0110111110"
        "DEC8b10bERR",  # "0110111111"
        "DEC8b10bERR",  # "0111000000"
        "DEC8b10bERR",  # "0111000001"
        "DEC8b10bERR",  # "0111000010"
        "DEC8b10bERR",  # "0111000011"
        "DEC8b10bERR",  # "0111000100"
        "011101111",    # "0111000101", -D15.7-, [228,192]
        "011100000",    # "0111000110", -D0.7-, [229,193]
        "011100111",    # "0111000111", +D7.7-, [230,194]
        "DEC8b10bERR",  # "0111001000"
        "011110000",    # "0111001001", -D16.7-, [231,195]
        "011111111",    # "0111001010", -D31.7-, [232,196]
        "011101011",    # "0111001011", +D11.7-, [233,197]
        "011111000",    # "0111001100", -D24.7-, [234,198]
        "011101101",    # "0111001101", +D13.7-, [235,199]
        "011101110",    # "0111001110", +D14.7-, [236,200]
        "DEC8b10bERR",  # "0111001111"
        "DEC8b10bERR",  # "0111010000"
        "011100001",    # "0111010001", -D1.7-, [237,201]
        "011100010",    # "0111010010", -D2.7-, [238,202]
        "011110011",    # "0111010011", +D19.7-, [239,203]
        "011100100",    # "0111010100", -D4.7-, [240,204]
        "011110101",    # "0111010101", +D21.7-, [241,205]
        "011110110",    # "0111010110", +D22.7-, [242,206]
        "DEC8b10bERR",  # "0111010111"
        "011101000",    # "0111011000", -D8.7-, [243,207]
        "011111001",    # "0111011001", +D25.7-, [244,208]
        "011111010",    # "0111011010", +D26.7-, [245,209]
        "DEC8b10bERR",  # "0111011011"
        "011111100",    # "0111011100", +D28.7-, [246,210]
        "DEC8b10bERR",  # "0111011101"
        "DEC8b10bERR",  # "0111011110"
        "DEC8b10bERR",  # "0111011111"
        "DEC8b10bERR",  # "0111100000"
        "011111110",    # "0111100001", -D30.7-, [247,211]
        "011111101",    # "0111100010", -D29.7-, [248,212]
        "011100011",    # "0111100011", +D3.7-, [249,213]
        "011111011",    # "0111100100", -D27.7-, [250,214]
        "011100101",    # "0111100101", +D5.7-, [251,215]
        "011100110",    # "0111100110", +D6.7-, [252,216]
        "DEC8b10bERR",  # "0111100111"
        "011110111",    # "0111101000", -D23.7-, [253,217]
        "011101001",    # "0111101001", +D9.7-, [254,218]
        "011101010",    # "0111101010", +D10.7-, [255,219]
        "DEC8b10bERR",  # "0111101011"
        "011101100",    # "0111101100", +D12.7-, [256,220]
        "DEC8b10bERR",  # "0111101101"
        "DEC8b10bERR",  # "0111101110"
        "DEC8b10bERR",  # "0111101111"
        "DEC8b10bERR",  # "0111110000"
        "DEC8b10bERR",  # "0111110001"
        "DEC8b10bERR",  # "0111110010"
        "DEC8b10bERR",  # "0111110011"
        "DEC8b10bERR",  # "0111110100"
        "DEC8b10bERR",  # "0111110101"
        "DEC8b10bERR",  # "0111110110"
        "DEC8b10bERR",  # "0111110111"
        "DEC8b10bERR",  # "0111111000"
        "DEC8b10bERR",  # "0111111001"
        "DEC8b10bERR",  # "0111111010"
        "DEC8b10bERR",  # "0111111011"
        "DEC8b10bERR",  # "0111111100"
        "DEC8b10bERR",  # "0111111101"
        "DEC8b10bERR",  # "0111111110"
        "DEC8b10bERR",  # "0111111111"
        "DEC8b10bERR",  # "1000000000"
        "DEC8b10bERR",  # "1000000001"
        "DEC8b10bERR",  # "1000000010"
        "DEC8b10bERR",  # "1000000011"
        "DEC8b10bERR",  # "1000000100"
        "DEC8b10bERR",  # "1000000101"
        "DEC8b10bERR",  # "1000000110"
        "DEC8b10bERR",  # "1000000111"
        "DEC8b10bERR",  # "1000001000"
        "DEC8b10bERR",  # "1000001001"
        "DEC8b10bERR",  # "1000001010"
        "DEC8b10bERR",  # "1000001011"
        "DEC8b10bERR",  # "1000001100"
        "DEC8b10bERR",  # "1000001101"
        "DEC8b10bERR",  # "1000001110"
        "DEC8b10bERR",  # "1000001111"
        "DEC8b10bERR",  # "1000010000"
        "DEC8b10bERR",  # "1000010001"
        "DEC8b10bERR",  # "1000010010"
        "011110011",    # "1000010011", -D19.7+, [257,221]
        "DEC8b10bERR",  # "1000010100"
        "011110101",    # "1000010101", -D21.7+, [258,222]
        "011110110",    # "1000010110", -D22.7+, [259,223]
        "011110111",    # "1000010111", +D23.7+, [260,224]
        "DEC8b10bERR",  # "1000011000"
        "011111001",    # "1000011001", -D25.7+, [261,225]
        "011111010",    # "1000011010", -D26.7+, [262,226]
        "011111011",    # "1000011011", +D27.7+, [263,227]
        "011111100",    # "1000011100", -D28.7+, [264,228]
        "011111101",    # "1000011101", +D29.7+, [265,229]
        "011111110",    # "1000011110", +D30.7+, [266,230]
        "DEC8b10bERR",  # "1000011111"
        "DEC8b10bERR",  # "1000100000"
        "DEC8b10bERR",  # "1000100001"
        "DEC8b10bERR",  # "1000100010"
        "011100011",    # "1000100011", -D3.7+, [267,231]
        "DEC8b10bERR",  # "1000100100"
        "011100101",    # "1000100101", -D5.7+, [268,232]
        "011100110",    # "1000100110", -D6.7+, [269,233]
        "011101000",    # "1000100111", +D8.7+, [270,234]
        "DEC8b10bERR",  # "1000101000"
        "011101001",    # "1000101001", -D9.7+, [271,235]
        "011101010",    # "1000101010", -D10.7+, [272,236]
        "011100100",    # "1000101011", +D4.7+, [273,237]
        "011101100",    # "1000101100", -D12.7+, [274,238]
        "011100010",    # "1000101101", +D2.7+, [275,239]
        "011100001",    # "1000101110", +D1.7+, [276,240]
        "DEC8b10bERR",  # "1000101111"
        "DEC8b10bERR",  # "1000110000"
        "011110001",    # "1000110001", -D17.7+, [277,241]
        "011110010",    # "1000110010", -D18.7+, [278,242]
        "011111000",    # "1000110011", +D24.7+, [279,243]
        "011110100",    # "1000110100", -D20.7+, [280,244]
        "011111111",    # "1000110101", +D31.7+, [281,245]
        "011110000",    # "1000110110", +D16.7+, [282,246]
        "DEC8b10bERR",  # "1000110111"
        "011100111",    # "1000111000", -D7.7+, [283,247]
        "011100000",    # "1000111001", +D0.7+, [284,248]
        "011101111",    # "1000111010", +D15.7+, [285,249]
        "DEC8b10bERR",  # "1000111011"
        "DEC8b10bERR",  # "1000111100"
        "DEC8b10bERR",  # "1000111101"
        "DEC8b10bERR",  # "1000111110"
        "DEC8b10bERR",  # "1000111111"
        "DEC8b10bERR",  # "1001000000"
        "DEC8b10bERR",  # "1001000001"
        "DEC8b10bERR",  # "1001000010"
        "111011100",    # "1001000011", -K28.6+, [286,37]
        "DEC8b10bERR",  # "1001000100"
        "000101111",    # "1001000101", -D15.1+, [287,250]
        "000100000",    # "1001000110", -D0.1+, [288,251]
        "000100111",    # "1001000111", +D7.1+, [289,252]
        "DEC8b10bERR",  # "1001001000"
        "000110000",    # "1001001001", -D16.1+, [290,253]
        "000111111",    # "1001001010", -D31.1+, [291,254]
        "000101011",    # "1001001011", +D11.1+, [292,255]
        "000111000",    # "1001001100", -D24.1+, [293,256]
        "000101101",    # "1001001101", +D13.1+, [294,257]
        "000101110",    # "1001001110", +D14.1+, [295,258]
        "DEC8b10bERR",  # "1001001111"
        "DEC8b10bERR",  # "1001010000"
        "000100001",    # "1001010001", -D1.1+, [296,259]
        "000100010",    # "1001010010", -D2.1+, [297,260]
        "000110011",    # "1001010011", +D19.1+, [298,261]
        "000100100",    # "1001010100", -D4.1+, [299,262]
        "000110101",    # "1001010101", +D21.1+, [300,263]
        "000110110",    # "1001010110", +D22.1+, [301,264]
        "000110111",    # "1001010111", +D23.1-, [302,265]
        "000101000",    # "1001011000", -D8.1+, [303,266]
        "000111001",    # "1001011001", +D25.1+, [304,267]
        "000111010",    # "1001011010", +D26.1+, [305,268]
        "000111011",    # "1001011011", +D27.1-, [306,269]
        "000111100",    # "1001011100", +D28.1+, [307,270]
        "000111101",    # "1001011101", +D29.1-, [308,271]
        "000111110",    # "1001011110", +D30.1-, [309,272]
        "DEC8b10bERR",  # "1001011111"
        "DEC8b10bERR",  # "1001100000"
        "000111110",    # "1001100001", -D30.1+, [310,273]
        "000111101",    # "1001100010", -D29.1+, [311,274]
        "000100011",    # "1001100011", +D3.1+, [312,275]
        "000111011",    # "1001100100", -D27.1+, [313,276]
        "000100101",    # "1001100101", +D5.1+, [314,277]
        "000100110",    # "1001100110", +D6.1+, [315,278]
        "000101000",    # "1001100111", +D8.1-, [316,279]
        "000110111",    # "1001101000", -D23.1+, [317,280]
        "000101001",    # "1001101001", +D9.1+, [318,281]
        "000101010",    # "1001101010", +D10.1+, [319,282]
        "000100100",    # "1001101011", +D4.1-, [320,283]
        "000101100",    # "1001101100", +D12.1+, [321,284]
        "000100010",    # "1001101101", +D2.1-, [322,285]
        "000100001",    # "1001101110", +D1.1-, [323,286]
        "DEC8b10bERR",  # "1001101111"
        "DEC8b10bERR",  # "1001110000"
        "000110001",    # "1001110001", +D17.1+, [324,287]
        "000110010",    # "1001110010", +D18.1+, [325,288]
        "000111000",    # "1001110011", +D24.1-, [326,289]
        "000110100",    # "1001110100", +D20.1+, [327,290]
        "000111111",    # "1001110101", +D31.1-, [328,291]
        "000110000",    # "1001110110", +D16.1-, [329,292]
        "DEC8b10bERR",  # "1001110111"
        "000100111",    # "1001111000", -D7.1-, [330,293]
        "000100000",    # "1001111001", +D0.1-, [331,294]
        "000101111",    # "1001111010", +D15.1-, [332,295]
        "DEC8b10bERR",  # "1001111011"
        "100111100",    # "1001111100", +K28.1-, [333,38]
        "DEC8b10bERR",  # "1001111101"
        "DEC8b10bERR",  # "1001111110"
        "DEC8b10bERR",  # "1001111111"
        "DEC8b10bERR",  # "1010000000"
        "DEC8b10bERR",  # "1010000001"
        "DEC8b10bERR",  # "1010000010"
        "110111100",    # "1010000011", -K28.5+, [334,39]
        "DEC8b10bERR",  # "1010000100"
        "001001111",    # "1010000101", -D15.2+, [335,296]
        "001000000",    # "1010000110", -D0.2+, [336,297]
        "001000111",    # "1010000111", +D7.2+, [337,298]
        "DEC8b10bERR",  # "1010001000"
        "001010000",    # "1010001001", -D16.2+, [338,299]
        "001011111",    # "1010001010", -D31.2+, [339,300]
        "001001011",    # "1010001011", +D11.2+, [340,301]
        "001011000",    # "1010001100", -D24.2+, [341,302]
        "001001101",    # "1010001101", +D13.2+, [342,303]
        "001001110",    # "1010001110", +D14.2+, [343,304]
        "DEC8b10bERR",  # "1010001111"
        "DEC8b10bERR",  # "1010010000"
        "001000001",    # "1010010001", -D1.2+, [344,305]
        "001000010",    # "1010010010", -D2.2+, [345,306]
        "001010011",    # "1010010011", +D19.2+, [346,307]
        "001000100",    # "1010010100", -D4.2+, [347,308]
        "001010101",    # "1010010101", +D21.2+, [348,309]
        "001010110",    # "1010010110", +D22.2+, [349,310]
        "001010111",    # "1010010111", +D23.2-, [350,311]
        "001001000",    # "1010011000", -D8.2+, [351,312]
        "001011001",    # "1010011001", +D25.2+, [352,313]
        "001011010",    # "1010011010", +D26.2+, [353,314]
        "001011011",    # "1010011011", +D27.2-, [354,315]
        "001011100",    # "1010011100", +D28.2+, [355,316]
        "001011101",    # "1010011101", +D29.2-, [356,317]
        "001011110",    # "1010011110", +D30.2-, [357,318]
        "DEC8b10bERR",  # "1010011111"
        "DEC8b10bERR",  # "1010100000"
        "001011110",    # "1010100001", -D30.2+, [358,319]
        "001011101",    # "1010100010", -D29.2+, [359,320]
        "001000011",    # "1010100011", +D3.2+, [360,321]
        "001011011",    # "1010100100", -D27.2+, [361,322]
        "001000101",    # "1010100101", +D5.2+, [362,323]
        "001000110",    # "1010100110", +D6.2+, [363,324]
        "001001000",    # "1010100111", +D8.2-, [364,325]
        "001010111",    # "1010101000", -D23.2+, [365,326]
        "001001001",    # "1010101001", +D9.2+, [366,327]
        "001001010",    # "1010101010", +D10.2+, [367,328]
        "001000100",    # "1010101011", +D4.2-, [368,329]
        "001001100",    # "1010101100", +D12.2+, [369,330]
        "001000010",    # "1010101101", +D2.2-, [370,331]
        "001000001",    # "1010101110", +D1.2-, [371,332]
        "DEC8b10bERR",  # "1010101111"
        "DEC8b10bERR",  # "1010110000"
        "001010001",    # "1010110001", +D17.2+, [372,333]
        "001010010",    # "1010110010", +D18.2+, [373,334]
        "001011000",    # "1010110011", +D24.2-, [374,335]
        "001010100",    # "1010110100", +D20.2+, [375,336]
        "001011111",    # "1010110101", +D31.2-, [376,337]
        "001010000",    # "1010110110", +D16.2-, [377,338]
        "DEC8b10bERR",  # "1010110111"
        "001000111",    # "1010111000", -D7.2-, [378,339]
        "001000000",    # "1010111001", +D0.2-, [379,340]
        "001001111",    # "1010111010", +D15.2-, [380,341]
        "DEC8b10bERR",  # "1010111011"
        "101011100",    # "1010111100", +K28.2-, [381,40]
        "DEC8b10bERR",  # "1010111101"
        "DEC8b10bERR",  # "1010111110"
        "DEC8b10bERR",  # "1010111111"
        "DEC8b10bERR",  # "1011000000"
        "DEC8b10bERR",  # "1011000001"
        "DEC8b10bERR",  # "1011000010"
        "110011100",    # "1011000011", -K28.4-, [382,41]
        "DEC8b10bERR",  # "1011000100"
        "010001111",    # "1011000101", -D15.4-, [383,342]
        "010000000",    # "1011000110", -D0.4-, [384,343]
        "010000111",    # "1011000111", +D7.4-, [385,344]
        "DEC8b10bERR",  # "1011001000"
        "010010000",    # "1011001001", -D16.4-, [386,345]
        "010011111",    # "1011001010", -D31.4-, [387,346]
        "010001011",    # "1011001011", +D11.4-, [388,347]
        "010011000",    # "1011001100", -D24.4-, [389,348]
        "010001101",    # "1011001101", +D13.4-, [390,349]
        "010001110",    # "1011001110", +D14.4-, [391,350]
        "DEC8b10bERR",  # "1011001111"
        "DEC8b10bERR",  # "1011010000"
        "010000001",    # "1011010001", -D1.4-, [392,351]
        "010000010",    # "1011010010", -D2.4-, [393,352]
        "010010011",    # "1011010011", +D19.4-, [394,353]
        "010000100",    # "1011010100", -D4.4-, [395,354]
        "010010101",    # "1011010101", +D21.4-, [396,355]
        "010010110",    # "1011010110", +D22.4-, [397,356]
        "DEC8b10bERR",  # "1011010111"
        "010001000",    # "1011011000", -D8.4-, [398,357]
        "010011001",    # "1011011001", +D25.4-, [399,358]
        "010011010",    # "1011011010", +D26.4-, [400,359]
        "DEC8b10bERR",  # "1011011011"
        "010011100",    # "1011011100", +D28.4-, [401,360]
        "DEC8b10bERR",  # "1011011101"
        "DEC8b10bERR",  # "1011011110"
        "DEC8b10bERR",  # "1011011111"
        "DEC8b10bERR",  # "1011100000"
        "010011110",    # "1011100001", -D30.4-, [402,361]
        "010011101",    # "1011100010", -D29.4-, [403,362]
        "010000011",    # "1011100011", +D3.4-, [404,363]
        "010011011",    # "1011100100", -D27.4-, [405,364]
        "010000101",    # "1011100101", +D5.4-, [406,365]
        "010000110",    # "1011100110", +D6.4-, [407,366]
        "DEC8b10bERR",  # "1011100111"
        "010010111",    # "1011101000", -D23.4-, [408,367]
        "010001001",    # "1011101001", +D9.4-, [409,368]
        "010001010",    # "1011101010", +D10.4-, [410,369]
        "DEC8b10bERR",  # "1011101011"
        "010001100",    # "1011101100", +D12.4-, [411,370]
        "DEC8b10bERR",  # "1011101101"
        "DEC8b10bERR",  # "1011101110"
        "DEC8b10bERR",  # "1011101111"
        "DEC8b10bERR",  # "1011110000"
        "010010001",    # "1011110001", +D17.4-, [412,371]
        "010010010",    # "1011110010", +D18.4-, [413,372]
        "DEC8b10bERR",  # "1011110011"
        "010010100",    # "1011110100", +D20.4-, [414,373]
        "DEC8b10bERR",  # "1011110101"
        "DEC8b10bERR",  # "1011110110"
        "DEC8b10bERR",  # "1011110111"
        "DEC8b10bERR",  # "1011111000"
        "DEC8b10bERR",  # "1011111001"
        "DEC8b10bERR",  # "1011111010"
        "DEC8b10bERR",  # "1011111011"
        "DEC8b10bERR",  # "1011111100"
        "DEC8b10bERR",  # "1011111101"
        "DEC8b10bERR",  # "1011111110"
        "DEC8b10bERR",  # "1011111111"
        "DEC8b10bERR",  # "1100000000"
        "DEC8b10bERR",  # "1100000001"
        "DEC8b10bERR",  # "1100000010"
        "DEC8b10bERR",  # "1100000011"
        "DEC8b10bERR",  # "1100000100"
        "DEC8b10bERR",  # "1100000101"
        "DEC8b10bERR",  # "1100000110"
        "DEC8b10bERR",  # "1100000111"
        "DEC8b10bERR",  # "1100001000"
        "DEC8b10bERR",  # "1100001001"
        "DEC8b10bERR",  # "1100001010"
        "001101011",    # "1100001011", -D11.3-, [415,374]
        "DEC8b10bERR",  # "1100001100"
        "001101101",    # "1100001101", -D13.3-, [416,375]
        "001101110",    # "1100001110", -D14.3-, [417,376]
        "DEC8b10bERR",  # "1100001111"
        "DEC8b10bERR",  # "1100010000"
        "DEC8b10bERR",  # "1100010001"
        "DEC8b10bERR",  # "1100010010"
        "001110011",    # "1100010011", -D19.3-, [418,377]
        "DEC8b10bERR",  # "1100010100"
        "001110101",    # "1100010101", -D21.3-, [419,378]
        "001110110",    # "1100010110", -D22.3-, [420,379]
        "001110111",    # "1100010111", +D23.3-, [421,380]
        "DEC8b10bERR",  # "1100011000"
        "001111001",    # "1100011001", -D25.3-, [422,381]
        "001111010",    # "1100011010", -D26.3-, [423,382]
        "001111011",    # "1100011011", +D27.3-, [424,383]
        "001111100",    # "1100011100", -D28.3-, [425,384]
        "001111101",    # "1100011101", +D29.3-, [426,385]
        "001111110",    # "1100011110", +D30.3-, [427,386]
        "DEC8b10bERR",  # "1100011111"
        "DEC8b10bERR",  # "1100100000"
        "DEC8b10bERR",  # "1100100001"
        "DEC8b10bERR",  # "1100100010"
        "001100011",    # "1100100011", -D3.3-, [428,387]
        "DEC8b10bERR",  # "1100100100"
        "001100101",    # "1100100101", -D5.3-, [429,388]
        "001100110",    # "1100100110", -D6.3-, [430,389]
        "001101000",    # "1100100111", +D8.3-, [431,390]
        "DEC8b10bERR",  # "1100101000"
        "001101001",    # "1100101001", -D9.3-, [432,391]
        "001101010",    # "1100101010", -D10.3-, [433,392]
        "001100100",    # "1100101011", +D4.3-, [434,393]
        "001101100",    # "1100101100", -D12.3-, [435,394]
        "001100010",    # "1100101101", +D2.3-, [436,395]
        "001100001",    # "1100101110", +D1.3-, [437,396]
        "DEC8b10bERR",  # "1100101111"
        "DEC8b10bERR",  # "1100110000"
        "001110001",    # "1100110001", -D17.3-, [438,397]
        "001110010",    # "1100110010", -D18.3-, [439,398]
        "001111000",    # "1100110011", +D24.3-, [440,399]
        "001110100",    # "1100110100", -D20.3-, [441,400]
        "001111111",    # "1100110101", +D31.3-, [442,401]
        "001110000",    # "1100110110", +D16.3-, [443,402]
        "DEC8b10bERR",  # "1100110111"
        "001100111",    # "1100111000", -D7.3-, [444,403]
        "001100000",    # "1100111001", +D0.3-, [445,404]
        "001101111",    # "1100111010", +D15.3-, [446,405]
        "DEC8b10bERR",  # "1100111011"
        "101111100",    # "1100111100", +K28.3-, [447,42]
        "DEC8b10bERR",  # "1100111101"
        "DEC8b10bERR",  # "1100111110"
        "DEC8b10bERR",  # "1100111111"
        "DEC8b10bERR",  # "1101000000"
        "DEC8b10bERR",  # "1101000001"
        "DEC8b10bERR",  # "1101000010"
        "100011100",    # "1101000011", -K28.0-, [448,43]
        "DEC8b10bERR",  # "1101000100"
        "000001111",    # "1101000101", -D15.0-, [449,406]
        "000000000",    # "1101000110", -D0.0-, [450,407]
        "000000111",    # "1101000111", +D7.0-, [451,408]
        "DEC8b10bERR",  # "1101001000"
        "000010000",    # "1101001001", -D16.0-, [452,409]
        "000011111",    # "1101001010", -D31.0-, [453,410]
        "000001011",    # "1101001011", +D11.0-, [454,411]
        "000011000",    # "1101001100", -D24.0-, [455,412]
        "000001101",    # "1101001101", +D13.0-, [456,413]
        "000001110",    # "1101001110", +D14.0-, [457,414]
        "DEC8b10bERR",  # "1101001111"
        "DEC8b10bERR",  # "1101010000"
        "000000001",    # "1101010001", -D1.0-, [458,415]
        "000000010",    # "1101010010", -D2.0-, [459,416]
        "000010011",    # "1101010011", +D19.0-, [460,417]
        "000000100",    # "1101010100", -D4.0-, [461,418]
        "000010101",    # "1101010101", +D21.0-, [462,419]
        "000010110",    # "1101010110", +D22.0-, [463,420]
        "DEC8b10bERR",  # "1101010111"
        "000001000",    # "1101011000", -D8.0-, [464,421]
        "000011001",    # "1101011001", +D25.0-, [465,422]
        "000011010",    # "1101011010", +D26.0-, [466,423]
        "DEC8b10bERR",  # "1101011011"
        "000011100",    # "1101011100", +D28.0-, [467,424]
        "DEC8b10bERR",  # "1101011101"
        "DEC8b10bERR",  # "1101011110"
        "DEC8b10bERR",  # "1101011111"
        "DEC8b10bERR",  # "1101100000"
        "000011110",    # "1101100001", -D30.0-, [468,425]
        "000011101",    # "1101100010", -D29.0-, [469,426]
        "000000011",    # "1101100011", +D3.0-, [470,427]
        "000011011",    # "1101100100", -D27.0-, [471,428]
        "000000101",    # "1101100101", +D5.0-, [472,429]
        "000000110",    # "1101100110", +D6.0-, [473,430]
        "DEC8b10bERR",  # "1101100111"
        "000010111",    # "1101101000", -D23.0-, [474,431]
        "000001001",    # "1101101001", +D9.0-, [475,432]
        "000001010",    # "1101101010", +D10.0-, [476,433]
        "DEC8b10bERR",  # "1101101011"
        "000001100",    # "1101101100", +D12.0-, [477,434]
        "DEC8b10bERR",  # "1101101101"
        "DEC8b10bERR",  # "1101101110"
        "DEC8b10bERR",  # "1101101111"
        "DEC8b10bERR",  # "1101110000"
        "000010001",    # "1101110001", +D17.0-, [478,435]
        "000010010",    # "1101110010", +D18.0-, [479,436]
        "DEC8b10bERR",  # "1101110011"
        "000010100",    # "1101110100", +D20.0-, [480,437]
        "DEC8b10bERR",  # "1101110101"
        "DEC8b10bERR",  # "1101110110"
        "DEC8b10bERR",  # "1101110111"
        "DEC8b10bERR",  # "1101111000"
        "DEC8b10bERR",  # "1101111001"
        "DEC8b10bERR",  # "1101111010"
        "DEC8b10bERR",  # "1101111011"
        "DEC8b10bERR",  # "1101111100"
        "DEC8b10bERR",  # "1101111101"
        "DEC8b10bERR",  # "1101111110"
        "DEC8b10bERR",  # "1101111111"
        "DEC8b10bERR",  # "1110000000"
        "DEC8b10bERR",  # "1110000001"
        "DEC8b10bERR",  # "1110000010"
        "111111100",    # "1110000011", -K28.7-, [481,44]
        "DEC8b10bERR",  # "1110000100"
        "111101111",    # "1110000101", -K15.7-, [482,45]
        "111100000",    # "1110000110", -K0.7-, [483,46]
        "111100111",    # "1110000111", +K7.7-, [484,47]
        "DEC8b10bERR",  # "1110001000"
        "111110000",    # "1110001001", -K16.7-, [485,48]
        "111111111",    # "1110001010", -K31.7-, [486,49]
        "111101011",    # "1110001011", +K11.7-, [487,50]
        "111111000",    # "1110001100", -K24.7-, [488,51]
        "111101101",    # "1110001101", +K13.7-, [489,52]
        "111101110",    # "1110001110", +K14.7-, [490,53]
        "DEC8b10bERR",  # "1110001111"
        "DEC8b10bERR",  # "1110010000"
        "111100001",    # "1110010001", -K1.7-, [491,54]
        "111100010",    # "1110010010", -K2.7-, [492,55]
        "111110011",    # "1110010011", +K19.7-, [493,56]
        "111100100",    # "1110010100", -K4.7-, [494,57]
        "111110101",    # "1110010101", +K21.7-, [495,58]
        "111110110",    # "1110010110", +K22.7-, [496,59]
        "DEC8b10bERR",  # "1110010111"
        "111101000",    # "1110011000", -K8.7-, [497,60]
        "111111001",    # "1110011001", +K25.7-, [498,61]
        "111111010",    # "1110011010", +K26.7-, [499,62]
        "DEC8b10bERR",  # "1110011011"
        "DEC8b10bERR",  # "1110011100"
        "DEC8b10bERR",  # "1110011101"
        "DEC8b10bERR",  # "1110011110"
        "DEC8b10bERR",  # "1110011111"
        "DEC8b10bERR",  # "1110100000"
        "111111110",    # "1110100001", -K30.7-, [500,63]
        "111111101",    # "1110100010", -K29.7-, [501,64]
        "111100011",    # "1110100011", +K3.7-, [502,65]
        "111111011",    # "1110100100", -K27.7-, [503,66]
        "111100101",    # "1110100101", +K5.7-, [504,67]
        "111100110",    # "1110100110", +K6.7-, [505,68]
        "DEC8b10bERR",  # "1110100111"
        "111110111",    # "1110101000", -K23.7-, [506,69]
        "111101001",    # "1110101001", +K9.7-, [507,70]
        "111101010",    # "1110101010", +K10.7-, [508,71]
        "DEC8b10bERR",  # "1110101011"
        "111101100",    # "1110101100", +K12.7-, [509,72]
        "DEC8b10bERR",  # "1110101101"
        "DEC8b10bERR",  # "1110101110"
        "DEC8b10bERR",  # "1110101111"
        "DEC8b10bERR",  # "1110110000"
        "011110001",    # "1110110001", +D17.7-, [510,438]
        "011110010",    # "1110110010", +D18.7-, [511,439]
        "DEC8b10bERR",  # "1110110011"
        "011110100",    # "1110110100", +D20.7-, [512,440]
        "DEC8b10bERR",  # "1110110101"
        "DEC8b10bERR",  # "1110110110"
        "DEC8b10bERR",  # "1110110111"
        "DEC8b10bERR",  # "1110111000"
        "DEC8b10bERR",  # "1110111001"
        "DEC8b10bERR",  # "1110111010"
        "DEC8b10bERR",  # "1110111011"
        "DEC8b10bERR",  # "1110111100"
        "DEC8b10bERR",  # "1110111101"
        "DEC8b10bERR",  # "1110111110"
        "DEC8b10bERR",  # "1110111111"
        "DEC8b10bERR",  # "1111000000"
        "DEC8b10bERR",  # "1111000001"
        "DEC8b10bERR",  # "1111000010"
        "DEC8b10bERR",  # "1111000011"
        "DEC8b10bERR",  # "1111000100"
        "DEC8b10bERR",  # "1111000101"
        "DEC8b10bERR",  # "1111000110"
        "DEC8b10bERR",  # "1111000111"
        "DEC8b10bERR",  # "1111001000"
        "DEC8b10bERR",  # "1111001001"
        "DEC8b10bERR",  # "1111001010"
        "DEC8b10bERR",  # "1111001011"
        "DEC8b10bERR",  # "1111001100"
        "DEC8b10bERR",  # "1111001101"
        "DEC8b10bERR",  # "1111001110"
        "DEC8b10bERR",  # "1111001111"
        "DEC8b10bERR",  # "1111010000"
        "DEC8b10bERR",  # "1111010001"
        "DEC8b10bERR",  # "1111010010"
        "DEC8b10bERR",  # "1111010011"
        "DEC8b10bERR",  # "1111010100"
        "DEC8b10bERR",  # "1111010101"
        "DEC8b10bERR",  # "1111010110"
        "DEC8b10bERR",  # "1111010111"
        "DEC8b10bERR",  # "1111011000"
        "DEC8b10bERR",  # "1111011001"
        "DEC8b10bERR",  # "1111011010"
        "DEC8b10bERR",  # "1111011011"
        "DEC8b10bERR",  # "1111011100"
        "DEC8b10bERR",  # "1111011101"
        "DEC8b10bERR",  # "1111011110"
        "DEC8b10bERR",  # "1111011111"
        "DEC8b10bERR",  # "1111100000"
        "DEC8b10bERR",  # "1111100001"
        "DEC8b10bERR",  # "1111100010"
        "DEC8b10bERR",  # "1111100011"
        "DEC8b10bERR",  # "1111100100"
        "DEC8b10bERR",  # "1111100101"
        "DEC8b10bERR",  # "1111100110"
        "DEC8b10bERR",  # "1111100111"
        "DEC8b10bERR",  # "1111101000"
        "DEC8b10bERR",  # "1111101001"
        "DEC8b10bERR",  # "1111101010"
        "DEC8b10bERR",  # "1111101011"
        "DEC8b10bERR",  # "1111101100"
        "DEC8b10bERR",  # "1111101101"
        "DEC8b10bERR",  # "1111101110"
        "DEC8b10bERR",  # "1111101111"
        "DEC8b10bERR",  # "1111110000"
        "DEC8b10bERR",  # "1111110001"
        "DEC8b10bERR",  # "1111110010"
        "DEC8b10bERR",  # "1111110011"
        "DEC8b10bERR",  # "1111110100"
        "DEC8b10bERR",  # "1111110101"
        "DEC8b10bERR",  # "1111110110"
        "DEC8b10bERR",  # "1111110111"
        "DEC8b10bERR",  # "1111111000"
        "DEC8b10bERR",  # "1111111001"
        "DEC8b10bERR",  # "1111111010"
        "DEC8b10bERR",  # "1111111011"
        "DEC8b10bERR",  # "1111111100"
        "DEC8b10bERR",  # "1111111101"
        "DEC8b10bERR",  # "1111111110"
        "DEC8b10bERR" 	# "1111111111"
    ]

    def __init__(self):
        self.__rd = 0
        self.__syncd = False
        self.__pendingdata = ''

    @staticmethod
    def _to10b(v):
        '''convert integer to bits, in the correct order, which is
        first (high) bit to be sent first.'''

        binstr = bin(v)[2:]

        return ('0' * (10 - len(binstr)) + binstr)[10:-11:-1]

    def issyncd(self):
        return self.__syncd

    __syncre = re.compile('11000001..|00111110..')

    def decode(self, bstr):
        '''Decode bstr, a string of 0's, and 1's to bytes.  This
        consumes all the bits, and stores any excess bits if some are
        missing.

        Returns either None, or a byte string w/ the data.

        If a control byte is received, it is returned by itself as an
        instance of ControlSymbol.

        Note that it needs to receive an EncDec8B10B.COMMA control byte
        first to establish sync, and then will data after that.
        '''

        if set(bstr) - set('01'):
            raise ValueError('invalid characters in: %s' % repr(bstr))

        data = self.__pendingdata + bstr

        if not self.__syncd:
            m = self.__syncre.search(data)
            if not m:
                self.__pendingdata = data[-9:]
                return

            self.__syncd = True

            data = data[m.start():]

        r = bytearray()

        for idx in range(0, len(data), 10):
            i = data[idx:idx + 10]
            if len(i) != 10:
                self.__pendingdata = i
                break

            try:
                ctrl, d = self.dec_8b10b(int(i[::-1], 2))
            except Exception:
                self.__syncd = False
                self.__pendingdata = data[idx + 1:]
                return

            #print(repr(ctrl), repr(d), repr(r))
            if ctrl and r:
                self.__pendingdata = data[idx:]
                return r

            if ctrl:
                self.__pendingdata = data[idx + 10:]
                return ControlSymbol(d)

            r += d.to_bytes(1, byteorder='big')
        else:
            self.__pendingdata = ''

        if r:
            return r

    def encode(self, bstr):
        '''Encode bstr into a string representing the binary (unicode
        string represented by 0 and 1).  The first bit to transmit is
        at index 0, and so on.'''

        r = []
        rd = self.__rd

        if isinstance(bstr, ControlSymbol):
            rd, c = self.enc_8b10b(bstr, rd, ctrl=1)
            r.append(c)
        else:
            for i in bstr:
                rd, c = self.enc_8b10b(i, rd)
                r.append(c)

        self.__rd = rd

        return ''.join(self._to10b(x) for x in r)

    @staticmethod
    def enc_8b10b(data_in, running_disparity, ctrl=0, verbose=False):
        '''Encode a single byte to 10 bits.'''

        assert data_in <= 0xFF, "Data in must be maximum one byte"
        encoded = int(EncDec8B10B.enc_lookup[(
            ctrl << 9) + (running_disparity << 8) + data_in], 2)
        new_disparity = (encoded >> 10) & 1
        encoded = encoded & 0x3FF
        if verbose:
            print("Encoder - In: {:02X} - Encoded: {:03X} - Running Disparity: {:01b}".format(data_in, encoded, new_disparity))
        return new_disparity, encoded

    @staticmethod
    def dec_8b10b(data_in, verbose=False):
        '''Decode 10 bits into a byte.'''

        assert data_in <= 0x3FF, "Data in must be maximum 10 bits"
        decoded = EncDec8B10B.dec_lookup[(data_in)]
        if decoded == "DEC8b10bERR":
            raise Exception(
                "Input to 8B10B Decoder is not a 8B10B Encoded Word")
        decoded = int(decoded, 2)
        ctrl = (decoded >> 8) & 0x1
        decoded = decoded & 0xFF
        if verbose:
            print("Decoded: {:02X} - Control: {:01b}".format(decoded, ctrl))

        return ctrl, decoded