ИКБО-12-22

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x8c 0x53 0x59 0x41, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	Адрес (uint32) структуры B
2	Размер (uint32) и адрес (uint16) массива uint32

Поле	Описание
1	Адрес (uint32) структуры C
2	uint16
3	Массив структур D, размер 2
4	Адрес (uint16) структуры E
5	double

Поле	Описание
1	uint16
2	Размер (uint16) и адрес (uint16) массива char
3	uint32

Поле	Описание
1	int16
2	int8

Поле	Описание
1	int8
2	Размер (uint32) и адрес (uint32) массива int16
3	uint16
4	uint64
5	Размер (uint16) и адрес (uint32) массива int8
6	double
7	float

(b'\x8cSYAK\x00\x00\x00\x02\x00\x00\x00a\x00pn~d\x02\x00\x0e\x00\x8e\xbf'
 b'\xdd\xf37\x8c\x9f\x98\x84\xc3\x1cB\x93\xfd\x06\xda\xd1\x05\x00\x00\x00\x1a'
 b'\x00\x00\x00p\xf2\x95\x8b\xe2l\xe1"\xb2*\x02\x00$\x00\x00\x00P\xa4F\xed\x92'
 b'\xb1\xeb?W\xb2\n>\x10\x00\x00\x00M\x0b\xb6o\xc7C\xefe&\x00\x92\xdd\xe1'
 b'\xc9]\xdc\xe3?\x12\xdbeJ\xe1\\\xef\xf4')

{'A1': {'B1': {'C1': 25726, 'C2': 'pn', 'C3': 4091395982},
        'B2': 2893,
        'B3': [{'D1': 28598, 'D2': -57}, {'D1': -4285, 'D2': 101}],
        'B4': {'E1': -47,
               'E2': [-29641, -26465, -15484, 16924, -621],
               'E3': 62064,
               'E4': 3076559847037242261,
               'E5': [6, -38],
               'E6': 0.8654265054984851,
               'E7': 0.13544593751430511},
        'B5': 0.6206501906407758},
 'A2': [1248189202, 4109327585]}

(b'\x8cSYAL\x00\x00\x00\x02\x00\x00\x00b\x00xzkpgx\x08\x84\x06\x00\x0e\x00\rt'
 b'P\xeb\xcbl\xad\x0e.:A)Ep\x03\x00\x00\x00\x1e\x00\x00\x00r\xca\xc2\x92'
 b'a\xea\xbf\x19e\x12\x03\x00$\x00\x00\x00\xca\x8b{\x042\xeb\xeb?\xf1\x97E?'
 b"\x14\x00\x00\x00\x08\x13\x8e03\xd9\xa4\xa4'\x00\xac\x1b\xf9I#1\xd3?\x14\x95"
 b'\xf3\t\xcdh\xf7e')

{'A1': {'B1': {'C1': 33800, 'C2': 'xzkpgx', 'C3': 3947918349},
        'B2': 4872,
        'B3': [{'D1': 12430, 'D2': 51}, {'D1': -23335, 'D2': -92}],
        'B4': {'E1': 112,
               'E2': [27851, 3757, 14894],
               'E3': 51826,
               'E4': 1325493977392190146,
               'E5': [65, 41, 69],
               'E6': 0.8724603736449066,
               'E7': 0.7718496918678284},
        'B5': 0.29987413619931647},
 'A2': [166958356, 1710713037]}

Вариант №2

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x2d 0x54 0x47 0x48, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	Структура B
2	int8
3	uint32
4	int32
5	Массив char, размер 6
6	uint32
7	Структура D

Поле	Описание
1	Массив char, размер 3
2	Массив адресов (uint32) структур C, размер 3

Поле	Описание
1	float
2	double
3	uint8

Поле	Описание
1	uint64
2	double
3	Размер (uint32) и адрес (uint32) массива uint32

(b"-TGHqge>\x00\x00\x00K\x00\x00\x00X\x00\x00\x00'K\x1a\x95\xe6]1:\xf4mivf"
 b'is\xbb\xf5SsKG$\x8cC\xb1\x1f\xc2\xd8\xdf\xf0\xbe\xe8\x17\xe3\xbf\x02\x00'
 b'\x00\x00e\x00\x00\x00\xbb\xa8\xda\xbe\xe0\xd8P&\xe8\xa8\xe5?\x9e\xa8[M?2'
 b'\xbdIHB\x16\xeb\xbf\x18\x12`D?t\x1fuT@s\xd1\xbfd\x95A\n{\x16\xb3\x1e\x82')

{'A1': {'B1': 'qge',
        'B2': [{'C1': -0.4270685613155365, 'C2': 0.6768685100894594, 'C3': 158},
               {'C1': 0.8021798133850098, 'C2': -0.8464671527744143, 'C3': 24},
               {'C1': 0.767090916633606,
                'C2': -0.27265938041499926,
                'C3': 100}]},
 'A2': 39,
 'A3': 3868531275,
 'A4': -197512867,
 'A5': 'mivfis',
 'A6': 1934882235,
 'A7': {'D1': 13988093871308162891,
        'D2': -0.5966685990633733,
        'D3': [2064269717, 2183050006]}}

(b'-TGHolt>\x00\x00\x00K\x00\x00\x00X\x00\x00\x00\xd7a\x0b\xa0\xb1/\xd8\x91\xdc'
 b'bmwtqc\xf3EuX\xfb\x9au\xc6)\xa4\x8d^H\xf8\x0c[U\xdf\xd5\xbf\x02\x00'
 b'\x00\x00e\x00\x00\x00\xe2|\x81>`{\x80\x87\x1d@\xb2\xbf\xb0d\x99\x12\xbfp'
 b'\xfbp\xa7\x9c\xa7\xcc\xbf\xce}+\xc0\xbe\xbex\x1c\x15\x17\xe9\xea\xbf'
 b'\xb7`\x1d\xad\xb5\x81\x00\xfcP')

{'A1': {'B1': 'olt',
        'B2': [{'C1': 0.2529059052467346,
                'C2': -0.07129082258368902,
                'C3': 176},
               {'C1': -0.57265305519104, 'C2': -0.2238651101669933, 'C3': 206},
               {'C1': -0.3753317892551422,
                'C2': -0.8409533893898453,
                'C3': 183}]},
 'A2': -41,
 'A3': 2980055905,
 'A4': -594421713,
 'A5': 'bmwtqc',
 'A6': 1484080627,
 'A7': {'D1': 6813282310611639035,
        'D2': -0.34175619022051196,
        'D3': [3048021344, 1358692481]}}

Вариант №3

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5a 0x44 0x4d 0x34, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	uint8
2	Массив адресов (uint16) структур B, размер 2
3	Адрес (uint32) структуры C
4	uint64
5	int64

Поле	Описание
1	Размер (uint32) и адрес (uint32) массива char
2	uint64

Поле	Описание
1	uint32
2	int8
3	uint16
4	Адрес (uint32) структуры D
5	uint8

Поле	Описание
1	uint16
2	Массив double, размер 4
3	float
4	uint16
5	Размер (uint32) и адрес (uint32) массива uint32
6	int32
7	int8
8	Размер (uint16) и адрес (uint16) массива float

(b'ZDM4\xf0\x1f\x001\x00\x9e\x00\x00\x00\xcb\xdc|\xf5`|\x86\xf0^v\xc6i7(\x0f'
 b'{uu\x02\x00\x00\x00\x1d\x00\x00\x00vw<P\xc4q\xed\x83jr\x02\x00\x00'
 b'\x00/\x00\x00\x00cB\x8b\xd9\x0e\x8b\x10.\x1d\xbe\x91\x89\x05\xc0\xc2'
 b'9\xd7l\xa0w|\xac\xf5\xd5b\xf7 ?$\x88T\xbfq\xb3\xfe\xbeq\xbd\x97>\xf3\x06\xb7'
 b'\xbd\xd5Zl\xf0@\xbd\xa0\xa2\xe3\xbf\xe48>[\xc1O\xe2?6\x12\x96\xefB'
 b'B\xeb\xbf\xeca`\x18M4\xe3\xbf\xc8\x98y\xbf\x8f\xb9\x04\x00\x00\x00A\x00\x00'
 b'\x00\xc1\xdd\\\xe3\x14\x05\x00Q\x00\xfc\xae\xd3E\xce3-e\x00\x00\x00K')

{'A1': 240,
 'A2': [{'B1': 'uu', 'B2': 9506379476422653814},
        {'B1': 'jr', 'B2': 3319305821267640931}],
 'A3': {'C1': 1171500796,
        'C2': -50,
        'C3': 11571,
        'C4': {'D1': 23253,
               'D2': [-0.6136020370827402,
                      0.5722357542124681,
                      -0.8518385581415433,
                      -0.6001344181159403],
               'D3': -0.9749875068664551,
               'D4': 47503,
               'D5': [2308029981, 969064453, 2007002327, 3589647484],
               'D6': -480453183,
               'D7': 20,
               'D8': [0.6287747621536255,
                      -0.8302023410797119,
                      -0.49746277928352356,
                      0.29636719822883606,
                      -0.08936872333288193]},
        'C5': 75},
 'A4': 17331676971859238091,
 'A5': 8867350409778722398}

(b'ZDM4\x99\x1f\x001\x00\x9a\x00\x00\x00\xf3(S\xb8\xdc\x04@k\xabK\x87\xd9\xd8K;'
 b'\xb3pc\x02\x00\x00\x00\x1d\x00\x00\x00\xfe\xa2\x03\x9f&Lv\xe8mq\x02\x00\x00'
 b'\x00/\x00\x00\x00\x19[\x8d\xa1\x9bx\x0c\xd4\xba\x8a\x1dx\x9c.\xd7u\r\xf7@'
 b'O\xd3"\xb7W\x94\xdf\xa3\x9c\x9a\x91\xa8\r\x0e\xa8!?\x9a9\x15\xbf2\x9bf'
 b'\xdc\xb05\xfb\xa0\xe5\xbf\x14\x1a\xd7\xe8\xc8\xc6\xe6?\\\xe3\xb7\xcd\xbf'
 b'\xd3\xd8?\x1c\xe3\xdb\xd2\xef\x11\xef?\xe7H?\xbf@\x0e\x06\x00\x00'
 b'\x00A\x00\x00\x00\xca"x)\xcd\x02\x00Y\x00VD\x87\x82\xd3!\x9da\x00\x00\x00h')

{'A1': 153,
 'A2': [{'B1': 'pc', 'B2': 16750659592811422462},
        {'B1': 'mq', 'B2': 15279720245586909977}],
 'A3': {'C1': 2189902934,
        'C2': -45,
        'C3': 40225,
        'C4': {'D1': 39730,
               'D2': [-0.6759010361337345,
                      0.7117657230053873,
                      0.3879241475074673,
                      0.9709395521486814],
               'D3': -0.7472061514854431,
               'D4': 3648,
               'D5': [2015201978,
                      1977036444,
                      1329657613,
                      1471619795,
                      2627985300,
                      229151130],
               'D6': 695739082,
               'D7': -51,
               'D8': [0.6314705610275269, -0.5829101800918579]},
        'C5': 104},
 'A4': 7728182306599545075,
 'A5': -5531744322559980629}

Вариант №4

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x63 0x53 0x51 0x49, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	int32
2	Массив адресов (uint16) структур B, размер 3
3	int16
4	Размер (uint16) и адрес (uint16) массива адресов (uint32) структур C
5	Адрес (uint32) структуры D

Поле	Описание
1	Массив char, размер 2
2	int16

Поле	Описание
1	uint8
2	uint32
3	float

Поле	Описание
1	uint16
2	Массив int32, размер 8
3	uint8
4	int16
5	uint32
6	uint8

(b'cSQI!\xf3^y\x18\x00\x1c\x00 \x00\x81\xa4\x04\x00H\x00X\x00\x00\x00xl\x8e\xee'
 b'od\x8c\x12om@^l\xe6\xb8G*#\xa46?\xc5\xb8\x803\x0b%i6?P\x02m*\xf5N'
 b'\xbca\xbe\xe1c1\xf2M=S1?$\x00\x00\x00-\x00\x00\x006\x00\x00\x00?\x00\x00\x00'
 b'?\xde\xb6|\xa2\xa2%\xff\xf6}\xddlr\x9d\xde&ac\x87)x\x01I\xca\x0e\xbf\xb0\xf4'
 b't\xb9\xe5N=\xb3\x8e-{@\xe0\x9c\x19\xd4')

{'A1': 2036265761,
 'A2': [{'B1': 'xl', 'B2': -4466},
        {'B1': 'od', 'B2': 4748},
        {'B1': 'om', 'B2': 24128}],
 'A3': -23423,
 'A4': [{'C1': 108, 'C2': 709343462, 'C3': 0.7134420275688171},
        {'C1': 197, 'C2': 187924664, 'C3': 0.7125418782234192},
        {'C1': 80, 'C2': 4113198338, 'C3': -0.22044488787651062},
        {'C1': 225, 'C2': 1307717987, 'C3': 0.6926763653755188}],
 'A5': {'D1': 56895,
        'D2': [-1566409546,
               2113339173,
               -1653445411,
               1667311326,
               24652167,
               -1089549751,
               -1183517520,
               -1287827739],
        'D3': 142,
        'D4': 31533,
        'D5': 429711424,
        'D6': 212}}

(b'cSQI?\x9d\xa9\xa8\x18\x00\x1c\x00 \x00\xb0v\x02\x006\x00>\x00\x00\x00'
 b'ee\xf4\xedau\x16\x1ben\xcaS\x13\xa3C<\x8a\x9c\x10\xd0>\xfbVZ\x81\xd5\x97\xd8'
 b'y\xbf$\x00\x00\x00-\x00\x00\x00\xe3:\xa9\x8d\xcd\x03$\xa9\x1f\x02'
 b"\xcc\x19\xb7*O\x8c\xcf&Ioq\x08al\xd3e\xd3J\xfa'\xd4\xcbM\xfc\x1f\xf4\xb2\xd5"
 b'\x8f\xfe\x9b\xa3')

{'A1': -1465279169,
 'A2': [{'B1': 'ee', 'B2': -4620},
        {'B1': 'au', 'B2': 6934},
        {'B1': 'en', 'B2': 21450}],
 'A3': 30384,
 'A4': [{'C1': 19, 'C2': 2319205283, 'C3': 0.4063767194747925},
        {'C1': 251, 'C2': 3582024278, 'C3': -0.9759611487388611}],
 'A5': {'D1': 15075,
        'D2': [63802793,
               35629348,
               716642764,
               651136079,
               141651785,
               1708354657,
               670714579,
               -62010412],
        'D3': 31,
        'D4': -19724,
        'D5': 2617151445,
        'D6': 163}}

Вариант №5

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xe1 0x59 0x47 0x44, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	int32
2	Структура B
3	Структура H

Поле	Описание
1	Структура C
2	Массив int32, размер 3
3	Адрес (uint16) структуры F
4	uint64
5	Структура G
6	uint64

Поле	Описание
1	Массив структур D, размер 2
2	int16
3	Структура E

Поле	Описание
1	int32
2	uint8

Поле	Описание
1	Массив int32, размер 2
2	uint64
3	int64
4	int8
5	double
6	int32

Поле	Описание
1	float
2	Размер (uint16) и адрес (uint16) массива int16
3	double
4	uint8
5	uint8

Поле	Описание
1	int32
2	double

Поле	Описание
1	double
2	uint16
3	int32
4	Размер (uint32) и адрес (uint32) массива uint16
5	double

(b'\xe1YGD_N\xd2\x96\x01\xcc\xf1\x81=aV\xed\xd8\xce\x14\xce\xad\xc7\xb3k'
 b'\xe0\xdc\xfa\x92\xc4\xba\x96\x1d\x03\xea\x1c\xbfwH\\\xa5.\xb8Zy\x96\xa4\x03,'
 b'\xc7\xf54\xed?\x8c\xd3\xca\xf7\x94\xa7\xc8\x8b\xd1z\x8b\x85\x01\xd0\xdb'
 b'\xb9\x89\x00\x9aE\xfa\xbfL}\x12+\x9f\xec\xa2\x89Xu\xfc\xc0\xc3}\xeb\xbf\x17'
 b'\xe4<\xef\xea\x96\xba\xc40&%K\xde4\xbe\xbf\\U\x9f\x95\x191\x05\x00\x00'
 b'\x00\x9b\x00\x00\x00\x14\xc9\x04}-o\xe9?\xef\xff\x0b\x1e\x025O\xd4\x8avy'
 b'\xbf\x04\x00\x81\x00\x8aTWR!\x10\xeb?KY\x9d\xa6@\xec\x8eF\xa0\xc2\x01\x85')

{'A1': -1764602273,
 'A2': {'B1': {'C1': [{'D1': -2114860031, 'D2': 61},
                      {'D1': -655534495, 'D2': 206}],
               'C2': -12780,
               'C3': {'E1': [1806944173, -1829053216],
                      'E2': 13771139059694353092,
                      'E3': 8744504136975534199,
                      'E4': -106,
                      'E5': 0.9127148523403901,
                      'E6': -137702516}},
        'B2': [-1949784172, -2054456623, -1176776703],
        'B3': {'F1': -0.974465012550354,
               'F2': [-17, 7691, 13570, -11185],
               'F3': 0.845719013998534,
               'F4': 75,
               'F5': 89},
        'B4': 3103680861803529626,
        'B5': {'G1': -1985811297, 'G2': -0.8591021317730947},
        'B6': 14175808712882316311},
 'A3': {'H1': -0.11799420675847538,
        'H2': 21852,
        'H3': 823760287,
        'H4': [42653, 60480, 18062, 49824, 34049],
        'H5': 0.7948214952250816}}

(b'\xe1YGD\x10@/">\xe0I;}\xa0\x0fv\x1aM\x96\xe8c\x8c\xb9\xee\x18\xa6\x82)'
 b'\xba\xc9=\x88\xd2}sk\xa6%\x96\xff|\xa8\x8f\x97\xd9\x10T]\xcbC\x9c\xec'
 b'?\xa9\xce\xa0\xae\xb1\xd4\x0b\x9e\xa3\x91\xc9\xd3r5\xb6\xd3\x89\x00\x02'
 b'h\x8dE\x1b\xabC\x8d\xb9\x89\xda\xf5L\x19\xca\xe4i\xd2\xe2?\x7f'
 b'\xed\x93\xc1\xa3t\x96\xfa\xa8\x8c\x8a|\x8dc\xc5?\xe8\x92\xf6\x0e\xee'
 b'\x1d\x05\x00\x00\x00\x9b\x00\x00\x00f\xd3\xfelw\xa6\xe4\xbf\xf2\xaa-'
 b'\xcc\x91\x8fT\x87\xad\x0b\xda\xbe\x04\x00\x81\x00\xa8\xd5\xe8\xa9\xe6v\xcc'
 b'?\x97H"\x8c\xd5\x81\xfaj\xcbvY ')

{'A1': 573521936,
 'A2': {'B1': {'C1': [{'D1': 994697278, 'D2': 125},
                      {'D1': 443944864, 'D2': 77}],
               'C2': -5994,
               'C3': {'E1': [-289829789, 696428056],
                      'E2': 7742670527562369466,
                      'E3': -7525611197495368282,
                      'E4': -39,
                      'E5': 0.8940752956356182,
                      'E6': -1365193047}},
        'B2': [-1643391823, -741764701, -743033486],
        'B3': {'F1': -0.4258703291416168,
               'F2': [-21774, -13267, -28783, -30892],
               'F3': 0.2223785714756279,
               'F4': 151,
               'F5': 72},
        'B4': 10179167716406814722,
        'B5': {'G1': -170227271, 'G2': 0.5881852596801678},
        'B6': 18056748002664770943},
 'A3': {'H1': 0.16710060673822125,
        'H2': 37608,
        'H3': 502140662,
        'H4': [35874, 33237, 27386, 30411, 8281],
        'H5': -0.6453206185166038}}

Вариант №6

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x55 0x53 0x48 0x6b, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	Структура B
2	Массив char, размер 7
3	Массив uint16, размер 5
4	int64
5	int8
6	int64

