ИКБО-28-22

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

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

Поле	Описание
1	Структура B
2	Массив адресов (uint32) структур E, размер 2
3	int64
4	Адрес (uint32) структуры F

Поле	Описание
1	Структура C
2	Структура D

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

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

Поле	Описание
1	int16
2	int64
3	int8
4	uint64

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

(b'DONL\xd4\xb76\xce\xb4\x11\xbedg\x7f\n\xf6\xb2j\x82\xf7Q\xbf!\xe5\x9aWBn'
 b'c\xa4\x8e\xd4\\Z\xa4\xca\xec\x87\x96;\x00\x00\x00N\x00\x00\x00\xeeM\x08\x9dm'
 b'pZ\xf6\x81\x00\x00\x00\x97\xb7gv\xdf\x00{KA\xf6;\xd9\xc8\xf7]\xbaO\x9cP_a'
 b'\xc4\xd4MJ"rN\xd4(\x8cu\xd0{5\x19\x8fX\x06\x1c9\x9e\xba\x92h\x11\xd0%\xc3'
 b'OH\xf0\xbf\xbf$s[\xf3\xbbj\xe6?\x0e\xd05.\x89\xd7\xe8\xf8\x04\x00\x00'
 b'\x00a\x00P&nF\xdc\x82\xb5?\x02\x00i\x00\xdeh\x1b\xe2\xaa\xc9\xa8\x04\x04'
 b'\x00\x00\x00y\x00\x00\x00')

{'A1': {'B1': {'C1': 918017100,
               'C2': -0.14229127764701843,
               'C3': 'dg',
               'C4': 127,
               'C5': 1790113290,
               'C6': -0.8201829195022583,
               'C7': 33},
        'B2': {'D1': 10278449574776904421, 'D2': 10846898582630063316}},
 'A2': [{'E1': -18537,
         'E2': -702197075225381273,
         'E3': 59,
         'E4': 5808605281260128473},
        {'E1': 24927,
         'E2': -3148453597884328764,
         'E3': 40,
         'E4': 6381346914508502412}],
 'A3': -695119576387006994,
 'A4': {'F1': [7174, -25031, -27974, 4456],
        'F2': 0.08402802199830117,
        'F3': [-0.12476016948053048, 0.7005290749617399],
        'F4': 335739908014172382,
        'F5': [-12274, 11829, -10359, -1816]}}

(b'DON\x9b\x9a\x00\x8e\x18\xc6\x13\xbecl4a:8\xba;q\x85\xbd\xbd\x9bC\x13\x06\xc8'
 b'\x81\xeb\x15\xc6\xa8\x0fM\xeeZ|`;\x00\x00\x00N\x00\x00\x00/\x03\xb8\xdc1'
 b"'\x01\xa2\x93\x00\x00\x00(r\xec\xef;w\x9e\xcd\xac\xd5}\x88\x99"
 b'\x86\xc2\x99\x1e\xe6I\x8bJ&y\xd46qB\xa4y\r\xeb\xa3P\xdd\x0f\xcb\x80fVM\xc5'
 b'V)\xff\x1a\x0e\x95\xef*\xaaX \x0b\x19\xe8?lG\x15lxU\xd6\xbftL\xca\xee\x16'
 b'\xbe\xe6?\xeb\xcb5\xe8\x8c\x17\xe0/\x94\xfc\x1d\x960V\x81\xe3\x05'
 b'\x00\x00\x00a\x00\x1cG\xfc\xc3\xac\x80\xe6\xbf\x03\x00k\x00\xc8\xab\x0e'
 b'\x135\xd5"\xf2\x08\x00\x00\x00\x83\x00\x00\x00')

{'A1': {'B1': {'C1': 2382404251,
               'C2': -0.1443103551864624,
               'C3': 'cl',
               'C4': 52,
               'C5': 3124247137,
               'C6': -0.06515737622976303,
               'C7': 189},
        'B2': {'D1': 1579498790418858907, 'D2': 6952531904294791366}},
 'A2': [{'E1': 29224,
         'E2': -3049836767147724820,
         'E3': 125,
         'E4': 5324977255154620808},
        {'E1': 19083,
         'E2': 8765203828788459814,
         'E3': 13,
         'E4': 7386126657885610987}],
 'A3': -6773089269478587601,
 'A4': {'F1': [19798, 22213, -215, 3610, -4203],
        'F2': -0.7032073810425774,
        'F3': [0.7530570632710056, -0.34896669917099277, 0.7107042945739424],
        'F4': -999001743393117240,
        'F5': [-13333, -6091, 6028, 12256, -876, -27107, 22064, -7295]}}

Вариант №2

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

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

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

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

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

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

(b'FPGc\x00\x00\x00i\x00\x00\x00\xf3\x98N\x02\n\xa8Q\xcdW\xe2\xed\xbf\x89'
 b'5\xb3^X\x07\xdaQe3\n\xff\xfa\xa6\xa6\xb5C\xce\xfb\xa4\x91\x81\x83\xc3\xdc'
 b'-\x07\xc9v\xe3D\x91\x93]\x81n\xec\xbf\xc4\x8aW\xbdT\x03\xe8?\x8e\x80X'
 b'\x9a\x9d\xbe\x10\x97=Y\x8e\x076\xec\xe7\xde\xab\xaa\xb3;\xb0w\xed#\xabq\xd4'
 b'\xbf\xd1\xc6txan4\xe9qmmu\xd7E')

{'A1': [{'B1': 'txan', 'B2': 59700}, {'B1': 'qmmu', 'B2': 17879}],
 'A2': {'C1': 38705395,
        'C2': {'D1': -0.9338797578941478,
               'D2': [13705, 24243, 1880],
               'D3': 12032209773750735322,
               'D4': 9336424903920039334,
               'D5': 16390508926532895619,
               'D6': -0.8884894206681015,
               'D7': 0.7504066179356745,
               'D8': -32626},
        'C3': -0.3078181743621826,
        'C4': [38672, 22845, 1934, 60470, 57063, 43691, 15283]},
 'A3': -0.3194377756934683,
 'A4': 50897}

(b'FPGc\x00\x00\x00i\x00\x00\x00\xc9\x90\xd6\xb0~z\x8fF\xb4\xd6\xe9\xbfU'
 b'f\x8f%\xec4\x1a\xc4w\nzN\xad\x941\xfd\x94\xb2\xf6\x9f\xd4\xffh\x8d\xb5'
 b'\xc3R\x06\xfd\xf2b\xbeu\x13\xbd\xc9\xec\xbfD\xc9\xfcM\x92\x9d\xd2??\x8c\x03'
 b'_\x84>\xfc?\x0f\xf4\xa6J\xfa\xa3\xd6G+\xbe\xa2{X\xca\x13:\xfc\x84\xe6'
 b'\xbf>\xb4fdvt\xb1\xa6wklk7\x14')

{'A1': [{'B1': 'fdvt', 'B2': 42673}, {'B1': 'wklk', 'B2': 5175}],
 'A2': {'C1': 2966851785,
        'C2': {'D1': -0.8074590089925804,
               'D2': [26197, 9615, 13548],
               'D3': 10713305374652875802,
               'D4': 18434535056641162545,
               'D5': 17509157878826896744,
               'D6': -0.8996262912823563,
               'D7': 0.2908674012752679,
               'D8': -29633},
        'C3': 0.2585373818874359,
        'C4': [16380, 62479, 19110, 41978, 18390, 48683, 31650]},
 'A3': -0.70373355239128,
 'A4': 46142}

Вариант №3

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

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

Поле	Описание
1	Адрес (uint16) структуры B
2	int64
3	Структура C
4	uint16
5	uint8
6	Структура F

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

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

Поле	Описание
1	uint8
2	float
3	uint8
4	Структура E

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

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

(b'TXUR\xaf\x9a\x00\xab\xf9z\xb6`\x17D\xe3\x17\xfc\x1f\xb6>\xa0\x02\x00\xa8'
 b'\x00}\xe0\xed\x08\xb0\xf7\xa4\xd5\x05\xbf\xfa\x03\x00\xaa\x00'
 b"\xf5\xbe\x7f\xa3\xe5!\xc5>'?\xb7\x03\x00\xad\x00\xd7\x07\x86\xb6\xcd"
 b'?\xc3\x8d\xfb>s\xe7\x96b-\xd3\xff\xf3\xd7\x03\xbe\x1e.?jh\x1eM\xe2'
 b'\xa5\xff\xdd\x87\x91\x8e\xd6\xe1\xe2\xedy2\x10\xdc[_\xf8\xf0\x85\xed'
 b'\xa0\x01\x99&0\x00\xa6|J\xcc5OIb\xd2-\x8b\xd9s\xd8\xcf\x89m}\x0f\x00\xd8\xf0'
 b'd?\x03\x9c\x7f\xca\xa93\xb3\xb0m\x1d\xd8o\xfd\xeeW\xe6H\x0ez\xc8X\xf5'
 b'n\x06\xf7\xbds\x8f\x9f\x93\x90S)>E,wGV\xea\xdc\xc7')

{'A1': {'B1': 107935064, 'B2': -16905, 'B3': 4479203184813772659},
 'A2': -2070504224537773653,
 'A3': {'C1': [{'D1': 23,
                'D2': 0.35571277141571045,
                'D3': 160,
                'D4': {'E1': [69, 44], 'E2': 125, 'E3': -1341592096}},
               {'D1': 247,
                'D2': -0.5227911472320557,
                'D3': 250,
                'D4': {'E1': [119, 71, 86], 'E2': 245, 'E3': -442269762}},
               {'D1': 33,
                'D2': 0.6533015370368958,
                'D3': 183,
                'D4': {'E1': [234, 220, 199], 'E2': 215, 'E3': -843676153}}],
        'C2': [49983, 64397, 29502, 38631, 11618],
        'C3': 65491,
        'C4': -13,
        'C5': 983,
        'C6': 0.6801565885543823},
 'A4': 26730,
 'A5': 30,
 'A6': {'F1': [4289061453,
               2391902173,
               3991069142,
               3692049017,
               4042809179,
               27323781,
               3155609,
               3427433638],
        'F2': [-2771070764101054667,
               4360034067667059,
               -3855191218243440424,
               8059223890132677545],
        'F3': -4000869612700307715}}

(b'TXUR\xaf\x9a\x00K\xb0\x9ez eD\xcf\xd0\xb8$8\xbf\xc5\x03\x00\xa8'
 b'\x00\xd2\xa9\xb4\xe7a\x11\xf2\xb4\xfc>1\x02\x00\xab\x00\xce\x14$.'
 b'\xa6\xba/\x12\xd4\xbe\xe7\x03\x00\xad\x00\xd0\xae\x95\x08\x8e|[\xadr3L1m'
 b'?\x8e\xb5\x8bM\xdbz8\x84Y\xbe\x1c\xd3HP\xd5\x9b7^\x19\xa8,8\xad\x03zc\x9c'
 b'\x1a\xa0m\x1d\x1f\xb1 n\xbc\xd6kQU\xf7\xfb\xd6\xc9\x06\n\xc8\xb8i\x0f:'
 b'\x9b)\x8d\xaa\x98\xf2v\xf5\xc2\xb7\xf0\xcf\xbal\xc5\xe5k\x08\xe1\xd3'
 b'\x9b\xe2\x88\xc8\xb1\xce\x8fh\xff\xf7;\xfc\xb2W\xbb{w4\x97k\x9e\x14x\xca'
 b'n\x82\xcf\xef\xfd&5\x18\x9a\xb4\xc4\x1b')

{'A1': {'B1': 880245691, 'B2': 27543, 'B3': 17280173707598763166},
 'A2': -3511570619271565237,
 'A3': {'C1': [{'D1': 208,
                'D2': -0.7193102836608887,
                'D3': 197,
                'D4': {'E1': [253, 38, 53], 'E2': 210, 'E3': 1642575017}},
               {'D1': 17,
                'D2': 0.4935680031776428,
                'D3': 49,
                'D4': {'E1': [24, 154], 'E2': 206, 'E3': -1506925548}},
               {'D1': 186,
                'D2': -0.4142012298107147,
                'D3': 231,
                'D4': {'E1': [180, 196, 27], 'E2': 208, 'E3': -1912040018}}],
        'C2': [23420, 29357, 19507, 27953, 36415],
        'C3': 35765,
        'C4': 77,
        'C5': 31451,
        'C6': -0.21241843700408936},
 'A4': 54044,
 'A5': 72,
 'A6': {'F1': [932959568,
               749214046,
               2047061304,
               2686098531,
               2971606381,
               3602673184,
               4149563755,
               113891067],
        'F2': [2998053814817835018,
               -5205328328061834611,
               606831210906963952,
               -3552838140775640095],
        'F3': 6319390561648208015}}

Вариант №4

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

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

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

Поле	Описание
1	double
2	int8
3	uint16
4	uint16
5	int16
6	uint8
7	Структура C

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

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

(b'fZHKO\x00\x00\x00G\x00\x00\x00\x04\x00\x00\x00eD\xd1\xd5\xf2\xd0\x9e\xb9'
 b'Ll\xda,F$\xe0\xf4(5E^Q\x83\x8751n\x1c\x92\xb1\x9d\xafg\xd24\xd9\xc2'
 b'\xee\xe3\x14\x19\x1d\xa6\x0b\xc7\x9b\x18k\x05\xbcv\xa2\xf9mco\xbf'
 b'\xd6\xd9\xf6\x9cv:L\xbe\xe2\x85\xa4\xf8|fg#\x00\x03\x00Dv\xcf\xffcJ?R"'
 b'\x90hbhw')

{'A1': {'B1': -0.35705342559314057,
        'B2': -66,
        'B3': 57989,
        'B4': 42232,
        'B5': 31846,
        'B6': 103,
        'B7': {'C1': 35,
               'C2': 'mco',
               'C3': 118,
               'C4': -805346486,
               'C5': 0.8208398818969727}},
 'A2': 'hbhw',
 'A3': 1154602482,
 'A4': [{'D1': 208, 'D2': [-98, -71, 76, 108, -38]},
        {'D1': 44, 'D2': [70, 36, -32, -12, 40]},
        {'D1': 53, 'D2': [69, 94, 81, -125, -121]},
        {'D1': 53, 'D2': [49, 110, 28, -110, -79]}],
 'A5': -25169,
 'A6': 103,
 'A7': [15146970878008562713, 2136408025162345221],
 'A8': -0.015053504146635532}

(b'fZHKO\x00\x00\x00K\x00\x00\x00\x06\x00\x00\x00io>\xfe"\xf6X-\xd9zX\x04'
 b'\xc5\xfc\xea\xf0\x8f\xb1\xfe\x05\xa7\x05\x05\x850\xe8,\xd1\xb2\xa0\xf9\x10'
 b'\x83\xb84x\\\xb4\x9eD\xf7\x11\xc3\xca\x8f\x9b\xe6\x02\xbf\x15\\eqqosonf\xbf'
 b'\xe8\xdd\r\x1eK\xf1 bm\xcc\x85\xea\x83\xd7I\x0b\x00\x07\x00D\xd4_Ce'
 b'\x13\xbe\xd3\xf4Eirzctx')

{'A1': {'B1': -0.7769837943774611,
        'B2': 98,
        'B3': 28108,
        'B4': 34282,
        'B5': -31785,
        'B6': 73,
        'B7': {'C1': 11,
               'C2': 'qqosonf',
               'C3': 212,
               'C4': 1598252307,
               'C5': -0.41397300362586975}},
 'A2': 'irzctx',
 'A3': 1866399266,
 'A4': [{'D1': 246, 'D2': [88, 45, -39, 122, 88]},
        {'D1': 4, 'D2': [-59, -4, -22, -16, -113]},
        {'D1': 177, 'D2': [-2, 5, -89, 5, 5]},
        {'D1': 133, 'D2': [48, -24, 44, -47, -78]}],
 'A5': -24327,
 'A6': 16,
 'A7': [9491393906239381060, 17803226076732450306],
 'A8': -0.5834410786628723}

Вариант №5

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

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

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

Поле	Описание
1	int8
2	uint64
3	double
4	Структура C

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

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

(b'3HPNV\xb80\xc7K>p\xdc??\x00\x00\x00\x01\x02\x00\x98\x00@\x05\xbd\x8fHR'
 b'\xcd\xbfR\x06\xbd\xa8i\xa7\xe3?x\x19R\xb9\xe4\x19\xeb\xbf\xe6\xb7'
 b'\x8c\x13\xef\xb9\xec?!\xfc\xd6R\xcd\xce\x83P{v\r\xe3-M\x00\xa1h\x90'
 b'\xdcnD\xe89/\xdc\xbf\xae\x83Z"\xb3UB\xb3\xf0u\xa9\x18\xf1\xa8nb\xe2ls~'
 b'\x983\x02\x00\x00\x00^\x00\x03\x00\x00\x00`\x00\x00\x00\xebi\x01\xed\xb8fyw'
 b'ez\x84\xcb8\xa9\xe2\xe3\x04\x00\x00\x00z\x00\x03\x00\x00\x00~\x00'
 b'\x00\x00\x06\x88\xb9\x0e\xd7\xeff\x00\x00\x00\x84\x00\x00\x00')

{'A1': 0.4443507900257475,
 'A2': {'B1': 118,
        'B2': 10405743961706455821,
        'B3': -0.44038245851855407,
        'B4': {'C1': 12916980909115868078, 'C2': 30192, 'C3': -1460594519}},
 'A3': 1,
 'A4': [{'D1': 'nb',
         'D2': [27874, 32371, 13208],
         'D3': -318674453,
         'D4': 184,
         'D5': 102},
        {'D1': 'ywez',
         'D2': [52100, 43320, 58338],
         'D3': 247040006,
         'D4': 215,
         'D5': 239}],
 'A5': [-0.22907359140848804, 0.614186124388832, -0.8469108218712753],
 'A6': 0.8976970083074292,
 'A7': [33, 252, 214, 82, 205, 206, 131, 80],
 'A8': 123}

(b"3HPNVP\xc8\xd69\x10s\xdd??\x00\x00\x00Y\x02\x00\x9d\x00\x1e\x93\xfd'0\x10"
 b'\xe0\xbfl+\xe5A\xee~\xdf\xbf>\xe1\x06JZ\xca\xe1\xbfP\x1e\rW$\xed'
 b'\xe8\xbf\xe0hr?^\xbd\xd4\x95.\xc7\xff\x17\x11a|H\t3\x8a\xa1-\xe2'
 b'N\xd7\xe7\xbf\xc2\xa8\t\xcf4\x1c\xf9t\x81s\xefW\xba\x0ewoiprx\x8c\x863\x12'
 b'\xcc&\x06\x00\x00\x00^\x00\x03\x00\x00\x00d\x00\x00\x00\xdc\xd8\x0b8g\xc8jg'
 b'veu\x1cK\xadb\x9ca\x05\x00\x00\x00~\x00\x03\x00\x00\x00\x83\x00\x00\x00K'
 b'\x10\xb4N>\x87j\x00\x00\x00\x89\x00\x00\x00')

{'A1': 0.46014791153277645,
 'A2': {'B1': -57,
        'B2': 3677550269766375423,
        'B3': -0.7450327317756529,
        'B4': {'C1': 8428799190737987778, 'C2': 29569, 'C3': 247093231}},
 'A3': 89,
 'A4': [{'D1': 'woiprx',
         'D2': [34444, 4659, 9932],
         'D3': 940300508,
         'D4': 103,
         'D5': 200},
        {'D1': 'jgveu',
         'D2': [19228, 25261, 24988],
         'D3': 1320423499,
         'D4': 62,
         'D5': 135}],
 'A5': [-0.5019760876717532, -0.49212223467900773, -0.5559512563550368],
 'A6': -0.7789479923457723,
 'A7': [224, 104, 114, 63, 94, 189, 212, 149],
 'A8': 46}

Вариант №6

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

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

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

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

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

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