Поле	Описание
1	Массив структур C, размер 2
2	uint16
3	Структура D
4	int16
5	float
6	uint64
7	int8

Поле	Описание
1	double
2	float
3	uint32
4	int16

Поле	Описание
1	uint64
2	uint8
3	int32
4	Адрес (uint16) структуры E

Поле	Описание
1	double
2	Массив uint16, размер 2
3	uint32
4	uint16
5	uint64
6	uint64

(b'KUSHk\xf8\x84\xbf\x88\xcbY\xc0?r\xb7|\xbf\x1b\x9c\x1e/p\x9b`R7\xf9>'
 b";\xa9?\xcc\xb8t?\x9b\x11Z\xbc;\xfb\x9d\x94\xed\x86t\xd0'Y%\xae\x1b"
 b'\n\x9dM\xc8k\x00\xb0.\x1b\x93U>\xc4.\x0e\xe9\xe5\xe6*\xdc\xb6nnpglcm'
 b'\xf7\xa1\x90\xd6i\xca0zz0\xd8s\x81\xa1\x99w*\nu\x7f_^q\x99k\x07\x94 '
 b'W\x0b\xd9|[\xc7?\x919\xf3gTJv\xa4\xc2\xf9\x19\x13\xd88B\xd3\x07'
 b"\xfb\xa4\xcc\x81\xc1\x03Z\x1f'")

{'A1': {'B1': [{'C1': 0.12774032761721066,
                'C2': -0.9871741533279419,
                'C3': 790535195,
                'C4': -25744},
               {'C1': 0.049280136033904354,
                'C2': 0.9559447765350342,
                'C3': 3160019355,
                'C4': -1221}],
        'B2': 38045,
        'B3': {'D1': 12548533964273649389,
               'D2': 27,
               'D3': -934437622,
               'D4': {'E1': 0.1824794826304066,
                      'E2': [14737, 26611],
                      'E3': 2759215700,
                      'E4': 63938,
                      'E5': 18088658709731873561,
                      'E6': 2819070863935130788}},
        'B4': 11952,
        'B5': 0.2085689753293991,
        'B6': 15864746512497913540,
        'B7': -74},
 'A2': 'nnpglcm',
 'A3': [41463, 54928, 51817, 31280, 12410],
 'A4': 732529391124444120,
 'A5': 117,
 'A6': -7780131524483063937}

(b'KUSHk(\x92~\x8d\xd0D\xcf\xbf\x05\xd8r?\xdf|O/=\x8f\xf0s\x8a\x19"'
 b'1\xb2\xbf\xc4\xddI\xbf\x91lcfJG\xb3\x11\x00\xd5\x11\xbf\xf4\xc0\xa9\xa2\xd4'
 b'\xb2\x1c\xe2\x15k\x00\xac1?\x02E\xbe\xe8&\xbdOMT[\xcf\xa3jgahczc'
 b"\x88\xfc^\xb9\x1f!\x8e\xe3}\x93P\xfe\xd2\xb0\xe9M\x16\xe8;\xf3%'\x80t"
 b'/\xd43\xb6\xcac\x19>\xc0\xe5\xbf\x82\xc9\xc4\x80l\xc7q\xba\x1b\xfc\x9f^\x92'
 b'\x98\x05-t\xad\x12\x834q\xe9v\xde\x13')

{'A1': {'B1': [{'C1': -0.24428755673319924,
                'C2': 0.9486086964607239,
                'C3': 793738463,
                'C4': -28867},
               {'C1': -0.07106221316867312,
                'C2': -0.7885401248931885,
                'C3': 1717791889,
                'C4': 18250}],
        'B2': 4531,
        'B3': {'D1': 11721111662618596608,
               'D2': 212,
               'D3': 367140018,
               'D4': {'E1': -0.6797171111960185,
                      'E2': [51586, 32964],
                      'E3': 3128018796,
                      'E4': 64539,
                      'E5': 12498664367917784735,
                      'E6': 1431712476549120786}},
        'B4': 12716,
        'B5': -0.19239138066768646,
        'B6': 14941628879758763752,
        'B7': -93},
 'A2': 'jgahczc',
 'A3': [64648, 47454, 8479, 58254, 37757],
 'A4': -1723104141333299632,
 'A5': 59,
 'A6': 3734662168409744883}

Вариант №7

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x4e 0x42, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	Размер (uint32) и адрес (uint16) массива char
2	uint8
3	Адрес (uint16) структуры B
4	uint64

Поле	Описание
1	Размер (uint32) и адрес (uint32) массива адресов (uint16) структур C
2	int8
3	Структура D
4	uint32
5	Массив uint32, размер 5
6	int32
7	uint8

Поле	Описание
1	uint64
2	float
3	int16

Поле	Описание
1	int64
2	Массив uint32, размер 6

(b'TNB\x00\x00\x00\x03\x00\x14e\x007U>\xaaF\x94\x11\xe1&erq\xf1M\x8e\x88\xc1'
 b'#\xcdW\xbfT\xc1[DL\x88\xb67\xdc\xce\x8bQ =\x19\x05\xa0_\x1a\x00\x17\x00%\x00'
 b'\x00\x00\x02\x00\x00\x003v~7\xbbk<\xe4%\xad\xce1}\xd4\xcc!\x94\xde;(=}'
 b'\xcf\x15~Ez`\xa1\x85\xd6\x894J\x83Q\x0eu\x18\x9c\x9e>q\xb1\x85\xaf'
 b'k\x17\xe8\xa8\x03\xf2P\xfb.\x13\xf1n\x9b\xc6\x00\xe6\x97')

{'A1': 'erq',
 'A2': 101,
 'A3': {'B1': [{'C1': 17387710454354398551,
                'C2': -0.8310753703117371,
                'C3': 17484},
               {'C1': 9851122656417108256,
                'C2': 0.037358880043029785,
                'C3': 24346}],
        'B2': 118,
        'B3': {'D1': 9094944041755485613,
               'D2': [3459349972,
                      3424752862,
                      992492925,
                      3474292293,
                      2053153157,
                      3599316042]},
        'B4': 2203127413,
        'B5': [412917310, 1907459503, 1796729000, 66212091, 773058926],
        'B6': -1681522458,
        'B7': 151},
 'A4': 6142534161888567590}

(b"TNB\x00\x00\x00\x02\x00\x14?\x006\xc6\x8f7\xca\x8d\xeb\x8a'em\x82\x8e"
 b'\x03\x1bg{q\xbe\xbe\xecd\x07\x07\x0fBm\x07\xd2\x9f\xc6Ps\xbe\x89[D'
 b'\xcd\x9b\x00\x16\x00$\x00\x00\x00\x02\x00\x00\x002\xc7E\x89\xbew\xeal\n\x03v'
 b"\xaa<\xd9\xfb\xe4'\xdb\xab\x85\n\x89k\x93\n\xe6h|r_\x93*Z\\yVG\x19\xf4"
 b'\xbb\x10\x1fD\x81\xe3\xe0}I\x81\x9a\xc9\x85\xaa\xe7(\xaf\xbah\x08'
 b'\x16\x180\xae')

{'A1': 'em',
 'A2': 63,
 'A3': {'B1': [{'C1': 9407460087858688446,
                'C2': -0.4617006480693817,
                'C3': 1807},
               {'C1': 4786490580169805939,
                'C2': -0.2682744264602661,
                'C3': -12901}],
        'B2': -57,
        'B3': {'D1': 5010745482669722115,
               'D2': [1990868185,
                      4226033627,
                      2877622921,
                      1804798694,
                      1752986207,
                      2469026396]},
        'B4': 2035697433,
        'B5': [4105900063, 1149363168, 2101969306, 3380980455, 682605160],
        'B6': 135665712,
        'B7': 174},
 'A4': 14307715884283300391}

Вариант №8

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x4b 0x4b 0x53 0x45, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	Адрес (uint32) структуры B
2	int32
3	int8
4	Структура F
5	Размер (uint16) и адрес (uint32) массива uint16

Поле	Описание
1	Структура C
2	Размер (uint32) и адрес (uint32) массива структур E

Поле	Описание
1	double
2	int32
3	Массив uint16, размер 5
4	Структура D

Поле	Описание
1	float
2	uint8
3	uint16

Поле	Описание
1	int8
2	uint64

Поле	Описание
1	int32
2	uint32
3	int16
4	Размер (uint16) и адрес (uint16) массива float

(b'MKKSE\x00\x00\x00=\xdcXC\xf5\x11f,\x12\xc8\xf0\xe3\xe7g\xc6\xf5\x00\x04\x00b'
 b'\x00\x06\x00\x00\x00r\xdd\x9d\x90/S:FL{{(e\xec#1{r\x1b\xa5\x05+\x0b'
 b'\xff\x92\x17\xc5E\xbf\xbc\xe5\xab\x9b\xf2\xc9 \x92\xb7G\x9f:\xe3\n\xa9{o\xec'
 b'\x88!-=\xff\xb6\xcd\x83\x8a\x88\x00\x00\x00\x03\x00\x00\x00"\xbesH$\xbd\x92'
 b'gZ\xbd\xed\x99F\xbf{F\xdc\xc01arx\xacsw0>\xd2\xef')

{'A1': {'B1': {'C1': -0.11287949139913112,
               'C2': -1833482337,
               'C3': [15075, 2729, 31599, 60552, 8493],
               'C4': {'D1': 0.12486038357019424, 'D2': 131, 'D3': 35464}},
        'B2': [{'E1': -35, 'E2': 11353626695107497083},
               {'E1': 123, 'E2': 2910992370063077915},
               {'E1': -91, 'E2': 372404586483795269}]},
 'A2': -598195211,
 'A3': 17,
 'A4': {'F1': 1714164424,
        'F2': 4041467751,
        'F3': -14603,
        'F4': [-0.23757988214492798,
               -0.07148618996143341,
               -0.1160150021314621,
               -0.9815499782562256]},
 'A5': [49201, 24946, 30892, 29559, 12350, 53999]}

(b"MKKSE\x00\x00\x004\x0cB\x8c'\xe7(\x0b3P\xd7\ty\x92MF\x00\x02\x00Y"
 b'\x00\x04\x00\x00\x00a\x89\xd9\xdc\xfd\xd2\xb9\xbc\xe3o\xb8s\xbe$\xd2'
 b'\xe7\x19CO?\xe5\xaa\xc7\x87\xa5\xe6\xba\xad\xcb\x93\x16\x00\xb8C\x9f'
 b'\xa7\x94\xd1g\x8e\xfc\xbd\xa2\xe3~\x8f\x16\x12\x00\x00\x00\x02\x00\x00\x00'
 b'"\xbe\x91\x02<>\x81\x0f\xaa\xab)\x88\xb8\x8b\x14\xdd\xd4')

{'A1': {'B1': {'C1': 0.6770970963836682,
               'C2': -1379167466,
               'C3': [184, 17311, 42900, 53607, 36604],
               'C4': {'D1': -0.07953546941280365, 'D2': 143, 'D3': 5650}},
        'B2': [{'E1': -119, 'E2': 15698701482607829871},
               {'E1': -72, 'E2': 8340144048175661903}]},
 'A2': 205687847,
 'A3': -25,
 'A4': {'F1': 671822672,
        'F2': 3607722386,
        'F3': 19782,
        'F4': [-0.28322017192840576, 0.25207263231277466]},
 'A5': [43817, 35000, 35604, 56788]}

Вариант №9

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x53 0x55, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	Массив char, размер 3
2	uint8
3	int8
4	Структура B
5	int32
6	Размер (uint32) и адрес (uint32) массива структур E
7	Адрес (uint32) структуры F
8	int32

Поле	Описание
1	Адрес (uint16) структуры C
2	uint32
3	float

Поле	Описание
1	int32
2	Адрес (uint32) структуры D
3	Размер (uint32) и адрес (uint32) массива double

Поле	Описание
1	int64
2	int32

Поле	Описание
1	double
2	uint16
3	int16

Поле	Описание
1	int8
2	double
3	Размер (uint16) и адрес (uint32) массива uint32

(b'NSUfrfC&\x00Z\xb4\xcfk\xe4\xbfe+NN\xbaf\x0b\x00\x00\x00\x03\x00\x00'
 b'\x00j\x00\x00\x00\xa6\xa6\x13\x83\r\xa0\x7f\xb3\x84f8h\xe4\x19\xcd'
 b'\x0e\x96?\xeeT\xc3\xf6\x10/h?\xd1?\r\xa7\xcf\xe2\x94\xbf\xe8JJ-\x8d'
 b'^\xd2\xbf\xd5\xfe\x0c\t\xbf\x92x\xbf\xda\xd4\xef\x13>W,+\xedJQ\x00\x00'
 b'\x00&\x00\x00\x00\x05\x00\x00\x002?\xedu{\x8e\xf0\nd\xa2M^\xb9\xbf\xef'
 b',B\xd6t\x88\x8e\xf7\xff\xa7\xf0\xbf\xef\xb8\xec\x14\x8a\xf5\xbc\xcb\xe8'
 b'\x9a\x02\x1d\x164\xa5\x95\xaaz\xb4\xc1;\x02\x1bf}\xb5\x0e\x83\xdd\x83C{\xdb'
 b'\xe1\x1c3\xbf\xe5\xfc\x80\x1aCd\x0c\x00\x06\x00\x00\x00\x8e')

{'A1': 'frf',
 'A2': 67,
 'A3': 38,
 'A4': {'B1': {'C1': 736971345,
               'C2': {'D1': -6881584324366800668, 'D2': 432869014},
               'C3': [0.947847347824319,
                      0.26947347057242976,
                      -0.7590685739223437,
                      -0.3436307997892878,
                      -0.41924645308732766]},
        'B2': 3033492452,
        'B3': -0.89519202709198},
 'A5': 1320838667,
 'A6': [{'E1': 0.9205911437750953, 'E2': 41549, 'E3': 24249},
        {'E1': -0.9741529644563955, 'E2': 63487, 'E3': -22544},
        {'E1': -0.9913235093333053, 'E2': 52200, 'E3': -26110}],
 'A7': {'F1': 51,
        'F2': -0.6870728028253565,
        'F3': [487994533,
               2510977716,
               3241869851,
               1719514382,
               2212332355,
               2078007580]},
 'A8': -1508670707}

(b'NSUiro\x83\x1f\x00Rd,A\xb9\xbes\xe4\xbc\xe0\xe3X\xfe\x00\x00\x00\x03\x00\x00'
 b'\x00b\x00\x00\x00\xa2\xe4\x15:Ne\x91\x9fN\xf7}\xaaRW2S\xc5\xbf\xda'
 b'\xf9/\x7f\xc1\xef\xd4\xbf\xea\x1c\x01@\xfb\xec\x8e?\xce\xb2\x8d\xe0z'
 b'\xd4\x88\xbf\xe4K*#^\xb76V\x14\xa22\x00\x00\x00&\x00\x00\x00\x04\x00\x00'
 b'\x002\xbf\xdc\tWvP3\xd4\x0f\x19"\x87?\x95\x0e\xc8\xa8\xe3\xf7\x00\x81\xd4'
 b'CG\xbf\xeaG%\x11\x1b*\xe8\xe9\x08\x81\xad\x1d\xe5\xd3J\xf0u\x855,9'
 b'\xdb\x00\xdd\xe1Tg\xea\x97\xb8<\n\xf2\xb5\xb1\x15\xcd\xe0\x08?\xbf'
 b'\xc3H\x8e\xd0\x8e\xc9\xb0\x00\x07\x00\x00\x00\x86')

{'A1': 'iro',
 'A2': 131,
 'A3': 31,
 'A4': {'B1': {'C1': 1444192818,
               'C2': {'D1': 7318806030962240082, 'D2': 1462916037},
               'C3': [-0.4214590785629728,
                      -0.8159185666294364,
                      0.23982404194763185,
                      -0.6341753664798719]},
        'B2': 1680622009,
        'B3': -0.23817723989486694},
 'A5': -521971458,
 'A6': [{'E1': -0.43807016901047047, 'E2': 3865, 'E3': 8839},
        {'E1': 0.020564208324677757, 'E2': 33236, 'E3': 17223},
        {'E1': -0.8211846670249914, 'E2': 59656, 'E3': -32339}],
 'A7': {'F1': 63,
        'F2': -0.15065179046139354,
        'F3': [501601098,
               4034233653,
               741989120,
               3722531943,
               3935811644,
               183678385,
               365813768]},
 'A8': -468370866}

Вариант №10

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x47 0x51 0x4f 0x8, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

Поле	Описание
1	double
2	float
3	uint16
4	Адрес (uint32) структуры B
5	Размер (uint16) и адрес (uint16) массива char
6	Адрес (uint32) структуры E

Поле	Описание
1	Адрес (uint16) структуры C
2	uint32
3	int8
4	uint32

Поле	Описание
1	Размер (uint32) и адрес (uint16) массива структур D
2	uint64
3	uint64
4	int8

Поле	Описание
1	int32
2	double
3	uint64
4	Массив int8, размер 8
5	double

(b'KGQO\x08\xbf\xdeJ\xdd\xb0l\x99\xec?J\xccW"\xfd\x00\x00\x00~\x00'
 b'\x05\x00\x89\x00\x00\x00\x9e[\xa02%\xbf\xd3\x1a=\xfd\x9b]\x1c\x8c'
 b'\xf0\x19\x9b\xc5\xf2\xc3)N\x17 \xbc&\x12\x91\x8a?\xec\xf9\xb8\x1c'
 b'\x1b\xeb|\xdd\xa0\x90^?\xa8\x85\x9b~Bl\x80\x18\xa1l\xcdT\x92\x8e\x85$'
 b'\xb9c\x15L\x9c\xe2\x07?\xd3\xbdd]\x9c\xc0\xd0\x00\x00\x00\x02\x00'
 b'\x1fq\x1a\x9e\xc1\xdf)\xc2\xde\x07e\\\xa6gN\x82z_\x00g\xb6B\x04o'
 b'a\xf0\x0f\x00\xb4ethwtf\x10_?I8\x17\x83\xdd}\xcb\xff[\x18a\xd2\x00\x00'
 b'\x00\x02\x00\x00\x00\x8e?^O\x9a\x936\x9e\xf8')

{'A1': -0.47331945637634365,
 'A2': 0.7921804785728455,
 'A3': 8957,
 'A4': {'B1': {'C1': [{'D1': 1537225253,
                       'D2': -0.29847669378564645,
                       'D3': 10155645316552114985,
                       'D4': [78, 23, 32, -68, 38, 18, -111, -118],
                       'D5': 0.9054832982068173},
                      {'D1': -576679842,
                       'D2': 0.04789434353116295,
                       'D3': 1774819357303672453,
                       'D4': [36, -71, 99, 21, 76, -100, -30, 7],
                       'D5': 0.3084345735724243}],
               'C2': 8150001031190266590,
               'C3': 532934000680796794,
               'C4': 95},
        'B2': 3057779823,
        'B3': 97,
        'B4': 4027515060},
 'A5': 'ethwt',
 'A6': {'E1': [7354482916912011139, -2486607121633222190],
        'E2': 0.8684021234512329,
        'E3': -1825136904}}

(b'KGQO\x08?\xec\xe1\xd8\x83\x7f=\xd0?,\x0fky\x83\x00\x00\x00~\x00'
 b'\x07\x00\x89\x00\x00\x00\xb0\xd0\xd9\x08m?\xef\xca\xb0\xc6>\xfa\x88\xa2'
 b'\x94\xd13\xb0|\x97_\x0f\xe6\x0f`(Q\xa1\x1d?\xe0S\xe3\x96m\x10R\xaaj>A?'
 b'\xe8`\x89\xb7qI\xaa%\xa0ks6;\x85\xd77\x16xC[\x07\x8d;?\xd6\xbbJ\xea'
 b'\xe57\x88\x00\x00\x00\x02\x00\x1f\x97\xf4\xf2\x01\xf3\x15.\xa3z\xdb\xdb'
 b"\xb8oa\xba,x\x00g\x8a\xcb\xe5 \xe4\xaa='\xd4tblbbvf\r/\xe2>\x10/\xb6\xae"
 b'~>\xcb\x17\xa2\x1dl\xba\xb1m\xff\x80U\xa9\x1b\x17B\xf9.\xed#\xa3\x8cf'
 b'\x00\x00\x00\x04\x00\x00\x00\x90=\xd0\xf7\x04\xd4\xa4<\xd3')