(b'LXHC\x11\xdd9~\xf6Z"mhpbbZ\x05\x00\x00\x00B\x00.^G\x93\xed\x1c\xe9*\xf5'
 b'\xd6\x91LJ\xf6\x95oT\xc7\x84\xdcO\x02\x00e\x00\x00\x00H\xe9\x9f\xbe\x08\x00'
 b'\x00\x00u\x00\x00\x00\x95\x00\x00\x00u\x0e\x1f\xf8\xa6C\x0c4i\xe8ZU\xc9\xaa'
 b'#\xe7\xe7\xc2\xd3\x84\xbf\x81vZ\x8e\\\xbf\xf7\xbe\x80\x15\x05\x91s\xa5):u'
 b'\x04w\x02\xcc\x9bg\xc03^\x08d\x80r0^\xc2\xc3\x80Y\x84\xadG%\xab\x9c\xca1\x95'
 b'\xa8\xe5W\xf2\xf3oL\xcb_\xec\xb7h\xb2\xf9\xdf\xbc\xdf\x00\x1fB'
 b'\x1f\x7f\xfe\xaf?9it\xff')

{'A1': {'B1': 4135467485,
        'B2': 8794,
        'B3': 'mhpbb',
        'B4': 90,
        'B5': [{'C1': 3701, 'C2': [31, -8, -90], 'C3': 3139},
               {'C1': 26932, 'C2': [-24, 90, 85], 'C3': -21815},
               {'C1': -6365, 'C2': [-25, -62, -45], 'C3': -16508},
               {'C1': 30337, 'C2': [90, -114, 92], 'C3': -2113},
               {'C1': -32578, 'C2': [21, 5, -111], 'C3': -23181}],
        'B6': 3092034425870310958,
        'B7': 245},
 'A2': 1246532054,
 'A3': 5754620415522608630,
 'A4': [11226350681326959145, 8250704504445714535],
 'A5': -0.31232666969299316,
 'A6': [-1010672080,
        -1383835264,
        -1666505401,
        -1466617398,
        -202221595,
        1607158895,
        -1301760020,
        -541270023],
 'A7': {'D1': 0.062488529744824106, 'D2': -9148103}}

(b'LXHC\x11\xc2\x04\x17\xda\xc7\xc8gzsqp\xb7\x05\x00\x00\x00B\x00W3\xb8\x01\x89'
 b'\xbc\xc7\xfbXAE+\x80}\xf7\xd1Sg\xd2\xe4\x08\x02\x00e\x00\x00\x00\xd3Q'
 b'n?\x06\x00\x00\x00u\x00\x00\x00\x8d\x00\x00\x00\x9dz\x05y\xc9\x9d'
 b'\xde\xa8\x0f\x01T\xd9\x87u~\x93C\x16f[\xc2\xf9\xcd\x07\xbd\x86\t\xca\xbc0'
 b'I\x0c\xbe\xb1\xeb\x1aX6h\xd3\xf0=e\x05\x00\x93\xb1\xfb62\xf8\xe5\xc0\x86'
 b'\xa8\x16\xcb\xf6\x91\xaffLq\x18Zu\xf8z\x92#\x94j\xc7\xeeRf\xc7\xb3Y \x8b\xee'
 b'?\xa8x\xd5\xf1')

{'A1': {'B1': 3658941634,
        'B2': -14137,
        'B3': 'gzsqp',
        'B4': -73,
        'B5': [{'C1': 31389, 'C2': [5, 121, -55], 'C3': -8547},
               {'C1': 4008, 'C2': [1, 84, -39], 'C3': 30087},
               {'C1': -27778, 'C2': [67, 22, 102], 'C3': -15781},
               {'C1': -12807, 'C2': [7, -67, -122], 'C3': -13815},
               {'C1': 12476, 'C2': [73, 12, -66], 'C3': -5199}],
        'B6': 18142676920510722903,
        'B7': 88},
 'A2': 2150319425,
 'A3': 640868388223186813,
 'A4': [7295251762187229210, 17884417524885553157],
 'A5': 0.9309360384941101,
 'A6': [-1467563803,
        -1846097130,
        1900832431,
        -126526952,
        -1809608070,
        1391380330],
 'A7': {'D1': 0.9544831993100444, 'D2': -237668184}}

Вариант №7

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

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

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

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

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

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

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

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

(b'PJBF\xce,e\x00\x00\x00x#\xf6\x14\xac\xb5\xef\xbf\xc3\xa0\xf5\x1aM\x18'
 b':_\xad\xd8\xd3\xe0\xbf\x9dW"\xab\xc4\x9d\xc9\xbe\xf3\xf0#\xc9\xee'
 b'\xe7C\x0b\x1d%\xd6\x18T\xad\xcf\xeb\xd6\x8c\x80/\x03\x00\x00\x00\xa5'
 b'\x00\x00\x00\xcfb@\x81\x91\xa2\xb7\x94\x0f`\x1e\x87\xe8\xc3\x7f\x92\xfc'
 b'\xb5\xa9\x01IV\xfe\xe0/MQ\x8eZ\x83\xdfc\xd7\xbe4\xb9\x02\x00\x00\x00K'
 b'\x00\x00\x00\xca4\x15\xa7\x03\x00\x00\x00O\x00\x00\x00lf\xe5\xb1\x03'
 b'\x00\x00\x00U\x00\x00\x00\xec\xfd\x8bp\x02\x00\x00\x00[\x00\x00\x00\xa0'
 b'\xca{\x8e\x03\x00\x00\x00_\x00\x00\x00\xcca\x00\xd6\x98\xec\xb1\x93\x84'
 b'\xeb@\\\xf2\x92\x9d4L/(\x8e\xe7[\xd8\xbb\xaf&"\xf7\x8d\xd2')

{'A1': {'B1': 11470,
        'B2': {'C1': [{'D1': -18124, 'D2': [24591, 34590], 'D3': 13514},
                      {'D1': -22763, 'D2': [50152, 37503, 46588], 'D3': 26220},
                      {'D1': -19995, 'D2': [425, 22089, 57598], 'D3': -532},
                      {'D1': 28811, 'D2': [19759, 36433], 'D3': -13664},
                      {'D1': -29061, 'D2': [33626, 25567, 48855], 'D3': 25036}],
               'C2': {'E1': 54784, 'E2': -4968}},
        'B3': -0.9909267815975076,
        'B4': {'F1': 41155,
               'F2': -11,
               'F3': 19738,
               'F4': -0.5258601556941498,
               'F5': [-1423812707,
                      -1094083132,
                      -920391437,
                      188999662,
                      416687389,
                      -338711212,
                      796953814]},
        'B5': [10588627107800454065,
               6622418080314963101,
               15172054445731068888]},
 'A2': -7730531489535728945}

(b'PJBF\xeb\xc8e\x00\x00\x00\xec}\x99)\xef\x7f\xe8?(\xe4S\x1e\xacB\xa1H\xc6\x1a'
 b'\xba\xe1\xbf\xe6\x85\xc4\xdd;\x027K\xe1U`\x81.!I\xd2"\x96d\xec\xe5&s\x93\xed'
 b'\xde\x9f9\x03\x00\x00\x00\xa5\x00\x00\x00k\xc3\xfd\x0e\xec\x93\x1c]a'
 b'\xb2\xd0\xca\xcctwh\xe3\x19%)\\I\x9b\t\x8d\xe8\xfb\xec\xffK\xae\xee|'
 b'\xd9\x08\x14\x03\x00\x00\x00K\x00\x00\x00kq\xe0\xf4\x02\x00\x00\x00Q'
 b'\x00\x00\x00\x89\x156h\x03\x00\x00\x00U\x00\x00\x00ry\xd7\x81\x02'
 b'\x00\x00\x00[\x00\x00\x00l\x07\xb0e\x03\x00\x00\x00_\x00\x00\x00\xda\xd7<$w'
 b"\xc6\xb3\xc6\xd1J-k\x8c\x1ff\xf4D\xe6\xdbl\xb6\xed\r\x81\xfd\xe0f'\xa2\xf2")

{'A1': {'B1': 51435,
        'B2': {'C1': [{'D1': 5128, 'D2': [45665, 51920, 29900], 'D3': 29035},
                      {'D1': -2848, 'D2': [26743, 6627], 'D3': 5513},
                      {'D1': 26678, 'D2': [10533, 18780, 2459], 'D3': 31090},
                      {'D1': -32297, 'D2': [59533, 60667], 'D3': 1900},
                      {'D1': 26032, 'D2': [19455, 61102, 55676], 'D3': -10278}],
               'C2': {'E1': 9276, 'E2': -14729}},
        'B3': 0.7656169712535621,
        'B4': {'F1': 58408,
               'F2': 83,
               'F3': -21474,
               'F4': -0.553967845223305,
               'F5': [-574323226,
                      1261896251,
                      -2124392991,
                      -766959314,
                      -328952286,
                      -1821169947,
                      966778605]},
        'B5': [2273309754188220083,
               17128997924467176550,
               17483580026220544269]},
 'A2': 6709400186948273003}

Вариант №8

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

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

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

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

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

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

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

(b'\xc9FUBY\x8b\x00\x00\x00\x02\x00\x10\x00\x00\x00Q\xd2\xc2\x0c\xef\x04v\xc9z'
 b"\x9b\x98`\xf4\x05FJ\x13'\xd1\xe1\xc1\xfa\x14\xc0F\x82\xbb7\x92\xe3-\xc1a"
 b'\\l_\xe7\xadDDK\x19b\xcc4\x0fFaB\x00\x03\x00(\xc6\xec\xc2\xae\xc6?\xe6.'
 b'\xde*\xd0?\x10\x00\x00\x00@\x8d\xda\x00\x8e\'\xef\xe3\x90y\rwf*"?'
 b'\xee\xb8*\xba\n~\xc0A\xf9Y\xf5\x90(v\x89\xe0\xd4\xaf%\x8d\x7f\xde\x1a\xaf'
 b'z\x8e\x0c\x9c\xaa?\x962\x90\xa0\xc2\xcc@\xbf\xe4>\x80f\x9f\x8a\x1c?\xd0\xd9'
 b'33\x0b\x04\x0832;\x047(\x96r\xe0\xaf\x83\x0c2\xc8')

{'A1': -117,
 'A2': [{'B1': -759034641, 'B2': 321665951837217012},
        {'B1': 88492563, 'B2': 2869322660852318278}],
 'A3': {'C1': {'D1': [9420184149591703905,
                      6659803397623137355,
                      1829248922632479042],
               'D2': 198,
               'D3': 3972181702,
               'D4': 0.6932211719704089},
        'C2': 36314,
        'C3': 0,
        'C4': {'E1': -8203324435571602057, 'E2': 102},
        'C5': [3036059393325709834,
               9133372583519293480,
               8541605372361018751,
               16004297166718540970],
        'C6': [0.021677264988010814, -0.6326295856818578, 0.26325683579131054],
        'C7': [13106, 15108, 14120, 38514, 57519, 33548, 13000]}}

(b"\xc9FUBY\xde\x00\x00\x00\x02\x00\x10\x00\x00\x00Y\xd1BI\x1fG'\x1flJ\x13\x96J"
 b'\x89\\\x1c\xc4Y\xea\xf3\x1a\x18d\xf0\xc1J\x8f\x9d\x07xp~2\xf8\xf4.\x9b'
 b'k\x8a\xdaU\xde\x058L\x90\xbc\xb1\x82R\x1c\xabM\xd6\x80!\xf0\x00\x04\x00('
 b'\xee\x7f\x80\xfc\x9a?\xe3\n\xe2W\xb0g`\x00\x00\x00H\xc3J\x98\x96\xbc:\n'
 b'\x83\xb7t\xb4\x8a4n\x94\xff\xde"\x89E\x9bC\x82\xd2\xdd\xb5\xd3\xd7\x88*\xb8'
 b'.}\xef`\xfb\xd3q\xacMHP*\x99?\xe7\xfe\xa3\xf1\x10\x97\xf8?\xe2M\xea\x9f\x89.'
 b'j?\xc1\x98b\xeb\xce\xe485<\xc8f\x84\xc3$\x08\xcd\xff\xce\xd6\xc2\xba')

{'A1': -34,
 'A2': [{'B1': -784185057, 'B2': 5127101250744325706},
        {'B1': -1990452028, 'B2': 6479258307329847489}],
 'A3': {'C1': {'D1': [5372685535887261234,
                      17939014460782598741,
                      15998255152800510338,
                      5916792361257542128],
               'D2': 238,
               'D3': 2139159706,
               'D4': 0.5950786316563885},
        'C2': 49994,
        'C3': 152,
        'C4': {'E1': -7585123855564835660, 'E2': 138},
        'C5': [3778120964074801477,
               11187929741492868055,
               9811857248000893179,
               15236148462296771225],
        'C6': [0.7498340328500026, 0.5720112911162236, 0.1374629641921119],
        'C7': [13628, 51302, 33987, 9224, 52735, 52950, 49850]}}

Вариант №9

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

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

Поле	Описание
1	int16
2	int32
3	Размер (uint32) и адрес (uint16) массива char
4	Размер (uint16) и адрес (uint16) массива char
5	Структура B
6	Размер (uint32) и адрес (uint16) массива адресов (uint16) структур D
7	Структура E

Поле	Описание
1	uint8
2	double
3	Структура C

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

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

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

(b'\x0fZQG}D\xc5\xf8\xa8\xa9\x00\x00\x00\x03\x00B\x00\x05\x00E\x0e\xbf\xcf '
 b'\xec<G\x96\xd0b>v\xf5\t)\x9c\xd84\x00\x00\x00\x04\x00\x7ff\x16\xbf7'
 b'\xf2\xd3\x03\xf2\xf3 \xbf\xee|\xa2P\xe9d\xa4\x979\xd7\x96qymaykfu1\xbe'
 b'\x00\x02\x00Jpc\xbd\xd5\x01u\xcd\xf5\xe2\x00\x03\x00VC\xdc\xbf'
 b'\x13\x7f\xb8\xdd\xe7\x87\xdd\x00\x04\x00c\xcaj?O\x08\x9c\xa9\xbb\x08'
 b'@\x00\x04\x00q\\M\xbfpk3\x00L\x00Y\x00g\x00u')

{'A1': 32068,
 'A2': -973559639,
 'A3': 'qym',
 'A4': 'aykfu',
 'A5': {'B1': 14,
        'B2': -0.24319222396223106,
        'B3': {'C1': 98, 'C2': 0.24116910994052887, 'C3': 698144820}},
 'A6': [{'D1': [49, -66], 'D2': 28771, 'D3': -0.10400668531656265},
        {'D1': [-51, -11, -30], 'D2': 17372, 'D3': -0.5761675834655762},
        {'D1': [-35, -25, -121, -35], 'D2': -13718, 'D3': 0.808725118637085},
        {'D1': [-87, -69, 8, 64], 'D2': 23629, 'D3': -0.939135730266571}],
 'A7': {'E1': 26134,
        'E2': -0.7185489535331726,
        'E3': 66253600,
        'E4': -0.9527141170793993,
        'E5': 2537150358}}

(b'\x0fZQG\xfcS\xbfU\\\x8b\x00\x00\x00\x03\x00B\x00\x03\x00Eq\xbf\xecf'
 b'\x13\xbcQdn\x14?,\x06B\x98\x11-\x87\x00\x00\x00\x03\x00n^\xe3>,\x88\xab\xc0H'
 b'\x95\xcc?\xe9-\xa1N/\xfap_\xb9\x9dgvtppdp\xdf\xba\xb4\x00\x03\x00H\x02'
 b'E=\xca\x9e>\xcb\x00\x00\x02\x00Ur?>\x94\x13\xb9\xd5(\xc8\x00\x03\x00a'
 b'\xb4c\xbf$\xeb\xde\x00K\x00W\x00d')

{'A1': -941,
 'A2': -1084924789,
 'A3': 'vtp',
 'A4': 'pdp',
 'A5': {'B1': 113,
        'B2': -0.8874605825505009,
        'B3': {'C1': 20, 'C2': 0.6719704866409302, 'C3': 2551262599}},
 'A6': [{'D1': [-33, -70, -76], 'D2': 581, 'D3': 0.09893463551998138},
        {'D1': [-53, 0], 'D2': 29247, 'D3': 0.2892129719257355},
        {'D1': [-43, 40, -56], 'D2': -19357, 'D3': -0.6442240476608276}],
 'A7': {'E1': 24291,
        'E2': 0.16849009692668915,
        'E3': 3225982412,
        'E4': 0.7868200804803802,
        'E5': 1605999975}}

Вариант №10

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

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

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

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

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

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

(b'KCPB\x18\xcd\x9eg\x8c\x97\xef\xbf\x03\x00\xd0\x00\x00\x00\xc4m'
 b"\x10\xb0\xc9\xb6O\xad\xfc\x80\xd8\xdf\x85f\xc2x\xa5\xc2\xe4s!'F`R.\xde\xcdc,"
 b'\xd0\xc9\xb6\xaa\x8d\xa4x\xb0\x94\x04\tU\xe0?\xa9\xd5\xae\xcd\xf7\x17'
 b'\x00\x14\x06\x04\x00?\x00\x00\x00\x7f\x8e#\x127!\xa5\x92\xcd\x03\x00'
 b'O\x00\x00\x00\xdc\xb2C\x00\x00\x00R\x00\x00\x00\x18\xb8\x15\x02\x00\x00'
 b'\x00^\x00\x91\xcf\x96\x01\xad\xe6\x02\x00o\x00\x00\x00\r8\xdc\xe4\x11'
 b'x\x9dT\xf0\x17\x1c\x05\x00}\x00\x00\x00\xde\xbfq\x00\x00\x00\x82\x00'
 b'\x00\x00\xab?\xd6\x02\x00\x00\x00\x8e\x00\x0e\x12u\xe4rR\x80z\x04'
 b'\x00\x9f\x00\x00\x00b\xc3\x9d\xd6*\x9b\xf9\x01\xda?\x04\x00\xaf\x00\x00'
 b"\x00'}\xa3\x00\x00\x00\xb3\x00\x00\x008'V\x02\x00\x00\x00\xbf\x00"
 b'f\x00\x00\x00\x96\x00\x00\x00\xc7\x00\x00\x00')

{'A1': -0.9872495673975292,
 'A2': [{'B1': 24,
         'B2': 5560,
         'B3': [{'C1': 101974039, 'C2': [213, 174, 205, 247], 'C3': 36479},
                {'C1': -846027487, 'C2': [35, 18, 55], 'C3': 45788}]},
        {'B1': -85,
         'B2': -10689,
         'B3': [{'C1': -424869482, 'C2': [145, 207], 'C3': 14349},
                {'C1': 471330900,
                 'C2': [220, 228, 17, 120, 157],
                 'C3': 49118}]},
        {'B1': 56,
         'B2': 22055,
         'B3': [{'C1': 2055230066, 'C2': [14, 18, 117, 228], 'C3': 50018},
                {'C1': 1071251961, 'C2': [157, 214, 42, 155], 'C3': 32039}]}],
 'A3': -5958342804629328444,
 'A4': {'D1': 8701630155205411068,
        'D2': [-91, -62, -28, 115, 33, 39, 70, 96],
        'D3': -841077166,
        'D4': 99,
        'D5': [44, -48, -55, -74, -86, -115, -92],
        'D6': 0.5103802766293617},
 'A5': -87}

(b'KCPB\x1aDO\x04c\x7f\xec\xbf\x02\x00\xa0\x00\x00\x00-\xdd\xe5\x9dinmJ\x08@'
 b'\xe4\xd2\xa4\xa0)X\xcd&\xbf\x11B\xda\x92\x92\xdbN\xf07\x18\xc5_\xe5\x8c\x13'
 b'\xee\nT\x06\x8d\r\x8d4\xd9?\x1a\xc2\xac\x9e \xc4\x00\x9b\x03\x00'
 b'?\x00\x00\x00\xad\xe5\x04-\xd4\x9fB`y\x8e\xdf\x05\x00N\x00\x00\x00\xa7\xdeB'
 b'\x00\x00\x00S\x00\x00\x00\x99\xc3\x08\x02\x00\x00\x00_\x00\x90\x9e\xc4\x87'
 b'y\x17\x18^\x04\x00p\x00\x00\x00\x8bs\x83\x81\xb2v/Z\x88\x03\x00\x80\x00\x00'
 b'\x00\x08?t\x00\x00\x00\x83\x00\x00\x00\x18\xeeo\x02\x00\x00\x00\x8f\x00'
 b'g\x00\x00\x00\x97\x00\x00\x00')

{'A1': -0.8905501445934789,
 'A2': [{'B1': -103,
         'B2': 2243,
         'B3': [{'C1': -1694448608, 'C2': [194, 172, 158], 'C3': 58797},
                {'C1': -544310944, 'C2': [4, 45, 212, 159, 66], 'C3': 56999}]},
        {'B1': 24,
         'B2': 28654,
         'B3': [{'C1': 1578637177, 'C2': [144, 158, 196, 135], 'C3': 29579},
                {'C1': -2007355530, 'C2': [131, 129, 178], 'C3': 16136}]}],
 'A3': 5363064131167837485,
 'A4': {'D1': 6352785379156049928,
        'D2': [-51, 38, -65, 17, 66, -38, -110, -110],
        'D3': 938495707,
        'D4': 24,
        'D5': [-59, 95, -27, -116, 19, -18, 10],
        'D6': 0.39383245776489173},
 'A5': 26}

Вариант №11

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

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

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

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

(b'WCU?\xdf\xce\x86\x07:\xe9\x94\x00\x00\x00U\x00\x00\x00\x9f\x00'
 b"\x00\x00\xe7\x80I\x00W\xccI':\xdb\x10\x0e\xce\x1c\x1f\x9f\x1f\x94"
 b'\x82\xa4\x842\xfc\x00\x00\x00\x02\x00\x00\x00\x19\x00\x00\x00\x02\x00\x1d1'
 b'\x80\x14\xaa\xc8\xd4\xbb\xf8\x00\x02\x00!\xb4\x10\xc0\x86\x00'
 b'\x04\x00\x00\x00%D\x0fz\xd6\xe8\xc7\xb8\xf0H$\x99\xfb\x00->\xe6(\xb3,'
 b'\xf6\xd1tsx\xbf\x8a\xe4\x86.I\x07\x8fI\xb1GrT\xa8\x00\x00\x00\x02\x00'
 b'\x00\x00c\x00\x00\x00\x02\x00gq|\xed\xe6\x15e$\x96\x00\x02\x00k\xe5\xe5q'
 b'\xea\x00\x04\x00\x00\x00o\x95~w|/\x0b\x8b\x06\x95\x1cK\xa4\x00w\xbe\x14\x10'
 b'H\xcd\xdc\xeb\xb9d\x86-\x9aDU\xf2XGk\xd7\x81\x8aR\x00\x00\x00\x02\x00'
 b'\x00\x00\xad\x00\x00\x00\x02\x00\xb1\xcalFj\xff\xf2m\xdd\x00\x02\x00'
 b'\xb5\x96\xc0\x13\xed\x00\x03\x00\x00\x00\xb9\x8a\x00i\xad(\x81\xee\x10\x9e'
 b'\x196m\x00\xbf\xbe\x83\xc5X')

{'A1': 0.49698019701067975,
 'A2': [{'B1': -1673165394402829829,
         'B2': {'C1': {'D1': [87, -13239], 'D2': [10042, -9456]},
                'C2': 3566873628623813624,
                'C3': [3790, 7199],
                'C4': 3020996742,
                'C5': [-24801, -27518, -23420, 13052],
                'C6': 1141865174},
         'B3': 0.4495292603969574},
        {'B1': 3389956004914154404,
         'B2': {'C1': {'D1': [11510, -11916], 'D2': [29560, -16502]},
                'C2': 8177672595855189142,
                'C3': [58502, 11849],
                'C4': 3857019370,
                'C5': [1935, 18865, 18290, 21672],
                'C6': -1786873988},
         'B3': -0.14459335803985596},
        {'B1': 2918875788652131949,
         'B2': {'C1': {'D1': [-12836, -5191], 'D2': [25734, 11674]},
                'C2': 14586110718520749533,
                'C3': [17493, 62040],
                'C4': 2529170413,
                'C5': [18283, -10367, -30126],
                'C6': -1979684435},
         'B3': -0.25736498832702637}],
 'A3': 32841}

(b'WCU\xbf\xcdc\xf7\xec\xd9\x84\xb8\x00\x00\x00S\x00\x00\x00\x99\x00'
 b'\x00\x00\xe3T\xe66\x10\x02\xea\xf1n\xd8\xfd\xa5f\xefcu^0cU\x89\x00'
 b'\x00\x00\x02\x00\x00\x00\x19\x00\x00\x00\x02\x00\x1d+"\xb9\x91\x9b{\xd2'
 b'`\x00\x02\x00!3k\xb0\xf8\x00\x03\x00\x00\x00%\x94\xcfQ\xcf\x19\xdf\x13F\x0b'
 b'\xc96\xd6\x00+\xbf\x1e0W\x84/j\x97\xa2Ls\xd7O/\xa6MfT\xf83\x00\x00\x00'
 b'\x02\x00\x00\x00a\x00\x00\x00\x02\x00ei\xac\xd9Rs\xe7\xba\xa9\x00\x02\x00i8'
 b'"\x86\x82\x00\x02\x00\x00\x00mV;|\xc3\xb9\xf9\x91\x82\rS\xc4j\x00q\xbe'
 b'\xadw\x82\xd0<\xb8^\xddm8\x87ae\xff\x06\x7f\xfex\xd1\xa7\xb2!\x94\x00'
 b'\x00\x00\x02\x00\x00\x00\xa7\x00\x00\x00\x02\x00\xab\xba\x07^'
 b'\xfd\xdb\x0e\x9d\xfc\x00\x02\x00\xaff+~\x1e\x00\x04\x00\x00\x00\xb3y'
 b'\xbe\xbb"Ni\xd4\xa81W\x0e\xf1\x00\xbb\xbd\xcaK\x05')

{'A1': -0.22961329522062157,
 'A2': [{'B1': 1864229962321049302,
         'B2': {'C1': {'D1': [13840, 746], 'D2': [-3730, -9987]},
                'C2': 3108250727869043296,
                'C3': [42342, 61283],
                'C4': 862695672,
                'C5': [30046, 12387, 21897],
                'C6': -1798352433},
         'B3': -0.6179251074790955},
        {'B1': -5045841919736560534,
         'B2': {'C1': {'D1': [-31697, 27287], 'D2': [-23988, 29655]},
                'C2': 7614700018131778217,
                'C3': [20271, 42573],
                'C4': 941786754,
                'C5': [26196, -1997],
                'C6': 1446739139},
         'B3': -0.33880239725112915},
        {'B1': 5650281026360381169,
         'B2': {'C1': {'D1': [-12228, -18338], 'D2': [-8851, 14471]},
                'C2': 13404787260286475772,
                'C3': [24933, 65286],
                'C4': 1714126366,
                'C5': [32766, 30929, -22606, 8596],
                'C6': 2042542882},
         'B3': -0.09877590090036392}],
 'A3': 21734}

Вариант №12

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

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

(b'HIZQ\x00|\xbe\xc4\x9f\xedtw\x99\xb3\x07\xaei\n&\x8a\x9c\xcb\xdf#'
 b'3\x1b\x82\xb2%\xa2\xc1$\xd8Q4j\x9eU&2^T|\xbf\x07\x00\xac;hq\xe0\xad'
 b'=\xa3\x10\xfe\x85Pa\xd8\xcf\xad\xcbJ\x00\x00\x00\n\x00\x00\x00\x13'
 b'\x00\x00\x00\x1c\x00\x00\x00%\x00\x00\x00.\x00\x00\x007\x85:\x00\x00'
 b'\x00\x06\x00\x00\x00@;\x06\xc9d}\x05\xd2Rr53\xe6\x00w\xa3D\xea\xa5'
 b'\x00\x00\x00\x02\x00\x00\x00XXM\x8a\x9f\x00\x00\x00Zw\xb9\xce\x1f'
 b'\x17\xac\x90\xe4\x11\xff\x8d,I\xa8\xe6\xda\xf5\xd9-\xcc\xb2H\x8a\xca'
 b'?\x0b?\x1e')

{'A1': {'B1': 1481476767,
        'B2': {'C1': [{'D1': 1953995187, 'D2': 1966, 'D3': 105, 'D4': 2598},
                      {'D1': -1969435681, 'D2': 9011, 'D3': 27, 'D4': -32078},
                      {'D1': 631423268, 'D2': 55377, 'D3': 52, 'D4': 27294},
                      {'D1': 1428566622, 'D2': 21628, 'D3': -65, 'D4': 1792},
                      {'D1': -1405392783, 'D2': 57517, 'D3': 61, 'D4': -23792},
                      {'D1': -24817567, 'D2': 55503, 'D3': -83, 'D4': -13494}],
               'C2': 4253308331529458258,
               'C3': 29237,
               'C4': [51, 230, 0, 119, 163, 68, 234, 165],
               'C5': [133, 58]},
        'B3': 30649,
        'B4': 52767,
        'B5': [397185252, 301960492, 1235805914, 4124650956, 2991098570],
        'B6': 0.5439318418502808},
 'A2': -1094410259}

(b'HIZQ\x00bC\xb3\xb8\x01\x10E\x9a\t>\x05\x90\x8e/pu\xd5\x8f\xb2'
 b'\xc9\xf0\x11\xcf.P\x16e\x94\xa6\xdb2\xc6\x87\n#\xdb\x97\xae\xbfX\x8f\x00\x00'
 b'\x00\n\x00\x00\x00\x13\x00\x00\x00\x1c\x00\x00\x00%W\xf4\x00\x00\x00\x04'
 b'\x00\x00\x00.\x91;\x8d\xba?;l,\xbev\xde\xb1$\x88\x1b\xac\x1a\xc1\x00\x00'
 b'\x00\x02\x00\x00\x00>\xf4B:\x96\x00\x00\x00@E\xf7\x83k\x1e\xb0'
 b'\xc8\xcd\xf5\x17\xc2<J\xc6Y\x87\xd9\xb0\xea\xcf9\xd0\x9a~\xbfP\x9a\x84')

{'A1': {'B1': -196986218,
        'B2': {'C1': [{'D1': 272996873, 'D2': 15877, 'D3': -112, 'D4': -29137},
                      {'D1': 1886770575, 'D2': 45769, 'D3': -16, 'D4': 4559},
                      {'D1': 777000549, 'D2': 38054, 'D3': -37, 'D4': 12998},
                      {'D1': -2029378597, 'D2': 38830, 'D3': -65, 'D4': 22671}],
               'C2': 10465113990189771820,
               'C3': 48758,
               'C4': [222, 177, 36, 136, 27, 172, 26, 193],
               'C5': [87, 244]},
        'B3': 17911,
        'B4': 33643,
        'B5': [514902221, 4111974972, 1254513031, 3652250319, 969972350],
        'B6': -0.8148577213287354},
 'A2': 1135851521}

Вариант №13

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

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

(b'\xe5RFV\xf9F\xe8\xe8\x07a\x00\x00\x00z\xde\x86A\rn\xf2\x0ei\xbe\xb2'
 b'b\x9a\\\x99{\x8b\x93l\xf3\xbd\x06Q3\xfd\xefj\xd8\x8d\x02\x02\xfa\xe3b\xb5'
 b'\xeb\xba\xc3\xa5\x92\t<\x982\x93&\xa4Z\x99\x8e/nm;\xd6a\xc7\xb2\x7f'
 b'-\xd0\xedO\x19z\xec\xf4.\xa4X6\x88\x93\x0c\xa0l\xdf\x870\xce_\xf7<'
 b'T\xe3\xaf\x1d8\xc4\xd2\xb9B]\xc6>\xcam\xd3S\xa7qTq\xf7\xdf\x83\xc4y\x0eE\x13'
 b'K\x9aR\xd4.\xa7ooq\xe8\xe1(\xbc\x9b\xef\x83\x10\x87\xd1t\xd5\xa0\x00\x00'
 b'\x00\x03\x00b')

{'A1': -1722,
 'A2': -5912,
 'A3': 1889,
 'A4': {'B1': 4977405139361214119,
        'B2': {'C1': 'ooq',
               'C2': 59617,
               'C3': 40,
               'C4': -17253,
               'C5': -4221,
               'C6': 4231,
               'C7': 3514095008,
               'C8': [12618304148962099805,
                      14285077641111512945,
                      6084917110914709774]}},
 'A5': [{'D1': [3733340429, 1861357161],
         'D2': [-4705590245530698869,
                -7823610459469040643,
                -1194904650977707293,
                7112850373880418825],
         'D3': 60,
         'D4': -104},
        {'D1': [848504484, 1520012847],
         'D2': [7957081908583051903,
                3301399450848259316,
                3360908213168049312,
                7845137719593269052],
         'D3': 84,
         'D4': -29}]}

(b'\xe5RFV\xc5\xab\x03\xc3\xb9y\x00\x00\x00r1\xee!\x18\x03 \xd8\xd0A?'
 b'\xe0a\xe8\x0c.\x1f\xb7\x01\x1c\xb6J\x00E$^\xfc{\x92M\xb4\x9d\x84{d'
 b'\xbc\x11i\xae\r\x91\xf69v\x89]ok\xca>3.\xa5\x86\xce\xdf\x0f\xee\x9e'
 b'*\xe1\xf8\xd4Q\x04\xcf9;%\x12\xbc\xe2\x8eu\x04.\x87I\xaf\xb9\xce\xdc\xfc'
 b'e*\xed\xf52i`X\xc7*\xeb\x0e\xc4\xcd\x9b\x18g\x90\xd8\x80\x1c^\x1fPeIhf'
 b'w\x90,\xf8\x99\x8b\\\x89\x07\xe8\xd7P\x17\x06\x00\x00\x00\x02\x00b')

{'A1': -14933,
 'A2': 963,
 'A3': -18055,
 'A4': {'B1': -2846243773920287415,
        'B2': {'C1': 'hfw',
               'C2': 36908,
               'C3': 248,
               'C4': -26229,
               'C5': 23689,
               'C6': 2024,
               'C7': 3612350214,
               'C8': [17146666584452417322, 16937691635936421776]}},
 'A5': [{'D1': [837689624, 52484304],
         'D2': [4701723247107649055,
                -5259891320540871388,
                6844481401995435396,
                8891438347309682065],
         'D3': -10,
         'D4': 57},
        {'D1': [1988713839, 1808416307],
         'D2': [3361240919965691550,
                3090024410128895801,
                4261833224840180996,
                3352729466686070012],
         'D3': 101,
         'D4': 42}]}

Вариант №14

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

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

(b'EMKL\x8e\x00\x9a\x0cO\'W\xe3\x0bt\xac\x1e\xc1(\x18e"\xde\nv\xf4\x91\\\xd9'
 b'\xd1\x00\xb5\xb0\x82\x89\xe0\x9b\xe1%\x02<n\x12\xe1\x9a\xa8L\x1fq'
 b'\xba\x8bW\xe24B\x1a\xf0\x84\xba\xbaa\xcfI:\x8e\xf0\x0e.\x00\x00\x008\x00'
 b'\x00\x00\x0bV\xdc\x84g\xa5\xbe\x1f\xb1\x98\x03,\xe4\xbf\xdc\xac<C'
 b'\x1dm\xe7\xbf\xb0Z\xd1+j\xe5\xdc\xbf\xda\xb0\xcc\xc3\xbe\x02\xe1?'
 b'\xa23\xd3\xea;Ze\xaey\xb0\xcc\xf6\x88T\xdeXN\x99\x03\xbf\x04\x00\x00\x00'
 b'P\x00\x00\x00\x15B\x02\x00B\x00\x00\x00\x06\x00\x00\x00J\x001\xb5'
 b'\xae\xd2`\x1fa.\xf7\xc8\xbb\xbfE\xcc\x97!\x86%2\xbep\x00\x94\xb0\x05?')

{'A1': {'B1': [{'C1': -1950715617, 'C2': [87, 226], 'C3': -266714572},
               {'C1': 1639627396, 'C2': [207, 73], 'C3': 250646074}],
        'B2': [11, 86, 220, 132, 103, 165],
        'B3': 3534665009,
        'B4': -0.10853524095830158,
        'B5': {'D1': 563596357, 'D2': -0.1739712655544281},
        'B6': {'E1': -5880194525073034334,
               'E2': 6403648667400319097,
               'E3': -0.514057993888855,
               'E4': [-0.630372808672284,
                      -0.7320696175787833,
                      -0.4515023639591318,
                      0.5315851043901845],
               'E5': 16917},
        'B7': 0.5222256183624268},
 'A2': [8362027096604609690,
        16006467180065529516,
        59067261741463050,
        2729634237845254325,
        5523835234437446658]}

(b'EMKL\x9c\x00\xf3d\x91!J\xf4T0\x15\xb5\x82\t\x813\x92*\xd5\xcb\xc7\xd8\xebZ'
 b'\xba\x7f\xf3e\x08&\xa7\xcf56\xb1\x19Y\xb9|ci=\x1bh\xafd\x9c\xb0#8o\xef'
 b"=\xfc\xfc\xa2\xe06i\xa7\xa5'/\xae\xc9\x11m^\xd9J\xfa\xd6.\x00\x00\x00"
 b'8\x00\x00\x00B\x00\x00\x00\xc6\xd56\x87}j"\xcey<4\xe8\xe2\xbf6\xef\xf3Un\xe5'
 b'\xe5\xbf" \xb1\xa6a\xc4\xee?>C\xd7}\xc7\xb7\xe4?\xf2\xca\x8e\xb9\xba%'
 b'\x12g\xf9\x1fb]\xf5\x1bG\xcb\xf0y\x04?\x04\x00\x00\x00^\x00\x00\x008j'
 b'\x03\x00L\x00\x00\x00\x06\x00\x00\x00X\x00\xf6`\xa4\xb6\x18\xa9\xf6\x00'
 b'Z \xe0\xbf\xfb\xe77\xb6h\x16\xf8>~\x00\xc1T\x8a\xbe')

{'A1': {'B1': [{'C1': 1689217051, 'C2': [156, 176], 'C3': -277923805},
               {'C1': -1560478659, 'C2': [224, 54], 'C3': 665167721},
               {'C1': 298429999, 'C2': [109, 94], 'C3': -688239911}],
        'B2': [198, 213, 54, 135, 125, 106],
        'B3': 3064226038,
        'B4': -0.5039491671389298,
        'B5': {'D1': 3057117179, 'D2': 0.4845459461212158},
        'B6': {'E1': 7427040219394657010,
               'E2': -3799037020016074759,
               'E3': 0.5174856185913086,
               'E4': [-0.590845220677185,
                      -0.6842567137495965,
                      0.9614723449421982,
                      0.6474339921788681],
               'E5': 27192},
        'B7': -0.2701778709888458},
 'A2': [3482677011092169971,
        3067570925496087829,
        9203768757485816789,
        3906256568618345971,
        4425177496204941745]}

Вариант №15

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

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

(b'MNSV\xf0\xa7\x12\x00\x00\x00\xa8\x1a*y\x86\x00\x00\x00q\x0e&=\xfb\x9a'
 b'\x13\xd1\xda\xe6C\\\xb6k\xa9\xefhfh\x82C\xb5U\xb2[HZ\xd9\x15E\x99\xd6h\xae'
 b'\x1fwd\xf4\xde\xcf\x9a\xcc\xc4\x92\x968\x16\xe82\x93\xa0\x93}\xde57\x8b\x08'
 b'\xb7\t{\xb4\x10\x9a\x85c\xa9\xee0\xab\xd6\xfb\x141&@\xbbCH\xeb\xb3q'
 b'\x13\xee{\xb3\ts\xe3\xaa\xd63\xa3\xa9\xf0q\x93\xa6\xf7\xf3WC\xab\xdc\xe6*'
 b'\xbb\xb7\x05\x00y\x00\x03\x1d\xdf\xbd\xc2\xc4\x03\x00\x00\x00"\x00\xb0\xf2'
 b'\xfc\x81N<\xe4?%\x00\x00\x001\x00\x00\x00=\x00\x00\x00I\x00\x00\x00U\x00'
 b'\x00\x00a\x00\x00\x00m\x00\x00\x00~\x00\x00\x00\x82\x87U_\x0b\xd9'
 b'h\x04\xd0\xfb')

{'A1': 42992,
 'A2': {'B1': 15065555582337814129, 'B2': 17269452677105051354},
 'A3': 2032802472,
 'A4': {'C1': 50370,
        'C2': 'hfh',
        'C3': 0.632361654170003,
        'C4': [{'D1': [17282, 21941, 23474], 'D2': [23112, 5593, -26299]},
               {'D1': [26838, 8110, 25719], 'D2': [-8460, -25905, -15156]},
               {'D1': [38546, 5688, 13032], 'D2': [-24429, 32147, 13790]},
               {'D1': [35639, 46856, 31497], 'D2': [4276, -31334, -22173]},
               {'D1': [12526, 54955, 5371], 'D2': [9777, -17600, 18499]},
               {'D1': [46059, 4977, 31726], 'D2': [2483, -7309, -10582]},
               {'D1': [41779, 61609, 37745], 'D2': [-2138, 22515, -21693]}],
        'C5': {'E1': [220, 230, 42, 187, 183], 'E2': -0.10894205421209335},
        'C6': 317742416596928386,
        'C7': -1072}}