{'A1': 0.9025690620709899,
 'A2': 0.6721102595329285,
 'A3': 31107,
 'A4': {'B1': {'C1': [{'D1': -791082899,
                       'D2': 0.9934924957268132,
                       'D3': 11715218550631995231,
                       'D4': [15, -26, 15, 96, 40, 81, -95, 29],
                       'D5': 0.5102403581627277},
                      {'D1': -1435877823,
                       'D2': 0.761784418379013,
                       'D3': 2711285118252320215,
                       'D4': [55, 22, 120, 67, 91, 7, -115, 59],
                       'D5': 0.35518143595697227}],
               'C2': 10949642684231659171,
               'C3': 8852911077715982892,
               'C4': 120},
        'B2': 2328618272,
        'B3': -28,
        'B4': 2856134612},
 'A5': 'tblbbvf',
 'A6': {'E1': [950226802585876142,
               9096931599699504314,
               -5661588229876802793,
               4825940071744244838],
        'E2': 0.10203364491462708,
        'E3': -727434029}}

Вариант №11

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x85 0x57 0x4b 0x4d 0x54, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'\x85WKMTa\xe9\x80\xcex\xff\x1b\xbd3\xd3\xc4\xbf\x1f\x00\x03\x00;\x00\x02'
 b'\x00\x00\x00>\x00in\x02\x00\x00\x00\x1d\x00\xa9\xd1\xfcP-X\xa7.c\xfc\xec'
 b'\x88f\xaaU:\xdb?\xb2\x05\xe5\x98fbk\xe5\x13l\xa5\x8b\xe2K\x04l\xb7'
 b'W\x7f\xd0\xcb\xdb?\x14?\xca\xdd\xcc~@\x93y\xe4\x84n\xe4\x84\xd0\xa4\x9f{'
 b'\xe9?\xa0\xd3\x1d\x03')

{'A1': 3464554849,
 'A2': -0.16269537671905332,
 'A3': {'B1': 'in',
        'B2': {'C1': -11863, 'C2': -260313057183575812},
        'B3': 0.42543546333958093,
        'B4': 2565146034},
 'A4': 'fbk',
 'A5': [{'D1': 309590088808666085,
         'D2': 0.43431484638028084,
         'D3': [16148, 56778]},
        {'D1': 7963741251910532812,
         'D2': 0.7963407725366349,
         'D3': [54176, 797]}]}

(b'\x85WKMTH:\x0ct\xd8\x03\xfc\x1c\xc3M\xd6?\x1f\x00\x02\x00;\x00\x03'
 b'\x00\x00\x00=\x00gg\x02\x00\x00\x00\x1d\x00\xdaklz\x0bl\xf4\x11\x1d\xa5\xd0'
 b'\xa0\xbbyS\x00\xbc\xbf\xf9m\x18]atI\x13T\xfe\x8b{VPd\xe7\xc0?Vr\xda'
 b'?\xed\x01\x96\xb2P\xb4\x83\xd4\x86\xf0\xa7!\xd8\xce\x81\x10mt\xc5?\xc9\\\xb3'
 b'P\x82"\xbc\xe6\x83k\xac9P\xecY\xd5\xa8\xfd\xed?\xef6\x90\x99')

{'A1': 1946958408,
 'A2': 0.3484962256480322,
 'A3': {'B1': 'gg',
        'B2': {'C1': 27610, 'C2': -6549058541644449172},
        'B3': -0.10937997552867107,
        'B4': 1561882105},
 'A4': 'at',
 'A5': [{'D1': 5788950212228944713,
         'D2': 0.4132285711854051,
         'D3': [493, 45718]},
        {'D1': 2425171386243986512,
         'D2': 0.16761554056176098,
         'D3': [23753, 20659]},
        {'D1': 4155814770412102274,
         'D2': 0.9372142951027715,
         'D3': [14063, 39312]}]}

Вариант №12

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x4e 0x57 0x55 0xbe, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'UNWU\xbe\xe4q\xb6SNi\xf6\x12\x00\x00\x00!\xbf\xd7\xc1X\xb5\xc6\n'
 b'\x88\x00\x00\x00U\x00\x04\x00qrp\xa8\x1e\xa6\xb7\xe8\xb7\x9b\xdbB\x05S\xa1{'
 b'\x08\xa1\xbf\xc1\xfe\x9f\xdd\x18\x92\x88\xb6\xe6\x93m\xce[X\x82U\xa0'
 b'\xa1\xa2\xb7\xb4\xb8o\xc0\xa7i\x9a\xa1\xf04\xe6\xc8\x12\xcc\x00\x00\x00'
 b'\x02\x00\x00\x00;\x00\x04\x00Q\xeekK\x85\xdc$=\xdak\x99\x0f\xd2U^\x07'
 b'\xef\x99E\xe0\xd8Sq9;t\r\x10\x8b\xb8%\xb7\x9c')

{'A1': 16461138581929981458,
 'A2': {'B1': 'rp',
        'B2': 168,
        'B3': 7846,
        'B4': -1209485413,
        'B5': -2647547774190810975,
        'B6': -0.14058302207662998,
        'B7': 182},
 'A3': -0.3711759352810664,
 'A4': {'C1': [{'D1': 230,
                'D2': 147,
                'D3': 1842240344,
                'D4': 2186649761,
                'D5': -94},
               {'D1': 183,
                'D2': 180,
                'D3': 3094331559,
                'D4': 1771741680,
                'D5': 52}],
        'C2': [-26, -56, 18, -52],
        'C3': 17179908241830985178,
        'C4': 1805193170,
        'C5': 1432225775},
 'A5': [2571493592, 1399929147, 1947013259, 3089479580]}

(b'UNWU\xbe\xa6\xc93ohuhG\x00\x00\x00!?\xdb\xcb&}\x1c\xdfT\x00\x00\x00'
 b'W\x00\x02\x00sdd\x04H\xf1^MK}\x9a^8\xfe\xb1\xe7\xf3{\xbf\xdd4\x08\xf5\xb4'
 b',\xa4o\x07.k\xd2>\x91\x8e\xc6\xfd\xa5 ~O8V\x12\xf6\xc5D\xdb\xe9|jY\x1f'
 b'2\xb7\xee\x00\x00\x00\x02\x00\x00\x00;\x00\x06\x00Qc&\x1c&\xd9\x04\xfb,B'
 b'\xa5\xa7\xd6\xdd\x88#\xe4\xe7d\xf1\xe0\x91\x83\xec1')

{'A1': 12018193634201790535,
 'A2': {'B1': 'dd',
        'B2': 4,
        'B3': 18673,
        'B4': 1582123901,
        'B5': -7323353277500230789,
        'B6': -0.45630096430313416,
        'B7': 111},
 'A3': 0.4342743131451148,
 'A4': {'C1': [{'D1': 7,
                'D2': 46,
                'D3': 1808940689,
                'D4': 2395405733,
                'D5': 32},
               {'D1': 126,
                'D2': 79,
                'D3': 945165046,
                'D4': 3309624297,
                'D5': 124}],
        'C2': [106, 89, 31, 50, -73, -18],
        'C3': 7144428812045187884,
        'C4': 1118152662,
        'C5': 3716686820},
 'A5': [3882152416, 2441342001]}

Вариант №13

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xb7 0x59 0x41 0x4e, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'\xb7YAN\xb6h\x00\x00\x00A\xc4\xba\x15$V\xe3HiFm\xb08\x06\xaa!\x83\xef\xaa'
 b'\x86\xa0\xae\x0e\x98\xb2\x1d\xdc~\xce7\xdd\xf71\x8b\x1a\x0c\xff\xe0|JE5`'
 b'\xffr^\xd30\x00\x00\x004\x00\x00\x00\xf6\x0b\xa9\xf3\x168\xec? Pg\x11'
 b'\x17\xf4\xc3?\x02\x008\x00\x1dZ\xd8\x9c\xf6\xed\xb3\xcdzY\xfe\xa4'
 b'\xbe\x1c\xb67\xc1\xdb\x8f"nm@\x00\xc93e>\x08C\x14 ')

{'A1': -74,
 'A2': {'B1': 28014,
        'B2': {'C1': 0.8818468817702285,
               'C2': 0.15588653898032678,
               'C3': [{'D1': 17738, 'D2': [53, 96]},
                      {'D1': 29439, 'D2': [94, -45]}],
               'C4': 2631424541,
               'C5': 11889038450276691446,
               'C6': 2490450741869026494},
        'B3': 0.22383035719394684,
        'B4': [8, 67, 20],
        'B5': 32},
 'A3': {'E1': 364561473,
        'E2': [22052, 18659, 18025, 45165, 1592],
        'E3': 8618,
        'E4': [-4221, -31062, -20832, -26610, 7602, 32476],
        'E5': 14286,
        'E6': 221,
        'E7': 8998472482936271351}}

(b'\xb7YAN\x92h\x00\x00\x00SQ\xd6\x1e\xc1m \x19\xca\xdf\x1e\xe6\x92\x15T'
 b'o\xaa\xd1\xf0J\xc8\x80\x80AkJ;\xfbF\x12\xf2\x827\xa8\xdd{\x05\x19\x00'
 b'\xfdOY\xb1}+=\xd70\x00\x00\x004\x00\x00\x00\x18\xfb\xa9Wy\x83\xcf\xbf'
 b'\x80v\xd1\x95i\x15\xdf?\x02\x008\x00\xe7M?\x9cQ\xfd\re\xad\xd5~\tc\xc9K\xa0'
 b'\x1c\x8ao\\p\x00@\x00l\x95\x04?8gS\xd6')

{'A1': -110,
 'A2': {'B1': 112,
        'B2': {'C1': -0.24619976788013598,
               'C2': 0.48568191176114084,
               'C3': [{'D1': 20477, 'D2': [89, -79]},
                      {'D1': 11133, 'D2': [61, -41]}],
               'C4': 2621394407,
               'C5': 684219134108368209,
               'C6': 6660694229457291619},
        'B3': 0.5179049968719482,
        'B4': [56, 103, 83],
        'B5': -42},
 'A3': {'E1': 517362003,
        'E2': [28097, 6432, 57290, 58910, 5522],
        'E3': 28500,
        'E4': [-11862, 19184, -32568, 16768, 19051, -1221],
        'E5': 4678,
        'E6': 242,
        'E7': 7042903975671682}}

Вариант №14

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x4e 0x41 0xb6, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'HNA\xb6\x0f\x82k-\x00W\x00Y\x11\xe2\x85\xc3\xa5\xb8V\x86\x00\x06\x00['
 b'\x00\x00\x00\x03\x00\x00\x00az)\xbc\xf3\x00\x02\x00\x00\x00dS\xdcIX\xf3\x00'
 b'\x04\x00\x00\x00lx@?\xcd\xe1\x97\x83l\xf5\x90\xe63\n\xae\xa23K\x03\x91'
 b'>\xc5\xb1>v2RbU\xf0j\\4c@\xbe\xc0\x15W\x00E/\x1e\x19\x83\xb8\xc7_\x91GS\x11'
 b'\x01\x89\x81\x1dD\xff\x19\xa8')

{'A1': 260205357,
 'A2': {'B1': {'C1': [{'D1': 190, 'D2': -64}, {'D1': 21, 'D2': 87}],
               'C2': 1288739518726821510,
               'C3': {'E1': [0, 69, 47, 30, 25, 131],
                      'E2': [184, 199, 95],
                      'E3': 122,
                      'E4': 41,
                      'E5': -68},
               'C4': 243},
        'B2': [-1857596655, 25788701],
        'B3': 1406945624,
        'B4': -13,
        'B5': [68, -1, 25, -88],
        'B6': 30784,
        'B7': 0.2334470168806715,
        'B8': -432862546},
 'A3': -6758976137059187279,
 'A4': 0.24042633175849915,
 'A5': 7085833928341480256}

(b'HNA\xb6f\xb7\xe8]\x00W\x00Y\x1dF\x88t\x94\n\x86\xc3\x00\x05\x00['
 b'\x00\x00\x00\x03\x00\x00\x00`Df\xfe\xe5\x00\x02\x00\x00\x00c\x84N'
 b'\x90\xc4\xbc\x00\x05\x00\x00\x00k\x8aB\xbf\xe942\xe9/\xb6\xdeMk]\xbbJ'
 b'#t\x04\xb5\x92i\xee>h\xe1i\x97\x98\x88mn\xabG\x88c\x96z\xe0+1\xc2\xc8\x12'
 b'lG\xa8\xc3>\xa7\xc5\xf8\xab\xc1\xae\xfe%S\xb3I')

{'A1': 1723328605,
 'A2': {'B1': {'C1': [{'D1': 99, 'D2': -106}, {'D1': 122, 'D2': -32}],
               'C2': 2109523509750957763,
               'C3': {'E1': [43, 49, 194, 200, 18],
                      'E2': [108, 71, 168],
                      'E3': 68,
                      'E4': 102,
                      'E5': -2},
               'C4': 229},
        'B2': [-1019303995, -122961490],
        'B3': 2219741380,
        'B4': -68,
        'B5': [-2, 37, 83, -77, 73],
        'B6': 35394,
        'B7': -0.7876219324513973,
        'B8': 1298881979},
 'A3': 5342241146566502894,
 'A4': 0.22742237150669098,
 'A5': -7523113173932882040}

Вариант №15

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x4c 0x46, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'PLF\x02\x00F\x00R\x00\xf2\xa2\xf6\xfc\xeb\xb8\x8e\xacm\xb8\x11\x16G\xbf\xba'
 b'?\xb6\xc2\xd9\xf9\xe3\xbf\x997\xcc=\x8a{>\xd1oknrree\xb3\x88Q\xa7\xbd*'
 b'\xf2\xcc\xdf`\xf3+W\xe3mIV$V9!Z\x8b3\x9b5\t2vb6\xe7[Zez\xddA\xad\x18\xc2\xea'
 b'|\xbf')

{'A1': [{'B1': 839464347, 'B2': 'vb'}, {'B1': 1515972406, 'B2': 'ez'}],
 'A2': {'C1': {'D1': 414007773, 'D2': -0.9879571199417114},
        'C2': -23822,
        'C3': 13289467804428008694,
        'C4': -0.7776804566383362,
        'C5': -0.6242493441550245,
        'C6': 0.09971541911363602,
        'C7': 3510533002},
 'A3': 'oknrree',
 'A4': [2807138483, 3438422717, 737370335, 1231938391, 961946710, 864770593]}

(b'PLF\x02\x00F\x00R\x00\x95q\x10\x84};\xc2\xb9\x1b\xc2/EJ?4\x8e,\x94\x88'
 b'\x82\xd5?\x7f\x0c\xd9>\x0e\xd1\x7fllwrpyof\xb8m\xcdq\xab\xb6U\xa6?<G\xe5m"'
 b'\x00\xa5I\x04\x80\x88\x93\x15\xe7\x1f\x8coH\xb3fhn\xf6\xa1\xfenpE\x86'
 b'\xca\xb6\xf3\x80\x8c>')

{'A1': [{'B1': -1287098484, 'B2': 'fh'}, {'B1': -22940050, 'B2': 'np'}],
 'A2': {'C1': {'D1': -1228241339, 'D2': 0.2744213044643402},
        'C2': 29077,
        'C3': 13986977311602082832,
        'C4': 0.7901181578636169,
        'C5': 0.33609213323709075,
        'C6': 0.42392346262931824,
        'C7': 1820315918},
 'A3': 'lwrpyof',
 'A4': [1909288376, 2790635179, 3846650943, 2768249453, 2290091081, 535238035]}

Вариант №16

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x53 0x57 0x58 0x51 0xa3, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'SWXQ\xa3\x82\x081\x86\x83"S\xef\x1d4q\x00\x00\x00\x03\x00\x00\x00z\x00G7\x1f'
 b'\x8ef\x9e\xca\x93\xbf\xbe\xf5\x8aJ4\xa6\xa5A%\x95\x85\x06(\x04\x00\x00\x00}'
 b'\x00\x00\x00\xd1\x14\xa5\x8c8\xf2\x0bt\xdeG\xc9o1\xf3H\xb7\x95\x16o\x15\x9a'
 b'\x0be\xefwd0v\x8a\xd5fQ5\xe5g\xe2Y\x03\xcc\xb3vX\xd5R\xfa\x1e\xdab\xe9'
 b'\xbb\xc2\xbe\x8b\xc6OQve\x02\x00\x00\x00o\x00\xc5\xa6\xbehzk?\xeeD'
 b'?\x1a\xa4\x95G\xfc\xef\xe6\xbf\xd3]\x81k\xd2\x12g\xbfH\xee\x8f'
 b"\xe1\xc4\x15\xcd?o;3\x1d\xf5Q\xdd>\x80Z\x05\xda\x9fi\xb9?\x98\xd3\x15'\x90s`"
 b'\xbed\xff\xc4u\xdfP\xe5\xbf\xa0/\x83\xf4')

{'A1': 17245165346419181698,
 'A2': 29,
 'A3': 52,
 'A4': {'B1': {'C1': 've', 'C2': -59, 'C3': 48806},
        'B2': 'hzk',
        'B3': -1910556857,
        'B4': -24986,
        'B5': 37834,
        'B6': 2331360959},
 'A5': -8821103331253013430,
 'A6': 10246,
 'A7': [{'D1': 0.7692603468894958, 'D2': -0.7167951009879545, 'D3': 1803640275},
        {'D1': -0.9026309251785278, 'D2': 0.22722683919697517, 'D3': 489896815},
        {'D1': 0.43226590752601624, 'D2': 0.0992679507520311, 'D3': 655741848},
        {'D1': -0.2191908359527588,
         'D2': -0.6661221790491081,
         'D3': 4102238112}],
 'A8': [8362043457835177169,
        -5239670772791162914,
        -1196537369584527723,
        5865610355361735799,
        -5491010161086044875,
        7123039821120231542,
        5859119943735491561]}

(b'SWXQ\xa3\x15 \x84\xb5_\xca;\xb5\xbclq\x00\x00\x00\x02\x00\x00\x00z'
 b'\x00\xaf\xcb\xd6\x8d\xeb\xf4U\x96\x86\x81IVHr\xaa(\xedK0\xa9hn\x03'
 b'\x00\x00\x00|\x00\x00\x00\x85j>\xf5D\x152\x87\xda\xfa\x10\x1e\x18\xb2j|\xe3'
 b'\xfa\xf2\x9eS\x86$v\x85\xe3_\x89\x0b\xfe\xff\xfe;\xb1\x96R\xb7'
 b'\xce\xd2\xd4\xa5\x14kXe\xfb(\x04LL\xec-\xe8\x0f"\xf4ty\x02\x00\x00\x00o\x00O'
 b'\xd5\xf4kg\xf9/\x13?P\x88\xd3\xe0\x86#\xb6\xbfpf$1\x13\xa5O=\x8cd%Udr\xd9?'
 b'\xf0\xea\xa2\x8b\xad~\xb3\xbe\xacRRx^\xe8\xee\xbf\xc7l\xf15')

{'A1': 13059254056906924053,
 'A2': -68,
 'A3': 108,
 'A4': {'B1': {'C1': 'ty', 'C2': 79, 'C3': 62677},
        'B2': 'kg',
        'B3': -1915302993,
        'B4': -2837,
        'B5': 38485,
        'B6': 1447657862},
 'A5': -6255416400456027576,
 'A6': 28264,
 'A7': [{'D1': 0.5749507546424866, 'D2': -0.08647959698603924, 'D3': 824469104},
        {'D1': 0.0506945364177227, 'D2': 0.39760692896886307, 'D3': 2342710000},
        {'D1': -0.35057583451271057,
         'D2': -0.9658653593092672,
         'D3': 905014471}],
 'A8': [-8704871743837279611,
        8965173824887782106,
        8513076889344211683,
        -72059743511780475,
        -3111197105799646917,
        299765787913819301,
        -855103489369682868]}

Вариант №17

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x58 0x54 0x4f, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'XTO\x00\x00\x00\x03\x00A\x9c\xbf\xd8\xca\x87\xa6`\xa8\xc8\x00\x03'
 b"\x00\x00\x00YAX\x16\x012l\xec&:\xc4u&\xd8'\xa7\xbf\x84<6f\xbb\x1c\x80Q"
 b'\x9d\xee\x00_\xa8\x1a]-\xd4\xe9\rH=p~:\x8b\x00\x04\x00\x00\x004\x0b'
 b'B\x00\x05\x00\x00\x0084\\\x00\x04\x00\x00\x00=G@Y8_\x13\x96]-t\xb2\xd6\x98'
 b'\xf1iN\x9e[\xaa\x9c\x8a\x94\x82\xf3\\\x8f\xf4\xbe\xf0S&5b\xae\xd7\xc4,'
 b'\xc9\xeeg\xe0\xd7\x91\x08\x9b\\\xdd\x97\xcf\xff2\x07\x80\xa62=\xab\xc4&\xf2')

{'A1': {'B1': [{'C1': [-88, 26, 93, 45], 'C2': 2882},
               {'C1': [-44, -23, 13, 72, 61], 'C2': 13404},
               {'C1': [112, 126, 58, -117], 'C2': 18240}],
        'B2': {'D1': 156,
               'D2': -0.3873614430218706,
               'D3': [22840, 24339, 38493],
               'D4': 16728,
               'D5': 5633}},
 'A2': {'E1': 3633538648320013606, 'E2': 216},
 'A3': 10151,
 'A4': -0.009880471239183786,
 'A5': {'F1': 81, 'F2': [-99, -18]},
 'A6': {'G1': 3275439463763896654,
        'G2': 2656807580,
        'G3': [2324988659,
               1552938174,
               4031981109,
               1655625668,
               751431271,
               3772223752,
               2606554519],
        'G4': 3489608199,
        'G5': 9270152123444897522}}

(b'XTO\x00\x00\x00\x06\x00N\x9c\xbf\xe49q\x1e\x04\x7f\x9c\x00\x03\x00\x00\x00~'
 b'j\xd7\xb1\xcd\xf4\xd9\xad\x84\xf5:b\xaaQ.\x18\xbf\xe3*\xba\xc20\xb18\xa7'
 b'\xfe\xad\x00\x84Q\xca\x91H\x91\x0b\xc03T\xd0f\xd57\xd5r\x14Sr\xcd3I,F\xc0'
 b'P\x07\x00\x04\x00\x00\x004\x99!\x00\x04\x00\x00\x008\x92L\x00\x06'
 b'\x00\x00\x00<Z\x0c\x00\x06\x00\x00\x00B;\xba\x00\x02\x00\x00\x00H'
 b'\x13\x8e\x00\x04\x00\x00\x00J\x13\xe7\xc5!d\\\\\xfdj\x81W\xdfBU\x7f_'
 b'\x7f\xb9\xc5\x8cAC>\x8d\x8a\xfb\x12r\x1d\xad\x8a$\xc4,I\xf2\x99\t\xd0U^^i-'
 b'\x9fd`\xa9\x82qc\xf2\xa2u\xb9\x08\xe35/\xb3')

{'A1': {'B1': [{'C1': [81, -54, -111, 72], 'C2': -26335},
               {'C1': [-111, 11, -64, 51], 'C2': -28084},
               {'C1': [84, -48, 102, -43, 55, -43], 'C2': 23052},
               {'C1': [114, 20, 83, 114, -51, 51], 'C2': 15290},
               {'C1': [73, 44], 'C2': 5006},
               {'C1': [70, -64, 80, 7], 'C2': 5095}],
        'B2': {'D1': 156,
               'D2': -0.6320119463234621,
               'D3': [50465, 25692, 23805],
               'D4': 27351,
               'D5': -20019}},
 'A2': {'E1': -803420271947390294, 'E2': 81},
 'A3': 11800,
 'A4': -0.5989660065438676,
 'A5': {'F1': -89, 'F2': [-2, -83]},
 'A6': {'G1': 7674511856418258783,
        'G2': 2142881164,
        'G3': [1094925965,
               2331710066,
               497912356,
               3291236850,
               2567557205,
               1583245613,
               2674155689],
        'G4': 2188469234,
        'G5': 11706466254242262963}}

Вариант №18

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x4c 0x4a, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'NLJ\x00\x88&\xe8\x9aj\xd7?\x83)\xaav\x95kC\xe4\x03\x00\x00\x00:'
 b'\x00\x00\x00\xfa\xa1r\xc3ox?F\x00\xf8\xcb\xf9i2\x02P\xb5\xd0\xcfizw\xedfz'
 b'iPqwd\x1a.\x00\x00\x002\x00\x00\x006\x00\x00\x00`4eeI\xbe\xc9?\x9c7'
 b'\x87\x14z\xd9{2%\xa9\xd6\x0b{\xc3.\xc6\x93#$\xe4\x96i\r\x9f/n\xe9\x0f\xd9>'
 b'Wk\xe2E\xb5\xef\x98\x862R\xfdGF<\x0c[2?4\x16\xa2>5\xb7H\xbf\xbe-'
 b'\x1d\xbf\x18,\x06?2\xbbS\x02\x81\xadx|\x87\xe26#"\xbdl,')

{'A1': 0.3658816592306948,
 'A2': 16448108553772345731,
 'A3': [{'B1': 'izw', 'B2': 237},
        {'B1': 'fzi', 'B2': 80},
        {'B1': 'qwd', 'B2': 26}],
 'A4': -6,
 'A5': 29345,
 'A6': 0.9704553484916687,
 'A7': {'C1': {'D1': 0.2011195893377673,
               'D2': 3637740242385450908,
               'D3': [198617381,
                      3324953467,
                      3827573651,
                      2668456342,
                      266956335,
                      1800879833,
                      4021634530,
                      1379042968],
               'D4': [0.012102124281227589,
                      0.6967017650604248,
                      0.31657564640045166,
                      -0.7840455174446106,
                      -0.6139792203903198,
                      0.5241103172302246],
               'D5': [47922, 595, 44417, 31864, 57991, 9014, 48418, 11372]},
        'C2': -5381799139158144008,
        'C3': -48,
        'C4': -49}}

(b'NLJ\xce\x07\xdb\xeb\x1e\x18\xeb\xbf2\x1aa\xe6g\x8e+\x19\x03\x00\x00\x00:'
 b"\x00\x00\x00\x7f\x1c'\x01\xfb\x9f>F\x00\xd0\xd1\x0b\xf1v/teG\xbdgib\xe2su"
 b'e\xe3saj\x8a.\x00\x00\x002\x00\x00\x006\x00\x00\x00\x14f\x11t\xbeY\xd1?\x0c>'
 b'A\xf2p\xab\xb1\xff8k\x01\xc4&\x94\xd2\r\xf7\xf4\x9dh\x04I\xc6\x18\xb0\x8d'
 b'\xdd\xfdN[`\xd4\x98\xf62\xe9\xd9\r\xba\x80}\xf6!\xbf?G\x95<bf'
 b'\xd4\xbe\x80\xa0\x04?\x92\xf8\x95\xbe\x97\xe2\xad\xbeK\x06\xc0)\xafjrFD\xcc'
 b'\xdd\xb6-\x14\xf3r')

{'A1': -0.8466944319300127,
 'A2': 1813699851844655666,
 'A3': [{'B1': 'gib', 'B2': 226},
        {'B1': 'sue', 'B2': 227},
        {'B1': 'saj', 'B2': 138}],
 'A4': 127,
 'A5': 10012,
 'A6': 0.31246188282966614,
 'A7': {'C1': {'D1': 0.2711025365329942,
               'D2': 18424696052138458636,
               'D3': [3288427320,
                      231904294,
                      1755182327,
                      415648004,
                      4259155376,
                      3563084622,
                      3912431256,
                      2159676889],
               'D4': [-0.6326673626899719,
                      0.018222449347376823,
                      -0.4148436188697815,
                      0.5180740356445312,
                      -0.2929120659828186,
                      -0.33961936831474304],
               'D5': [1611, 10688, 27311, 18034, 52292, 46813, 5165, 29427]},
        'C2': 7310520283025887696,
        'C3': 71,
        'C4': -67}}

Вариант №19

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x53 0x54, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'VST\xee\xa8\xa9\xe4s\x80fV\x7f\xe8\xbf&ww\x00\xb9&\xfd\xf5\x07\x00'
 b"\x00\x00\x81\x00\x00\x00,\xfc\xffJ\xbf\xb2'\xdf\xf7T\x91\x87y6U\x9fgV"
 b'\x1d\xc0\xf5\x0c-i\xa6\xe5k?\xbcP\xbc\xb70\xb7\xd8?\x93\xb9a\tH\x80897\xca'
 b'&\xc6\xbf\xdbN:\xe9\x9a\x03\x00\x00\x00D\x00\x00\x00A\x19\xe6\x08'
 b'\x12\xd6\xad\xc8\xe4?\xeb+\x81\x9f\xc8\x02\x00\x00\x00\\\x00\x00\x00G'
 b"\x00^\x00'W&>\x98\xa2\x02\x00s\x00\xfa\xc8\xd3>\x08!\x13?h\xcf\x1f"
 b'>\xba\xd0\x1e\xbf\xb7mi\xbe\x81i1? 3B\xbe')

{'A1': -18,
 'A2': 43432,
 'A3': -0.7655441286075271,
 'A4': 30502,
 'A5': {'B1': {'C1': 0.16244183480739594,
               'C2': -23912,
               'C3': [{'D1': -0.1730587739606939,
                       'D2': -382054693,
                       'D3': 154,
                       'D4': [97, 9, 72]},
                      {'D1': 0.6494969540656512,
                       'D2': -1618924565,
                       'D3': 200,
                       'D4': [65, 25]}]},
        'B2': 9913,
        'B3': {'E1': -2563,
               'E2': [0.4136427044868469,
                      0.5747227668762207,
                      0.15606462955474854,
                      -0.6203724145889282,
                      -0.2279575914144516,
                      0.6930161118507385,
                      -0.18964815139770508],
               'E3': -2366726544493118420,
               'E4': [11481142720644338935, 7578727997564081767],
               'E5': 0.9214729070663452,
               'E6': 0.38618104880266535}},
 'A6': -18029}

(b'VST\x96.\x90by$\xb9.\xd5\xe9\xbfJ\x12v\x00\xa0_\xb3g\x03\x00\x00\x00\x80\x00'
 b'\x00\x00\xe5K\xa9\x9a\x19\xef\x89\xb1/\xa1~)\x8f\xc7\xd9\xac\xb0\xfc'
 b'+\x87\xee\x88!\xcbi\x13\xe7=(t\x82\xd6v\xbb\xea\xbf\xeet\xc1a\x92\x81'
 b'\x8a\xa9\xa0w\xed??\xa4\x18\xe3\xa5\x02\x00\x00\x00D\x00\x00\x00\x81'
 b'^\x80\xc4\xa1V2A\xbd?\xd5\\W\xe61\x02\x00\x00\x00[\x00\x00\x00F\x00'
 b']\x00\xb15p?`\x9d\x02\x00r\x000\x18a\xbf\xa8Y\x04?\xf2 b\xbd')

{'A1': -106,
 'A2': 36910,
 'A3': -0.8072732559265143,
 'A4': 4682,
 'A5': {'B1': {'C1': 0.9383192658424377,
               'C2': -25248,
               'C3': [{'D1': 0.9208529769276075,
                       'D2': -484924353,
                       'D3': 165,
                       'D4': [-63, 97]},
                      {'D1': 0.11427607169186338,
                       'D2': -430482219,
                       'D3': 49,
                       'D4': [-127, 94]}]},
        'B2': 24480,
        'B3': {'E1': 26547,
               'E2': [-0.8792753219604492,
                      0.5169930458068848,
                      -0.05520720034837723],
               'E3': -5653724963938939931,
               'E4': [12455205662160232751, 14637130821982223536],
               'E5': 0.11282999068498611,
               'E6': -0.8353838147774058}},
 'A6': 29934}

Вариант №20

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x4a 0x52 0x87, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'DJR\x87\x88\x00\xef\xf1\xac\x0eu\x1a\xc5\xa1&\xfa\xdc\xc2\xfd\x93'
 b'G\x9b\xe9\xeb\xa7%G-l>\x97:\xdb\xb7[Jp\x8b]\xb1\xf3\x19\xfb\xb5C\xb3cn'
 b'\x02\x00\x12\x00\x00\x00\xd1\x18\xc8a\x828)\xbf,&A\x1aK\xad\xa6\n\xd7\x03'
 b'\xd3s\xab\x07\xd8U\xf8j\x990\xaf\xe1\x172\x91\x0f\x93\xc6h)y"\xd7\xb8'
 b"\x92up\x06\xf2\xd0*\x0f\xba\x19\xc4\x07\xb5\r\xdb,\xdc\x05''Z\xdek\xba"
 b'&qu\x02\x01X\x02\x00\x00\x00\x10\x00"\x00\x00\x006\x00a\x98\r\xe8^\xa5'
 b'v~\xe6q\n')

{'A1': {'B1': {'C1': [{'D1': 13774603067926780113,
                       'D2': 44,
                       'D3': 38,
                       'D4': 6721},
                      {'D1': 8346018756579208523,
                       'D2': -85,
                       'D3': 7,
                       'D4': 21976},
                      {'D1': 3609601768911629048,
                       'D2': -111,
                       'D3': 15,
                       'D4': 50835},
                      {'D1': 8472037083173169512,
                       'D2': 112,
                       'D3': 6,
                       'D4': 53490},
                      {'D1': 987704232104300330,
                       'D2': -37,
                       'D3': 44,
                       'D4': 1500},
                      {'D1': 8153409147855578919,
                       'D2': 117,
                       'D3': 2,
                       'D4': 22529}],
               'C2': [-36, -62],
               'C3': {'E1': [19035,
                             -29840,
                             -20131,
                             6643,
                             -18949,
                             -19645,
                             28259],
                      'E2': [2713396689079079933, -5198496923607356089]}},
        'B2': -401762207,
        'B3': [94, -91, 118, 126, -26],
        'B4': 2673},
 'A2': 11656752300578107887,
 'A3': 64038}

(b'DJR\x87\x88\x00\xbb\xd6b\x02fk\xce\x92H\xe5>\x00\xf2h-Q\xc6c\xfc/6\xf1'
 b'\x0e\x1e\xd5\xed\x91\xba\xc3Z\xd5\xcd\xa6\xf63\x06\x99\x1b\x0e\x9cT\xd2'
 b'\x02\x00\x12\x00\x00\x00\n\xe0\xe9o\xaa\tz\xd7\xa7$\xadt\xf4\xe1'
 b"\x86*\xf2\xba[\x88\x0c2\n\xa0'\xe4\xd6\x0f\x94,\x80\x88R\x95S\x06\x18]"
 b'\x87\xa0>\xd3\x0eG\xac\xfb:l\xb1<Z\xe3h\xe4Q8\x15\xb3\xb2#\r\xd3'
 b'\xc0\xe0\xd9\xcd\xc9\xcey\x8b\xad\xa3\x02\x00\x00\x00\x10\x00"\x00\x00\x00'
 b'6\x00+S\xa9\x91\xe4\xfc\xceB4p\x8d')

{'A1': {'B1': {'C1': [{'D1': 15526733292939894794,
                       'D2': -89,
                       'D3': 36,
                       'D4': 29869},
                      {'D1': 9825652561297203700,
                       'D2': 12,
                       'D3': 50,
                       'D4': 40970},
                      {'D1': 9835910600609686567,
                       'D2': 82,
                       'D3': -107,
                       'D4': 1619},
                      {'D1': 5120262092301491480,
                       'D2': -84,
                       'D3': -5,
                       'D4': 27706},
                      {'D1': 4058275878379601073,
                       'D2': 21,
                       'D3': -77,
                       'D4': 9138},
                      {'D1': 14900667177794327309,
                       'D2': 121,
                       'D3': -117,
                       'D4': 41901}],
               'C2': [62, 0],
               'C3': {'E1': [23235, -12843, -2394, 1587, 7065, -25586, -11692],
                      'E2': [3457748317330303218, -5002956211443797706]}},
        'B2': -1851174101,
        'B3': [-28, -4, -50, 66, 52],
        'B4': 36208},
 'A2': 10578510660610741947,
 'A3': 58696}

Вариант №21

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x57 0x4c 0x49, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'CWLI\x19\x00\nvy\xa4x\x00\x97\xbb\x12\xa2\xce\xeeQVm*fdx\xb0\x0c"4\xeaW@'
 b']\x85D\xf3G\xecB\xb5YM\xf1\r\x1c\xecZ;\x1f\x046\xab\x08\x95\xbe\x82'
 b'\x03\x00\x00\x00\x16\x00\x00\x00\xebo\x8a#\xc0xE\x10\xef\x94\x9e=\xb0[L\n'
 b"\x9b4\xfb\x82=JHen\xf3h\xbfV\x0cw?\xcd9T\xbf\x18\x19\x10?'\xd5E\xbf"
 b'\xc2\x01\x1a?r)\xc7>\xbe\x83\xbc\xbe@\x00\x00\x00\x16\x0b\x86\xe7'
 b'\x06\x00\x00\x00X\x00\x00\x00\x02\x00\x00\x00p\x00')

{'A1': {'B1': [{'C1': 176, 'C2': 8716},
               {'C1': 52, 'C2': 22506},
               {'C1': 64, 'C2': -31395},
               {'C1': 68, 'C2': 18419},
               {'C1': 236, 'C2': -19134},
               {'C1': 89, 'C2': -3763},
               {'C1': 13, 'C2': -5092},
               {'C1': 90, 'C2': 7995}],
        'B2': 4,
        'B3': 2500373302,
        'B4': 33470,
        'B5': 'fdx'},
 'A2': -1535543798,
 'A3': {'D1': {'E1': 1172476044625211371,
               'E2': 0.07743250578641891,
               'E3': 172776368,
               'E4': -2097466213,
               'E5': 1699236413},
        'D2': -410645738,
        'D3': [-0.9099644422531128,
               0.9650319814682007,
               -0.8290069699287415,
               0.5628829002380371,
               -0.7727836966514587,
               0.6015893220901489],
        'D4': [0.38898807764053345, -0.3681926131248474]},
 'A4': 2719136663,
 'A5': [61134, 22097],
 'A6': 10861}

(b'CWLI\x18\x00%\xc4\xfc\x80{\x00\x1f\xa0<!\x18En\r\xfa>mt)o\xd2\xfc\xb9\\\xb8G'
 b'\xbd\x1cq_W\xb1-b\xfb\xa3\x0f\xd4\xf5\xd9\x973\x01A\x88\xfaZ\x04]\x02'
 b'\x00\x00\x00\x16\x00\x00\x00\x08\xe5\xa8\x9e\x00\x05\xa5\xef/=\xcc>OmS)D'
 b'3I\xc6j\x07<\xe3\x94\xba\x18\xbfeU\xb6>\xf1\xfaf?CM\xa6\xbe@5\xb1>\xee'
 b'e\xa2>\xb2\x83t?\xd5Z\x9c>\xf0q\x1f??\x00\x00\x00\xc4K/-\x06\x00\x00\x00W'
 b'\x00\x00\x00\x03\x00\x00\x00o\x00')

{'A1': {'B1': [{'C1': 41, 'C2': -11665},
               {'C1': 252, 'C2': 23737},
               {'C1': 184, 'C2': -17081},
               {'C1': 28, 'C2': 24433},
               {'C1': 87, 'C2': 11697},
               {'C1': 98, 'C2': -23557},
               {'C1': 15, 'C2': -2604},
               {'C1': 217, 'C2': 13207}],
        'B2': 1,
        'B3': 1526368321,
        'B4': 23812,
        'B5': 'mt'},
 'A2': -2130918363,
 'A3': {'D1': {'E1': 17268213846442042632,
               'E2': 0.39890429377555847,
               'E3': 693333327,
               'E4': -968281276,
               'E5': 3812362090},
        'D2': 758074308,
        'D3': [-0.5965969562530518,
               0.3561202585697174,
               0.9022665619850159,
               -0.3248082101345062,
               0.34610939025878906,
               0.3171839118003845],
        'D4': [0.9551345109939575, 0.3053804934024811, 0.6228322982788086]},
 'A4': 557621279,
 'A5': [17688, 3438],
 'A6': 16122}