(b'MNSV\xf7\xf0\x12\x00\x00\x00IM7\xb0\x82\x00\x00\x00\x86&g\xa9eCZj\xc8K'
 b'\x13\x19\xfaO\x83AjaQ\xc9\xf6f\n\xd3Yl\xd1\x02h\xf5Pk\xb9\x00\xb7\xc43\n'
 b'\xd6\xe5\xda\rY\xdd\x97!\xc8\x84\x92\x9co\xdb\xefn\xda:\x1b\x8c'
 b'\x85\xd8\xf1\xc3\x9e\xcc\x1d\xd3\x90\xfbn\x0f.\xf6\xe8*j\x11\x81\xb0* <%'
 b'\xff|\xde\x87 D:\x893m\xf6t"\xd6\xed\x94\xa9\xf4\xe2`\x01=\x02\x00'
 b'x\x00\x94\x9f\x12?\xed\x93\x02\x00\x00\x00"\x00.@@U$D\xea?$\x00\x00\x000\x00'
 b'\x00\x00<\x00\x00\x00H\x00\x00\x00T\x00\x00\x00`\x00\x00\x00l\x00'
 b'\x00\x00z\x00\x00\x00\xf7\x1a\xd51*\xf9\x88\xad\xcd\xaa')

{'A1': 61687,
 'A2': {'B1': 7663511819837187718, 'B2': 4720704769995525064},
 'A3': 2956414281,
 'A4': {'C1': 37869,
        'C2': 'ja',
        'C3': 0.8208181061800184,
        'C4': [{'D1': [51537, 26358, 54026], 'D2': [27737, 721, -2712]},
               {'D1': [27472, 185, 50359], 'D2': [2611, -6698, 3546]},
               {'D1': [56665, 8599, 33992], 'D2': [-25454, -9361, 28399]},
               {'D1': [15066, 35867, 55429], 'D2': [-15375, -13154, -11491]},
               {'D1': [64400, 3950, 63022], 'D2': [10984, 4458, -20351]},
               {'D1': [8234, 9532, 31999], 'D2': [-30754, 17440, -30406]},
               {'D1': [27955, 29942, 54818], 'D2': [-27411, -2903, 24802]}],
        'C5': {'E1': [1, 61], 'E2': 0.5727474689483643},
        'C6': -5942225748695377161,
        'C7': -21811}}

Вариант №16

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

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

(b'ILDN/\x8d\x04\x07\xe2a\xd7v3L=f\xbb\x19\x05Xa\xa7\x8a\xdd\x0c\xbdG\x1a'
 b';)F\xbc\xd00\xce{\xdc\x194\xc7\x8b\x81H%\x9a\xf1\x15\xa0`\x06\x1cX'
 b'G\xad\x14\xa3O\xb2\x86_\xde\x00\x93c\xaeT\xda\xcc \xf7Z\xe1\xf9\xa4\x12\xc5'
 b'\xc6\xe9\xfdR\xa3Z0\xf5s\xc30\x84\x04\x10,:\xebHz\xcf\xc9\xf6\xde\xe6'
 b'\xa0\xb4\x171\x99\x0c\x91\xed\\*\xa7h\xf5\xf9W|\xae.\xa5\xc3\xd8\xe6\xd7\xd7'
 b"[i\xa96$\x8b\n\xb4b\xa2'n\x824p\x0f2\xba,\x9e\xa2j\xe3\xc1\x00\x00\x00A"
 b'\x00\x00\x00K\x00\x00\x00U\x00\x00\x00_\x00\x00\x00i\x00\x00\x00s'
 b'\x00\x00\x00}\x8f\x18c\x00\x00\x00\x06\x00\x00\x00\x87')

{'A1': 47,
 'A2': 10161255328140195379,
 'A3': [{'B1': 1279092411, 'B2': 419780705},
        {'B1': 2810895628, 'B2': 3175553595},
        {'B1': 692501712, 'B2': 818838492},
        {'B1': 422889355, 'B2': 2168989082},
        {'B1': 4044726368, 'B2': 102520903},
        {'B1': 2903810895, 'B2': 2995150814}],
 'A4': {'C1': -63,
        'C2': [{'D1': 84,
                'D2': -9524,
                'D3': 32,
                'D4': 4149928441,
                'D5': -92,
                'D6': 18},
               {'D1': -59,
                'D2': -14615,
                'D3': -3,
                'D4': 1386437168,
                'D5': -11,
                'D6': 115},
               {'D1': -61,
                'D2': 12420,
                'D3': 4,
                'D4': 271334123,
                'D5': 72,
                'D6': 122},
               {'D1': -49,
                'D2': -13834,
                'D3': -34,
                'D4': 3869291543,
                'D5': 49,
                'D6': 153},
               {'D1': 12,
                'D2': -28179,
                'D3': 92,
                'D4': 715614453,
                'D5': -7,
                'D6': 87},
               {'D1': 124,
                'D2': -20946,
                'D3': -91,
                'D4': 3285771991,
                'D5': -41,
                'D6': 91},
               {'D1': 105,
                'D2': -22218,
                'D3': 36,
                'D4': 2332734562,
                'D5': -94,
                'D6': 39}],
        'C3': [-113, 24, 99],
        'C4': [28290, 13424, 3890, 47660, 40610, 27363]},
 'A5': 25518}

(b'ILDN%\xdf\xee\x87\x8f\xdf<\xc3\xd2\x111\xf3mO~"\x98)\xdb3{I\xdf\xb19\xd9u\\'
 b'|L\xb4\x184\xef\xb8\x14\xc3\x0fi3tRr`\xf0\x8c\xa3a}\x89\x99\t\xfe\xda}3'
 b'{\x00\x91\r\x95\x0b\r\xb4\x82\xb4\xd4\x10*#\x83N\xf4<\xa5pO!\xd7\x9a'
 b'\xcb\x9e\x9d2\xd90\xe2n\xb3\x11\xb8Y\xb1t\xaf\xe1\xbc\xb2X\t\x879\xde\xdc'
 b'\xf0m\xca\xc2\xcf|\x19\xfd\xe6\x9b\x14\xe8;v\xc1\xd3\xce\xb3O\xb0K\xa5:\xa2'
 b'\x1d\xcc\xdc\x85/\xac\xe68iP}^\xe8\xe2\x00\x00\x00A\x00\x00\x00K\x00\x00'
 b'\x00U\x00\x00\x00_\x00\x00\x00i\x00\x00\x00s\x00\x00\x00}pHB\x00\x00\x00'
 b'\x05\x00\x00\x00\x87')

{'A1': 37,
 'A2': 16135983566910440402,
 'A3': [{'B1': 288486253, 'B2': 1333666456},
        {'B1': 702231419, 'B2': 1239396665},
        {'B1': 3648347260, 'B2': 1286871092},
        {'B1': 4021818563, 'B2': 258552692},
        {'B1': 1383227632, 'B2': 2359517565},
        {'B1': 2308508158, 'B2': 3665638267}],
 'A4': {'C1': -30,
        'C2': [{'D1': 11,
                'D2': 3508,
                'D3': -126,
                'D4': 3033796650,
                'D5': 35,
                'D6': 131},
               {'D1': 78,
                'D2': -3012,
                'D3': -91,
                'D4': 1884234199,
                'D5': -102,
                'D6': 203},
               {'D1': -98,
                'D2': -25294,
                'D3': -39,
                'D4': 820145843,
                'D5': 17,
                'D6': 184},
               {'D1': 89,
                'D2': -20108,
                'D3': -81,
                'D4': 3787240024,
                'D5': 9,
                'D6': 135},
               {'D1': 57,
                'D2': -8484,
                'D3': -16,
                'D4': 1842004687,
                'D5': 124,
                'D6': 25},
               {'D1': -3,
                'D2': -6501,
                'D3': 20,
                'D4': 3896211137,
                'D5': -45,
                'D6': 206},
               {'D1': -77,
                'D2': 20400,
                'D3': 75,
                'D4': 2772083229,
                'D5': -52,
                'D6': 220}],
        'C3': [112, 72, 66],
        'C4': [34095, 44262, 14441, 20605, 24296]},
 'A5': 3477}

Вариант №17

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

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

(b'*VHN\xf4\x18<\xbb}L\xf5\xce\x19u\xceI\x86\xbe5\x16{0>#\x8c\xa5\xbe\xc8'
 b'I*\xbc\x1b\x9cd\xbf\x8d\xc2e\xfeu\x00\x9caQ\xf4\xe8\xadx\xd4\xcb\x9ds'
 b'\xb5\xa5\r\xc7\xbb\x81]\xcaFm\x7f\x93@\xac*\x90.%\xbf\xbf\xa4\xdc>xG\xa0>a'
 b'?\x93>Kr\xeb\xc6\x92\x00^\x7f,E\x84\xf3\xe5\xa4\xf88\x8b\x85e\x1c\xb4'
 b'\x0b\xb2\x0b\xd8\xf4\xf8<r\xcb\xf6\xeb\xb9J\x02\x00m\x00B\x9ba~Y\x82\xec'
 b'%\xbey\xf5\x7f\xb7kR\xb6|\x00\xa8\xce(\xbbz\xd0\xcb\x04\x00\x82\x00L1'
 b'\xdb_\xcd[8\\?')

{'A1': 14912909844003166452,
 'A2': {'B1': 25,
        'B2': [{'C1': [-12683, -31159, 13758],
                'C2': [0.17234453558921814,
                       -0.32333478331565857,
                       -0.010393567383289337,
                       -0.8930069804191589],
                'C3': -26885491,
                'C4': {'D1': [-881705736, 1253698550],
                       'D2': 2120325954,
                       'D3': 89,
                       'D4': -0.1620350182056427},
                'C5': 24988,
                'C6': 81,
                'C7': 244,
                'C8': {'E1': 3564678632,
                       'E2': 13530798610822962635,
                       'E3': 1187667329}},
               {'C1': [32621, 16531, 10924],
                'C2': [-0.6452417373657227,
                       0.43094441294670105,
                       0.3130452632904053,
                       0.28759291768074036],
                'C3': -957648309,
                'C4': {'D1': [-1216350855, 2092323435, 684632064, -875529541],
                       'D2': 1608200524,
                       'D3': -51,
                       'D4': 0.8602349162101746},
                'C5': 32606,
                'C6': 44,
                'C7': 69,
                'C8': {'E1': 2766533508,
                       'E2': 843330252582893816,
                       'E3': -187167822}}]}}

(b'*VHN\xb23\x17\xc50\xd8&\xa0\xe5\x8c\\\\w\xc7"\x0el"\xbf\xf1`K?N<"?\xf5'
 b'\xb5Y\xbf\xa1\x92\xca\xb0}\x00\xd9\x9b\xd1\xe5\xd4\x17\\\xcbG\xe1\x85'
 b'\xd9^\xd7\xb7\xa3\xee\xcb\x87\x96\x987\xf3W\xe7\xcf\x8c\xdb\x00?x'
 b'g\x7f\xbe\x00\x88\xe8\xbe2\xfe\xf3\xbe\xcc\xc3\xce\xc8\x9e\x00\xff\xad]'
 b'\x17\xc4\xb1\x1dV|\x94Y\x9f\x8b\xf5\xab79E8\xa2m\x1e\r\r\xeac\xa8'
 b'\x9b\xc0\x02\x93\xd9\xc6\xecg?\x04\x00m\x00v\xa1=;\xd8+\xd7\x13>\x8aw'
 b'\xbf\xcbT\x80\xb2\xc6\xf2<\x8f\x94\xd7]\xac\xe3\x00\xf4z\xb6\x05\x00'
 b'\x8a\x00*KdW\xd5\xc09 \xbf')

{'A1': 11540148799160136626,
 'A2': {'B1': 229,
        'B2': [{'C1': [23692, 30556, 8903],
                'C2': [-0.6344612836837769,
                       0.7944479584693909,
                       0.6337326765060425,
                       -0.8504326939582825],
                'C3': -1328901471,
                'C4': {'D1': [218963565, -1683463190, -644676928, 1063775430],
                       'D2': 993894774,
                       'D3': -40,
                       'D4': 0.1443754881620407},
                'C5': 39897,
                'C6': 209,
                'C7': 229,
                'C8': {'E1': 3411810260,
                       'E2': 11797134551296631111,
                       'E3': -1769485330}},
               {'C1': [14232, 22515, -12313],
                'C2': [0.503350019454956,
                       -0.24941813945770264,
                       -0.45416259765625,
                       -0.4765487313270569],
                'C3': -925973556,
                'C4': {'D1': [-876644470,
                              -961380268,
                              -1802552078,
                              -475243049,
                              -1233456128],
                       'D2': 1466190634,
                       'D3': -43,
                       'D4': -0.6258811950683594},
                'C5': 44543,
                'C6': 93,
                'C7': 23,
                'C8': {'E1': 1444786628,
                       'E2': 4011569873126265980,
                       'E3': -1573370567}}]}}

Вариант №18

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

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

(b'MKYF=Q\x00ajyertvi,\x11>\x01\xa8\xc7D\x05n\x00\x00\x00\xa6\x99,\xe5\x91'
 b'\xb9g\xceW\xe5)\xa8\xb94\x9c\x06q"\x03\x03_\xd4\xb4GJ\x04\x00\x00\x00'
 b'\x1b\x00\x00\x00\x1dk\xe0\x1d\xaa\x9b\xc2\xc09\xedw0[A\x00\x00\x00E\x00\x00'
 b'\x00\x1d\xbf\xc3#n\x16\x11\x85+\x00\xdd\x9f\x81\xf2M|?\x02\x00I\x00\x00\x00'
 b'\xc4m\xc0\xf9r\x1aF/`l\x03\x00\x00\x00h\x00\x00\x00')

{'A1': {'B1': 9588469743950741277,
        'B2': {'C1': 113,
               'C2': 5352445506373223202,
               'C3': [-450061914, -832063087, -1473649321, 110900409],
               'C4': 501246749,
               'C5': 170},
        'B3': -24611,
        'B4': 2085483137,
        'B5': 63,
        'B6': [{'D1': 49819, 'D2': 14784}, {'D1': 30701, 'D2': 23344}]},
 'A2': 'ajyertvi',
 'A3': 379647792995242284,
 'A4': {'E1': 1818242886, 'E2': [28100, 63936, 6770]}}

(b'MKYF=a\x00xbnljyeq\xb7\xdc\xecd5y\xc7z~\x00\x00\x00\xb5\xac\xc8c\xe6'
 b'\xea\x8c\xb4W\x04\xa7B\x1a\x8b\x99\x87\x93t\xff8\xde\xa3q\rl`7\x1cK'
 b'\x1a{+\xae&\xe4\xd3\x8a\xe1O\xc4\xea\x08\x00\x00\x00\x1b\x00\x00\x00'
 b'x\xd4\xb2>\xd3\xc4\xccM\t\xdf\xfb\x86\xaeQ\x00\x00\x00U\x00\x00\x00\x85\xfeB'
 b'C\xbe\xcc\xf2L;\x00P\x99\xe0\t\xb9\xd0\x02\x02\x00Y\x00\x00\x00{\xaa\x12\xdb'
 b'\xe9\xc9\xd5\xe5\xa5\xa6\x03\x00\x00\x00x\x00\x00\x00')

{'A1': {'B1': 5544719208790818437,
        'B2': {'C1': -82,
               'C2': 16916733930425803814,
               'C3': [1674095797,
                      -1265833242,
                      1118241879,
                      -2019980518,
                      956265619,
                      225551326,
                      473391212,
                      729487947],
               'C4': 1051907192,
               'C5': 211},
        'B3': -26288,
        'B4': -793179680,
        'B5': 2,
        'B6': [{'D1': 52420, 'D2': 2381}, {'D1': 64479, 'D2': -20858}]},
 'A2': 'xbnljyeq',
 'A3': 8847173263226100919,
 'A4': {'E1': -1499077163, 'E2': [43643, 56082, 51689]}}

Вариант №19

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

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

(b'EJPV\xbf\xecu\xfd\xd87\xee\xbe\x00H\x0c\xf5\x87rTgqd\xe1lY\x95-/'
 b"\x02\x15\xe8\x85&\x04\x05\xd0\xc7\xc3\xb1\x8e'8\xa5\xfc\x10\x17\\\xd9"
 b"\x91\x8b\x9f\x05\x00\x07\x00\x16\xf9\x9d}\x99\xf0\x88\xc2\x0c\xbc|\xd1'"
 b'-\x84\xf4\xa1\x00\x03\x00\x13\xfa\xf6{\xa2k\x7f\x03;\xd4\xae\xf1qM\xdb\xb6}'
 b'\xff\x98K\xa4\xab&\x1fcy\xa4\xfd\xc6:\x0f\xe1\xcb\xd2>_\xc3\x81\x00\x00\x00'
 b'2\x00\x00\x00\x02\x008')

{'A1': -0.8894032691018408,
 'A2': {'B1': 'gqd',
        'B2': [{'C1': 250, 'C2': 63099, 'C3': -6743156365191762191},
               {'C1': 113, 'C2': 19931, 'C3': -5296796557148640474},
               {'C1': 31, 'C2': 25465, 'C3': -6557867529704715310}],
        'B3': 0.21851922571659088,
        'B4': {'D1': -24827,
               'D2': [3781974421,
                      758055445,
                      3901040132,
                      97568707,
                      2978883384,
                      2784759831,
                      1557762443]},
        'B5': [-460073486802959860, -4864783531269360479]},
 'A3': 12,
 'A4': 245,
 'A5': 34674,
 'A6': 84}

(b'EJPV\xbf\xe1\xc70\x19I\x15z\x00UQ\xc4\xf2;{kixaa\xa5-\x8d\\\x06?\x88\xee'
 b'lt\xac\xf1\xfaWO\xe6\x05\x04\xf1\xc6\xbfe0\x9eG\xdb\xb1\x1fH\xee\x97\xe0'
 b'\x8a\x00\x08\x00\x17`\xab\xc7z\x95\xdfl\x92.RaU\x90I\x18\xc2l\x88/\x9fo\xa6a'
 b"'\x00\x04\x00\x13\xd7\x08\x87\xa5\x9e\x14K,\xa4\x94\xc4k\x9f\xaaqy@,Fp}\xb97"
 b'5\x8f\x8a\xdav\x00\x81\xc1\xd7\x7f?\x1e-\x91\x00\x00\x007\x00\x00'
 b'\x00\x03\x00=')

{'A1': -0.5555649274689778,
 'A2': {'B1': 'kixa',
        'B2': [{'C1': 215, 'C2': 2183, 'C3': -6512745698027072316},
               {'C1': 107, 'C2': 40874, 'C3': 8176637157372362169},
               {'C1': 55, 'C2': 13711, 'C3': -8441304807003531393}],
        'B3': 0.6178827881813049,
        'B4': {'D1': -8054,
               'D2': [1638215053,
                      1543913352,
                      4000085164,
                      4059715407,
                      3859088625,
                      3334432048,
                      2655509425,
                      524873367]},
        'B5': [6965880577972989074, 3337837293955782850, 7820553114748346663]},
 'A3': 81,
 'A4': 196,
 'A5': 62011,
 'A6': 123}

Вариант №20

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

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

(b'JKQS`!\x9f\xf0^?\xe7\x98.=\x00\x00\x00@\r\x1e?\x06\x00B\x00\xdf\xb50'
 b'\x1f\n\xb3rm\xdb?J\x13\x8b\x1e\xdch\x9b>H\x00\x00\x00N\x00\x00\x00T'
 b'\x00\x00\x00Z\x00\x00\x00h\x00v\x80\x83\x1a\xe6qekkov\x19\xb0\x849BwY-'
 b'\xf1)(We"\xc4\x98\x06\x1a\x87O\x07\xbdY5\xa4\x9e\xd2\x0ey\x1c\xd1\x07'
 b'\x04\x00\x00\x00`\x00\x00\x00\x14>\xb4SK<\x83\x1fJ~\xc7,\xbe{\xbf`'
 b"\x99a\xbf\x04k|{\x01\x93\x05\xbb'E\x82\x12\xeeW5\x9f\xca\xc6\xc3\xd3H"
 b'\xe2\x18\xd6\x88')

{'A1': 3357687781566488353,
 'A2': {'B1': {'C1': 118, 'C2': -434470016},
        'B2': 0.6173896789550781,
        'B3': 'qekkov',
        'B4': -18977,
        'B5': 0.4285551784928314},
 'A3': 512430922,
 'A4': 0.3035343885421753,
 'A5': [{'D1': 25, 'D2': -80, 'D3': 14724, 'D4': 30530},
        {'D1': 89, 'D2': 45, 'D3': 10737, 'D4': 22312},
        {'D1': 101, 'D2': 34, 'D3': 39108, 'D4': 6662},
        {'D1': 135, 'D2': 79, 'D3': 48391, 'D4': 13657}],
 'A6': {'E1': [40612, 3794, 7289, 2001],
        'E2': 1404321300,
        'E3': [3226686514855623755,
               342099408084499390,
               2862888117067283563,
               -3846296904978496955,
               -8586648279371758650]}}

(b'JKQS`\xb35,5\xdb\xaa\xeb\x12=\x00\x00\x00\x97\x18\xc3>\x03\x00B\x00\xdaG\x90'
 b'jI\xae\xef\xdb\xb9?;\xfdu|\xfffp\xbeE\x00\x00\x00K\x00\x00\x00Q\x00\x00\x00W'
 b'\x00\x00\x00a\x00$E\n\x0f\xd3wnkiK\x06\xf0\x13\xa2s\xaf\xb1l\xb3'
 b'\x05\xb61\xc5\xeeJ\xab\x98"\x07\xd6o\x0f\x93\xbcJP\x02\x00\x00\x00]\x00\x00'
 b'\x00\xaf\x89K\xec\x96&\xdd\x1bf(t \xe28\xd1\x98\xdeB\xb4\xcc\xf4\xef\xc2'
 b'\x91\x08\x1d\xa1\xdc\xb4H\xdc\x1ej \\@\xb6\x0e\xd16\xe7\xc0\xe4\xaa')

{'A1': 1363371170676356531,
 'A2': {'B1': {'C1': 36, 'C2': -753989051},
        'B2': 0.38104698061943054,
        'B3': 'wnk',
        'B4': 18394,
        'B5': 0.10101221089409251},
 'A3': 2088107323,
 'A4': -0.23476789891719818,
 'A5': [{'D1': 105, 'D2': 75, 'D3': 61446, 'D4': -24045},
        {'D1': 115, 'D2': -81, 'D3': 27825, 'D4': 1459},
        {'D1': 182, 'D2': 49, 'D3': 61125, 'D4': -21686},
        {'D1': 152, 'D2': 34, 'D3': 54791, 'D4': 3951}],
 'A6': {'E1': [48275, 20554],
        'E2': -330593873,
        'E3': [2338538525531383446,
               -3696255870350313246,
               -2548723991472574476,
               4637617356441143476,
               -6132564693282124106]}}

Вариант №21

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

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

(b'XBW&61[[\xb0\xdcf\xcb\xc0[\xf0/ui\xeb,\xdc\x92\x06\xc2\xdc\x164\xca\xbdxwJ'
 b'\x00O\x00T\x00Y\x00^\x00c\x00h\x00\x13\xee\xc2\xce\xc4\x81\xcf\xb3\xbc)\xd1'
 b'?m\x00\xb2\x8e\x00\xbeg\xf0r\x1f\x03\xe7\xbf\x08\xa7&\xbfE2\x02\xcd\xd19'
 b'\xc2\xcdbp\xed`\x8fV\x1cvN\xc4a\x04\x01\x10\xb8q\x9a\xda\x8dA\xb3[10\xbd\x9f'
 b'zH\x1b\x84\xa5h\xa9>\xf9\xeb\x9d\xbeow\n?>\xb2\x19\xbf\xe2[+\xbe\xfc\x0eU>'
 b'\xac@AK-0\x15\x92|\x8a\xb9\x03\\5+\x08Qb')

{'A1': {'B1': 1532703030,
        'B2': -9040,
        'B3': 102,
        'B4': 49355,
        'B5': 1966075995,
        'B6': 15907284061654936425},
 'A2': {'C1': -0.09873215854167938,
        'C2': 'xw',
        'C3': [{'D1': 69, 'D2': 3519873586},
               {'D1': 57, 'D2': 1885523394},
               {'D1': 237, 'D2': 475434848},
               {'D1': 118, 'D2': 73516110},
               {'D1': 1, 'D2': 2591143952},
               {'D1': 218, 'D2': 1538474381},
               {'D1': 49, 'D2': 2057289008}],
        'C4': -826085869,
        'C5': 0.26817243156076764},
 'A3': {'E1': {'F1': 6984,
               'F2': 132,
               'F3': [0.33087649941444397,
                      -0.3084409534931183,
                      0.5408849120140076,
                      -0.6003760099411011,
                      -0.16734269261360168,
                      0.2080649733543396],
               'F4': 1262567596,
               'F5': [45, 48]},
        'E2': -78,
        'E3': {'G1': 3844952277294813717, 'G2': 1649477675},
        'E4': -0.7191312069801297},
 'A4': -0.6509861946105957}

(b'XBW&\xd5\xa3,\x0f\x08R\x1dy\xb9\xcc*\xcf\xaep\x00\xef\tz7\xf0\x18A\xd2\x8b'
 b'\xbeeoJ\x00O\x00T\x00Y\x00^\x00c\x00h\x00\x7f\xafq.\xe2\xb6\x16b/l\xe0'
 b'\xbfm\x00V\x8e\x00\x00\xf5B9i\xca\xd5\xbf\xe1\x83\x8d>tW\x93\xba*\x1e'
 b'L|\xe8\xe8\xc7\x81\x1b\x14\x06\xe0\xa8x\xde]<\xb8\x87b#9\x10q\xc0\x14'
 b'\x8c3\x97\x9bG\x171\x86\xfd\xcba\xbf\xf7\x95H\xbf\xea\xbc\x19\xbf\xa0o\xbc>'
 b'\x03\x9a\xe6>>\xfe0?\xc7\x87\xf7r\xdb;Bc\xbfR\x80r\xf5\x1c\xccn\xee\xdc')

{'A1': {'B1': 254583765,
        'B2': 21000,
        'B3': 29,
        'B4': 47481,
        'B5': -1362154804,
        'B6': 1796997248613023856},
 'A2': {'C1': -0.2730884850025177,
        'C2': 'eo',
        'C3': [{'D1': 116, 'D2': 716870487},
               {'D1': 30, 'D2': 3907550284},
               {'D1': 199, 'D2': 101981057},
               {'D1': 224, 'D2': 1574860968},
               {'D1': 60, 'D2': 593659832},
               {'D1': 57, 'D2': 348156176},
               {'D1': 140, 'D2': 1201379123}],
        'C4': 779202431,
        'C5': -0.5132061878009291},
 'A3': {'E1': {'F1': 12567,
               'F2': 134,
               'F3': [-0.8820188641548157,
                      -0.783538281917572,
                      -0.6005388498306274,
                      0.3680391311645508,
                      0.45039376616477966,
                      0.6913794279098511],
               'F4': 1928824775,
               'F5': [219, 59]},
        'E2': 86,
        'E3': {'G1': 2086699897825747778, 'G2': 3706613452},
        'E4': -0.3404791888422807},
 'A4': 0.276396781206131}

Вариант №22

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

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

(b'GHULmrxmygu\xd9\x04\x00 \x00\x00\x00\x02\x00\x00\x00$\x00D\x00\x00\x00'
 b'\x8d\x00\x00\x00filfD\xb9\x8es\x1e9\x89\xc1\xe0G\xbd\xe8 j\xe9?\x93M\x01\x91'
 b'\xed\x85?\x11(Q.\xecW\xff\xd2?\x1e6P-\xf7\xc8\x136\xfa"\xd7\xdc'
 b'\xa3\x0c\x19\x99\xd0\x18L\xd9x\xf2(\xd8\xd9\x01\xe0\x8cE\xc8\xc3\xee'
 b'B\x95\xa0\xaa,D\xf6\xc9rsA\xfdU\xb4c\xa4x\x07\t\xa4>\x83\xcb\x0c'
 b'\xd1\x0fV\xb5\xd0uL7M\x9e\x9d\xcd\x9a?Y\xaai\xb4\x04\x00M\x00\x00\x00'
 b'\xca\x04\x00\x00\x00m\x00\x00\x00')

{'A1': 'mrxmygu',
 'A2': 217,
 'A3': 'filf',
 'A4': [{'B1': -4501003549629564604, 'B2': 0.7942051454249359},
        {'B1': 1242859277564071315, 'B2': 0.29683492722075977}],
 'A5': {'C1': 30, 'C2': 18029619912085688374},
 'A6': {'D1': -76,
        'D2': [15031072773405202210,
               15697341523074567192,
               4823007515888115713,
               8271412963310215317],
        'D3': -54,
        'D4': [8693182806919823731,
               -3383105455509993209,
               5563999933535966735,
               7613996249738223006]}}

(b'GHULxbgiucj\xbf\x05\x00 \x00\x00\x00\x02\x00\x00\x00%\x00E\x00\x00\x00'
 b'v\x00\x00\x00ughwo~t\x9d\xd2\xffa\x140\xd0\x89\'mh(\xba?\xc2d\xdc+\xbf"Z'
 b'\x95\xccjR>\xb4\xf2\xe0?7\x10+{[\xceoec\x9e\xc3737=\xda\xd1\xb8\x87'
 b'\xce/\xe1\x04v`)8h\xddw\x1c\xa75\x90d\xad6\xf4\xb0pEv\x86r\xfc[,^z\xcf\x03'
 b'\x00N\x00\x00\x00\x91\x02\x00\x00\x00f\x00\x00\x00')

{'A1': 'xbgiucj',
 'A2': 191,
 'A3': 'ughwo',
 'A4': [{'B1': 3464501764732843134, 'B2': 0.1021790758600567},
        {'B1': -7684791609684368190, 'B2': 0.5296269623971397}],
 'A5': {'C1': 55, 'C2': 7162253714491386640},
 'A6': {'D1': -49,
        'D2': [15121466006141649822, 6950748440109156280, 3866090106262140969],
        'D3': -111,
        'D4': [5003693748944462992, 8817533894027019894]}}

Вариант №23

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

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

(b'PDWKd\x19{>\xbf\xd7R9\x7f\x02\x00\x7f\x00\x0f\x0c\xfbX@\xf2<\x93\x00\x00\x00'
 b'[\xf8{ \xa2\xf3\x8a\xa55!B=\xe0U\x8284\x19\xc5?!\xe4\xa1e\xea*\x10\xed'
 b'? \xfe\x8f\xfb\x89?\xb0?\xc0\xc1\xd6azK\xdc?$\xbfrw\xd8\xb4\xe6?\xa2u\x9c'
 b'\x8e\xe7m\xe7?\x18\xb6\xf3g\xa0\xf3\xdd?$Um!*\xd5\xda\xbf\xe8\xb5W'
 b'\x0b\xebu\xeb\xbf\xff\xe7#=jtfj\x18cmqtWu\x00\x00\x00z\x00\x00\x00v'
 b'\\\xb1J\x01\x8fVx\xa3/\xfc\r\x03\x00\x00\x00\x87\x00\x00\x00\xb4'
 b'\xa0\xfe\xfcd\xbf\xaf\x8fk\xbf\xc9\x96\xef\xbe\xa6\xa4\x1c?\x87}\xf1'
 b'\xbed\xde`\xbf')

{'A1': {'B1': -0.7440658211708069, 'B2': 2134463191},
 'A2': [{'C1': 'jtfj', 'C2': 24}, {'C1': 'cmqt', 'C2': 87}],
 'A3': {'D1': 3087, 'D2': -5},
 'A4': 0.029571697115898132,
 'A5': {'E1': {'F1': [1253137526, 2018938625, 234631075],
               'F2': -24396,
               'F3': [-0.894485354423523,
                      -0.9201611876487732,
                      -0.4679472744464874,
                      0.6118873357772827,
                      -0.4716608226299286,
                      -0.8783934116363525]},
        'E2': {'G1': 11928614440699426907, 'G2': 0.047394949942827225},
        'E3': 0.16483166465029253,
        'E4': 33,
        'E5': [0.9082235887590824,
               0.06346952811872386,
               0.44210681490497095,
               0.7095758755658363,
               0.7321660790800488,
               0.467994786754248,
               -0.41926053299296684,
               -0.8581443044219528]},
 'A6': 0.04001617059111595}

(b'PDWKd\xd4\xd3f?\xb3E\xb6\xfb\x02\x00\x7f\x00\\\xc3\xe1\x8b\xa0\xf4>'
 b'\x8f\x00\x00\x00\xd5\xc1\xac\x10c5\xbe)f\xeb"\xbf\xcc\x1d\xd0Z'
 b'\xb1\x0e\xd4\xbf\r\x88\xbe"\x1e`\x17\xe3\xbf^\xe4\x8f\xcb!X\xea'
 b'\xbf\x1e\x97\xe8\xc4!\xef\xe2?>\xaaB\x0e:c\xe5\xbfDl\x90\xbf_S\xdb?d\xe3\x9d'
 b'\x98\xd4\x80\xdd?\x88p\xd1\xde\x9b\x00\xd3\xbf\x82\xfb\xceB`\x8b\xef\xbfsvS'
 b'\xbfzzvo\xc1hqpu\xa1u\x00\x00\x00z\x00\x00\x00A\x85l\xb4\x8f\xe2Z\xa9\x02'
 b'\x00\x00\x00\x87\x00\x00\x00jK\x94\xcf8?\n\xfdf?uBm=c\r0\xbf\xa9\xa5j'
 b'\xbf\x93Gq>')

{'A1': {'B1': 0.9016697406768799, 'B2': 4223026611},
 'A2': [{'C1': 'zzvo', 'C2': 193}, {'C1': 'hqpu', 'C2': 161}],
 'A3': {'D1': -15524, 'D2': -31},
 'A4': 0.4777873456478119,
 'A5': {'E1': {'F1': [3027010881, 2841305743],
               'F2': 19306,
               'F3': [0.7219173908233643,
                      0.9022985696792603,
                      0.05792470648884773,
                      -0.6877042651176453,
                      -0.9165902733802795,
                      0.23562459647655487]},
        'E2': {'G1': 3007900300727861717, 'G2': -0.6364043951034546},
        'E3': -0.3133967768521557,
        'E4': 13,
        'E5': [-0.5966034496868398,
               -0.8232583022901385,
               0.5916909070844871,
               -0.6683626440547596,
               0.4269637461417839,
               0.46098818687419496,
               -0.29691216239530904,
               -0.9857636742452629]},
 'A6': -0.8260261416435242}

Вариант №24

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

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

(b'LRR@\x03\x00\x00\x00B\x00\x94\xd2\xdf\xbe\x04\xd5\xc1n\x9b\xd4\xe7?\x8az'
 b'\xf9\x8c\x8b.\xe6\x9cF3UWwp\x02\x00\x00\x00f\x00&dr\x00\x00\x00\xdef\x8c\xd7'
 b'\xd9k\xc2z\xb1> \xe9%\xdcg\xc4\xe5\xbfX\x99\xfa\xf3b\x9a \xc8Ei\x81<\xae\xc3'
 b'\x0f\xf9MWJ\xe1\xe4\xcf\x8f\xd8\xd7\x86\xe3\xd2\xab\x01\x1eo"p\xb7\x00\x7f|'
 b"\xaf\xbb\x95\xe8W\xbfn\x19\x1c\xbf\xe6b'\xa8\x07\x96x\xb4\x82P\x02\x00j\x00"
 b'\xc4\x9c1\xeb\xd3\xdeX\xe5\xbf\xea\x12\xcc\xc7\x18B')

{'A1': [{'B1': 14420695756631087448, 'B2': 26949, 'B3': 15489},
        {'B1': 16233883799213032366, 'B2': 53220, 'B3': -10097},
        {'B1': 8006839025000482519, 'B2': 28706, 'B3': 183}],
 'A2': -0.4371534585952759,
 'A3': {'C1': 0.744703022310802,
        'C2': -1929807222,
        'C3': 6292992432693194379,
        'C4': 'wp',
        'C5': [31871, 48047],
        'C6': 25638,
        'C7': {'D1': 25318,
               'D2': 5801397700012779559,
               'D3': [-0.8433926701545715, -0.6097630262374878],
               'D4': -60,
               'D5': -0.6670984400785076,
               'D6': 4842,
               'D7': 1108920268}},
 'A4': -678664482,
 'A5': 217,
 'A6': 107,
 'A7': 0.3466396927833557,
 'A8': -0.680225305535064}

(b'LRR@\x02\x00\x00\x00B\x00\x86^\x14\xbe\x84\x9c\x08\x94>%\xde?\xb4\x88'
 b'8\xfeV\xa2\x0e:\r$\xa7\xa3qd\x02\x00\x00\x00Z\x00\xd7\xd6z\x00\x00\x00'
 b'\\\x17z\x10\xa1U\xf5\xa1\xf8=F4k2W\x05\xea\xbf\xcc\xae>w\xf1\x0c'
 b'\x87\x17=\x8d\xddcL\xb7\xd5\xa9\xe8\xdb\xa2\x163\xe4\xda\x18\xc3n'
 b"y\xaf\xe5\x0cP\xbf\x18Q\xa9\xbem \xb9\xbe\xeb\xbfz\xbe\x0b\x07'\xbf*Q"
 b"#\xbf\xe2\xa26\xbf6\x01\xeeK\xc6\xbb\x11y\x14\xcd\x07\x00^\x00\x05\xce'\x92"
 b'\xc1\x13\xb1\xe3\xbf\x8f\x00\x11\xab\xf3\xbc')

{'A1': [{'B1': 1695338015955529420, 'B2': 36157, 'B3': 25565},
        {'B1': 1631107807389792076, 'B2': 58419, 'B3': 6362}],
 'A2': -0.14489182829856873,
 'A3': {'C1': 0.4710232206002234,
        'C2': -29849420,
        'C3': 11792433788520145494,
        'C4': 'qd',
        'C5': [28355, 44921],
        'C6': 54999,
        'C7': {'D1': 310,
               'D2': 14777569394381179886,
               'D3': [-0.8126967549324036,
                      -0.33069682121276855,
                      -0.36157551407814026,
                      -0.24487273395061493,
                      -0.65245121717453,
                      -0.6379572153091431,
                      -0.7134228944778442],
               'D4': 5,
               'D5': -0.6153658657724408,
               'D6': 143,
               'D7': 3170085649}},
 'A4': 276436828,
 'A5': 161,
 'A6': 85,
 'A7': 0.12140265852212906,
 'A8': -0.8131519303075343}

Вариант №25

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

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

(b'SVZH\xca\x0bN\x95\x9c\xa5\x92\xce\x82s\x03\x00\x00\x00s\x00qnscrp\xc6m'
 b'\xdc.\x99{e],\xda\xfe\xbeJ>8+@\xfd*\xb0\xbc\tT<\xd0\x1f\xd0\x04\xb4\xb6'
 b'\xdf\x18\x04\xccX\x03\x8c\xdeE\x14\xf8\xb0\xc8\xe8=\xa7\x1f\xde;\x9c'
 b'\x0c\x90\xea\xbe\x18\x95|x\xceM\x02\x82\xce\xb4\xc6\xc5\xc5\x7fS\xa2'
 b"\xcbw\x9f\xf3V\xe0*Z\x92v\x00\x05'a\xf4\xf4\x0f\xc2\xfancc\xdf\x82")

{'A1': 14885141810351311818,
 'A2': {'B1': 29570, 'B2': 'ncc', 'B3': 'qnscr'},
 'A3': [{'C1': [-14736, -9107, -26322], 'C2': 5386022417382335867, 'C3': 14398},
        {'C1': [16427, 11005, -17232], 'C2': -5475022411919502327, 'C3': 57270},
        {'C1': [1048, 22732, -29693], 'C2': 4461036093312353758, 'C3': 8103},
        {'C1': [15326, 3228, -5488], 'C2': 166015778164119742, 'C3': 52866},
        {'C1': [-14668, -14907, 21375],
         'C2': 3089564948728630178,
         'C3': 37466}],
 'A4': {'D1': 223, 'D2': 130},
 'A5': -377721873999255803}