Вариант №22

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x47 0x47, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'CGG\xbe\x97\xea\xec\xbf\xb1\xc0+\xe8\x97\xe0\x90>\xd5X\x80\x00)\x00=\x91'
 b'\xa9R\xe1/\xd6L\xbb\xc2\x00\x00\x00elaibg\xbf\xe64\xab\xbc\xfbh\xb2\xbd\xe2@'
 b'\xe1\x00\x00\x00\x05\x00$rr?\xe8F\xa7\xe7\xa1\xbf\xd2\xbe\xbf\x03'
 b'1\x00\x00\x00\x02\x00;_\x9b*\xe1R\xe0?\xeb\x06\xc3`\xc0@\x80\xbf\xcd]'
 b'\x81\xec\xcfQh\xd0\x8d\xc3\x02\x00\x00\x00O\x00\x00\x00\x02\x00\x00\x00U')

{'A1': -0.296714186668396,
 'A2': -0.06933855465456618,
 'A3': 0.4166908264160156,
 'A4': [{'B1': -0.6939295474105818, 'B2': -0.11047530919313431, 'B3': 'laibg'},
        {'B1': 0.7586249851283304, 'B2': -0.37307122349739075, 'B3': 'rr'}],
 'A5': -111,
 'A6': -6245682137634391102,
 'A7': {'C1': 3498951426,
        'C2': {'D1': 1604004577, 'D2': [82, -32]},
        'C3': [0.844575585333601, -0.2294161230371501]}}

(b'CGG?P\xba\x90?\xec\xd1v\t\xf9J\x08\xbe\xef\x97\xce\x00(\x00@R\xe8RQ\x07'
 b'O\xbc\x88\xb3\x00\x00\x00xxfkz?\xde\xf8DYm\x810\xbd\xf6|\x7f\x00\x00\x00\x04'
 b'\x00$ophajj\xbf\xed\xf5\x86\xe61\x9e2?\\\x8b\\\x00\x00\x00\x06\x00:\x99\xcd'
 b'\xf7\x9e\x83s?\xdf\x98\x1a\x97\x14&\xd8?\xc6\x19\xf0\x1b\xddb@?\xeb\xd2\xce'
 b"\x11\x0b.\x08?\xe0\x12\x1b\x8a\xa5\xfa\x8e\x86'\xdd\xd7\x00\x00\x00R"
 b'\x00\x00\x00\x04\x00\x00\x00X')

{'A1': 0.8153467178344727,
 'A2': 0.9005689806747919,
 'A3': -0.4679550528526306,
 'A4': [{'B1': 0.4839030144994636, 'B2': -0.12035464495420456, 'B3': 'xfkz'},
        {'B1': -0.9362215515111016, 'B2': 0.8615014553070068, 'B3': 'ophajj'}],
 'A5': 82,
 'A6': -1706212216975619917,
 'A7': {'C1': 2250759639,
        'C2': {'D1': -1714554978, 'D2': [-125, 115]},
        'C3': [0.493658683336077,
               0.1726665626581667,
               0.8694830258259012,
               0.5022103984809563]}}

Вариант №23

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x54 0x45, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'PTE\xb7\x84\x83\xfbE?\x93\xae\x00 \x0f\x8c\x12\xfb\x00\x00\x00'
 b'\x04\x00\x00\x00Hwmhmkzv\xbf?\xf93e\x04\xb6\xe6\xbfOy\xd6\xe4\xfaj\x1c'
 b'\x00\x07\x00\x00\x00\x19\x8d\xbd\xc5\xd9.*\xe2=\xdf\nFa\xb3]\xe7`\xc9\x86'
 b'\xdd\x04\x84\x06\xdb0\xbb6A\xf0\x95\xcc~v@\xf7\xb1~\\P^k"7\xd4\x112\xfe'
 b'\xd7\xd7\xc5\xe2`\x18\t\x0c\x15\xd1\x87\xf9p\xc4n\xfb\xfc\x03\xc9\x13'
 b'\x03\xfcxL\xe0\x91\xe2\xf1')

{'A1': -5222904552621108306,
 'A2': {'B1': -0.749896228313446,
        'B2': {'C1': 1694807782,
               'C2': -0.8104528188705444,
               'C3': -453350884,
               'C4': 'wmhmkzv',
               'C5': {'D1': -115, 'D2': -0.09660564363002777, 'D3': 10978},
               'C6': {'E1': 1038027334,
                      'E2': 97,
                      'E3': [-19619, -6304],
                      'E4': -55}},
        'B3': -122},
 'A3': 260838139,
 'A4': [{'F1': 56580,
         'F2': -31738,
         'F3': 56112,
         'F4': [-69, 54, 65, -16, -107, -52, 126],
         'F5': 118},
        {'F1': 16631,
         'F2': -20098,
         'F3': 23632,
         'F4': [94, 107, 34, 55, -44, 17, 50],
         'F5': -2},
        {'F1': 55255,
         'F2': -14878,
         'F3': 24600,
         'F4': [9, 12, 21, -47, -121, -7, 112],
         'F5': -60},
        {'F1': 28411,
         'F2': -1021,
         'F3': 51475,
         'F4': [3, -4, 120, 76, -32, -111, -30],
         'F5': -15}]}

(b'PTEa[\xdd\xe4\xaf\xe6\\Y\x00\x1e\xa5T\x84\xb4\x00\x00\x00\x05\x00\x00\x00'
 b"Firloi\xbew\x97'\xe5w\xf5\xe3?x\xbb\x96\xe5Om\xef\x00\x05\x00\x00\x00\x19"
 b'\xa9?+\x9a>\xb7Nn\xfc\x19N\x08\xb7\x8c\xa7IC\xa9\x1fOo\x9f\xaf\xb7'
 b'\xfa\x1eX\x9c(\x88vdT/cwK3,\xcbm\x95.\x85#\xf7}\xa7\x1d\x0f\x85<\t$\xb0\xe7'
 b'qs%\xca\xc3s\x18\xcb3\xa1k\xbdn\xa0S\xfc\xc9u\xa3\xab\x03e\x9d\xa6$*\x06\xbd'
 b'\xf3*\x1e\x95')

{'A1': 7015444818833071193,
 'A2': {'B1': -0.24178753793239594,
        'B2': {'C1': -445123101,
               'C2': 0.9716123342514038,
               'C3': -447779345,
               'C4': 'irloi',
               'C5': {'D1': -87, 'D2': 0.6703222990036011, 'D3': 46926},
               'C6': {'E1': 1862015310,
                      'E2': 8,
                      'E3': [-18548, -22711],
                      'E4': 67}},
        'B3': -87},
 'A3': 2773779636,
 'A4': [{'F1': 8015,
         'F2': 28575,
         'F3': 44983,
         'F4': [-6, 30, 88, -100, 40, -120, 118],
         'F5': 100},
        {'F1': 21551,
         'F2': 25463,
         'F3': 19251,
         'F4': [44, -53, 109, -107, 46, -123, 35],
         'F5': -9},
        {'F1': 32167,
         'F2': 7439,
         'F3': 34108,
         'F4': [9, 36, -80, -25, 113, 115, 37],
         'F5': -54},
        {'F1': 50035,
         'F2': 6347,
         'F3': 13217,
         'F4': [107, -67, 110, -96, 83, -4, -55],
         'F5': 117},
        {'F1': 41899,
         'F2': 869,
         'F3': 40358,
         'F4': [36, 42, 6, -67, -13, 42, 30],
         'F5': -107}]}

Вариант №24

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x55 0x49 0x54, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'NUITQa\xd9\xddK\x13j\x1ct\xeb\xce\x15\x0f\xa2\x8c\xbf\xde\nc\xa37:\xc0\xe7'
 b'\xcc\xb1\xa6\xd7\x881\x9a?J6\x97?\xdb\x05#y\x9d"\x047\xf3^]#\xf2L\xc7\x8d'
 b'{a\xbf\x0b\xc5\x0b\xbf\xe5\xcck\x9b\xca\xbf\xb6wA\xf7z\xfb\xf6 \xfa}\xa3'
 b'\xd8?b\xfe\x1e\xbf\xea\x1e\xc8?\x8d\x93\xf0\x00\x93\xbf\xca\x8d\x0f\x99'
 b'\x0e\x99\x08\xbf\xe4O\xedj~2\xf6?T\xaax\x00\x02\x00\x00\x00_b\xca\x88'
 b']\x00\x86\xbd[K\xcc\x11\'!\x9f\xdd\n\xf9\xbf\xaa\xc1\x82"$\x15\xa3b\xdf'
 b'\x95N\xb9D]? \x00o\xbe\x00\x00\x00\x87\xbeA7\xc5\xc6\xdd3U\xb8\xbf\x00\xb4')

{'A1': 1365367261,
 'A2': 5409784247855336981,
 'A3': 1126617612487910307,
 'A4': [{'B1': 55,
         'B2': 58,
         'B3': 13900303838282745905,
         'B4': 154,
         'B5': 0.7898954749107361,
         'B6': 0.42218863369319615},
        {'B1': 55,
         'B2': 243,
         'B3': 6799630535976521083,
         'B4': 97,
         'B5': -0.545975387096405,
         'B6': -0.6812036555111181},
        {'B1': 119,
         'B2': 65,
         'B3': 17832842709060713891,
         'B4': 216,
         'B5': 0.8866900205612183,
         'B6': -0.8162575951833997}],
 'A5': {'C1': -2335874274098856160,
        'C2': {'D1': 0.830726146697998,
               'D2': [-0.20742983792769842, -0.634756763452599],
               'D3': [1657440349, 8830299],
               'D4': 75,
               'D5': -871291103,
               'D6': -97},
        'C3': 190,
        'C4': {'E1': [221, 10, 249, 191], 'E2': -1430158814, 'E3': 605397858},
        'C5': -0.18868930637836456,
        'C6': 14329666032627548340}}

(b'NUIT\xb8wT\x8b\xd6\xf6&-6\xfb\xe8d\xf2F\x7f\x95\x04\xcc\x8b\xa0\xaa\x9fx\x85'
 b'\xaf\xfe\x92\xf3\x13o\xc1\xbfY\xf1k\xbf\xce\xac\xce\x1cD*x\xef~$^v'
 b'\xf3\xc4\r\xde\xc0\xb0?%\x1f\x0c?\xbc\xb0e\xb6!\xab\x90M)\x93U$\x99'
 b'\x07>\xf1\xbe\x16\xbf}\xd76?\xe0\xd1\xa6R\xb2\xa2J\x00\x93\xbf\xd9\xb4\xfeK'
 b',\xa3\xb8\xbf\xe6e\xb0\xe3\xa9,\xdc\xbe\xb3\xfe\xc1\x00\x02\x00\x00\x00'
 b"_\xe4\xe1\xd1\x1b\xfet'W,{>5-\x9f\xf5\x96\xb8\xea{6\x80\xc6\xfcg{u\xc4"
 b'\xbcr&\xd0\xf2\xe7\x00\x00o\x0b\x00\x00\x00\x87\xbf\x00\x1c\xbd-\x9a'
 b'\x18\xf1\x0c\xa7\xcaH')

{'A1': -1200139125,
 'A2': -2957134129684289436,
 'A3': 17457781283555675040,
 'A4': [{'B1': 170,
         'B2': 159,
         'B3': 8684540964375827311,
         'B4': 193,
         'B5': -0.8513399958610535,
         'B6': -0.23964859371365654},
        {'B1': 239,
         'B2': 126,
         'B3': 2620662822514581184,
         'B4': 176,
         'B5': 0.6450049877166748,
         'B6': 0.1120666093499223},
        {'B1': 77,
         'B2': 41,
         'B3': 10616431936265974206,
         'B4': 22,
         'B5': -0.9915651082992554,
         'B6': 0.5255920043173969}],
 'A5': {'C1': -4270412835614169344,
        'C2': {'D1': -0.3515529930591583,
               'D2': [-0.40167195645568254, -0.6999134489537044],
               'D3': [-454962917, -25942185],
               'D4': 44,
               'D5': 2067674413,
               'D6': -97},
        'C3': 11,
        'C4': {'E1': [245, 150, 184, 234], 'E2': 2067169478, 'E3': -60327051},
        'C5': -0.5004385113716125,
        'C6': 3285966301698705992}}

Вариант №25

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x57 0x45 0x49 0xbe, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'WEI\xbe\x02\xce^\x92\x02\x00\x00\x00\x16\x00\x00\x00.\x00\x00\x00`\x00\x8a['
 b'b\xba*\xf0\xeb?n\x93,~\xd4\x9a\x1fvI\xd9\xdd?d\x08\xbd\x14\xd2\xb9'
 b"\x10\x19\xebxw\xb8xx\xc3\x047%\xa0\x85T\r\xec\xff$\xd7S'\xe0\xfe\x00ePC"
 b'\x89&ws\xf1\xab\xcc\x10=\x1b\xf8\x9e\xc6\x90\xea\xc3\x13\x13k;W\x07X\xd8'
 b'f\xf1S\xd20.,\xba\x0c\xb6\x05\x008\x00')

{'A1': -1839280638,
 'A2': [{'B1': 0.8730672493282878, 'B2': -27794, 'B3': 32300},
        {'B1': 0.4663871434735658, 'B2': 2148, 'B3': 5309}],
 'A3': {'C1': -5154518297369069102, 'C2': 'xx'},
 'A4': {'D1': 1879,
        'D2': -244918184,
        'D3': [83, 210, 48, 46, 44, 186],
        'D4': 46604,
        'D5': [960539543402382531,
               -81021552247373844,
               8320161207571997952,
               -6991808472403891215,
               4281536846358024390]}}

(b'WEI\xbe\xb9a\xa63\x02\x00\x00\x00\x16\x00\x00\x00.\x00\x00\x00X\x00\xfc\xa4'
 b"X\xe8\x08\x8e\xe3?\xbf\x0f'!\x00\xcez\xddafg\xbf\xbe&\x90\xf9\xd9\\"
 b'\xe1\x94\xc8]T\xf3cnq5\xd3M\xfdr\x0225\x9f\xbd\x04\r00\xff\x86\xf2\x8b\x1e'
 b'\xf3x \x06|\x0bywj\xd7\x8e?\xc6\x96\xca\x1c\xf6\x7f)m\xe1\x1a\x828'
 b'B\xf4\x04\x008\x00')

{'A1': 866542009,
 'A2': [{'B1': 0.6110882318509137, 'B2': 4031, 'B3': 8487},
        {'B1': -0.002856436865693146, 'B2': 9918, 'B3': -1648}],
 'A3': {'C1': -913001708376728359, 'C2': 'cn'},
 'A4': {'D1': -26938,
        'D2': 2146835658,
        'D3': [41, 109, 225, 26, 130, 56],
        'D4': 62530,
        'D5': [3603569084107797873,
               -58493962683572427,
               441485749067182726,
               4579834723353299836]}}

Вариант №26

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x42 0x4c 0x47 0x52, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'BLGRfjjjnuy-\x88\x1c\x00\x93\x84\x116\xe8j\\\x00\x06\x00\x00\x00\xa7'
 b'\xa8\xa1T\x11\xc1T\x00\x02\x00\x00\x00\xad\xc5T1\xd7\x19\x19\x00\x02'
 b'\x00\x00\x00\xaf\xc8y#\xfd\x84\x14\x00\x04\x00\x00\x00\xb1\n\x96"\xac'
 b'\xd6R\x00\x06\x00\x00\x00\xb5r\xb3\xb5\xc9\xec\xcf%M/6\x1e\xae'
 b'\x7f\xb0\x9e\x0e\xb6\xf7\x1bJ\xa4\x7f\x8e\xcfg\xef\x00\x02\x00\x00\x00\\'
 b':\x00\x00\x00^\x9e\xcc\xd6\xa5D6/\x1b\xdc\xbat\xbf\x81\xa2X\x1a)N\xe1'
 b'\xf7(\x90)xN\x91\xf4\r\xd1]\x85\xce\xf3M?\xe5\xe2x\xb9\x84\xde\x86\x00'
 b'l\xb1as\xf2\xb5P"\xa6\x90\x94\x0f\x1c\xf6\ta\xfa\x951\xf4\xe2p[q\n#l5'
 b'\xa3\xad\xcf')

{'A1': 'fjjjnuy',
 'A2': 45,
 'A3': 34844,
 'A4': {'B1': 0.6838954566400879,
        'B2': {'C1': 58,
               'C2': {'D1': 1966565055064401903, 'D2': [-74, -9]},
               'C3': -24884,
               'C4': 15466843494783114426,
               'C5': 1958707618,
               'C6': 1478109518,
               'C7': 16282527577417469585,
               'C8': -860801754150800563},
        'B3': 45409,
        'B4': 8354939614509043860},
 'A5': [{'E1': [-124, 17, 54, -24, 106, 92], 'E2': [15, 28, 246, 9, 97, 250]},
        {'E1': [-88, -95, 84, 17, -63, 84], 'E2': [149, 49]},
        {'E1': [-59, 84, 49, -41, 25, 25], 'E2': [244, 226]},
        {'E1': [-56, 121, 35, -3, -124, 20], 'E2': [112, 91, 113, 10]},
        {'E1': [10, -106, 34, -84, -42, 82],
         'E2': [35, 108, 53, 163, 173, 207]}],
 'A6': 29363,
 'A7': {'F1': 3049909455, 'F2': 2687856462099546032, 'F3': -25074}}

(b'BLGRycpnqom)\x07\x96\x00\x96J\xdc\x90\xd4\xd1x\x00\x05\x00\x00\x00\xaa'
 b'6\xd9\x82-y\xcd\x00\x05\x00\x00\x00\xaf\xfd\xa2\xf4\xcf\x16\xec\x00\x05'
 b'\x00\x00\x00\xb4\xad\x88x\xc43\xaa\x00\x02\x00\x00\x00\xb9\xdaY\x1d\x96'
 b'\xf2\x8b\x00\x02\x00\x00\x00\xbb\xcf\xc6b\xd5h\x86\xebZl\x07\x1e\x11'
 b'\x1a\xfd=\xdbK>\x1b\xdb\xccZA\xb1\xbe\xa7\xbc)\xf7\x00\x05\x00\x00\x00\\\x16'
 b'\x00\x00\x00ax\x11}z\xc9wF\xc6!C\x1dK#\xc2\xca\xaa\xd2+S\xa3m\x04\xd1+'
 b'J\x0b\x08-\xca1\xb8co\xd1\xbf\xe6\xf4\xf2\xea\xe1\x0b\xde\x00oC\xb0\xc4\x04'
 b"\x10r\x11\x16\x95>\xb9\xd9\xe6\x00\x03\xdfJ\x9b`nV\xc8\xe0c\x00'\xc5\xebA")

{'A1': 'ycpnqom',
 'A2': 41,
 'A3': 1942,
 'A4': {'B1': -0.7174009883386778,
        'B2': {'C1': 22,
               'C2': {'D1': 6503674769315736055, 'D2': [75, 62, 27, -37, -52]},
               'C3': 30737,
               'C4': 9041760716025372995,
               'C5': 491463618,
               'C6': -894774741,
               'C7': 6026780593808427531,
               'C8': 589349441151135697},
        'B3': 17328,
        'B4': 14124432413439726910},
 'A5': [{'E1': [74, -36, -112, -44, -47, 120], 'E2': [185, 217, 230, 0, 3]},
        {'E1': [54, -39, -126, 45, 121, -51], 'E2': [223, 74, 155, 96, 110]},
        {'E1': [-3, -94, -12, -49, 22, -20], 'E2': [86, 200, 224, 99, 0]},
        {'E1': [-83, -120, 120, -60, 51, -86], 'E2': [39, 197]},
        {'E1': [-38, 89, 29, -106, -14, -117], 'E2': [235, 65]}],
 'A6': 53190,
 'A7': {'F1': 1658153094, 'F2': 16958986124642032381, 'F3': 15835}}