(b'SVZH\xe1Z\xd4o\xa9Yf\xd7q<\x03\x00\x00\x00s\x00tnkmq\x10}\xeb\xe2\t\xfc\xfe'
 b'\xe5\x83%\xfc\x01\x1c\x8a\xbao\xca\xef\xd3\x10\xb0T,\xa0\x97qp|\xdb\xa5\xf9'
 b'P\xa2x\x8bO\xb1E\x9b\xd3jLn\x8d\x04\x15\xd3#\x8d\x14#\x9a\xa4\x01\r'
 b'\x07\xf5\x1c\xa2\x97\xc9\xd6\x0cP\x1f\x84\xa3M\xaf\x1e)\x7f\xaa\xf7Zlv]\xa1'
 b'\x0fv\x00m\xb9<\x14/x \xf7lkh\xaaz')

{'A1': 15521191750039526113,
 'A2': {'B1': 15473, 'B2': 'lkh', 'B3': 'tnkmq'},
 'A3': [{'C1': [32016, -7445, -1015], 'C2': -8494912614654810626, 'C3': 28602},
        {'C1': [-4150, 4307, 21680], 'C2': -6495461215167864788, 'C3': 20729},
        {'C1': [30882, 20363, 17841], 'C2': 1514490879571317659, 'C3': 9171},
        {'C1': [5261, -26077, 420], 'C2': -2969675756747815155, 'C3': 20492},
        {'C1': [-31713, 19875, 7855], 'C2': 6734689430737157929, 'C3': 4001}],
 'A4': {'D1': 170, 'D2': 122},
 'A5': -639379003488290451}

Вариант №26

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

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

(b'EQAB\xa1\xc1e\xdd<\x03\x00A\x00ga\x0e\x95\xd9\x9c\x9cv\x8dn\x04\x96\xe6\xa2v'
 b'\xd5\xde?E\xc0\x02\x00\x00\x00h\x00#\xb1E\xbfLl\xa4\xbe\xe2\xf4\x9c\x98\x12'
 b'\x9d\xc6\xacVL\x8b\xa0t\xbf#\x90\xc0=\xd4c\xa4\xb3\xa0v\xca\xcd\xe4\xcb\xbb'
 b'\x00\x0e\xa3.\x01 \xc8r\x02\xb0\x12g\x1a#\xec\xa0\r\x93\xa4\x18\x02mp\xe5'
 b'1\xbe\\\xb2\x12\x04\xd9H\x10%\xe5\xbf\xcc\x07\xde&\xa9\x0c\xd9\xbf')

{'A1': 0.027026059105992317,
 'A2': {'B1': [{'C1': -3617948918058032172, 'C2': 12307428, 'C3': 14},
               {'C1': -5763918369224839517, 'C2': 588932882, 'C3': 236},
               {'C1': 8101133609572961696, 'C2': 1555968485, 'C3': 178}],
        'B2': 'ga',
        'B3': 7966153730906756366,
        'B4': 0.48177877338670805,
        'B5': {'D1': 49221, 'D2': [-0.6607743666464805, -0.3913977508128681]},
        'B6': [-0.7722341418266296, -0.32113873958587646],
        'B7': -2846,
        'B8': {'E1': 5500773963918383260,
               'E2': -0.9555746912956238,
               'E3': 0.09402491897344589}}}

(b'EQAB\xa1\x9b\xe4\xe9>\x02\x00A\x00yt\xb6S9\xcb\xdf\x01?\xfb\xa83\xe0]\x16'
 b'\x8b\xdf?K!\x02\x00\x00\x00[\x00\xad,\x8a>\xd8,z\xbf\x916l\xfd\x12'
 b'\x9a\xb0(\xb5\x9fl*\xc0>\xea\xa99\xbf\xb1$\xbe\xee(\x7f}\xd6\xbd\xebm'
 b'\xefUd\xb7r\xf7\xf4\xe6\xc01,\x97R\xb5\xcd\xa0\xfb\xe6\xd0\xbd'
 b'\x86\xae\xbf\xea\xf9\xff\x11\xb3L\xec\xbf')

{'A1': 0.4568222463130951,
 'A2': {'B1': [{'C1': -2991094763723283279, 'C2': -278008899, 'C3': 85},
               {'C1': 3585119243184813924, 'C2': -1252878548, 'C3': 205}],
        'B2': 'yt',
        'B3': -342552985958001738,
        'B4': 0.492864219356131,
        'B5': {'D1': 8523, 'D2': [-0.05962174582554458, -0.8843627311287581]},
        'B6': [0.26987209916114807, -0.9772467613220215],
        'B7': 13969,
        'B8': {'E1': 11508149161779461484,
               'E2': 0.37532365322113037,
               'E3': -0.7252489328384399}}}

Вариант №27

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

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

(b'ODD\xe4G8\xd7r\xc9\x02\x00\x00\x00>\x00 _\x00\x00\x00\x03\x00\x00\x00'
 b'\x8b\x00\x00\x00\xfc\x08 \xfa\xc4\xab\xec\xbfbnknl\xf1,#\xbffwTR\xc7\xe8\xe6'
 b'?asyss\xff\x90\xe1\xbe\x1c\x00-\x00,\xce\x00@P<|?l\xdfV\xbc\xbf\x99'
 b'\x97\x0cr@u\xb6<\x10\x01\x94\x16f(\xe7\xbf\xea\xea\t3\xa60X\xa9X\x8b\x82j|'
 b'gL\x14a\x90\x01q\x8d\xd9B\x00\x00\x00!\xcd\x0e\xad\xdb*~\xd9\xa4v\xcc'
 b'\xfeS\x00\xb3\x1cl\xa0#\x04\xdd\xcb\xcc\xa3')

{'A1': 14407,
 'A2': 215,
 'A3': 51570,
 'A4': [{'B1': -0.8959679494148811, 'B2': 'bnknl', 'B3': -0.6374045014381409},
        {'B1': 0.7159153564459586, 'B2': 'asyss', 'B3': -0.44055935740470886}],
 'A5': 32,
 'A6': {'C1': 856287978,
        'C2': 7674849927907258534,
        'C3': 26492,
        'C4': -2770433944231799732,
        'C5': {'D1': 1073794604,
               'D2': 0.985295295715332,
               'D3': 108,
               'D4': 8218110106646894303},
        'C6': [-1391538911, -646042917, -20154716],
        'C7': {'E1': 0.022272706031799316, 'E2': -0.7236814919452019},
        'C8': 2691439795},
 'A7': [1059, 52189, 41932]}

(b'ODD\xe4Fs\\\xd02\x02\x00\x00\x00>\x00\x89_\x00\x00\x00\x03\x00\x00\x00'
 b"\x8b\x00\x00\x00p\x93\xbcO5\n\xbc?gmjwa\xa2'[\xbf\x86\x88\xdePQ>\xe1?wlu"
 b'gu9\xb9\xf2\xbe\x1c\x00-\x00aA\xb2\x0f\x92\xc6\xec\xbe"\x14\xf5\x9fkh'
 b'\x11\xf1j\xb4,\xbb<XO/\xb2N&\xd2\xbf|\xdf\xa9\x1a\xd6\xc8\xbbtG[\xf0\x9f\x0e'
 b'v\xd6\x9fLA\xdc`\x18\xfdB\x00\x00\x00F\xe9\xaf\xab\xf9P\xb51\t\x93Z'
 b'\x98S\x00\xe9\x89e|0\x96\xf5\xff03')

{'A1': 29510,
 'A2': 92,
 'A3': 13008,
 'A4': [{'B1': 0.10953076550192775, 'B2': 'gmjwa', 'B3': -0.8560734987258911},
        {'B1': 0.5388571338155692, 'B2': 'wlugu', 'B3': -0.47406938672065735}],
 'A5': 137,
 'A6': {'C1': 447340412,
        'C2': -6921932264809183018,
        'C3': 30222,
        'C4': -209310883568115754,
        'C5': {'D1': 263340385,
               'D2': -0.4624524712562561,
               'D3': 34,
               'D4': 7705959577587545364},
        'C6': [-1414534842, 833966329, -1738894583],
        'C7': {'E1': 0.0228484645485878, 'E2': -0.28358809853420075},
        'C8': 2087029225},
 'A7': [38448, 65525, 13104]}

Вариант №28

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

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

(b'TVHRi\x01\xf7~\xdf\xe5\xbd\xfe6\xf5\xbc\x00\x04\x00#\x00\x00\x00~J\x12\xa0H|'
 b'\x86\xe8\xee\x95\xf9\xe3\r\x00\x17\x00\x1a\x00\x1d\x00 \xbaL\xd6\x01"'
 b'\x18\xdew0\x1a]\xf2\xbe\xe7/\x17\xb5\xceI\xe5v\xd8h22\xb7.\x16R'
 b'\xdb\xcc\xee\xc3\xc6:\x9b\x06\x9d`\xeb\xc9\xa2\x04\x14\x00\x06\x00I\xc4'
 b'\xc6sA\x87\x00\x04\x00\x00\x00O\xbf\xb9i\xf0_z\xdb\x00\xcc\xe8ot\xdaJ'
 b'3\xbc\x91U\x85\xb5\x1b\x00J\x96i\xcd\x83\x16\x00+29\x97\x11w\x82@\xdd9s\xa37'
 b'u|}\rA\xeb5\x18\xe2\xbd\xe0\x1f\xdc`\x00W')

{'A1': 1382613495,
 'A2': 9142278372761990588,
 'A3': [{'B1': 18962, 'B2': 160},
        {'B1': 18556, 'B2': 134},
        {'B1': 59630, 'B2': 149},
        {'B1': 63971, 'B2': 13}],
 'A4': {'C1': 1775076118,
        'C2': {'D1': [-17844, -10751, 8728, -8585, 12314, 24050, -16665],
               'D2': 3393380741854623448,
               'D3': 7508119291113657051},
        'C3': 842635025,
        'C4': 30594,
        'C5': 4673955157102785916,
        'C6': 2098020843,
        'C7': 3826057188588117088,
        'C8': {'E1': [204, 238, 195, 198, 58, 155],
               'E2': 196,
               'E3': -965525113,
               'E4': [1693, 24811, 51618, 1044],
               'E5': -0.09927275019695614,
               'E6': [-3681570147706195012, -7974320552301016426]}}}

(b'TVHm\xbe\xd2;i\x174\x02\xbd\xa2\x19Q\x00\x03\x00 \x00\x00\x00u\x87H<\x82\x15'
 b'\xb4\xbf^\xe6\x00\x17\x00\x1a\x00\x1d\xab\xe6|\xe5\x13j\xac\xc3]<Kt\x7f\xad'
 b'e\x13~G\x1b\x1a\xf9W\xf3"u\xb8Z\x12\x8d\x18\x8b\xf3\xe3x@\x89\xcd\xc1'
 b'\x9b\xd0\x00\x02\x00De9\xcd\xaeQ\x00\x04\x00\x00\x00F\xbf\xd0O\x1ek\xd6\xae'
 b' 5\x147\xe4\x9d\xe4\xc3\x84!\xa0\x88\x1d\x92\x14\xf9\x81\xcf2\\\x0f\x00&\xc1'
 b'\xb31S\xc8\xe6T\xee\x99=\x94\xfa,\xfa\xc7\x14D\xf3\x7f\xe4Vm|\x1c\xf9'
 b'\xcf\x00N')

{'A1': 1841222203,
 'A2': 7572578484822874449,
 'A3': [{'B1': 34632, 'B2': 60},
        {'B1': 33301, 'B2': 180},
        {'B1': 48990, 'B2': 230}],
 'A4': {'C1': 3476184079,
        'C2': {'D1': [-21530, 31973, 4970, -21309, 23868, 19316, 32685],
               'D2': 7283303866250754391,
               'D3': -927049138639303400},
        'C3': -1045221037,
        'C4': -14106,
        'C5': 6119997433414561018,
        'C6': 3339994355,
        'C7': 9215585765740575183,
        'C8': {'E1': [139, 243],
               'E2': 101,
               'E3': 969780817,
               'E4': [58232, 16521, 52673, 39888],
               'E5': -0.25482903033364046,
               'E6': [3824743438585480068, 2423086260111604097]}}}

Вариант №29

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

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

(b'JXTU\x86?\x9b\x18\xa4\x00\x00\x00\xc2\xda\xe1\x08dn\xf3\xbe\xadH\x1d\xbf'
 b'\xd3\xe5\xcf\xed\xb1\xe6.\x9c#\xfe\xe1>\xa4&\xf7\xae\xef\xafA\xc9'
 b'\x14\x00\x00\x00 \x00\x00\x00\x02\x00\x00\x00,\x00\x00\x004 \xea\\'
 b'\xc3s\xc6\x08@\xdc\xa5\xde\xd9\xa7b\x03\xee\xba\xf6\xfe\r\x02\x94~'
 b'\xca\x1b\xfbQ2\x08~m\x93M\xea[\x01\xbe\x8b\x98p\x11r\x8c$\xd1Y\x83'
 b'\xfa\xc85\x1c~TZ\x96p\xbd\xd1s\xd8\xba(\xbb\xbb\xbd\xbb\xd5|i\xf5\x83'
 b'\xc7\xa4\xc3\xc1\x15E7\x99\xf8\xd91:\x12k\xfd\x13\xd5Z\x15&\x0c<\xb7\xc6'
 b'}\xa9\x98\xaen}a?{\x94\x0b\xdc \xbfs\xf9\x1a\xbf\x9a\xf8\xa1\xceT4'
 b'\x00f\x00\x00\x00z\x00\x00\x00')

{'A1': 412827526,
 'A2': {'B1': -27525,
        'B2': -0.6283575892448425,
        'B3': -0.6053687930107117,
        'B4': -102,
        'B5': 1422828024,
        'B6': {'C1': [{'D1': -0.6143901944160461, 'D2': 11254186170718873043},
                      {'D1': 0.44139203429222107, 'D2': 14502065719077185188}],
               'C2': 632320080606797876,
               'C3': [64, -36, -91, -34],
               'C4': {'E1': -22567,
                      'E2': [-1158806686,
                             34471670,
                             466255508,
                             137515515,
                             1301507454,
                             -1107207190]},
               'C5': 292591755},
        'B7': {'F1': -3964712100162139022,
               'F2': 1417550901,
               'F3': -27046,
               'F4': [48496, 29649, 47832]},
        'B8': {'G1': [-1111770328,
                      1769788859,
                      -1530428427,
                      1159053763,
                      -638019273,
                      1796356657,
                      1523913725],
               'G2': 21,
               'G3': 38,
               'G4': 12,
               'G5': 2110175036,
               'G6': -87,
               'G7': -20840,
               'G8': 0.8808201551437378}},
 'A3': 149019330,
 'A4': -0.47545158863067627}

(b'JXTU>T\xf7\xce\xa4\x00\x00\x00~\xfb~\x8d\xa0\x16\xc3\xbd\xb1w:\xbc\x86\x181*'
 b'\xd3\xc0s\x17\xbd]\x81\xbeN\xd7q\x01\x04\x81\xb7\xb5\x14\x00\x00\x00'
 b' \x00\x00\x00\x02\x00\x00\x00,\x00\x00\x00<\x10a\x0f>\xa5i\xd1#\xfe5a'
 b'\x10hX\x84/\x0b\x10yn>\x8d\x1d+\x9e\xd9\x82\xc8$\t\x01\xa8\x89EF'
 b'\x92\xc9\x13\x80R9\x12/,\xb6\x17\xa7\xb5\x13\x9a\xc7\x8d\xe9\xe0\\\xfd3\x1bP'
 b']\x96\x91\x98\xef\x18\x16\x9bs\xbb\x81\x86\xd9u\x89\xbf\xb4\x97\xba\xf0'
 b'\x1d\xecE\x9c\xc3\xb8\x0c3\x05DY(jhZO\x80\xc7uc\xcd\x16\x1d>yM\x95\x04'
 b'\xa4\xbd\x9dC\xe5>\xec\xd7^\xc4\x0b4\x00f\x00\x00\x00z\x00\x00\x00')

{'A1': 3472315454,
 'A2': {'B1': 19833,
        'B2': -0.08008686453104019,
        'B3': 0.4477814733982086,
        'B4': -20,
        'B5': 197418711,
        'B6': {'C1': [{'D1': -0.011381075717508793, 'D2': 1689906298372561030},
                      {'D1': -0.2526682913303375, 'D2': 13094076295807096654}],
               'C2': 15089773712446132284,
               'C3': [35, -2, 53, 97],
               'C4': {'E1': 26640,
                      'E2': [187663448,
                             1047427344,
                             -1641341555,
                             617120473,
                             -1985478391,
                             -913160635]},
               'C5': 961708051},
        'B7': {'F1': 1420224977787694866,
               'F2': 3918383002,
               'F3': 23776,
               'F4': [13309, 20507, 38493]},
        'B8': {'G1': [418355345,
                      -1150051562,
                      1977190017,
                      -1749762167,
                      -333582150,
                      -1195140027,
                      1141191436],
               'G2': 89,
               'G3': 40,
               'G4': 106,
               'G5': -2142283160,
               'G6': -57,
               'G7': 25461,
               'G8': 0.1534072905778885}},
 'A3': 2373909374,
 'A4': -0.09525799751281738}

Вариант №30

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

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

(b'YTV\x11\x00?\x8e\xe2n\x93:\x95\x187\x00\x00\x00B\x00\x00\x00H\x00\x00'
 b'\x00N\x00\x00\x00T\x00\x00\x00Z\x00\x00\x00`:\xc2{r\x89\xff:C7\x85'
 b'\x00\x00\x00\x03\x00f\x9f?\xbe\x04K\xd6\xdd\xd8\xa0ip\xbf\xc76\xea\xa4\n\x18'
 b'\x84\xc6cN\xb5\xd8\x1b\x8cL\xff\xf7N\x1a\xa7\xceAG\xac\xb5\xb9\xa9}\x99;'
 b'8\xb3\x8f\x8d\xc7p\xd1\xc6\xc5\xf3\xdeu\xb4\xee\x8a\n:\xeb\xc9\xe8'
 b'\xcf\xf1\tRs\x89w\xc0\xf1\x83')

{'A1': {'B1': 'ip', 'B2': 191},
 'A2': -8150830796965078985,
 'A3': {'C1': [{'D1': 3342264996, 'D2': 2584},
               {'D1': 2227594062, 'D2': -18984},
               {'D1': 462179583, 'D2': -2226},
               {'D1': 447204929, 'D2': 18348},
               {'D1': 3048843645, 'D2': -26309},
               {'D1': 951291789, 'D2': -14480}],
        'C2': [58, 194, 123, 114, 137, 255, 58, 67],
        'C3': 14213,
        'C4': [15115986850515629294, 9946827511380365297, 671726328688472451]},
 'A4': -97,
 'A5': 0.11725305553213383}

(b'YTV\x11\x00?F\xdd=\xa9\x0c\xb9\r\xf9\x00\x00\x00B\x00\x00\x00H\x00\x00'
 b'\x00N\x00\x00\x00T\x00\x00\x00Z\x00\x00\x00`\x87\xc7/_\xd5\x84\xda=\xe4\xbc'
 b'\x00\x00\x00\x03\x00fw?\xed\xe6\x99dL\xcb\xa4ch\x12\xb6n\x9f\xb7v\x80'
 b'\x02>J\x06\xa8\xd7\xa6A\xc0_*p\xb4\xfa\xc7:WIL\xc2\xfe\xc1\xf08<u6\xb8'
 b'\xdc{6\xb4\x9d$}|\xde-Z\x95J:\x0e\xc2\xd3\xe3\xcf9t\x13nzj\xfa')

{'A1': {'B1': 'ch', 'B2': 18},
 'A2': 5106305348780232185,
 'A3': {'C1': [{'D1': 3060703159, 'D2': 30336},
               {'D1': 37636614, 'D2': -22313},
               {'D1': 2789326943, 'D2': 10864},
               {'D1': 3036333882, 'D2': 22345},
               {'D1': 1287847617, 'D2': -4040},
               {'D1': 1014314680, 'D2': -9093}],
        'C2': [135, 199, 47, 95, 213, 132, 218, 61],
        'C3': 58556,
        'C4': [3941948353905745453, 6527204848159609827, 14932093666330307322]},
 'A4': 119,
 'A5': 0.9343993147834806}