Вариант №27

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x57 0x53 0x4b, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'WSK$\xb0\xbe\xb6zzmsnaty.\xc1C\xe4\xbd\x0c\xae\x000\xac\x04\xbf\x0f'
 b'\x8e\xfa\xc8g\xf0XF\x00w\xcf\xf9\xaa\xf3r\xfc\xabg\xec\xbf+V\x85\x9f\xd2'
 b'h\xe7ZL\xdc(\xfc\xc5\xda\xe1\xc9\x07#K\x00\x02\x00\x00\x00\x1ew\xe4NM'
 b'l\x008\x93Y\xa7\xd1\x8c\xc0\xd2\xd5\xb7\xbb\xd1\x96\x17\xdc\xbc%\x00'
 b'\x02\x00\x00\x00 *#\x06\x88\xe5\xd2\x8b\x88\xe3\xb15\x96\xc3\xbe\x8b'
 b'\xbd\x02\xe8\xfd\xd2\xbf\xd1\x05?\xda\xde\xe5g\xde-\xc4\x00\x00\x00"')

{'A1': 615562934,
 'A2': 'zzmsnaty',
 'A3': 784417764,
 'A4': -67,
 'A5': 3246,
 'A6': {'B1': [{'C1': [1451597778, 1759992396, 3693673669, 3672230151],
                'C2': 35,
                'C3': 75,
                'C4': [200, 103],
                'C5': 119,
                'C6': 228,
                'C7': 78,
                'C8': 19820},
               {'C1': [3707737, 2815528128, 3537221563, 3516274652],
                'C2': 188,
                'C3': 37,
                'C4': [240, 88],
                'C5': 42,
                'C6': 35,
                'C7': 6,
                'C8': 35045}],
        'B2': 15171370281239680707,
        'B3': -4716468364543929665,
        'B4': -12027,
        'B5': 0.4198544992766211,
        'B6': {'D1': 17920, 'D2': 2010118570, 'D3': -904382762034872533}},
 'A7': 44036,
 'A8': -0.5607753992080688}

(b'WSK\xe6F{\xf4wdvrjilv\xbb\x08\xed\xcftR\xd8\x007lC>\x9f\x9e\xb5\x13\xfa'
 b'\x81\x1b\xda7/*\x8e\x8b[R\xb5\xfe\xb9\xc3\xcb\xcd\xfb\xb7!u$\xef7\x85'
 b'\xa3\x8c>\xaa3x\x9dW\xed\x16?\xaa\x10\xb34\xfc[\x00\x06\x00\x00\x00\x1e\x1e'
 b'\xac"\xdcF\xd5-K\x9f\x04)\xaep\xab\xd4\xb7T\x07\xdf\x1e\xf8\xdd\x1f\x00\x05'
 b'\x00\x00\x00$Z\xe1\x8a~\x8aJ\xae\x94\xc4*_\t\xe1\xf1\xa5\xd5-\x16\xa0\xfd'
 b'\x91\xec\xe8\xbf\xec\xb6\x17a\x14\x10\xd0\x00\x00\x00)')

{'A1': 3863378932,
 'A2': 'wdvrjilv',
 'A3': 3137924559,
 'A4': 116,
 'A5': 21208,
 'A6': {'B1': [{'C1': [2242087998, 2855499933, 1475155519, 2853221172],
                'C2': 252,
                'C3': 91,
                'C4': [19, 250, 129, 27, 218, 55],
                'C5': 30,
                'C6': 172,
                'C7': 34,
                'C8': 56390},
               {'C1': [3576515487, 69840496, 2882844500, 132062968],
                'C2': 221,
                'C3': 31,
                'C4': [47, 42, 142, 139, 91],
                'C5': 90,
                'C6': 225,
                'C7': -118,
                'C8': 32394}],
        'B2': 5381402174999693793,
        'B3': -1034186149781766767,
        'B4': -4888,
        'B5': -0.8972279449522151,
        'B6': {'D1': 21173, 'D2': -21380149, 'D3': -3604085722452791497}},
 'A7': 27715,
 'A8': 0.3117577135562897}

Вариант №28

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x2e 0x57 0x52 0x54, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'.WRTI{mjlqpqu\x87?)\x96\xd3\xfa<P]\xcaFY\xde\x00\x03\x00\x00\x006'
 b'\x00\x00\x00T+n\x00\x04\x00\x00\x00\x80k\xb7\xea\xf4\xa2\x1a\x80v'
 b'\xfb\xa5\xbd\xe7\xda-\xbc\xc0F\xdb\xcb\x9b?{\x15\xac\xd8\xa9\xebF'
 b'\xb8g\xbd\x14*\xa0)\xa9K,\x9a\xf8?\xd6\x1d\xe1\xea\xbay\x08g\xd4\x8c '
 b'\xa2\xe5C\xe2\x8d~\x18\xe1\xb6\xb2\x88\xe7~`\xaf\xa9\xaf\x04\x02`'
 b'\xd4&\x9a\xd9\xd6\x88F\xac(\xbc\xcd\xc0\xb6\x85\xfe\xed\x18M\xd6\xe9'
 b"\x12\x07'\xc2\xa2\x97\xc9\xa9")

{'A1': 18811,
 'A2': {'B1': {'C1': 'mjlqpqu', 'C2': 135},
        'B2': 0.6624576449394226,
        'B3': 18031375371840412126,
        'B4': [{'D1': -0.11320910602807999, 'D2': -1128249637, 'D3': -13413},
               {'D1': 0.9807994365692139, 'D2': -659952826, 'D3': -18329},
               {'D1': -0.036173462867736816, 'D2': 698960684, 'D3': -25864}]},
 'A3': {'E1': 0.3455738823194143,
        'E2': [1741982752,
               2732934114,
               2373851361,
               3065153767,
               2120265641,
               2936275552,
               3559299801],
        'E3': -2988060647528542784},
 'A4': {'F1': 11118,
        'F2': [-1232732435, 407754473, 302458818, -1567110743],
        'F3': 27575},
 'A5': 16930335133900667813}

(b'.WRT\xa6\x16aqgedvb\xc0?\x17\xdf:\xbd\x10a\x13\xc6\xf6$\n\x00\x03'
 b'\x00\x00\x006\x00\x00\x00T2\xa0\x00\x04\x00\x00\x00\x80\xebW0\xa0\x85\x8d[^'
 b'\xe4|\xbd\xb5\x9eI\xe0\xf6\x81\x0c\xaf\xaf?L\x03\xe4\x0e\xbeKs'
 b'\x95\x84\xbe\x93V3\x9f=\xa7\xd1\x07\t\xbf\xdd\xd8\x17\xa9\x81\xe4\x84'
 b'\xab\xe9I]\xd1\x91\xeb\xf3\x0c\xec\x91a(uz](./MZh\x94\x07"A(\xc3'
 b'\xce\xd7\x867\xcbN\xa7\xc4\x08~\xbdAP\x96u0\t\xc7~\x83\x8e;6\x97')

{'A1': 42518,
 'A2': {'B1': {'C1': 'aqgedvb', 'C2': 192},
        'B2': 0.5932499170303345,
        'B3': 13623495610366043146,
        'B4': [{'D1': -0.08868081122636795, 'D2': -520716020, 'D3': -20561},
               {'D1': 0.7969343662261963, 'D2': 247352179, 'D3': -27260},
               {'D1': -0.2877670228481293, 'D2': -1623349295, 'D3': 1801}]},
 'A3': {'E1': -0.4663142352433811,
        'E2': [2884192605,
               3516001267,
               216830305,
               678787677,
               674115405,
               1516803079,
               574695619],
        'E3': -3542215007711352892},
 'A4': {'F1': 12960,
        'F2': [142523713, 1352037680, 164068995, -1908722025],
        'F3': -5289},
 'A5': 3503947352264074364}

Вариант №29

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x4d 0x52 0x43 0x51, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'OMRCQ7\x8c\xa3\x8e\xad\xb2h\x0bL\xe1\x0c\xe8\xbf\xf1\xf4\x05\x00\x00\x00'
 b':\x00\x04\x00\x00\x00g\x00\x00\x00\xa8j\x9c\x97s,\x1d{\x7f\x00'
 b'\x00\x00\x03\x00\x93\x00Pc\xbd\xa4\xc1\xda\xacc\xcd\xb3\xac8S2'
 b'\xe0\xf7\xbe\x8a!\xd1\xd0\xde\x13gA\x01?\xed\xc3P(\x9b\xb3\xb7\xb1<\xbf\x86'
 b'\x07\xf4)\x90@\xddC\xc0>\x9c\x11\xa1\x96\xf2\x8a?\x00I\x00S\x00]\x00\x91'
 b'l\xe3Th\xbd\xd2\x02\xa1\xfa\xc7\x0b\xdf\xfat\xc9\x1d`\xd2\xa1\xdd'
 b'\xf7\xf7\xfe z@\x84\x02\x00\x00\x00o\x00\x00\x00\x8c#t\xb3&\x91\xa9\xad\xd1'
 b';\x86#')

{'A1': {'B1': 55,
        'B2': 2911806348,
        'B3': -0.7515722737546382,
        'B4': -2831,
        'B5': [-51, -77, -84, 56, 83],
        'B6': [{'C1': -0.4841323494911194, 'C2': [8586, -12079, 5086]},
               {'C1': 0.5049042105674744, 'C2': [-15379, 10320, -19557]},
               {'C1': -0.7370867133140564, 'C2': [1926, 10740, 16528]},
               {'C1': 0.37551775574684143, 'C2': [4508, -26975, -29966]}]},
 'A2': 8871295715966216872,
 'A3': {'D1': 18372425736155979805,
        'D2': 2218818080,
        'D3': [203433188983532689, -3930240738905294175]},
 'A4': [-1284234356, -1381396186, 595999697],
 'A5': 7182356030976516944}

(b'OMRCQ\xe4#<\x90\xc7\x0c\xd6\x9e\xc0c\x11\xd6?\x1d\xac\x02\x00\x00\x00'
 b':\x00\x03\x00\x00\x00Z\x00\x00\x00\xc7A!K\x04dndp\x00\x00\x00\x02\x00'
 b'\x84\x00\x10\xb5\xf9qQ\xb4GD\xca\xa5\xf5\x13f?\x12\xe6|G\xb5=\xac\x9d'
 b' \xbf$\xc30\xad\xc6\xc0?\xb2K?>#\x82\xfb<\x17<\x00F\x00P\x00\x0c\xa07N'
 b'2\x8fj8\xd3\xd1\x13y\xcaM\x0b\xe5\x86%Y\x96?\xb9\x9c\xaf\x16\xd1\x9e\xff'
 b'\x02\x00\x00\x00`\x00\x00\x00\xa97\xd4M\x9c\x12\x8a\xfc')

{'A1': {'B1': -28,
        'B2': 3348118563,
        'B3': 0.3448113804873578,
        'B4': -21475,
        'B5': [-54, -91],
        'B6': [{'C1': 0.8987420201301575, 'C2': [-6638, 18300, 15797]},
               {'C1': -0.6274058818817139, 'C2': [-15580, -21200, -16186]},
               {'C1': 0.7956885695457458, 'C2': [9022, -1150, 5948]}]},
 'A2': 7236831620834083271,
 'A3': {'D1': 12654192735760754054,
        'D2': 4288598294,
        'D3': [4065219059878699020, -1942373282270162477]},
 'A4': [1305753513, -58060132],
 'A5': 4920099379823097104}

Вариант №30

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x56 0x52, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'VVR\xe2\\\xe8\xfa\xb3\x96$1<\xd4\x9e\xe2\x96\x88\x89\xeb\x93\xf8\x1a\xb7\x1c'
 b']\xd2\xc6_\x1cI\x9aV?4\xea\x86\x00X>\xbb\xe0\x9aw\x8a\x9f\xbf\x00\x02'
 b'\x00\x8b=U\x81\xb2\x1bs\xa2:\x0e\x8fJ:\xc2WP\xdb\xbd\x05\xd0L\x1a+\xf5\x13Wh'
 b'\x0b\xe0\x0c\xd8[\xb2tM\xcbN\xd7\xb4z\x00\x04\x004g\x0f\x00\xbf\x1d3\xe8'
 b'E|\xb8xQ?\xbe\x96\xb8\xc7\xbf \xc0\xbf\xea\xafh;(\x9f>\xbf\xed\xc4'
 b'\x12\x1fd\xb2\x00\xbf\xc9\xc6\xbf\x0b\xc2\x8d\xf8q5v\x98')

{'A1': -497227526,
 'A2': -5506173700521287966,
 'A3': -27000,
 'A4': {'B1': 2313917432,
        'B2': 1925038555017928476,
        'B3': 73,
        'B4': -26026,
        'B5': 0.7067035436630249},
 'A5': {'C1': {'D1': 122,
               'D2': [{'E1': 33202,
                       'E2': 7027,
                       'E3': 162,
                       'E4': [14862, 36682]},
                      {'E1': 15042,
                       'E2': 22352,
                       'E3': 219,
                       'E4': [48389, 53324]},
                      {'E1': 6699, 'E2': 62739, 'E3': 87, 'E4': [26635, 57356]},
                      {'E1': 55387,
                       'E2': 45684,
                       'E3': 77,
                       'E4': [52046, 55220]}],
               'D3': [26383, 191, 7475, 59461, 31928, 30801],
               'D4': [0.1194873321211416,
                      -0.8339120059435812,
                      -0.9301844227935021,
                      -0.20137775491922105],
               'D5': 28981},
        'C2': {'F1': 0.3669479489326477, 'F2': 30602},
        'C3': -24641,
        'C4': [118, -104]},
 'A6': 15701}

(b'VVR\x07\x0c\xcazr\x0e[\x08\xd7\x01\xfc|\x82\xc8U\x1e\x997h\xce\xd8'
 b'\xc3\x887\xe7\x13\xdc\xf8\xa5>V\xd47\x00O\xbf\x1e\xad\xc9t\xf41P\x00\x03'
 b'\x00\x82\x19\xad\xb5\xed v\x04\xdcP_\xf7>\xeb\xe5,\x0c\t\xe21~\x1ah'
 b'\x97\xc4@\xd7S\xda\xd4\xbc\x00\x03\x004\xde<=R\x8f\xd1\x80\x82A+\xcc\xa8'
 b'\xbf\x93\xb2\xbc\x92^k\xc0\xbf\xd5\x9f}\xea\xf1`\xfc\xbf\xe9n\xb3'
 b"\xf2\xb8t\x14?\xea\xb9\nto'J\x07U\xac\x9b\\")

{'A1': 118278778,
 'A2': 8218606463522831484,
 'A3': -32056,
 'A4': {'B1': 1428068663,
        'B2': 7552211959462487827,
        'B3': 220,
        'B4': -1883,
        'B5': 0.20979391038417816},
 'A5': {'C1': {'D1': -68,
               'D2': [{'E1': 46573, 'E2': 8310, 'E3': 4, 'E4': [56400, 24567]},
                      {'E1': 16107, 'E2': 58668, 'E3': 12, 'E4': [2530, 12670]},
                      {'E1': 6760,
                       'E2': 38852,
                       'E3': 64,
                       'E4': [55123, 56020]}],
               'D3': [56892, 15698, 36817, 32898, 16683, 52392],
               'D4': [-0.019236513551373013,
                      -0.3378596109737513,
                      -0.7947635403285198,
                      0.8350879930596673],
               'D5': 1877},
        'C2': {'F1': -0.6198392510414124, 'F2': 29940},
        'C3': 12624,
        'C4': [-84, -101, 92]},
 'A6': 6573}

Вариант №31

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x54 0x4c 0x30, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'NTL0\x13\x00\xcf\x02\x00\x00\x00e\x00\x00\x00J\xcc8\x1a`[\xd8\xb1\xferzmc'
 b'alE\x00\x10}\xd6\xc8-\x8a\xbfk \x8a\x1f\x83(\xc2\x00\x8a\x00\x12*\xa6Q.M\xff'
 b"^&\x11\x8a<?R\xbd\x1a4\xd3Qf\xf5\xaeG\tP/X\x96E\x06'\x00\xf8Hz\tD4\x97"
 b":\x89:\x94\xbeW\xd5\x9d\x05\xf0\x06c\xf5\x07\x00'\x00\x9a`\xad\x04\xff\r\xc4"
 b'\xd95\x00|\xd20\x03\xe5\xe6A^\xe8\xbf\x07\x00F\x00\xcbY\x13d66\x06\xefT\x00f'
 b'\xdf\xb8\xc7\xe8]\xa4\xb2\xdc?')

{'A1': {'B1': -1311220896,
        'B2': -2,
        'B3': 'rzmcal',
        'B4': 69,
        'B5': -0.012782639547033625},
 'A2': 207,
 'A3': [{'C1': [8299, 8074, 10371, 194, 138, 10770, 20902],
         'C2': [78471322, 3653504511],
         'C3': {'D1': 46,
                'D2': 643759949,
                'D3': 0.7364817261695862,
                'D4': 17682910954470948178},
         'C4': 53884,
         'C5': -0.7615060338649524},
        {'C1': [18350, 20489, 22575, 17814, 9990, 63488, 31304],
         'C2': [1678989771, 4010161718],
         'C3': {'D1': 9,
                'D2': 982987844,
                'D3': -0.2895090878009796,
                'D4': 17681984189942846807},
         'C4': 57190,
         'C5': 0.44840344591932135}],
 'A4': 439929930}

(b'NTL0\x13\x00\x0f\x02\x00\x00\x00g\x00\x00\x00\x0eFF\x99\xce\xd45<\xcarocu'
 b'vv\xd9*D<\xf5r$\xed?P\xe2\xec\xf9\xf7\xa7\xfc\x1f\xc3`O\xc2m\\:\xbdo'
 b'\xfe\xfb\x99f\xdd\x84)?p\x03id\x07$\x83s\r*\xafkB\x83\x8f\xca\xff\x8c`5'
 b'\xa0\x18\xd5\x8d\xef\xe8\x0e\x13\x87B\xbe\x9a\x1e%\x86@\x8d\x1a\xdc\x08'
 b"\x00'\x00;lr,\xcf\xd6\x9a\x907\x00\x0c\x07\xc0\x85\xdfv\xc1\r\xb8\xbf\x07"
 b'\x00H\x00\xba\t\x8d\xa7\x17_YxV\x00\xce1\xe2\x13\x8a\xffF\xf1\xe5\xbf')

{'A1': {'B1': 1010160846,
        'B2': -54,
        'B3': 'rocuvv',
        'B4': -39,
        'B5': 0.9106993474725915},
 'A2': 15,
 'A3': [{'C1': [57936, 63980, 42999, 8188, 24771, 49743, 23661, 48442],
         'C2': [745696315, 2426066639],
         'C3': {'D1': 111,
                'D2': 1721367550,
                'D3': 0.6621835827827454,
                'D4': 8323536150478783344},
         'C4': 1804,
         'C5': -0.0939598956315626},
        {'C1': [10765, 27567, 33602, 51855, 36095, 13664, 6304],
         'C2': [2811038138, 2019122967],
         'C3': {'D1': -43,
                'D2': 250146701,
                'D3': -0.18996839225292206,
                'D4': 15860144346006625946},
         'C4': 12750,
         'C5': -0.6857027998927345}],
 'A4': 2571519502}

Вариант №32

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x62 0x56 0x4b 0x59 0x57, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'bVKYW?V*\xfa\x00n\xbf\xc56\xc2|\x1fsP\xd2Xa\x88\xc6\xec\x0b\xaex}\xd69\xcc'
 b'-\x15\xbf$\xdb\x9e\xefhl\xd8\xc8\x0f\x1f\xeb\xd2\xc8h\xcak\x16\xbbPs\xcf'
 b'\x9eI\xc1(%\xea\x8a\xec\xcc[\x00\x02\x00\x1e\xfa\xb5\xfbm\xbc\xca'
 b'\x8dV\xd3\xae\xed\xff\x1f\x8by!\xcbdC\x00\xf9KW\xfd*\x94\xfcc\xc0\xaa'
 b'\x00\x02\x00"\xb4\xe2\xbc\n(I\x8c\x1f\x00\x00\x00\x02\x00\x00\x00&'
 b'\x00\x04\x00\x00\x00j\xa4L\xf8\x04\xe0\xb481a\xf0?`U\xb5\x10\xbd3')

{'A1': 0.8365932703018188,
 'A2': {'B1': -29665,
        'B2': {'C1': [{'D1': -1195586022741696533,
                       'D2': 3536349386,
                       'D3': 7716560965760687689,
                       'D4': 13918416337671867483,
                       'D5': [14796, 11541],
                       'D6': 64181},
                      {'D1': -329399619587484754,
                       'D2': 3992919947,
                       'D3': 8728481184302037323,
                       'D4': 6340270669785448618,
                       'D5': [-16604, -9314],
                       'D6': 46306}],
               'C2': [188, 10, 40, 73],
               'C3': {'E1': -6607633853425895375, 'E2': 25072},
               'C4': 0.8763077855110168,
               'C5': 16},
        'B3': -17101},
 'A3': -0.1657336336201305,
 'A4': [-46, 88, 97, -120, -58, -20, 11],
 'A5': 2927132118}

(b'bVKYW\xbf\x11\\Z\x00l?\xd7N^\x7f\x16\xf9h\xa9\xea\x0c\xea\x03\xf4\x92\r\x15'
 b'z\x8a\xfak\t\x9a\xe1\xcd\x93\xf8$\xe4\xa9\x9b\x9a\xda\xa9\x81\x9aT'
 b'\x04{\xf4\x0b\xf5\xab\xa4\x9a\xd5\xa8Yc\x0eW\xc2G\x903\x00\x02'
 b"\x00\x1e\x94\xb8\xe4\xbfC80\x15\xeb\xc9\x04f\xf0\xfc*'\x94_O\xfc-\xfb"
 b'\x895i\x16\xd3\xb3s\xae\x00\x02\x00"\xbdXz\x9d5Y\x00\x00\x00\x02\x00\x00'
 b'\x00&\x00\x02\x00\x00\x00j\x8a\xb5^8~\xf0\xd8\x9c3\x86?\n3\x18\x16\xd4t')

{'A1': -0.5678154230117798,
 'A2': {'B1': 13657,
        'B2': {'C1': [{'D1': 2658436165838481793,
                       'D2': 2589197435,
                       'D3': 17585419287548057000,
                       'D4': 6441007662154354739,
                       'D5': [-1429, 2458],
                       'D6': 38072},
                      {'D1': -1963777003906274359,
                       'D2': 73855228,
                       'D3': 3037559610769419771,
                       'D4': 9886924103723742126,
                       'D5': [-7731, -27656],
                       'D6': 48472}],
               'C2': [122, 157],
               'C3': {'E1': -8451745528949974884, 'E2': 13190},
               'C4': 0.5398421287536621,
               'C5': 22},
        'B3': -11148},
 'A3': 0.36415827189548233,
 'A4': [-87, -22, 12, -22, 3, -12, -110],
 'A5': 219511434}

Вариант №33

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x4b 0x59 0x56, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'DKYV\xeb\xf1\xb8N\x91\x1f)\xd0\xbf@6\x00\xce\xd4^\xae\xc1\x10\x88\xbc'
 b'\x80V\x00\xec,\xd9\xf2\xbel\xa9/?\xe4\xf8\xf4\xa2\x17lk0\xc8\xbc\xbd\xc9'
 b'J\x16\xcd\\\xa1\xcf\xb1Th\xf9n+d\x81 \x00\x00\x00+\x00\x00\x008\x99'
 b'\xb7~g\xf8\xf0[\xc4-a\xcb\x03\x18\xba%\xb4\x85\x80\xf3el\xb0\x17>')

{'A1': 14999554742885609963,
 'A2': 16575,
 'A3': {'B1': {'C1': 9323624884194530481,
               'C2': [{'D1': 0.6861789226531982,
                       'D2': [-28, -8],
                       'D3': [-12, -94, 23, 108, 107]},
                      {'D1': -0.09217870235443115,
                       'D2': [-55, 74],
                       'D3': [22, -51, 92, -95, -49]}],
               'C3': [39224, 32439, 63591, 23536, 11716, 52065, 6147, 9658]},
        'B2': -50,
        'B3': 24276,
        'B4': 2282799534,
        'B5': -32580,
        'B6': {'E1': 180, 'E2': 32901, 'E3': 26099, 'E4': 0.14813393354415894},
        'B7': 236,
        'B8': -0.4743131399154663}}

(b'DKYV\x92\xaag\xc2Hq\xd3\x8e\x9d\x126\x00\xb8p\xb7d&g\xde3[V\x00T'
 b'\xf3\xcfV\xbf\xe7\x1f&?\xc8\xe3([\x1d\x96C\x00\r\x06\xbf\x01\x0b\xf6\x9b\xdf'
 b'e\xd8\x1d\x8a\xb9\xa6f\xe2&\x99 \x00\x00\x00+\x00\x00\x00\xe2\xa6l\xffzk'
 b'\xb1_\x83bw\xec\x01P0\x1b\x03\xff\xefcp\x07Cx\xbf')

{'A1': 10291694130784873106,
 'A2': 4765,
 'A3': {'B1': {'C1': 11035756867429698077,
               'C2': [{'D1': 0.6489242911338806,
                       'D2': [-56, -29],
                       'D3': [40, 91, 29, -106, 67]},
                      {'D1': -0.5236358642578125,
                       'D2': [1, 11],
                       'D3': [-10, -101, -33, 101, -40]}],
               'C3': [42722, 65388, 27514, 24497, 25219, 60535, 20481, 6960]},
        'B2': -72,
        'B3': -18576,
        'B4': 3731301988,
        'B5': 23347,
        'B6': {'E1': 3, 'E2': 61439, 'E3': 28771, 'E4': -0.9697727560997009},
        'B7': 84,
        'B8': -0.8391105532646179}}

Вариант №34

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x91 0x49 0x44 0x50 0x54, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'\x91IDPT\x02\x00\x00\x008\x00h#>u\xa4\xb2\xc2\xbf\x94\x00\x00\x00\x03'
 b'\x00\x00\x00\xa1\x00\xcb;S\xbd\xb9F\x90\x05\xe7\\\x9f\x1c\x88\xbdO>6\xf0\xc7'
 b'?Jz\xac\xf4\x9f\xf3>\x1e\x00+\x00W\\\xde\x03\xb2\xc7n\x11\xc4\x9fZ\xd6'
 b'Zg\xffAY\\bsX\xbbx\x95\x0f\xe2\xd8\xea\xe2@g\xd1{p\xf9\x95\xce2\x04\x8b'
 b'\xe9\xa5\xd7v K\x93\xb6\x9d\x8f\xe2\x90\xf2\xa8\xc2\xc1f\xdcQ\xc9\xf6A5\r'
 b'\xa9\xe1sB\xf4>\xff*\x16?\xd7\x14Q\xbf\xc9\\\xf1=\xac\xfei>\xea^F=<\x00'
 b'\xa9\xaafD\xaa\xd8Z\x8a\x1f\xdd\xf7\xa2\xa2\x95\x13$\xcdF\x8c\xb4'
 b'\xf4\x10\xa8\xfa\\\xf6\x85\xa6Oy\xb0\x89\xb2')

{'A1': [{'B1': 59, 'B2': 6694325488329538899, 'B3': -0.06646084040403366},
        {'B1': 79, 'B2': 12428327759480108606, 'B3': 0.47582972049713135}],
 'A2': -0.14607673382513586,
 'A3': {'C1': 15686,
        'C2': {'D1': [1256160913465957463,
                      4755633371367514052,
                      10770564497423883353,
                      15089100419875004943,
                      10017187334039629947,
                      13155941539284231657],
               'D2': 2430767005,
               'D3': -22286,
               'D4': 4753207810163392962,
               'D5': 3785952565,
               'D6': [0.4770694673061371,
                      0.5865935683250427,
                      -0.8167242407798767,
                      0.11785275489091873,
                      0.2285105586051941],
               'D7': 24298},
        'C3': 9969518950941633193,
        'C4': 31},
 'A4': {'E1': [14781961410336454621, 6699852186445450310, 12865007845634377206],
        'E2': 203}}

(b'\x91IDPT\x02\x00\x00\x008\x00\xa0\xf9\x12=3\xa6\xeb\xbf\x94\x00\x00\x00\x03'
 b'\x00\x00\x00\xa1\x00\xb8<\xe9i\xab\x05Wo\x03\x11\xc3\x81\x7f\xbe\xe1'
 b'\xd0gh\xb0\x1c\xd6\xdd\xd6B\xfeo\xbd\x1e\x00+\x00\xa0Rr\x90\x17\x01~\x12'
 b'\x18\xab7\x06K\x051\xe3]\x03^\x7fb\x89V\x83\xfbv\xfa\xb25Q\xfa\xb3t.2\xb1'
 b'@\x03\x1b\x8f\x89\x02k:\x978$<?\xf2*0$\xda4\xd7PNqLT\xc6\xcc\xc1\x91F9\xc9'
 b'N\xbfto\xca>\xf96[\xbf`n\x0f\xbe\x855V>4C\x84X<\x00\xec|4cQ\x18&\xac'
 b'D\x93j\x0c\xfc\xf2\x96O\x1fEt\x16\xe9\x93\x14v\xc7!\xfa\x8a\xd5xVH\xbd')

{'A1': [{'B1': 60, 'B2': 1225945943122864617, 'B3': -0.24951843917369843},
        {'B1': 225, 'B2': 15482766512676693968, 'B3': -0.058592088520526886}],
 'A2': -0.8640381043294845,
 'A3': {'C1': 22660,
        'C2': {'D1': [1332503740467532448,
                      16370871940253461272,
                      9463902723102344029,
                      12968767368044639995,
                      10311839348180528756,
                      4333650963608568457],
               'D2': 808120895,
               'D3': -9692,
               'D4': -4155612506627188940,
               'D5': 1183957452,
               'D6': [-0.8077579140663147,
                      0.3953815698623657,
                      -0.8563075661659241,
                      -0.14006948471069336,
                      0.2091885358095169],
               'D7': 17204},
        'C3': 12404628961474411756,
        'C4': 68},
 'A4': {'E1': [2256187908690832019, 14372697886302827589, 13639246548470266401],
        'E2': 184}}

Вариант №35

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x4a 0x52 0x48, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'LJRH\x00\x00\x00H\xad\x89\x00af\xe9\xe8\x94 \xe3eW\xaf\xcdM\x91'
 b'\xb2\xd3\x82\xbc\xda\xe0\x00\x00\x00\x02\x00\x10\xbe\x0fS\xe3N\xf8\x99J'
 b"\x05'i\x9f\xbb)\x02\xbf\x00\x00\x00\x02\x00\x12W\xcd\xfcC\\\xabA\xed\xd1~"
 b"\x97'\xb0\x81\x00\x00\x00\x14\xfaj)Dy\xa3\xa0\x1c\xef\xa5@\x91"
 b'\xbb\xbe\xb2\xd0\x1c\xbfy\tK\x08\x1b\x83\xd6\xb4E\x0eo\x00\x05\x00'
 b'\x00\x00T\x00\x02\x00Y\xfe\n\xbe\xa0,\xe8?\x1ay\xaa>\xd5\x81\x85\xbfg\x0e'
 b'\xbb\xbf3\x0f\x99')

{'A1': {'B1': {'C1': [{'D1': -20531,
                       'D2': 1301394131,
                       'D3': -2101552416,
                       'D4': [32, -29],
                       'D5': -1106291741,
                       'D6': 20216},
                      {'D1': -26294,
                       'D2': 86469023,
                       'D3': -1154940225,
                       'D4': [101, 87],
                       'D5': 1473117251,
                       'D6': 23723}],
               'C2': 4750683523577786497},
        'B2': -402463842620956644},
 'A2': {'E1': 173,
        'E2': -119,
        'E3': {'F1': 584205534845275759,
               'F2': [239, 165, 64, 145, 187],
               'F3': [-0.34924399852752686, -0.9727980494499207],
               'F4': -502,
               'F5': [-0.31284260749816895,
                      0.6034189462661743,
                      0.4170037806034088,
                      -0.902568519115448,
                      -0.6994567513465881]},
        'E4': 26345},
 'A3': -5996}

(b'LJRH\x00\x00\x00H\n\xa3\x00j)\xea\x1fb\xc7^\x19\x1c\x0f\xc6\x81\x8d'
 b'S\x05\x8d\xd2\xde\xdc\x00\x00\x00\x02\x00\x10\xfc\xcf\xf8\xe4*\xc1\x85\x93'
 b'\xb0\xde\xb1\x82v\x87\x02\xbb\x00\x00\x00\x02\x00\x12\xb9\xa5\xa1\x1d4\xbf'
 b'\xf8\xf9\xbd\xae\x8c2&!\x00\x00\x00\x14\xad\xbc\x01Ky\xb1&%\xed/>\xee'
 b'\x9a\xdb>\x9ce\xc5=\x13/6\xbfN_\xe2?}\xd0\x9e\xcc?\xc7\xe9\x91<0\xff\x00\x02'
 b'\x00\x00\x00T\x00\x05\x00Vk.\xbe\x93\x80\x98\xbe\xe2\xd4\x91\xbfi'
 b'\xa0\xfe\xbf<\x08\xec?S\x075')

{'A1': {'B1': {'C1': [{'D1': 4038,
                       'D2': -2121444603,
                       'D3': -1915560228,
                       'D4': [-57, 94],
                       'D5': -53479196,
                       'D6': 10945},
                      {'D1': -31341,
                       'D2': -1327582846,
                       'D3': 1988559547,
                       'D4': [25, 28],
                       'D5': -1180327651,
                       'D6': 13503}],
               'C2': 17940579147981137441},
        'B2': -5927861585850587611},
 'A2': {'E1': 10,
        'E2': -93,
        'E3': {'F1': 14717701913248018687,
               'F2': [237, 47],
               'F3': [0.4660252034664154,
                      0.3054639399051666,
                      0.03593369573354721,
                      -0.8061505556106567,
                      0.9914644956588745],
               'F4': 27438,
               'F5': [-0.28809046745300293,
                      -0.4430280029773712,
                      -0.912612795829773,
                      -0.734511137008667,
                      0.8243287205696106]},
        'E4': 10730},
 'A3': 8034}

Вариант №36

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x58 0x5a 0x44, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'QXZD\xd8\x8e\x0bb\xd9\x7f\x83V\x0c\xfd\xaa\xd83\x08L\xcb\xa2vL\x1a\x8d\x91}E'
 b'!\xb9\x0b\x98\xc24Zne\xech\x95N\xdc\x0c*O\xc0d\x15\x82\x12ZY0\xe9\xef\xd4'
 b'\xce\xce\x01\xff\x87Li\x9d\xf0\xd9\xc9\xbe\xa5-d\x10_\x02\xaa2\x9f\xf1:\x04'
 b'\xf3Q\x1d\xe5UXa\xbf\x84H"}\x00\x8b\x02C\xcd\xd3w\x1b\x1a]\tw\xe2e&2'
 b'\xe1\t?\x02\x00\x00\x00\xa9\x00\x00\x00\xc00pb@\xab6\x95\x06\xd1\x98L\xe8'
 b"O\x10;\xf1\xb7\xf8/\xfd\xed\x85\xa8\xd0\x16ov\xfd\xd1X'rW\x7f[\x04"
 b'\x00\x00\x00y\x00\xfa{\xdbV\x0b\x1eP?\x93\x95\xbc2')

{'A1': -28968,
 'A2': {'B1': {'C1': [{'D1': 11,
                       'D2': 12321017721268459874,
                       'D3': 13272,
                       'D4': 8},
                      {'D1': 76,
                       'D2': 9048168270455546571,
                       'D3': 8517,
                       'D4': 185},
                      {'D1': 11,
                       'D2': 7560529399082435224,
                       'D3': 20117,
                       'D4': 220},
                      {'D1': 12,
                       'D2': 6490393041390554922,
                       'D3': 12377,
                       'D4': 233},
                      {'D1': 239,
                       'D2': 7587589001529183956,
                       'D3': -3939,
                       'D4': 217},
                      {'D1': 201,
                       'D2': 12250458460405999038,
                       'D3': -24782,
                       'D4': 241},
                      {'D1': 58,
                       'D2': 7014450862157329156,
                       'D3': -31553,
                       'D4': 72}],
               'C2': 34,
               'C3': {'E1': -788097738,
                      'E2': [19608,
                             20456,
                             15120,
                             47089,
                             12280,
                             60925,
                             43141,
                             5840],
                      'E3': 6301142091078399599,
                      'E4': 23423,
                      'E5': [112, 98, 64, 171],
                      'E6': 4562179456577010682}},
        'B2': [651, 52547, 30675, 6683, 2397, 57975, 9829],
        'B3': 0.5385924577713013,
        'B4': [38291, 12988]},
 'A3': 12480}

(b'QXZD?\x06\xfd<\xcfH\x06\xdc\xc7\xa3\x8b\x00\xebA\xf2\xdf\xed\x81\r\xca'
 b'\xf7\x03\xe5\xadSr$h\xbf\x01\xf5\x80\xfc\x01\xff\x9f\xbeZ\xe8u\x8f0b5'
 b' \x18g\x0c\xe1E\xdf\xbf\x00\xe0\xebA\x02w=\xe0\xfaR\xaf\xe9G\x92)nC\x8e\x1cz'
 b'v\\\x10o\xad\x04\x11\xcdG\x98\x8c\xfb?Ea~\x00\xafb\x0cF\tq\xb6\xe1\xd6j\n'
 b'x\x92t\x0e\xd2T?\x02\x00\x00\x00\xaa\x00\x00\x00\x05\xaaJx\x98\xa6\xfbzT'
 b'\xcd\xf5\x80\xf5\x02\x86m\xfa\xb4 \r\x05"V\xbb\xd7w\x7f\x1e\x94\xe6\xb9\xb9:'
 b',\x1c\xda!\x05\x00\x00\x00y\x00Xc\x9d\xaf\xd6\x124\xff[<\x17?')

{'A1': 1599,
 'A2': {'B1': {'C1': [{'D1': 253,
                       'D2': 10062105740287987516,
                       'D3': -5376,
                       'D4': 65},
                      {'D1': 242,
                       'D2': 16502305906797702623,
                       'D3': 21421,
                       'D4': 114},
                      {'D1': 36,
                       'D2': 18375245585444880232,
                       'D3': -16737,
                       'D4': 90},
                      {'D1': 232,
                       'D2': 7428722999000338293,
                       'D3': -7924,
                       'D4': 69},
                      {'D1': 223,
                       'D2': 4429011240695627967,
                       'D3': -1312,
                       'D4': 82},
                      {'D1': 175,
                       'D2': 2057656220177811433,
                       'D3': 30330,
                       'D4': 92},
                      {'D1': 16,
                       'D2': 10130926307849317743,
                       'D3': 16379,
                       'D4': 69}],
               'C2': 97,
               'C3': {'E1': -171092870,
                      'E2': [62848,
                             34306,
                             64109,
                             8372,
                             1293,
                             22050,
                             55227,
                             32631],
                      'E3': 2030062101399507998,
                      'E4': 8666,
                      'E5': [74, 120, 152, 166, 251],
                      'E6': -57400181970345128}},
        'B2': [25263, 17932, 28937, 57782, 27350, 30730, 29842],
        'B3': 0.8313301801681519,
        'B4': [15451, 16151]},
 'A3': 43525}