Вариант №31

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

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

(b'BBY\x1f\x00+\x009\x00\xd9\x00\x89\xcf\xce\x14\t\xc3\xc0C\xda\x06\x17B)'
 b'\x83\x00atigq\x05\x00\x00\x00\x1a\x00\x00\x00\xed\xd7ic\x02\x00\x00\x00)'
 b'\x00\x00\x00L\xb3phrl\x04\x00\x00\x005\x00\x00\x00\x19\x1d2pr\xbfg\x12w>\xb0'
 b'*\xe3\xbev\\l?\x04\x00\x00\x00C\x00\x00\x00\xe8\x169\xef\xae\xd96wH'
 b"j\x04\x17\xff\xbaQ\xeeSU\xb6\xfb'<\x96t\xab\xf5\xf7\\\xe8\x99\x05\x98\xf6"
 b'\xe4E.\x966\xe7\xbf`\xcf\xba}\x7f\x17\x93Z%\xa7S\x00')

{'A1': [{'B1': 'atigq', 'B2': 55277},
        {'B1': 'ic', 'B2': 45900},
        {'B1': 'phrl', 'B2': 7449}],
 'A2': 217,
 'A3': -30464,
 'A4': -2719117806098133297,
 'A5': 692197126,
 'A6': {'C1': 2109394784,
        'C2': 1519589247,
        'C3': 42789,
        'C4': {'D1': [-0.9470244646072388,
                      0.24128113687038422,
                      -0.44368505477905273,
                      0.9232858419418335],
               'D2': -281471256,
               'D3': [2000083374,
                      386165320,
                      3998333695,
                      4223030611,
                      1956002855,
                      1559754155,
                      2550503912],
               'D4': -0.7254134086389559}}}

(b'BBY\x1d\x00)\x007\x00\x94D;"l\xfb\x89\x0b\xa1\x9a-v\xf8>\x96\x81\x00bx'
 b"x\x03\x00\x00\x00\x1a\x00\x00\x00O\x1fcv\x02\x00\x00\x00'\x00\x00"
 b'\x00\xaa\x84fktg\x04\x00\x00\x003\x00\x00\x00;\x9c\xb4\xdc1\xbfN\x0cE'
 b'\xbf\xfd<K?k?\r\xbf\x04\x00\x00\x00A\x00\x00\x00\x11&\x9fR4\x97\x80'
 b'e\xce\x1b\xf6\xbbb\xe3\xba\xa9\xea\xf4\xcay\t\x7f>Zm\xfd\xe6\x87\xf4\x8f\x84'
 b'}\x04\xb1\xca\x8d\x13\x7f\xdf?\xef_D\xf5\xbcP1I\xb7\x07Q\x00')

{'A1': [{'B1': 'bxx', 'B2': 8015},
        {'B1': 'cv', 'B2': 33962},
        {'B1': 'fktg', 'B2': 39995}],
 'A2': 148,
 'A3': 15172,
 'A4': 3286115949051866146,
 'A5': -1774258058,
 'A6': {'C1': 4114898927,
        'C2': 1227968700,
        'C3': 1975,
        'C4': {'D1': [-0.6947739124298096,
                      -0.7697190046310425,
                      0.7938993573188782,
                      -0.5517489314079285],
               'D2': 1386161681,
               'D3': [1702926132,
                      3153468366,
                      2847597410,
                      2043344106,
                      1514045193,
                      2280062317,
                      2105839604],
               'D4': 0.4921311268506232}}}

Вариант №32

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

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

(b'\xacNBQ\xcbM*0\xb5\x14\xfd\x90Em\xce\x80\xce\xfa\xe5M\x00Y\x00e\x00q\x00}'
 b'\x00\x89\x00\x02\x00\x00\x00\x95\x00\x00\x00\x05\x00\x00\x00\x97'
 b'\x00\x16]\xfd(\xcc\xddN\\\x80.OT\x1d\xa6\xeb?/\xff\xa7\x1b\x12\xa1i'
 b'\x90\xa4\x8fQ\xdf@,\x83m\xdc\x9f\x1a4\xe8\xbe\xb7\xd8\xfc\t\xe4?*\xfc['
 b'\x00P\xaf\x10\xf0jM\xd2\xbf`\xbf\x80\xd7\xb6%\x8eq\xb8\x15\xe5\xbfY\xe2\xa6'
 b'\x9e\xf0\xa4\xcc|\xf08\xe9?\x85\xb76\xb4h\x8et\x1a<7\xdf\xbfY\x8f\xa6'
 b'\x10*y\xf3V\x915\xec?\x83\xc8\xf0\x0bkJ/\xb2\xcac\xf9\x8a\x94\x13\x81'
 b'\xf1+\x87>\xea!c')

{'A1': {'B1': -7999214594710417973,
        'B2': {'C1': 69,
               'C2': -830419347,
               'C3': -6662,
               'C4': [{'D1': 874160092, 'D2': 0.6262191994446455},
                      {'D1': 6028330, 'D2': -0.2859752029787517},
                      {'D1': 3615539040, 'D2': -0.658901426112769},
                      {'D1': 2661737049, 'D2': 0.7882006108749504},
                      {'D1': 3023484805, 'D2': -0.4877462633469123},
                      {'D1': 279351129, 'D2': 0.8815390299094237}],
               'C5': [131, 200],
               'C6': [1248529392,
                      1674228271,
                      328502009,
                      2267804033,
                      1663167038]}},
 'A2': 6651497568603561238,
 'A3': 0.8640276571909027,
 'A4': 463994671,
 'A5': 41234,
 'A6': [105, 144, 164, 143, 81, 223],
 'A7': 1837313088}

(b'\xacNBQRs\x07\xe26t\x08\xaf\xe5\xe4\xcec#\xf5\x89M\x00Y\x00e\x00q\x00}'
 b'\x00\x89\x00\x06\x00\x00\x00\x95\x00\x00\x00\x06\x00\x00\x00\x9b'
 b'\x00\xb9~\xe1\xff\xee\x08.<\xf0w\xf6\xf2\\m\xde?\xc8\xbc\xea\xfc\x080\x10'
 b',\x1b?\xa1\xf9d\xa2d_\xc8\x9d\x9f\x11,\xfd\xfc~Yz\xd2?\xa5\x9e\x1b'
 b"\xc5\xc8\x0e\xfev\x17P\xd5\xbf'e\x05x@+\x02\x9a\xc3\xb8\xe9??\x1e\x9d"
 b'\xff\x02\xc9\x97\x80\xea\xe2\xe4?\x15\x1bG\xc6rwE\xb3\xe8\x1c\xe7'
 b'\xbf\x9a\xe6\x15\x02\xe26\xbb\x0bI\xac\xed?\x03\xa7\xa0`\x04\xa5\xd0'
 b'\xfd\xc3\xda~\xa9\x98\x88\x82\x10\x8f\xbc\xe9)\x0cK\xab\xc8u\xcd\x92\x0fNm')

{'A1': {'B1': -5834285538189282478,
        'B2': {'C1': 229,
               'C2': 593743588,
               'C3': -30219,
               'C4': [{'D1': 295673288, 'D2': 0.2887176265830529},
                      {'D1': 3306921637, 'D2': -0.3330134069476398},
                      {'D1': 2013619495, 'D2': 0.8038042076089837},
                      {'D1': 4288486975, 'D2': 0.6526997100429812},
                      {'D1': 3326548757, 'D2': -0.7222789288896208},
                      {'D1': 34989722, 'D2': 0.9272809247138094}],
               'C5': [3, 167, 160, 96, 4, 165],
               'C6': [3670277584,
                      2291706238,
                      3163492482,
                      1259088361,
                      3447048363,
                      1833832338]}},
 'A2': 4336413313792573113,
 'A3': 0.4754249928172376,
 'A4': -51725112,
 'A5': 12296,
 'A6': [16, 44, 27, 63, 161, 249],
 'A7': 1600430692}

Вариант №33

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

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

(b'\xc9DWET\x00\x00\x00w\xa23\xe0j\x96\x94\xbf]\xban)j15\x0b\xfb\x81\xd9['
 b'x\x02\x00\x00\x00\x03\x00\x00\x00\r,A\x9e\xdc\xf2g\xb9\x9d=\xfd{u\xa4\x04'
 b'-\x91\xeb\x00\x00\x00\x03\x00\x00\x00&\x00\x00\x00\x10\x00\x00\x00)?'
 b'\xd2\xa1%\xc2\xedfX\xe1\xb8\xf5%\xcb3\xb0A3\x9d\xbf\xdbh\x8ex\x00\xdd'
 b"\x10\xc8\xb3m\x93x\x96\x0e\xf2o\xbc\xb3[\x81\x9b\x9d{>\xbfc[i'\xab"
 b'\x1e\xbf \x00q\xc9\x06|\x06\xbf\xe1\xf7\xa2\x94g\xe4RxZ\xa4\xe9\x8b\xfb\xe8'
 b'OT\x90\x00?\xe3X\x85\xc8\x84\xa4f\x1f\x89]\x00Y')

{'A1': {'B1': 43806,
        'B2': {'C1': -0.6250067353248596,
               'C2': 3372645382,
               'C3': -0.5614788912345239,
               'C4': 8672425355438188623},
        'B3': 21648,
        'B4': {'D1': [{'E1': [23994, 28201, 27185, 13579, -1151, -9893, 30722],
                       'E2': [-106, -108, -65]},
                      {'E1': [-8974, 26553, -25283, -645, 30116, 1069, -28181],
                       'E2': [44, 65, -98]}],
               'D2': 0.2910856631839116,
               'D3': 57784,
               'D4': 17664748536291472285},
        'B5': [-29, 88, -123, -56, -124],
        'B6': 164,
        'B7': 1713342813,
        'B8': {'F1': -0.42825662345008286,
               'F2': 14462023308567514866,
               'F3': 8051507439429459323,
               'F4': 0.37380489706993103,
               'F5': 26919}},
 'A2': 2721308778}

(b'\xc9DWET\x00\x00\x00v\xe5K\x02{.z\xc2\xa84W\xc2;\xbf\xc1\x1c\xfcOi\xfe'
 b'e\x00\x00\x00\x02\x00\x00\x00\r9&B\x05\x02\xf3\xc6\xd7t\xc7\x8bXG\xe7\x91'
 b'\x9c\x8b\x00\x00\x00\x03\x00\x00\x00%\x00\x00\x00\x0f\x00\x00\x00(\xbf\xe5'
 b'\x10l^!\xb3\x86\x03\xc2\x0cX\xde\xf6\xa9\x8eh\r?\xe8\xae\x9a\x99_Y\xfa'
 b'\xd1~\xbe\x0fL_a\xe4\xcdY\x169\xf6m\x8d0?F;`\xa0\xec\xa9]?\\\xc1\xbf'
 b'\xebJ\x0c\xf1\xbf\xc7>4`\xe2\xe4\xb0:\x07\xe3\xf2\xc5k\x99T>\xb0\x00>g_\xc6)'
 b'\xaf\xceaUZW\x00X')

{'A1': {'B1': 43357,
        'B2': {'C1': 0.8623313307762146,
               'C2': 3947498737,
               'C3': -0.18158583384300675,
               'C4': 4181561410870548820},
        'B3': 16048,
        'B4': {'D1': [{'E1': [-15704, 13399, -15813, -16447, 7420, 20329, -411],
                       'E2': [46, 122]},
                      {'E1': [1282,
                              -3130,
                              -10380,
                              -14453,
                              22599,
                              -6255,
                              -25461],
                       'E2': [57, 38, 66]}],
               'D2': -0.6582547987469389,
               'D3': 962,
               'D4': 889706077393676301},
        'B5': [103, 95, -58, 41, -81],
        'B6': 206,
        'B7': 1632983639,
        'B8': {'F1': 0.7713139529758444,
               'F2': 15095711973907587556,
               'F3': -3649861584803754704,
               'F4': 0.7743434906005859,
               'F5': 41196}},
 'A2': 3846898299}

Вариант №34

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

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

(b'INWG\x18\xce\xdb\xbd\xbdH2\xee\xb1\xc8\x08\x844\x05<\x02\x00\x91\x00\x00'
 b'\x00\x18$\x02>\x02\x00\x95\x00\x00\x00\x95\x18\xdd\xbe\x02\x00\x99\x00\x00'
 b'\x00\x1d&\x03>\x02\x00\x9d\x00\x00\x00_\x1aV?\x02\x00\xa1\x00\x00'
 b'\x00\x00\xf6\x0e\xbf\x02\x00\xa5\x00\x00\x00\xb0\xecv?\x02\x00\xa9\x00\x00'
 b'\x00\xf0\xfc\xf1\tp\x1f\xee?\xad\x00<#\xc08\xa7\xe7\x02\x00\xb7'
 b'\x00\x00\x00\xcf\x92\xc5\xcc\x81#\xf2\xbe\x8aF\xb6\x9d\xf6\xa4\xe6\t\xfa'
 b'\x15\x84z"\x08kf,\x12\xc3\xac}\xbb\xe5j\x91\xc4\r<\xfb\xd3\xe9Tv\x1a\x00ow'
 b' P\x81\x86\xd10\x934/\x9a\xe0"\xfd\xaa\x996\x01\x10``\x94\x9bT\x15'
 b'\x92\r\x02W\x1c\xd0,*\xc5s\xbd`\xf2w>')

{'A1': -0.0927044004201889,
 'A2': {'B1': {'C1': 72,
               'C2': 3367104050,
               'C3': 8,
               'C4': [{'D1': 0.00813019648194313, 'D2': [21737, 6774]},
                      {'D1': 0.12709081172943115, 'D2': [28416, 8311]},
                      {'D1': -0.43182817101478577, 'D2': [33104, 53638]},
                      {'D1': 0.12807507812976837, 'D2': [37680, 12084]},
                      {'D1': 0.8363398909568787, 'D2': [57498, 64802]},
                      {'D1': -0.558441162109375, 'D2': [39338, 310]},
                      {'D1': 0.9645490646362305, 'D2': [24592, 37984]}],
               'C5': 0.9413376039737198,
               'C6': {'E1': -1844095845, 'E2': [525, 7255, 11472]},
               'C7': 952116028,
               'C8': -6233},
        'B2': [-0.05951420217752457, 0.24213552474975586]},
 'A3': 37583,
 'A4': {'F1': -13115,
        'F2': -0.47292712330818176,
        'F3': -118,
        'F4': 4137530950,
        'F5': 164,
        'F6': [2534, 5626, 31364, 2082, 26219, 4652, -21309],
        'F7': 4327330945815657341,
        'F8': 54267}}

(b'INWG\x18J\xe9\x03=\xd6u\xfc\\U\x8b\x8c<<\xbf\x02\x00\x91\x00\x00'
 b'\x00\x8a\x8f?\xbf\x02\x00\x95\x00\x00\x00\xaa\xe3L?\x02\x00\x99\x00\x00'
 b'\x00d\x18\x17\xbf\x02\x00\x9d\x00\x00\x00\xb7\xbdQ?\x02\x00\xa1\x00\x00'
 b'\x00(\xa5.?\x02\x00\xa5\x00\x00\x00%#\x01>\x02\x00\xa9\x00\x00'
 b'\x00\xa4\x1a\x96\x10\x0bM\xd4?\xad\x00\x05\x01\x94\xf6s\x9e\x03\x00\xb7'
 b'\x00\x00\x00\xa4M\x1d\xa4 1;?*S\x9a\xd1\xd8s\xa1{\xdb\xe4\xc6\xd9/'
 b'\x91\x9b\xda\xecB`\x03dg\xc4\x1e\xed] a\xed\xf2(=>\xeb\xc9\t\xf0\xb7:^v'
 b'\xba\xce\xc9R\xdb\xbd\xc9\x98W\xdc\xbf\x19\x1cY\x08\xd1\xf0\xcd\x93('
 b"\x05\xac\xfa\x07\x04'k9\x90&?\xb8\xefY=\xb8\x10<\xbe")

{'A1': 0.03220490366220474,
 'A2': {'B1': {'C1': 214,
               'C2': 1432157301,
               'C3': -117,
               'C4': [{'D1': -0.7352988719940186, 'D2': [15656, 60222]},
                      {'D1': -0.7482839822769165, 'D2': [2505, 47088]},
                      {'D1': 0.8003488779067993, 'D2': [24122, 47734]},
                      {'D1': -0.5902159214019775, 'D2': [51662, 56146]},
                      {'D1': 0.8193010687828064, 'D2': [51645, 22424]},
                      {'D1': 0.6822075843811035, 'D2': [49116, 7193]},
                      {'D1': 0.12611062824726105, 'D2': [2137, 61649]}],
               'C5': 0.3172023450828567,
               'C6': {'E1': 86545357, 'E2': [-1364, 1031, 27431]},
               'C7': -158072571,
               'C8': -24973},
        'B2': [0.6506381630897522, 0.05320712924003601, -0.18365752696990967]},
 'A3': 19876,
 'A4': {'F1': -23523,
        'F2': 0.7312183380126953,
        'F3': 42,
        'F4': 3637615187,
        'F5': 115,
        'F6': [31649, -6949, -9786, -28369, -9573, 17132, 864],
        'F7': 6998697093938571108,
        'F8': 62189}}

Вариант №35

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

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

(b'\xcfYTM\\\x00\x00\x00c\x00\x00\x00j\x00\x00\x00q\x00\x00\x00x\x00\x00\x00'
 b'\x7f\x00\x00\x00\x86\x00\x00\x00\x8d\x00\x00\x00hzkorbat\x13\x00\xdb\x00'
 b'\x8f\xe3/\x9b\n\xf7\x8f\xa0\x96\x009\x84\xb8\x94\xef\xaf\x1a\x80\xe5\xba'
 b'S\xe0\xe6?*\xb6\xf3\xaa\xb2\xd5{\x0b\x03\x85\xc2\x02Z74\xa2Yz\xe7\xbf'
 b'\xefrn\xa54N\xbf\r4\xc1\x8b\xe1\xad>\xa7\xd6\x1b\xc4\xb68\xbf\xc12\x1c'
 b'B\xfd^?>\x08\x93;L\xf6\xbe\x92_6\x07\x11\xd0<\xbcF\xf6\xa4\xe9\xdf'
 b'\xbe/\xa3\x8c\xa7D7\xbf\xc9\xab\xc3A\xb0\xbdr\xbb7\x03\x02\x00'
 b'\x00\x00\x94\x00,?\xe38P\xb7')

{'A1': {'B1': [{'C1': 29423, 'C2': 110, 'C3': -0.8054907917976379},
               {'C1': 13325, 'C2': 193, 'C3': 0.33961138129234314},
               {'C1': -10585, 'C2': 27, 'C3': -0.721538782119751},
               {'C1': 12993, 'C2': 28, 'C3': 0.8710519075393677},
               {'C1': 2110, 'C2': 147, 'C3': -0.4810503423213959},
               {'C1': 24466, 'C2': 54, 'C3': 0.025398744270205498},
               {'C1': 18108, 'C2': 246, 'C3': -0.43732941150665283},
               {'C1': -23761, 'C2': 140, 'C3': -0.7158913016319275}],
        'B2': 'hzkorbat',
        'B3': [14352403, 2603606927, 2693789450],
        'B4': {'D1': -0.08606293052434921,
               'D2': 53984114,
               'D3': [201, 171],
               'D4': 16172,
               'D5': -1219479325},
        'B5': -1799846855,
        'B6': 45039,
        'B7': 0.7148836756059638,
        'B8': 827489919901611562},
 'A2': 34051,
 'A3': 706,
 'A4': -0.7336853187605172}