Вариант №37

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc7 0x55 0x4d 0x4b 0x41, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'\xc7UMKAg\x11"*[?\xc2\xe3\x00]\x1b\x18\x80\xcc_\xb7i\xd8[y\xf4A7C\x1a\\\xbb'
 b'Y\x00\x00\x00\xab\x00\x02\x00\x00\x00\xb4y\xee!d\x07X\xa5a\xb3'
 b'\xd2\x00\x00\x00+\x00\x00\x000\xbeh\x08\xe9\n\xa9\xffr\xf6\xa8\xf9Sp\xa6\x8a'
 b'\xba]\xf3\xcf\x83c0\x02IHv\x8c\x81\xdf*o\xff\xc0\x83\xdf\xb9\xff:\x13'
 b"\x13\x00\x02\x00\x00\x005rzid\xbf\xce\xbc\xe9U7=\xd8?\xec\xd0\xe7M+'\xb0?"
 b'\xc9\x7f\x1e\x10\x1c\xfb\x98?\xe6W\x00_\xb1i\xd0\xbf\xe3f\x94\xad\x01xP\xbf'
 b'\x93\xbe\x83\x00QS@?\xd8K\xfa<I\x16\xdc\x00\x00\x00=?\xd1\xa1{\xf1F+d\x99'
 b'C\x06\x12\x0e')

{'A1': 7426754825825534691,
 'A2': {'B1': -4574566806534352109,
        'B2': [{'C1': 121, 'C2': 3995165703}, {'C1': 88, 'C2': 2774643666}],
        'B3': 'rzid',
        'B4': [-0.2401401201336586,
               0.9005009181212156,
               0.1991918162038615,
               0.698120295429641,
               -0.6062720660227203,
               -0.019281432051076353,
               0.37963729750877717],
        'B5': {'D1': 13720226061783531378,
               'D2': -2392,
               'D3': 17965827199105392115,
               'D4': [53123, 25392, 585, 18550, 35969],
               'D5': 3744100351}},
 'A3': 454590668,
 'A4': 24503,
 'A5': 1775786873,
 'A6': 17600409580085230425,
 'A7': {'E1': 0.2754812103454951, 'E2': -103},
 'A8': [17158, 4622]}

(b'\xc7UMKA\x134&6E\x17\xc5\x04\x00]\xdf\x96\xea!O\x06\x80\xdc\x9d\xcaD\r`'
 b'm\xea\xee\\\xaa\x00\x00\x00\xab\x00\x03\x00\x00\x00\xb4\xcec\x07\xaa\xe0'
 b'I\xb2@H\x80\x00\x00\x00+\x00\x00\x000\x05)\x91\x16 `\x89\xa3\x07\xf3\x03'
 b'\x18\xea\t\xbe\xf0\x080\xf0\xa6}\xce\xf8\x0c\xf7\xa6\xabiy\xceV\x00\x13(\xa2'
 b'n\xac\xceM\x07\x00\x02\x00\x00\x005osue\xbf\xcb\x1f\x86]\xdaR\xb8\xbf'
 b'\xdb\xb2\xdd\xc9\xfa\xd6L\xbf\xc5#\xff\x97\xd3\x1f\xc8\xbf\xee\x89"h'
 b'\xf1W\xb0\xbf\xc9\x05\xd4\xff\x82\xc4 ?\xcf\xb6\x16\xf4g\xbah\xbf'
 b'\xedV\xc3\xc10\x9e\xbe\x00\x00\x00=\xbf\xdf\xbb\xbe\x80\xf45\xf0\xbc'
 b'6\x8c\xbb\xf1\x13\xed')

{'A1': 1383773000038860036,
 'A2': {'B1': 1380531882018360583,
        'B2': [{'C1': 206, 'C2': 1661446880}, {'C1': 73, 'C2': 2990557312}],
        'B3': 'osue',
        'B4': [-0.21189956267030197,
               -0.432792136426859,
               -0.16516108430209742,
               -0.9542400407469724,
               -0.1954904792415002,
               0.24774443563315462,
               -0.9168413899651211],
        'B5': {'D1': 371987968453282211,
               'D2': 2035,
               'D3': 223185509133846576,
               'D4': [61606, 32206, 63500, 63398, 43881],
               'D5': 2043565568}},
 'A3': 3751209505,
 'A4': 20230,
 'A5': 2161941962,
 'A6': 4903681594485529770,
 'A7': {'E1': -0.4958339938465022, 'E2': -68},
 'A8': [13964, 48113, 5101]}

Вариант №38

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xf3 0x4c 0x4e 0x56 0x4b, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'\xf3LNVK?\xe5i\xd9\xbf$\xfeH?\xb0,\xda\x00\x00\x009\x00\xab8\xfd\xec\x8f\x92'
 b'f\xa1d\xdf\x89\xdb\x04\x98"\xb9cX\xc2Q7\xd3\xd62h\x84}\x1d\x1al5v\xb5\x04'
 b'\xe2\x03\x00\x00\x00\x03\x00\x00\x00!\ro\xb6z\x8fR\x00\x00\x00\x05'
 b'\x00\x00\x00$y\x97\x93\xc9\x0c\xde\x00\x00\x00\x05\x00\x00\x00)\xf6\xbb'
 b'\x17\xad7l\x00\x00\x00\x06\x00\x00\x00.\xf2\xca\xa5\xf7\xb0\xbc\x00\x00'
 b'\x00\x03\x00\x00\x004\x96\xbf\x11@\xd36\x00\x00\x00\x02\x00\x00\x007'
 b'\xce\xcd\xf3J\xe9?1\xb1\xa2\xf8\xd7\x07s\xba\xdb.n\xb4>\xefb\xbf\xda\xc5'
 b'Kb-\x8dh\x00\x00\x00\x02\x00\x99\\\x9bGz\x00\x8f\x00\x9b?0\x93\x8c\xbf'
 b'V\x08\xff\x80\xc1?\x1b\xa5\x05J]')

{'A1': 0.6691712125102152,
 'A2': 1068510426,
 'A3': {'B1': [{'C1': 3, 'C2': [219, 4, 152], 'C3': 13, 'C4': 1874229903},
               {'C1': 82,
                'C2': [34, 185, 99, 88, 194],
                'C3': 121,
                'C4': -1751922420},
               {'C1': 222,
                'C2': [81, 55, 211, 214, 50],
                'C3': -10,
                'C4': -1156076233},
               {'C1': 108,
                'C2': [104, 132, 125, 29, 26, 108],
                'C3': -14,
                'C4': -895092816},
               {'C1': 188, 'C2': [53, 118, 181], 'C3': -106, 'C4': -1089388333},
               {'C1': 54, 'C2': [4, 226], 'C3': -50, 'C4': -839693591}],
        'B2': 16177},
 'A4': {'D1': 1553680250,
        'D2': {'E1': -20062, 'E2': -515935438673072530},
        'D3': {'F1': -17, 'F2': 98, 'F3': -0.4182918986100135, 'F4': [-76, 62]},
        'D4': 0.689751386642456,
        'D5': -0.8360747694969177,
        'D6': -9168977978384364963},
 'A5': [14589, 60559, 37478, 41316, 57225]}

(b'\xf3LNVK?\xef&Bj\x07H\xa2:C\xadz\x00\x00\x008\x00\xaa\xb1\xd9\xcbb\x81'
 b'|.\xc4w\x00\xfaq\x0cI\xff\xaa\xc4\x18K\x1c\x15\x1b\x17\x08\xcf\xba"\x8e\x13'
 b'\xb5\x8f\x87\xa4\x13\x00\x00\x00\x02\x00\x00\x00!\xf4d\xc3I{\xb3\x00'
 b'\x00\x00\x04\x00\x00\x00#\x13\xa8/\xd7\xfe\x9e\x00\x00\x00\x05\x00\x00\x00'
 b"'\xf4\xb7\xe2\xd5\x87\xae\x00\x00\x00\x02\x00\x00\x00,\x16\x95\x0b\xee!"
 b'f\x00\x00\x00\x03\x00\x00\x00.v\x11\x18\xbd\x0c\x88\x00\x00\x00\x07\x00'
 b'\x00\x001\xb2&\xc7\x1a\xbc\xb5:$_#/\xc7\xeb\x96\x0f\xf59\x07sy\xf3'
 b'?\xc1\xd8\x031t\xad`\x00\x00\x00\x02\x00\x98\x16\xaf\x94:\x00\x8e\x00\x9a?,'
 b"\xe1\x02=\x97\xf0\xb9y\xa9\xfe\xcf{\xea'\x83")

{'A1': 0.9734203406208233,
 'A2': 977513850,
 'A3': {'B1': [{'C1': 19, 'C2': [250, 113], 'C3': -12, 'C4': 1690519931},
               {'C1': 179,
                'C2': [12, 73, 255, 170],
                'C3': 19,
                'C4': -1473259522},
               {'C1': 158,
                'C2': [196, 24, 75, 28, 21],
                'C3': -12,
                'C4': -1209870969},
               {'C1': 174, 'C2': [27, 23], 'C3': 22, 'C4': -1794380255},
               {'C1': 102, 'C2': [8, 207, 186], 'C3': 118, 'C4': 286833932},
               {'C1': 136,
                'C2': [34, 142, 19, 181, 143, 135, 164],
                'C3': -78,
                'C4': 650582716}],
        'B2': -19142},
 'A4': {'D1': 380605498,
        'D2': {'E1': 9311, 'E2': 2535464929881748793},
        'D3': {'F1': 121, 'F2': -13, 'F3': 0.1394046775325064, 'F4': [7, 115]},
        'D4': 0.675308346748352,
        'D5': 0.07418961077928543,
        'D6': 8766818316744009603},
 'A5': [45529, 52066, 33148, 11972, 30464]}

Вариант №39

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x52 0x49 0x54 0x4d, за которой следует структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'RITM\xc8\x9b\xc6\x11\xb9^p\xbd\x10\xa1\xa1\x05\xc2\xd4EY\xdc/\x00\x82'
 b'\xc8\xa4-s4h`\x1d\x9al\xe3\xdbGS`\rs\xeb>\x02\x00\x17\x00Va\xc6oa'
 b'\xce\x99\x853\x86d\xd7\x8c\xec\x89\xeb\x8bz\x105\xe2b\x98\xe7?\x08\x14jB'
 b'7\xf6c\x1a\x1f\x00\x8e\x1dBB\xff\x15\xe5\x07\xe3\t\x0b\x0e\x185\xb8\xbe\x96L'
 b'mq\nV\xb9G\x90\xeaI\xde\x19\xb9\xad*\x02\x99\x17YZ-\xaa\xef\x94D\x81}k\xb0'
 b'6`?rhK\x01\xcd\xd2u\xe2?\xc2\xca\x10\x8a\xafn8\x17')

{'A1': [{'B1': 200, 'B2': 155},
        {'B1': 198, 'B2': 17},
        {'B1': 185, 'B2': 94},
        {'B1': 112, 'B2': 189},
        {'B1': 16, 'B2': 161}],
 'A2': 1441,
 'A3': 194,
 'A4': -598129196,
 'A5': {'C1': 1875272022,
        'C2': -2053517727,
        'C3': 16972356760375690803,
        'C4': 139,
        'C5': {'D1': 0.7373518388854017,
               'D2': [8, 20, 106, 66, 55, 246, 99],
               'D3': 26,
               'D4': {'E1': 6940970460447021597,
                      'E2': 0.4598621428012848,
                      'E3': [765773954, 1617441907]},
               'D5': 7566,
               'D6': [712421846552625730,
                      5518808091763150347,
                      16902088262859518317,
                      11025421763379584585,
                      4941838205316651287,
                      8232404431860891009]},
        'C6': 0.5768827442173974,
        'C7': 1673208961782827714}}

(b'RITM+c\xf4N\xc7\x19>\x8c_\xa9\xc3\xf9\x82M\x1c\x9b\xd6/\x00\x93s\xffq\xac'
 b'\x95\xf0Z\xed\xe3\xd2\xfe\xb2\xad\x04\xb1gnh\xbf\x02\x00\x17\x00\xb8'
 b'\x9c\\\xf97\x06\xf7\xaf\x8d\x0c\x8a#\x92\xc8\x91\xa63&\x02\xf1\xee\xdaK\xee?'
 b'\x9fM\r`"\xf2\xe5=\x1f\x00\xda\xa1\xb7\x89\xa0\x8c\xd9aY\x89\xfb\xbf6\x0e'
 b',z\xb3\x8b\x0eq*\x96\x01X\x05\xf2\xed\x1d\xaa\xb5\x1cX\x82\xf0jFP`\xccu\xe0a'
 b']\xa2\xbe-\xd4\x10\xc8b\xdc\xf1O`\xc9Y\xed?\x95\x90\x9f\xe77\x96\xaao')

{'A1': [{'B1': 43, 'B2': 99},
        {'B1': 244, 'B2': 78},
        {'B1': 199, 'B2': 25},
        {'B1': 62, 'B2': 140},
        {'B1': 95, 'B2': 169}],
 'A2': -1597,
 'A3': 130,
 'A4': -694477747,
 'A5': {'C1': 4183596216,
        'C2': -1342765513,
        'C3': 12002595011906112653,
        'C4': 51,
        'C5': {'D1': 0.9467596690011006,
               'D2': [159, 77, 13, 96, 34, 242, 229],
               'D3': 61,
               'D4': {'E1': -5691233044798446611,
                      'E2': -0.9079346060752869,
                      'E3': [1912566675, 1525716396]},
               'D5': 41434,
               'D6': [9897049243118504375,
                      10066523921738809339,
                      17439441895899689230,
                      17330511196405243373,
                      7052766537111848554,
                      7117957714545648221]},
        'C6': 0.9172102814769079,
        'C7': 8046408851104174229}}

Вариант №40

Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x4b 0x51 0x46, за которой следует структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль struct.

Ниже показаны примеры разбора двоичного формата.

(b'JKQFj\x00\x00\x00mL\xa8\x00\x02\x00\x00\x00\x8fh\xcf\xf6\x0cXKW'
 b'\x9b\xbe\x90\nW\xde\x00\x96Y\xd2\xc9w\xef\xd1\x80 se7\xbfrp\x9d\x18'
 b'\xeb\xcc;H\x0eI\xc7;\x95R\x89\x97\xf4\xbf\x18M\xe51\x97\x1e\x162n\xb4'
 b'\x9c\x0c\xf3\x19\xcb\x94\t\x00\x19\x00+\x00=_S\x1c\xf3\x84\x8b\xfe'
 b'\x87\xfc`\x98\x14\xd2\x80Q\x18"-\xc8\xcb=2\xe5\x14\xbf\xde\xb8\xd1_\xdb\xf4'
 b'\x10\xdaP\x00\x03\x00O?z\x11\xeb\xbf\xed\xa8Z}\xc4\xef\xdaI\xcf\x00\x00\x00'
 b'U\xa5-\xe3\xe9')

{'A1': 106,
 'A2': {'B1': -0.4800303875088625,
        'B2': -9648,
        'B3': [{'C1': -0.28132888674736023,
                'C2': -8704,
                'C3': 38489,
                'C4': 53961,
                'C5': 8642356558177723703},
               {'C1': -0.9470308423042297,
                'C2': 6379,
                'C3': 52283,
                'C4': 18446,
                'C5': 5316283397655074804},
               {'C1': -0.5949385762214661,
                'C2': 12695,
                'C3': 7702,
                'C4': 12910,
                'C5': -5432452812266302455}],
        'B4': 0.9768359065055847,
        'B5': -0.9268009621077866,
        'B6': 18895,
        'B7': {'D1': 1599282419,
               'D2': [-124, -117],
               'D3': [-105838574421355904, 5843458096550853938],
               'D4': -6892},
        'B8': 42285},
 'A3': 19624,
 'A4': [227, 233],
 'A5': 26831,
 'A6': 4128004171,
 'A7': 22427}

(b'JKQF\x12\x00\x00\x00Y\xc3r\x00\x03\x00\x00\x00{\x9b\xb8\x8e\xb7\xe0@\xe6'
 b'\xc6\xbf}\x83\x00=5\xd2\xba\xc7\xce\\\xb1\xf4\x8e\x84X\x9b\xd7\xbe'
 b'\xa9\xf5n\xbbpK\xf0q\xbfY\x0c\xb6nFH\xe1=\x00\x19\x00+\xb8\xb2R\xca\xcf\x84E'
 b'\x1a|:\x89+\xee\x0e\xcb\xd8\xf1\x9boII\x9f+ ?\xd9\xa6\x15\x94\xd6\xe0'
 b'\xacP\x90\x00\x02\x00=?d\xce\xe1?\x97*\xbf\x15d\xd2\xc0\xc4\x01\x00\x00\x00'
 b'A\xc9\x96\xc74I')

{'A1': 18,
 'A2': {'B1': 0.4007619813451224,
        'B2': 20624,
        'B3': [{'C1': -0.9902801513671875,
                'C2': 15669,
                'C3': 53946,
                'C4': 51150,
                'C5': 6679388615310089175},
               {'C1': -0.3319506049156189,
                'C2': -17552,
                'C3': 19440,
                'C4': 29119,
                'C5': 6416704153837953341}],
        'B4': 0.8937817215919495,
        'B5': 0.022624002152229705,
        'B6': 50177,
        'B7': {'D1': 3098694346,
               'D2': [-49, -124],
               'D3': [4979428928862809614, -3757988239151380065],
               'D4': 11040},
        'B8': 51606},
 'A3': -15502,
 'A4': [199, 52, 73],
 'A5': -25672,
 'A6': 2394415168,
 'A7': -6458}

Поле	Описание
1	Массив адресов (uint16) структур D, размер 2
2	uint64
3	Структура E
4	uint8

Поле	Описание
1	Адрес (uint16) структуры D
2	int16
3	uint64
4	float
5	double
6	float
7	uint32

Поле	Описание
1	int64
2	uint32
3	Массив uint32, размер 7
4	uint32
5	uint64

Поле	Описание
1	double
2	uint64
3	Массив uint32, размер 8
4	Массив float, размер 6
5	Массив uint16, размер 8

Поле	Описание
1	Адрес (uint16) структуры C
2	int32
3	Массив int8, размер 5
4	uint16

Поле	Описание
1	Массив структур D, размер 6
2	Размер (uint32) и адрес (uint16) массива int8
3	Адрес (uint32) структуры E

Поле	Описание
1	Массив int16, размер 7
2	Размер (uint16) и адрес (uint32) массива int64

Поле	Описание
1	Массив структур C, размер 8
2	uint8
3	uint32
4	uint16
5	Размер (uint32) и адрес (uint32) массива char

Поле	Описание
1	int16
2	int32
3	Массив uint8, размер 6
4	uint16
5	Размер (uint16) и адрес (uint16) массива int64

Поле	Описание
1	Массив int8, размер 6
2	Размер (uint16) и адрес (uint32) массива uint8

Поле	Описание
1	uint32
2	Массив char, размер 8
3	uint32
4	int8
5	int16
6	Адрес (uint16) структуры B
7	uint16
8	float

Поле	Описание
1	Массив uint32, размер 4
2	uint8
3	uint8
4	Размер (uint16) и адрес (uint32) массива uint8
5	uint8
6	uint8
7	int8
8	uint16

Поле	Описание
1	int8
2	Размер (uint16) и адрес (uint16) массива структур E
3	Массив uint16, размер 6
4	Массив double, размер 4
5	uint16

Поле	Описание
1	Размер (uint16) и адрес (uint16) массива uint16
2	Массив uint32, размер 2
3	Адрес (uint16) структуры D
4	uint16
5	double

Поле	Описание
1	uint64
2	Массив адресов (uint32) структур D, размер 2
3	Массив uint16, размер 8

Поле	Описание
1	float
2	Массив int8, размер 2
3	Массив int8, размер 5

Поле	Описание
1	Массив uint64, размер 6
2	uint32
3	int16
4	int64
5	uint32
6	Массив float, размер 5
7	int16

Поле	Описание
1	Структура C
2	Массив uint16, размер 7
3	float
4	Размер (uint32) и адрес (uint32) массива uint16

Поле	Описание
1	Массив структур D, размер 7
2	uint8
3	Адрес (uint16) структуры E

Поле	Описание
1	int64
2	Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C
3	Массив char, размер 4
4	Массив double, размер 7
5	Адрес (uint32) структуры D

Поле	Описание
1	Массив структур B, размер 5
2	int16
3	uint8
4	int32
5	Адрес (uint16) структуры C

Поле	Описание
1	double
2	Массив uint8, размер 7
3	uint8
4	Адрес (uint16) структуры E
5	uint16
6	Массив uint64, размер 6

Поле	Описание
1	uint32
2	Массив int8, размер 2
3	Массив int64, размер 2
4	int16