(b'\xcfYTM\\\x00\x00\x00c\x00\x00\x00j\x00\x00\x00q\x00\x00\x00x\x00\x00\x00'
 b'\x7f\x00\x00\x00\x86\x00\x00\x00\x8d\x00\x00\x00powhqhclp\xcc\xad\xcd'
 b'\x12\x91\xdf\x89\x0c\xca\x92\xcc\x96\x00\xd6\x852\x9ar\nt`\xb8X\xd0\x83\xe6?'
 b'\xd3~\xcd\xe5.]Ul.~%\xe0\xe4\xb8$\xd0@A\xd9?\xd5\x82\x85\x1f\x19\x9a\xbe\xb8'
 b'\x85\xbbaI\x08\xbf\x0b\xd4\\A\xba\x83=:\xa4\x8c\x04\xfa.?\xea[\x9d-'
 b'\x1c\xa1\xbe\xa1\\y7pF?\xe1\xca8\x88\x8fE\xbe\x82\xd4\xdb\xdf\x97\xba\xbe'
 b'\xb1AXy\xcd\xbe\xe7ZL\x08\x02\x00\x00\x00\x94\x00v\xf2\xd0\x92\x9a\xec')

{'A1': {'B1': [{'C1': -32043, 'C2': 133, 'C3': -0.30097290873527527},
               {'C1': -31304, 'C2': 187, 'C3': -0.5323696732521057},
               {'C1': -11253, 'C2': 92, 'C3': 0.06432009488344193},
               {'C1': -23494, 'C2': 140, 'C3': 0.6835024356842041},
               {'C1': 23530, 'C2': 157, 'C3': -0.31466808915138245},
               {'C1': 23713, 'C2': 121, 'C3': 0.7751497626304626},
               {'C1': -13599, 'C2': 56, 'C3': -0.19293034076690674},
               {'C1': -11134, 'C2': 219, 'C3': -0.3644399344921112}],
        'B2': 'powhqhcl',
        'B3': [3450719344, 2313130258, 3432172044],
        'B4': {'D1': -0.40131640434265137,
               'D2': 139221735,
               'D3': [177, 65],
               'D4': 62070,
               'D5': -325414192},
        'B5': -1707964970,
        'B6': 2674,
        'B7': 0.703590558320697,
        'B8': 7806247985121951443},
 'A2': 32302,
 'A3': 57381,
 'A4': 0.3946077377940027}

Вариант №36

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

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

(b'CFA\xbb-g\x01P\xbf\xe8i\x08\x05L\xbe\xf2\x00X\xe4\xbbD.\xbf\xe2\xd0s\xbf\x14'
 b'\x7f\x92\x00b=\xf2\xbd\x10?\xc7\xde\x19F\xc6W\xf8\x00l\x00\x8f?\xd2\x17;'
 b'\x12\x87i\xf8\xbf|H\xfc\x1d\x14\xe4\x00?\xe9)\x13\xbf\x9bR\x9a?\xe2\xd1\xa3'
 b'j\xae\xc8\x82?\xd0\xbc\x16\xc2\x01\x1e\x98/\xbd\xfa\xb8\xaf>q\xdf'
 b'U\xbd\xe5\xdd\xdaj!g\xda.\x7f\xc6\x87i0+3\xd1v@\xec\xa3%y\xfb\x0e\x13g'
 b'_J\x16\xbbg\xe6I\xd4\xe1\xbd\x00\x00\x00\x03\x00\x00\x00v\xe4slc\x00\x00'
 b'\x00\x82?s\x8eF:\xf6\xa3\xb1X\x88\x94\xcc')

{'A1': [{'B1': 761725264,
         'B2': -0.7628212073813911,
         'B3': {'C1': 3440181361501958623, 'C2': 21949}},
        {'B1': -457489362,
         'B2': -0.5879458171875618,
         'B3': {'C1': 16563635153900395054, 'C2': 32710}},
        {'B1': 1039318288,
         'B2': 0.18646541553306384,
         'B3': {'C1': 9757383029785982528, 'C2': 60579}}],
 'A2': {'D1': 'slc',
        'D2': {'E1': 1238688189,
               'E2': [628751118, 325541706, 381380582],
               'E3': 228},
        'D3': 0.9513896703720093,
        'D4': 4248763280560526540},
 'A3': [0.2826678925463564,
        -0.006905541247129499,
        0.7862642996138505,
        0.5880906184813883,
        0.26148003526439245]}

(b'CFA\xbbC\xbe\x16\x15?\xc5!\xdf\x91\x1a\xd7\xb8\x00X\xa0\x16\x85\xa6\xbf\xe5'
 b'\x02\xd6\x15\xc6\xd6\n\x00btV \xad?\xebk7\xadI\xa9\xfe\x00l\x00\x97'
 b'?\xe5\x8b\xd2&?\x94p\xbf\xe4{5\n\xe0\xc2\x1c\xbf\xe0\xd0\x89%%\xee\xc0'
 b'\xbf\xb4g\x18\x95mmP\xbf\xa8*/\xa1\xbc\x1a`\x1d\xd0\x8cK\x08\x08\xcf\x85'
 b'"\xd6\x96\x83\xae\xe5\x155R 8-\x0b\x85\xbeGyC\xb2z\xb1(YH\xf9\x00\x1d\x9f'
 b'\xa4\xab\x17%\xce\x91\xa4Y@\xe6\xefP\x8c:\xd5\t\x04\x07\x00\x00'
 b'\x00\x05\x00\x00\x00v\xf0dna\x00\x00\x00\x8a?D\x03\xe4\xea5$\x1a\xb2D'
 b'\x1d\xba')

{'A1': [{'B1': 1136530965,
         'B2': 0.16509623131940798,
         'B3': {'C1': 2148371276140957573, 'C2': 8918}},
        {'B1': -1609136730,
         'B2': -0.6565962243391266,
         'B3': {'C1': 10845704626564846112, 'C2': 14381}},
        {'B1': 1951801517,
         'B2': 0.8568380722547884,
         'B3': {'C1': 830278920506159738, 'C2': 45352}}],
 'A2': {'D1': 'dna',
        'D2': {'E1': -720829433,
               'E2': [1497954560, 497001643, 388353681, 2757312742, 4015033402],
               'E3': 240},
        'D3': 0.7656843662261963,
        'D4': 16876434875719359930},
 'A3': [0.6733179804838425,
        -0.6400399410686677,
        -0.5254560208845405,
        -0.07969812057620129,
        -0.04719685410787089]}

Вариант №37

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

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

(b"ZUFL'\x9b\x9f\x1c\x00\x00\x00\x02\x00S\x00g\x00\x03\x00\x00\x00z?=f\xd9oa"
 b'\xb9\x84Gi>\x02\xcc\xa5\xbc\x05\x84\xbe\xd4%\x00\x00\x00\x02\x00\x00'
 b'\x00\x1a\x00\x00\x00\x1cexe\xdfY@\xf3O\x90-6\xe4N\x0b\xa9\xd6\xab\x00'
 b'\x00\x00\x03\x00\x00\x006\x00\x00\x009\x00*\x00G\x10\x84Ib\x92\xb4-]Q'
 b'R\xa5\xa0\xf5\x02\r&\x0e}\x9c\xbf\xdbV;\xb9\x84\xf3\xe4\x00\x00'
 b'\x00\x04\x00\x00\x00WLV?R\\\xf4\xfc\xde\x81Rt\x04')

{'A1': 664510236,
 'A2': [{'B1': 'oa',
         'B2': {'C1': 47492,
                'C2': 1198079490,
                'C3': 52389,
                'C4': 3154478270,
                'C5': 54309}},
        {'B1': 'exe',
         'B2': {'C1': 57177,
                'C2': 1089687440,
                'C3': 11574,
                'C4': 3830320041,
                'C5': 54955}}],
 'A3': {'D1': 3709,
        'D2': 156,
        'D3': -0.4271382629120224,
        'D4': [277104994, 2461281629, 1364370848, 4110552358]},
 'A4': [1280720722, 1559559390, 2169664516],
 'A5': 0.7398505806922913}

(b"ZUFL\x0e:%'\x00\x00\x00\x02\x00S\x00k\x00\x02\x00\x00\x00~=\xcd\xcb\xeari"
 b's\xb0\xfc.s\xd9\xa8\xe3\x05\xd3g@W*3\x00\x00\x00\x03\x00\x00\x00\x1a\x00'
 b'\x00\x00\x1drp\xa6^\xb1\xf6f\xf3\xcf\x9e\x08\x06^\xa4\x97\xb2\x00'
 b'\x00\x00\x02\x00\x00\x007\x00\x00\x009\x00+\x00G\x9b\xa9\x04\xf2S'
 b'\x0f\xb2\x8d\xb1\x9aH\x7f\xb2Q\xe4\xfd\xa9\xee{P\x84\r,\xbf\xb0.\xfeS\x92'
 b'\xf0p\x00\x00\x00\x05\x00\x00\x00Wf/\x0c$,\xea\x173')

{'A1': 238691623,
 'A2': [{'B1': 'ris',
         'B2': {'C1': 45308,
                'C2': 779344296,
                'C3': 58117,
                'C4': 3546759255,
                'C5': 10803}},
        {'B1': 'rp',
         'B2': {'C1': 42590,
                'C2': -1309251853,
                'C3': 53150,
                'C4': 134635172,
                'C5': 38834}}],
 'A3': {'D1': -31731,
        'D2': 44,
        'D3': -0.0632170633352318,
        'D4': [2611545330, 1393537677, 2979678335, 2991711485, 2850978640]},
 'A4': [1714359332, 753538867],
 'A5': 0.10048659145832062}

Вариант №38

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

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

(b'VHI\x15\x00C\x00\x03\x00\x00\x00[p\xa4\xb5\x9fmJ2H\xfd \x0f\xfb\x91\xd9\x96u'
 b'l\xbf\xe3\x08\xefj\xc7\x99\xea\x00\x00\x00\x02\x00\x00\x00\x1b\xe4Y\x05'
 b'\x8aj\x0ci4\x0c\xc0\xc3\x9a@i\xc2%\x81\x86\xba\n[\xcc\xcd\x97\x00\x00\x00'
 b"\x1d\xbe=\xc7e\xde'=\xe8@\xee\xb5t?6\xaa\xe4+\xff\x00\x00\x00I\x00"
 b'\x00\x00O\x00\x00\x00U')

{'A1': {'B1': 52631,
        'B2': {'C1': -0.5948407254734864,
               'C2': 'ul',
               'C3': [-463927926,
                      1779198260,
                      213959578,
                      1080672805,
                      -2121876982],
               'C4': 23500}},
 'A2': [{'D1': -0.18533094227313995, 'D2': 56871},
        {'D1': 0.11340509355068207, 'D2': 46452},
        {'D1': 0.7135450839996338, 'D2': 11263}],
 'A3': 1889842591,
 'A4': [27978, 12872, 64800],
 'A5': 268145113,
 'A6': 150}

(b'VHI\x15\x00D\x00\x04\x00\x00\x00bF\xe9W\xc3\xf6\xfa\x17\\\xb9\xb9\x12I'
 b'9\xd6@svn\xbf\xe3k9\xdc\xcf\xb0\x0e\x00\x00\x00\x03\x00\x00\x00\x1b\xd1\xd4'
 b'\x90\xfb\x96\xbc\xf3\x0f\x1bq\xd2a,\xa5ze\xc8\xe5!\x01\xf9\xcb'
 b'\xe0\xf2\x00\x00\x00\x1e>\xca\xebj$\xfe>\x8d\xba\xfaJ\x1f\xbe\x83wu5\x03'
 b'?\x1a(\xf0\xb3\x12\x00\x00\x00J\x00\x00\x00P\x00\x00\x00V\x00\x00\x00\\')

{'A1': {'B1': 57586,
        'B2': {'C1': -0.6068391144485774,
               'C2': 'svn',
               'C3': [-774598405,
                      -1766001905,
                      460444257,
                      749042277,
                      -924507903],
               'C4': -1589}},
 'A2': [{'D1': 0.39632731676101685, 'D2': 9470},
        {'D1': 0.2768171429634094, 'D2': 18975},
        {'D1': -0.2567707598209381, 'D2': 13571},
        {'D1': 0.6021871566772461, 'D2': 45842}],
 'A3': 1189697475,
 'A4': [63226, 5980, 47545],
 'A5': 306788822,
 'A6': 64}

Вариант №39

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

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

(b'\xf2PXX\x02\x00S\x00\x00\x00&O\xe1\xf6\xe5\xa6z\xdbO\x83\xa21\xb5\xd7'
 b'W\xa9P\x12\xc1\xfe\x84\xa5\xa8\x13\xdc\xf0\x0f3\x1e\xbf\xac\xcbW\xbe'
 b'\x04\x1a}\xbff\x03\x13\xdb\xe5\x13\\\x10\x08\xbb[\r%\xd5\xbe\x08\xecjsz'
 b'\xeb\xbf/\xfe\xad\xee>\x04\x00\x00\x00i\x00\x00\x00\xd47.\x1fc\xd6?x\x19'
 b'\x86LC\xb4\xdcLd$\x88V\x15\x7fs\xf7n-\x07\xf9,\xc6/')

{'A1': {'B1': [{'C1': 212, 'C2': 1835287038172016183, 'C3': -122, 'C4': 76},
               {'C1': 67, 'C2': 1537566012676562100, 'C3': 127, 'C4': 115}],
        'B2': {'D1': 15815136548084600614,
               'D2': [79, -125, -94, 49, -75, -41, 87, -87],
               'D3': 4688,
               'D4': {'E1': 17355768679031439041,
                      'E2': [-0.6179665923118591,
                             -0.21073788404464722,
                             -0.9886782169342041]},
               'D5': 870,
               'D6': 56083}},
 'A2': [5093, 4188, 47880, 3419, 54565],
 'A3': -0.8586976135559536,
 'A4': 47,
 'A5': 0.4661712050437927,
 'A6': [28407, 1837, 11513, 12230]}

(b"\xf2PXX\x03\x00S\x00\x00\x00\x15\xac\xfbMM\xeb:'\xf2b\xf7{\x0f\xd3"
 b'\xf7\xa7\xe7\xd4\xa5\r\xcf?s\xb5XI\x07\xcb1?0DC=\xdf\xac\x18?'
 b'\x92\x95\xd5\xcca\x0bA~"\xb7\xd6\xa0\xd0\'\xc0\xc8\x07\x0bt\xd6\x99?A]'
 b'W\x00?\x05\x00\x00\x00t\x00\x00\x00\xe5\xa1\xee\xa1a\xa9c\xd7\x99'
 b'\x88L\xb2\x93\x9d\xe3\xd3\xcc\x14\r\xa8\x85\xc6\xe0\x97\xd3\t\x1e4\xda'
 b'L^x\xda|\x14\xe7\xddN\xdcU\x02\xbe\xf2')

{'A1': {'B1': [{'C1': 229, 'C2': 11085438586934390433, 'C3': -120, 'C4': 76},
               {'C1': 178, 'C2': 12109357843029925267, 'C3': -123, 'C4': 198},
               {'C1': 224, 'C2': 6795045855172350871, 'C3': 120, 'C4': 218}],
        'B2': {'D1': 2826830433381755925,
               'D2': [-14, 98, -9, 123, 15, -45, -9, -89],
               'D3': 54503,
               'D4': {'E1': 5285173669315677605,
                      'E2': [0.6945042014122009,
                             0.04767245054244995,
                             0.5963878035545349]},
               'D5': -27246,
               'D6': 52437}},
 'A2': [2913, 32321, 46882, 41174, 10192],
 'A3': 0.025232136891596424,
 'A4': 65,
 'A5': 0.5013330578804016,
 'A6': [5244, -8729, -9138, 597, -3394]}

Вариант №40

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

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

(b'rDFGBo\r\x99\x00q\xb6O\x02WY\x05\xa5\xf9H)\x81Vj2\xc5\x0ba+I\xdc\x8b\x0b'
 b'T\x02\x00\x00\x00\t\x00\xa4\x12cIHs\xe9?\x0b\x00\x84\xb5\xd5\xf7p\x15\x87'
 b'7\x181I\x8d&h\xe3\x8b\x8c\x12\xd5u\xfc\x9a\xc82\x02\x00\x00\x001\x00\x00'
 b"\x1c\x04\xed\xff\x05\xd8\xbf3\x009\xe72\x1cW\xe8\xbd\xfb!'\xdbJ}\x08\x1b"
 b'\xaa\xf5[K|\x16\xdf\x1bU\x02\x00\x00\x00Y\x00\xfc\x0bV[\xce\xa8\xd5?['
 b'\x00G\xa0\xbd\x10I\xf6\x02\x0b<XGjC\x1eb\x03\xf8\xbb\x8b\x97\xff\xb7\x08'
 b'2\'\x00O\x00w\x00\x04\xfd\xadFw\xb1\xd1\xbfM\xff\x9fs\xa6"\x12\x8b6'
 b'I\x04\x00\x81\x00\x04\x00\x91\x00\x00\x00\x0b\xac{\xf3')

{'A1': 111,
 'A2': 13,
 'A3': {'B1': [{'C1': 0.7953225549068361,
                'C2': {'D1': 591,
                       'D2': 87,
                       'D3': 1369,
                       'D4': 692648357,
                       'D5': 3125792557954127489,
                       'D6': 73,
                       'D7': 1410042844,
                       'D8': [113, -74]}},
               {'C1': -0.3753661932573209,
                'C2': {'D1': -2091,
                       'D2': 112,
                       'D3': -30955,
                       'D4': 1227954231,
                       'D5': -3093255461606513011,
                       'D6': 117,
                       'D7': 852007676,
                       'D8': [-124, -75]}},
               {'C1': 0.3384281055406857,
                'C2': {'D1': 7218,
                       'D2': 87,
                       'D3': -16920,
                       'D4': -618192389,
                       'D5': 5430203886672051530,
                       'D6': 124,
                       'D7': 1427889942,
                       'D8': [57, -25]}}],
        'B2': {'E1': -0.2764566602927092,
               'E2': -8425633854556995763,
               'E3': 18742},
        'B3': [280862791, 184743497, 1783060540, 56761923],
        'B4': [48120, 38795, 47103, 12808],
        'B5': 4084968459}}

(b'rDFGB)\xb3\x93\x00\xd0\x0e\x9ef\xa6\x99pmy\x87<\x98p\xa8cC[U\x05'
 b'\x02\xabB\xb8\xfd\x02\x00\x00\x00\t\x00X\xc4d\xdd\x11*\xeb?\x0b\x002\x92\x90'
 b'\xb4\xf0F\x12\x10;\xaaJ8\xcfo\xc0v\x08&\xc4\x9dc\x86\x9d\x13\x02\x00\x00'
 b'\x001\x00$\xaal\x90\xc4\xb1\xdf?3\x00v\x7f\x8d?\xb2R\xc2\xe0\xb8\xc2>'
 b'A}\xfc\xe6.p\xae\xca\xec\xe0\xb3\xf2D\x02\x00\x00\x00Y\x00\xa4\xad\x95d+'
 b"U\xd4?[\x00$3\xb5\x93sz\x8ez\x18\xd5\xc4V\x82\x00b=\x00%'\x00O\x00w"
 b'\x00d}\x03\x81\xbc\xa8\xe6\xbf|/\\\xbd\x0e\xc9\xda\xea\xaeG\x02'
 b'\x00\x81\x00\x05\x00\x89\x00\x00\x00D*\xbf^')

{'A1': 41,
 'A2': 179,
 'A3': {'B1': [{'C1': 0.8488854717344436,
                'C2': {'D1': 26270,
                       'D2': -90,
                       'D3': 28825,
                       'D4': 1015511405,
                       'D5': 384313688202965144,
                       'D6': 2,
                       'D7': -38255957,
                       'D8': [-48, 14]}},
               {'C1': 0.4952250872035242,
                'C2': {'D1': -19312,
                       'D2': -16,
                       'D3': 4678,
                       'D4': 1252670224,
                       'D5': -4312750287032955080,
                       'D6': -99,
                       'D7': 329090659,
                       'D8': [50, -110]}},
               {'C1': 0.31769833395693525,
                'C2': {'D1': 16269,
                       'D2': -78,
                       'D3': -15790,
                       'D4': 1052948704,
                       'D5': -3842010085354341055,
                       'D6': -20,
                       'D7': 1156756448,
                       'D8': [118, 127]}}],
        'B2': {'E1': -0.7080976981923581,
               'E2': -1523684458767831172,
               'E3': 18350},
        'B3': [2478125860, 2056157811],
        'B4': [54552, 22212, 130, 15714, 9472],
        'B5': 1589586500}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поле	Описание
1	Адрес (uint32) структуры F
2	Структура G
3	double
4	int8
5	Массив double, размер 8

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

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

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

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

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

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

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

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

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