ИКБО-20-22

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

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

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

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

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

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

(b'\x91HTSM\x03\x00\x1c\x008\xb4\x92D\x03\x8f\xd1\xbf\xaa\x1f\x00<\x00g\x00'
 b'\xbe\xa8M?zah\x08\xd9h\xb7\x9f\xc8\xfc\x94\xa1\x8c\xbd\x8fR\xfag\xbfX'
 b"\xf7\x1e\x95V\x0c,\x97T\x8b<\xdc\xbf\x91\xc5\xd7GC\x9d\xe7\xbc'v\x1f5\xdbVS?"
 b'\xd9\xec\xf2/\xde\xc0\xe3\xd9\xc6XH\xc5\xbf\xd6\xd6Q\xd7|g\x19)I-\xf3'
 b'7\xd5n\xc7\x8ch\xa3ae\xd5!\xed\x80\xd9\xe7#\xa6\x8e\xea\x0f>\xbe\xd8\x81'
 b'\x06j\xe5\xf8\xc8D\xb2\x86\xaar\xd5Fy\x17VY\x90\xdaY6x\xcfN\xdeU\xc0\x97\x03'
 b'\x00Y\x00\x00\x00\x88\xa7\x08\xe3\xc1\xb2\xc3\x84\xe9\xe2\x02\x00\x00\x00e'
 b'\x00\xe8\xd3sZ')

{'A1': 'zah',
 'A2': -0.27435380646312835,
 'A3': 170,
 'A4': [{'B1': {'C1': 10735676200046876936,
                'C2': 2411564193,
                'C3': -0.9061633348464966,
                'C4': -1793132712},
         'B2': 86,
         'B3': -0.44119532833855213},
        {'B1': {'C1': 13612021311044306321,
                'C2': 891254311,
                'C3': 0.8255440592765808,
                'C4': 804449497},
         'B2': 222,
         'B3': -0.16627034863975432}],
 'A5': {'D1': [2437966243318762695,
               -1545114948997644051,
               -1915711536735830513,
               -3066200900792694536,
               6474646127669377350,
               -7511909765160667082],
        'D2': [-682502442, 689530748, 938683721],
        'D3': 9566686579272492936,
        'D4': 58089,
        'D5': [-43, 110],
        'D6': 1517540328},
 'A6': 0.8033560514450073}

(b'\x91HTSM\x03\x00\x1c\x00\x84\xc0-\x96w\x06\xd7?\xea\x1f\x00<\x00g\x00'
 b'\xa9{\xb5=epg^3X\xcb\xee\x87\xbbe\xeer\x1c\xabg\x7fL\xbf\xdd-PbA'
 b'\x8c\xac\xc1y\x92\x87\xea\xbfQ\xc3\xb56\x7fp\xdb\xb8)\xc4 \xad\x88QN\xbe'
 b'\xaf\\.\x9f\x7f\x9e\xc1Q\xa8\xbd\xa0\xe3\xbfgSW\xf0\xce\x84\x00R\xd9\x16\xea'
 b'n\xc3\x04A\xed#\xd4\x84\x8f<\xbe0\xbc\xdf\xf0\xe1\xf3N\x1c\xb1X\xf5e4'
 b'f\xc3\n\xa3nLV\xc4O\x0c\x01\x1f\x92\xdf\x17\x1e\x0e\x05\x08\x1a'
 b"\xc8\xf6\xb3\xbe's9\x02\x00Y\x00\x00\x003iA\xecS_b\xd5\x0e\xd2\x06"
 b'\x00\x00\x00a\x00s\xf3\x94e')

{'A1': 'epg',
 'A2': 0.35976972261324414,
 'A3': 234,
 'A4': [{'B1': {'C1': 7330602278159135582,
                'C2': 2870768366,
                'C3': -0.7988190054893494,
                'C4': 1649421789},
         'B2': 65,
         'B3': -0.8290493372018246},
        {'B1': {'C1': 13320364014559413073,
                'C2': 2904605737,
                'C3': -0.201482892036438,
                'C4': -1624351569},
         'B2': 127,
         'B3': -0.613371685742141}],
 'A5': {'D1': [-4738754907243025087,
               2039835832979799088,
               775575936072767665,
               75522998438489763,
               577883649599312415,
               4139696182500182042],
        'D2': [-262712473, 1375765710],
        'D3': 15375956891846928691,
        'D4': 53774,
        'D5': [-39, 22, -22, 110, -61, 4],
        'D6': 1704260467},
 'A6': 0.08861476927995682}

Вариант №2

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

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

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

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

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

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

(b';UBZQ\x00\x00\x00g\x00\x00\x00p\x00\x00\x00y\x00\x00\x00\x82\x00\x00\x00'
 b'\x8b\x00\x00\x00\x94\x00\x00\x00\x9d\x00\x00\x00\xa6\xbd\xa8"\xa0q2\xe1'
 b')q\xf6\xa2\xd2`\xba\x92J\xe1\xdd\xb3<\x00\x00\x00\x02\x00\x00\x00'
 b'\xaf\x00\x03\x00\x00\x00\xb1\xeb\x99I\x81\xe1\xde\xf9S-\xec\x91\x94\xfa'
 b'\x9dI\x97\xcfyy\x97vVr\xf6\xbe*#\x88h\xeaB\xdf\x9c\xbf\xe8\xd5w\x1d{,\xbc'
 b'L\xbf\xee\xbe\xc8\xad\xbc\xec\xe0I\xbf\xed\xfa\x88-^\xe2\x12\x15?'
 b'\xd45\xa2\xa6\x16\xdb\xe8\x16\xbf\xe4Rp||\xb5\xe0\x0c\xbf\xe9q'
 b'\xf9\xdc\xd2\xedR\xf8\xbf\xe8\x80\x19\x1e\x8c\xdc\xa07\xbf\xe6^UW|\xc9\x80k'
 b'rj\xc3qu\x91\x99\xd5\xb3\x1b\x1c\x01\xc6\xad!\x8b1\x0b\x0f\xa5\xc2\xb7\xe9K'
 b'\xf3')

{'A1': [{'B1': 156, 'B2': -0.7760577750972497},
        {'B1': 76, 'B2': -0.9607890504188639},
        {'B1': 73, 'B2': -0.9368325124879127},
        {'B1': 21, 'B2': 0.31577364177377243},
        {'B1': 22, 'B2': -0.6350634032621052},
        {'B1': 12, 'B2': -0.7951630890815216},
        {'B1': 248, 'B2': -0.7656369778332142},
        {'B1': 55, 'B2': -0.699015303491521}],
 'A2': 13666211141745041705,
 'A3': 8211929995006349898,
 'A4': 3789402940,
 'A5': 'kr',
 'A6': {'C1': [7693117338246829491, 1953438291191761713, 797037914795625459],
        'C2': {'D1': [3952691585,
                      3789486419,
                      770478484,
                      4204611991,
                      3480844695,
                      1985377014],
               'D2': 190,
               'D3': 42,
               'D4': 9096,
               'D5': 1760183007}}}

(b';UBZQ\x00\x00\x00g\x00\x00\x00p\x00\x00\x00y\x00\x00\x00\x82\x00\x00\x00'
 b'\x8b\x00\x00\x00\x94\x00\x00\x00\x9d\x00\x00\x00\xa6\x0c9\x96\x11V\x9f%'
 b'\xf2\x1fG\x83\xc8\xc5\x05\xff5}N\xa4\xb0\x00\x00\x00\x05\x00\x00\x00'
 b'\xaf\x00\x03\x00\x00\x00\xb4\xb3\t\x005B\x06\xfc\x19\xd3\xc0\xe1\xd7|'
 b'\xe8#\x1f7\xdd\xed\xe6c\xc9L\xe4\xb7]$\xbb\xd7\xf1\xb2\xd3\x8e?\xe5\xa7\r'
 b'\x84\x13.\xec3\xbf\xcd\xd6\xf0\x13\xf40\x80p?\xeb\xe7\x87\x88\x8a\xceD2\xbf'
 b'\xe0\xc6la\xd4\xe4\xc4\x0f?\xe7\xe3\xf7\x0ev\xe1\xa2m?\xc0\xddJ \x81\x9d'
 b'(\x14?\xe8\x04E\xbf\xb1\x80\xb2\xaa\xbf\xed?p{7]\x9eqaysw0\x8a\x96]'
 b'@B\xfd\xb5\xc0&\x1e\xc2\x85X\xfd$^M\xa4X\xeb,\xb2\xe7')

{'A1': [{'B1': 142, 'B2': 0.6766421870792931},
        {'B1': 51, 'B2': -0.23312188123998467},
        {'B1': 112, 'B2': 0.8720128695335423},
        {'B1': 50, 'B2': -0.5242216025136703},
        {'B1': 15, 'B2': 0.7465777666575841},
        {'B1': 109, 'B2': 0.13175322138997925},
        {'B1': 20, 'B2': 0.7505215400706418},
        {'B1': 170, 'B2': -0.9139940649574105}],
 'A2': 880900203339523570,
 'A3': 2253915036844425013,
 'A4': 2102305968,
 'A5': 'qaysw',
 'A6': {'C1': [3497773387860868533, 13845787925206859044, 6795268114581598951],
        'C2': {'D1': [3003711541,
                      1107754009,
                      3552633303,
                      2095588127,
                      937291238,
                      1674136804],
               'D2': 183,
               'D3': 93,
               'D4': 9403,
               'D5': -672025901}}}

Вариант №3

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

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

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

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

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

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

(b'\xfcKVUZ0\x95\xd0\x80~\n\xe8f\x00t]\xbe\xf2-<\xe5\x81?p\xf2J\xa9\xed'
 b'B\x96\xde\xbfs\xef\x96\xc9\x7f\xbf\x12\x1a\x05\x1d\xb0/\x88\xa0\xbd\xae'
 b'\xa5q\x85k?y\xdd\xd4_\xc0\xd9A\x00\x0f\x00\x1e\x00-mtt\x95\xbd\x8b\xf3GB\xf9'
 b'\xbcC\x8bn\xe9\x1e\xab3v\x998\x0c7\x00\x00\x00\x02\x00Ea\xa4(\xbf4'
 b'\x8e\xa3\x00\x06\x00\x00\x00M\x1a\xec \x8e\xb6#\xa6w\x00\x03\x00\x00'
 b'\x00<\x00\x03\x00B\xbfY\xd1.\xe8\xd1 \x00\x00\x00\x00Yi\rz\xc1\xe0\xdb')

{'A1': 3500933535639464038,
 'A2': {'B1': [{'C1': 93,
                'C2': -0.4730013608932495,
                'C3': 58753,
                'C4': 0.9411970376968384,
                'C5': -1444068714},
               {'C1': -34,
                'C2': -0.9528745412826538,
                'C3': 51583,
                'C4': -0.5707095265388489,
                'C5': 498085768},
               {'C1': -96,
                'C2': -0.08527649194002151,
                'C3': 34155,
                'C4': 0.9760410785675049,
                'C5': 1606474049}],
        'B2': 'mtt',
        'B3': -0.0015757520771035871,
        'B4': {'D1': [-1782739981, 1195571644],
               'D2': 1638148287,
               'D3': 13454,
               'D4': 163,
               'D5': [17291, 28393, 7851, 13174, 39224, 3127],
               'D6': 1939961336803075703},
        'B5': 26893,
        'B6': 2059526363}}

(b'\xfcKVUZ7d\x9e\x11:\xe1\xa5\xe4\x00\x81\x07\xbfh\xe5\x82\x05\x89>\xbb\xec`u^'
 b'\xb7\xc7\x91\xbfwJ\x88\x9b\xd0>\xea\xda[oDK\xf0\x98\xbe\xd3\xf4&\x13h'
 b'\xbe\xb8\xea\x02}\xc7-&w=\xd6\x9f\x8f\x8fB\xbf\t\x9a\x0ez\xea\x02\xde\x00'
 b'\x0f\x00\x1e\x00-\x00<trf\xb7/\xda_\xa1C\x9d\xab\x10\xb5\xebo\xd9H'
 b'\x96\xce\x00\x00\x00\x03\x00V\xb3V\xe7\xe7P|:\x00\x02\x00\x00\x00'
 b'b\xfc\x95\x07\xa6\xae\x8ay\xa7\x00\x04\x00\x00\x00K\x00\x03\x00S?'
 b'\xea\xc0\x9dfy\x8dx\x00\x00\x00f\x1c\x16_\xec\xa32')

{'A1': 3991488966596601316,
 'A2': {'B1': [{'C1': 7,
                'C2': -0.9097520112991333,
                'C3': 1417,
                'C4': 0.3670377731323242,
                'C5': 1969141703},
               {'C1': -111,
                'C2': -0.9659810066223145,
                'C3': 39888,
                'C4': 0.4586971700191498,
                'C5': 1866746864},
               {'C1': -104,
                'C2': -0.41397207975387573,
                'C3': 4968,
                'C4': -0.3611603379249573,
                'C5': 2110205222},
               {'C1': 119,
                'C2': 0.10479652136564255,
                'C3': 36674,
                'C4': -0.5375069379806519,
                'C5': 2062156510}],
        'B2': 'trf',
        'B3': 0.8360125543080548,
        'B4': {'D1': [-1221600673, -1589404245, 280357743],
               'D2': -1286150169,
               'D3': 20604,
               'D4': 58,
               'D5': [55624, 38606],
               'D6': -246282192147547737},
        'B5': 7190,
        'B6': 1609343794}}

Вариант №4

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

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

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

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

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

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

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

(b'YWO\xbf\x92jcXHH@\xbfa\xda\xf5ZYc\x16p\x1e\xa7[\xf4\xa9cQ\x00\x8bld\n'
 b'\xf8\xbfL\xf1\xb0a\xe6\xc1\xbf]uEZ\x00\xc4\xbe \xb3U\xe3\x01\xcf\xbf9'
 b'\x8e\x04\x90y\xff\xbfA\xc3\xab\x90\x0br\xbfJ\x86\xa7\xb4OQ\x16r\xc9\x7f\x95'
 b'>\x9bi\xe5Ujx>\x91\xd9\x0c&Q\xc9ip\xcf\x1b\xfc_[f\xf17\x17jy\xa7'
 b'\x00\x02\x00\x00\x00I \x16\xecd\x8d\x96`\xc3Yq\xa8\xaf7\x02q\x90\xb6\xa5'
 b'2\x84\x18\x00\x02\x00v\x00\x00\x00\x02\x00\x00\x00\x1d\x00\x00\x00\x06\x00'
 b'\x1f\x00\x00\x00K\x00~7\x07\x93s8\x86T\xb9\x893\x1b\x91')

{'A1': -0.017983963263823677,
 'A2': -0.882247269153595,
 'A3': 1515807510,
 'A4': 8079078794937852753,
 'A5': {'B1': 'ld',
        'B2': [{'C1': 2808, 'C2': -0.800562858581543, 'C3': 97},
               {'C1': 59073, 'C2': -0.865070641040802, 'C3': 90},
               {'C1': 196, 'C2': -0.15693409740924835, 'C3': -29},
               {'C1': 463, 'C2': -0.7248232364654541, 'C3': -112},
               {'C1': 31231, 'C2': -0.7568919062614441, 'C3': -112},
               {'C1': 2930, 'C2': -0.7911171317100525, 'C3': -76}],
        'B3': {'D1': 1617576765981367145,
               'D2': 3847580280,
               'D3': 0.2848590612411499,
               'D4': 2761209501256195068,
               'D5': 6871198842681256569,
               'D6': 167,
               'D7': [79, 81],
               'D8': [32, 22, 236, 100]},
        'B4': {'E1': 55,
               'E2': 176080974574158872,
               'E3': [2375442627, 1500620975]},
        'B5': 923243379,
        'B6': 4073036068850703249}}

(b'YWO?\xee\xcf\x9a\xd13\n4>\xfc\x0eQrp\x9eh\xe9\x84QMa\xb5\x14\xf3\x00\x9bwoz'
 b'\x85\x0f\xbe\xb5}*\xe2F\x9c?\x1d\x0f\xa7\xd1\xdd\xdb\xbf\x1c\xd9\x01'
 b'\xee\xfe&>\xd7\xf9q\xbd\xbf\xb4\xbfIA\t\x05F\x9e?v\xb0z\x1c;c>\x04J\x8d'
 b'\x02\xcaHl\xe0C\xf0\x9f\xde+\x13\x1ar=F>\xd3\xbb\xf5\xf1\xa6\xda\xc3C\xe4ucA'
 b'\xd0J\xc7\xa8\x02?&J\x00\x02\x00\x00\x00QY\x8c\x9e\xc7CG\xe4%\x93l!\xc1\x19f'
 b'A\x820$\xe2\x9c\x19\x19\x98\xb7\xb2\x8d\x84\xa8\x16\x00\x04\x00~\x00'
 b'\x00\x00\x03\x00\x00\x00\x1d\x00\x00\x00\x07\x00 \x00\x00\x00S\x00\x8e\xe7'
 b'j\xb7\xc6_\xf4\xfe\x1e\x95q\xc1"')

{'A1': 0.9628423772740633,
 'A2': 0.4922967255115509,
 'A3': 1919983208,
 'A4': -1620080573152946957,
 'A5': {'B1': 'woz',
        'B2': [{'C1': 34063, 'C2': -0.35447055101394653, 'C3': -30},
               {'C1': 18076, 'C2': 0.613520085811615, 'C3': -47},
               {'C1': 56795, 'C2': -0.6126862168312073, 'C3': -18},
               {'C1': 65062, 'C2': 0.42182496190071106, 'C3': -67},
               {'C1': 49076, 'C2': -0.7861486077308655, 'C3': 5},
               {'C1': 18078, 'C2': 0.9636303186416626, 'C3': 28},
               {'C1': 15203, 'C2': 0.12919063866138458, 'C3': 2}],
        'B3': {'D1': 7845345251632753427,
               'D2': 443694406,
               'D3': 0.41354337334632874,
               'D4': 17412845541467125091,
               'D5': 4742372628998799142,
               'D6': 74,
               'D7': [-54, 72],
               'D8': [89, 140, 158, 199]},
        'B4': {'E1': 25,
               'E2': 1844426024914561046,
               'E3': [1128784933, 2473337281, 426131842, 807723676]},
        'B5': 3882530758,
        'B6': 6914430735230288162}}

Вариант №5

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

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

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

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

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

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

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

(b'YZG\x0c/\xc2\xfb\x03\x05</?\x86\x00\x00\x00\x89\x9c\x9a!\x03\x00\x00\x00'
 b'\xa4\x00\x00\x00\xd4\xa44\xa3Y\xbcG\x04\x00\xb0\x00\x00\x00Nk\x90'
 b"\xc8Z\xa0\xa4R\xc0<\n'\xc7\xe1\xea?\x0cL\x8f\x91\xee\xa2\xde\xbfv5#T4\xe0s"
 b'6 \x1aE\xabxr\xda\xb2\x0b\xd4\x03\xdf\xc3\x87\xac\xe333\x9a\x0c\x15\x97Y'
 b"'U\x95No&\x0b\xb6\x9c\xea\xb6{O\xfd\x02\xccu\xbc\xef4\x80\xa6G}\xb4\xd5'6"
 b'4\xfd|\xb4\x0cQ\x951P\x0bF\x00\x00\x00R\x00\x00\x00^\x00\x00\x00j\x00'
 b'\x00\x00\x17(o\xe3\x02\x00v\x00\x00\x00\xcb:@:\xf7/x\n\x0eB@$\xceO`\x80'
 b'\x0fqf\x99C\xb8\n\x17')

{'A1': 12,
 'A2': -15825,
 'A3': 1019,
 'A4': {'B1': 1060060165,
        'B2': {'C1': [{'D1': 29664, 'D2': 8246, 'D3': 842976265457321242},
                      {'D1': 980, 'D2': 50143, 'D3': 1516756719221582983},
                      {'D1': 22935, 'D2': 21799, 'D3': 16905587260247723669},
                      {'D1': 31670, 'D2': 64847, 'D3': 11997647611578665986}],
               'C2': 3815712791,
               'C3': [18245267535101721927, 815206049933735036],
               'C4': 977287883},
        'B3': {'E1': 563780745,
               'E2': [175648759, 608190990, 2153795534],
               'E3': -44,
               'E4': 1503868068,
               'E5': 18364,
               'E6': [28943, -26266, -18365, 5898],
               'E7': 5955060919063046990}},
 'A5': 0.8400607836246294,
 'A6': -0.47869457449741115,
 'A7': [13686, 21539],
 'A8': 52}

(b'YZG\xb3\xff\x83\x8f\xeb\xa2\xf2#\xb3\x86\x00\x00\x00\xc1\xc2\x99\x01'
 b'\x04\x00\x00\x00\xa4\x00\x00\x003\x03\xe3\x89J\xb1\xcb\x05\x00\xb4\x00\x00'
 b'\x007\xe3\x8d\xf3g1\xb9k\xc2\xa8$\xb4\xd8\xca\xe8\xbf\xd0cR\xe8~\xad\xd7'
 b'?\x02\xa3\xb0\xf0h\xbf\xc3\xc05\x9cX\xd9\xf0\x89\xe7\x06\x9c\x1e\x82'
 b'\xf1s\xd7RWQXZ\x9f\x86\x8b\xf8\xa4f\x8d\x16\x1c\xd0\xd3ddA\xab%\x92\xb0\x12;'
 b'\xe6\xb2|\x0c\xc8;\xb3)\x9a*t\xce\x0bYU\x8c\x02)\xa9^X\xb7F\x00\x00\x00R\x00'
 b'\x00\x00^\x00\x00\x00j\x00\x00\x00\x9a\xec\xd8m\x02\x00v\x00\x00\x00'
 b'\xd0\x82\x92\xd1\xc6\xb6\xfb\x0c\n/"\x92V+\xe1d\xe7W\x04\x8a*\xc3\xcf\x89'
 b'\x102\x98K5\xdb')

{'A1': -77,
 'A2': -31745,
 'A3': -5233,
 'A4': {'B1': 3005477538,
        'B2': {'C1': [{'D1': 50111, 'D2': 13760, 'D3': 11242928099414333596},
                      {'D1': 33310, 'D2': 29681, 'D3': 9700571457747636951},
                      {'D1': 63627, 'D2': 26276, 'D3': 4712001971028760205},
                      {'D1': 9643, 'D2': 45202, 'D3': 4307706773296790290}],
               'C2': 1842932890,
               'C3': [6416449092445678003, 13211413587521866837],
               'C4': -778927408},
        'B3': {'E1': 26854081,
               'E2': [217822918, 2451713802, 1692478294, 2315540455],
               'E3': 51,
               'E4': 1250550531,
               'E5': 52145,
               'E6': [-15574, -30257, 12816, 19352, -9419],
               'E7': 7762289755287315255}},
 'A5': -0.7747615354940296,
 'A6': 0.3699643391387868,
 'A7': [41730, 61616],
 'A8': 104}

Вариант №6

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

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

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

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

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

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

(b'HNL\xf4\x02\x00\x00\x00\xb9\x00\x00\x00@\xcc\xc9U\xc0\x02?\xb0.r\xbfG'
 b'\x1d\xe9\xbe-\x14\xd3>>\xfa\x7f\xbfa!<\xbf\xf9\xf1#=\xd6Y\xec\x95\x0c'
 b'\xc34\x129\xd7\x90\xe5\x8b}Q^\xbd\x00\x00\x00mv\x17\xe9\x92\x15w\xbf0'
 b'\xe7\xdc\x1e\xb1`4\xdf2m\xaf\x0f\xaf2\x0cz\x02t\x02\x00A\x00\xeb\x8f\x11'
 b'\xef\x82@\x17\xa0\xd3P\x9cA\xe7J\x81\x02\x00\x00\x00?\x00\x00\x00'
 b'C\x00\x00\x00\x0e\x87\xa3\x0cbi\x18rG\xa9=?\n\xcey\xb9\xd2!\xe4\xf9'
 b'\x91\x80\xf8\x18\xc7\xbc\x17B\x90s\x02\x00~\x00\xaa\xc0\x8c\x1f\xc8\xb0'
 b'\x1d\xcc\xf4\xd3\x99\xcf\xc9\x83b\x02\x00\x00\x00|\x00\x00\x00\x80\x00\x00'
 b'\x00\xb3W\x15\xd6l\x00\xa9\x00\xae(\xf2\x96\xbe\xc3\xba?\x8c\xac\xa0'
 b'\xd7\x1e\xfa\\\xcf\xe8?\xbd\xe4\xbf')

{'A1': [{'B1': 'mv',
         'B2': {'C1': -0.9651728868484497,
                'C2': 59184,
                'C3': 7868596915023191772,
                'C4': 8359378051161591727,
                'C5': [23, 233],
                'C6': 11535759901633646571,
                'C7': [211, 80, 156, 65, 231, 74, 129]},
         'B3': 212043534},
        {'B1': 'bi',
         'B2': {'C1': 0.7408642172813416,
                'C2': 52746,
                'C3': -9182283407016412807,
                'C4': 8327228380726892792,
                'C5': [24, 114],
                'C6': 14708106331631173802,
                'C7': [244, 211, 153, 207, 201, 131, 98]},
         'B3': -703244365}],
 'A2': 64,
 'A3': -13876,
 'A4': [0.5107472538948059,
        -0.9460248947143555,
        -0.4553014934062958,
        0.41226330399513245,
        -0.9999121427536011,
        -0.7348843216896057,
        0.04002568498253822],
 'A5': 1311887850293975510,
 'A6': 6796351352484190009,
 'A7': {'D1': 174,
        'D2': -0.294816255569458,
        'D3': 2222421604078435011,
        'D4': -0.6481017634459072}}

(b'HNL\xf4\x02\x00\x00\x00\xb9\x00\x00\x00v\x8d\x1dh\xc5\x85>\xc0 \xd3>\xc7'
 b'\x91\xda>\xd4\xc6e\xbf;\xdd|?\x8a\xf3o?8\x06\x15?\x8cAw\xf5\xd2\xe8P\xf7\x19'
 b'\xac\xee\xc7\xa1nVZ\xbd\x00\x00\x00od~\x11\r\x14m\xbf\xf8G\xa2\x97e'
 b'\x05KY\x8e$\xec\x82%\xcb~\xe7\x80\xff\x02\x00A\x00\xc3\xcd\x03\xd7\xf2X\xe4'
 b'\xe1\xf1b\x1f\xff\xb5O\xae\x02\x00\x00\x00?\x00\x00\x00C\x00\x00\x00'
 b'\xa1\xae\x8e\xd8lq\xd6\x04Zk\r?k\xe5\xcbq\xccv\xf9\xae\xa8\xd6-ZF\xf79\x81'
 b'\xa57\x02\x00~\x00\xc0\t\x03!\xed\x83&\xa2a\xdc+\xf4\x9f,\x1a\x02\x00\x00'
 b'\x00|\x00\x00\x00\x80\x00\x00\x00\xa0\xdf\xc0bl\x00\xa9\x00\xd6_\xfd'
 b'\x85\xbe\x14\x04i\xab\xack\xc4\xc0\xfc\xc0\x8b^\xa57\xd1?')

{'A1': [{'B1': 'od',
         'B2': {'C1': -0.9260872006416321,
                'C2': 18424,
                'C3': 2634141010806282146,
                'C4': -35774265258835220,
                'C5': [126, 17],
                'C6': 16277232753236495811,
                'C7': [241, 98, 31, 255, 181, 79, 174]},
         'B3': -661737823},
        {'B1': 'lq',
         'B2': {'C1': 0.5524193048477173,
                'C2': 58731,
                'C3': -2978938767042383413,
                'C4': 4009753129204996653,
                'C5': [214, 4],
                'C6': 11684171337743665600,
                'C7': [97, 220, 43, 244, 159, 44, 26]},
         'B3': 1656807328}],
 'A2': 118,
 'A3': 7565,
 'A4': [0.26127171516418457,
        0.41235923767089844,
        0.4268934428691864,
        -0.8975651264190674,
        0.9877507090568542,
        0.9373098611831665,
        0.5821261405944824],
 'A5': 17820999718264062348,
 'A6': 6509511952533728281,
 'A7': {'D1': 214,
        'D2': -0.2616986930370331,
        'D3': -4556398533637766124,
        'D4': 0.2690213607120453}}

Вариант №7

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

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

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

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

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

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

(b'wPCTW\xe3\x05L_\xbf\xe4N`\xaf\xc5\x86z\x00\x00\x00\x07\x00\x00\x00'
 b',\x00\x02\x00\x00\x00k\x00\x05\x00\x00\x00\x8fh\xcdn\x9e\xd19@exqiwgr\xb3'
 b'\xbb\xbb\xe4r[]\x90S\x9b\t.\xbb\x05\xb9\xfd\xd8\x11\xb6\x86\xe7\xcb\xb9<\x0e'
 b'F\xce\xd0\x82\x1dq"\x96)XTj\xf1y\x19h\x1e\xe0\xa4R3\\\xc6\x9d\x9d\x9b\xf8X'
 b'\x1a~\xa7\x003?\xe6tO\x9d\x85\xfe\xf6\x00\x00\x00\x05\x00\x00\x00;\x00O?'
 b'\xc2\xb2x\xfd\xf0\xcd\x00\x00\x00\x00\x05\x00\x00\x00W\x12a\xa7\xfd\xff')

{'A1': -486192033,
 'A2': {'B1': -0.6345675881422743, 'B2': 'exqiwgr'},
 'A3': [{'C1': {'D1': 3015424996, 'D2': 1918590352},
         'C2': 0.7016981197957353,
         'C3': [1402669358, 3137714685, 3625039494, 3888888124, 239521488]},
        {'C1': {'D1': 2182967586, 'D2': -1775675308},
         'C2': 0.14607155227131585,
         'C3': [1794210073, 1746854052, 1379097798, 2644351992, 1478131367]}],
 'A4': [18, 97, 167, 253, 255],
 'A5': 1758293662,
 'A6': 209,
 'A7': 14656}

(b'wPCTW\x93\xb5>\xa6?\xe0\xe6\x89\x03\x94o\x14\x00\x00\x00\x08\x00\x00\x00'
 b',\x00\x02\x00\x00\x00d\x00\x03\x00\x00\x00\x88\x84\xd2%\x89\x13\xb28yshqzovm'
 b'a\xa8%\xd2I\xf0J\xe7\xf6m\xe5\r\x1eVZ\x87\xf8\xbeB\xb0\xb2\x9e\x1f\xd2'
 b'g\xa1&\xbb_U\x89\xb7\xd2[a\xc5\x17\x90\x98\xa1[\xef|\x14\xba\xe7\xb9\x7f'
 b'\x004\xbf\xe0h-\xa8\xc9$x\x00\x00\x00\x02\x00\x00\x00<\x00D?\xe0\xe6C'
 b"\xf7G\xe7\xfa\x00\x00\x00\x06\x00\x00\x00L'\xa9\x0b")

{'A1': -1816838490,
 'A2': {'B1': 0.528141505233608, 'B2': 'yshqzovm'},
 'A3': [{'C1': {'D1': 1638409682, 'D2': 1240484583},
         'C2': -0.5127170845600082,
         'C3': [4134397197, 508975751]},
        {'C1': {'D1': 4173218480, 'D2': -1298260014},
         'C2': 0.5281085805611376,
         'C3': [1738614459,
                1599441335,
                3529204165,
                395352225,
                1542421524,
                3135748479]}],
 'A4': [39, 169, 11],
 'A5': -2066602615,
 'A6': 19,
 'A7': 45624}

Вариант №8

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

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

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

Поле	Описание
1	Массив структур C, размер 3
2	uint8
3	uint8
4	double
5	uint64

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

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

(b'\xd4AYNK\x1a\x00\x00\x00f\x07M\xcfdA\x92\xbc\xa7\xa1\x0f%\xf5Pjr"\x06\x88'
 b"\xab>\xdd@M?e\x05?\r'\xe4\x9d6\xd5\xdf\xa4c\xf8U\xb0\x9a\x9c\x02"
 b'\x00\x10\x00\x1a\xcc%y\xa5\xc2\xee\xbf+\xf7\xb0\x89\x17\x85PoA\xbf:`\xde'
 b'\xbeA\x7f\xb3-o\xfb\xb4I\x14c%\x1b\xc2\xb7\xfc\xef\xb3\x04\x00\x12\x00|\\'
 b'9\x0f\xa1\t\xe6?4\xbabB\xff\t\x17\xb6\\?\xf8\x00\x9c>\xa1\x1eYA\x19\x1e\x8dR'
 b'\xf4\x91\xb5\xb0\x91\xd4\xf5\t\xb4\x04\x00\x16\x00\xf8\x10w\x04\x99\x8c\xdb'
 b'\xbf\x9d\xb2\x13r\xd6\xb5\xc8\x1d^\xb1\x81\xd1\x84\xb4\xe1\xbfd7\xb1'
 b'\x0b@\x16\x18+')

{'A1': {'B1': [{'C1': 0.3350221514701843,
                'C2': {'D1': 0.8017709851264954,
                       'D2': [101, 5, 63, 13, 39, 228, 157],
                       'D3': [54, 213, 223]},
                'C3': [25508, 22008, -25936],
                'C4': 156,
                'C5': [188, 167],
                'C6': -0.9612605444111779,
                'C7': -1984891093,
                'C8': -31465},
               {'C1': -0.7556047439575195,
                'C2': {'D1': -0.4343279004096985,
                       'D2': [65, 127, 179, 45, 111, 251, 180],
                       'D3': [73, 20, 99]},
                'C3': [6949, -18494, -4100],
                'C4': 179,
                'C5': [161, 15, 37, 245],
                'C6': 0.6886754319520061,
                'C7': 1113766452,
                'C8': 2559},
               {'C1': 0.8621534705162048,
                'C2': {'D1': 0.30469489097595215,
                       'D2': [161, 30, 89, 65, 25, 30, 141],
                       'D3': [82, 244, 145]},
                'C3': [-20299, -11119, 2549],
                'C4': 180,
                'C5': [80, 106, 114, 34],
                'C6': -0.43045640407605346,
                'C7': 1913893533,
                'C8': -18986}],
        'B2': 200,
        'B3': 29,
        'B4': -0.5532859889913586,
        'B5': 3105256407401838436},
 'A2': 1894,
 'A3': 1097125709,
 'A4': 146}

(b'\xd4AYNK\x18\x00\x00\x00\x93Ksg\x0c\\\x18\x068\x95\xe1M,\x12\x18'
 b'\x96\xdey\xbf\x04\xaan\xbf\xa8\xcd\xd4\xca\xc0\xe6\xca\xbb\xe0\xdd\xbc@'
 b'&\x94}\xbd\x00\x02\x00\x10\x00x\x9a\n\x9b\xa6#\xc9?\x7f\xe1\x01!\xb1\x0f;'
 b'z\r\xbeHY\xc4\xbe\xdc\xbc\xf1&z^\xa5t6\x1b\xe5\xa4\x92\xe5^\xa5\x9f'
 b'\x02\x00\x12\x00\xf4\xe8-\x8e\xdc\x87\xd1\xbf\x18\x9f\xc7\r&\x8f]X\xc6\xbeE-'
 b'X\xbf\x96\x98\\\x89\xc5\x0f\xdao%\x97\xcc\x06uB4\x92{\x04\x00\x14\x00:'
 b'\xf0\xce\xea\x80\xec\xe2?4\xb9\x95\x18N_\x83\x9e\xd0#U \xceX\xdc\xbf\xfb'
 b'\xbe\xc5\xd0k{\rA')

{'A1': {'B1': [{'C1': -0.9760526418685913,
                'C2': {'D1': -0.9322817325592041,
                       'D2': [168, 205, 212, 202, 192, 230, 202],
                       'D3': [187, 224, 221]},
                'C3': [16572, -27610, -17027],
                'C4': 0,
                'C5': [6, 56],
                'C6': 0.19640047617322742,
                'C7': 553771391,
                'C8': 4017},
               {'C1': -0.1381615847349167,
                'C2': {'D1': -0.38349366188049316,
                       'D2': [220, 188, 241, 38, 122, 94, 165],
                       'D3': [116, 54, 27]},
                'C3': [-23323, -6766, -23202],
                'C4': 159,
                'C5': [149, 225],
                'C6': -0.27391733059597745,
                'C7': 231186200,
                'C8': -28890},
               {'C1': -0.38739290833473206,
                'C2': {'D1': -0.844440758228302,
                       'D2': [150, 152, 92, 137, 197, 15, 218],
                       'D3': [111, 37, 151]},
                'C3': [1740, 17013, -28108],
                'C4': 123,
                'C5': [77, 44, 18, 24],
                'C6': 0.5913700662708898,
                'C7': 412465460,
                'C8': 24398}],
        'B2': 131,
        'B3': 158,
        'B4': -0.44292023808935443,
        'B5': 4687538490156891899},
 'A2': 19347,
 'A3': 1544316787,
 'A4': 24}

Вариант №9

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

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

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

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

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

Поле	Описание
1	float
2	int64
3	uint8
4	Размер (uint32) и адрес (uint16) массива адресов (uint32) структур E

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

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

(b'MCZG\x97\x8b\x02\x00\x00\x00Z\x00@eM@\ta4\xd9\xb5\xaa\x01\xd0\xcfY#\xbf'
 b'D\xf3\xf7\xa8\xbaY2\xc1\x7f\x0c\x9e\xf6T\x84\x90\x9c\x0e\xa8r?\xe3\\t\xa0'
 b'Z\x86h\xda\xc5\x02\x00\x00\x00q\x00\xf3\x86z\xc9$>\x17h;\t\x04\x00y'
 b'\x00\x02\x00\x00\x00\x99\x00\x8cCm\xbf\xb9\xa6Emj\xe0\x06\x92\x83'
 b'\x02\x00\\\x00\x00\x00\xec\x9fF\xeax\x03\x00f\x00\x00\x00^\x00\x00'
 b'\x00i\x00\x00\x00\xdd\x00\xed\xef\xa6\xe7T\xf7@\xff[!\x1a\xadz'
 b'\x9a\x9d\x8f\xe4\xcc\xea\xdf\x88\xae\xe9h\xd1^)8\x9e\x02u\xec\x15\xcef\x1bv'
 b'\xe1')

{'A1': 35735,
 'A2': 'mj',
 'A3': {'B1': {'C1': -2795502776328821440,
               'C2': -805197131,
               'C3': -0.638089120388031,
               'C4': -1460145340},
        'B2': 17770654922492238266},
 'A4': -1668250540,
 'A5': {'D1': 0.9478768110275269,
        'D2': -2708767452066194205,
        'D3': 197,
        'D4': [{'E1': -31854, 'E2': [-32, 6]},
               {'E1': 30954, 'E2': [-20, -97, 70]}]},
 'A6': {'F1': 7500532032128845555,
        'F2': 2363,
        'F3': [17822124329587769565,
               11131399756740034368,
               12576548158984982429,
               188649984731736297],
        'F4': [-837424011, -512353434],
        'F5': -0.926811933517456,
        'F6': -71,
        'F7': 17830}}

(b'MCZG\xc1\xd3\x03\x00\x00\x00Z\x00\x8eB\xe7\xfe\xf5\xbbA=\xc8\x8c\n\xb1'
 b'\xbe\xdf\x1e?\xfaL0\xfd3\n3\xab\x89Z\xc7\xc8\xf7d\xcf\xdc\x9a\xc4\x03<'
 b'\x16_\xeeK\x8c\xa3b\x05\xb5\x02\x00\x00\x00r\x00/\x01\xe6\x89w.1p\xb5'
 b"\xdd\x03\x00z\x00\x02\x00\x00\x00\x92\x00\x85?'<\xbb\xb5\xc0vxe\xf5\xe6\xf8"
 b'm\x02\x00]\x00\x00\x008\xd4\xfe\xd5G\x03\x00g\x00\x00\x00_\x00\x00\x00j\x00'
 b'\x00\x00\x19As\x1d4G\xf8\x8c$a7\xd0)m\xf0\xbb\xdb\xdb\xe4\xfe\xa2]E|\x85\x95'
 b'\x99\xde\xfa\x8c\xf9>')

{'A1': 54209,
 'A2': 'vxe',
 'A3': {'B1': {'C1': 4414015775017747086,
               'C2': -1324708664,
               'C3': 0.6206015348434448,
               'C4': -47166214},
        'B2': 14467631875280276019},
 'A4': -590387977,
 'A5': {'D1': 0.008042478933930397,
        'D2': 388052340871946006,
        'D3': 181,
        'D4': [{'E1': 28152, 'E2': [-11, -26]},
               {'E1': 18389, 'E2': [56, -44, -2]}]},
 'A6': {'F1': 8084293897056289071,
        'F2': -8779,
        'F3': [10157947248692117785, 13542444105857458468, 8954666388738595803],
        'F4': [-560360059, 1056541946],
        'F5': 0.010208015330135822,
        'F6': -69,
        'F7': -16203}}

Вариант №10

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

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

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

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

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

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

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

(b'wIIBP\r{\x00\x00\x00a\x00\x00\x00\x02\x00p\xbe\x08E\x0c\xbf\x12\xc0'
 b'\xae\xbe\x87r\xf3=\xfa}\x05?\x1f\x98\n\xbf(~\xf5\xbe*,w\x85?\xcc'
 b'4\xe0\xbd\xea\xf5\x90\xee+\xfb\xfe\x05\xb0m\xfd\xaf\xf4\xd6!\xbe\x18'
 b'\xf4\xc5\xfb?\xe9\xc6\xa7\x83\xfb\xc4\x92\xce\xbf\xed\x10\x03\xfa o6'
 b'\x08?\xc7\x88\x8b\xcf\xfc\xfd\xf8?\xc32u\x88\xe2\x03\xb8\x88\x00F\x00O\x00X'
 b'\x17@\xc6\x12\xbc\x9e\xcf\xec\xe2\xdeLU\xad-\xa2S{\xe6\xf4+')

{'A1': 13,
 'A2': 123,
 'A3': {'B1': {'C1': 0.14997739013418054,
               'C2': -120,
               'C3': [{'D1': 251, 'D2': 0.8054997995187867},
                      {'D1': 206, 'D2': -0.9082050214087534},
                      {'D1': 8, 'D2': 0.18385455756832392}]},
        'B2': [{'E1': 1675556845158060012, 'E2': 226, 'E3': 222},
               {'E1': 5500492931411442662, 'E2': 244, 'E3': 43}],
        'B3': [-0.13307589292526245,
               -0.5732525587081909,
               -0.2645488679409027,
               0.12230876833200455,
               0.6234136819839478,
               -0.658187210559845,
               -0.16618524491786957],
        'B4': 133,
        'B5': 1070347488,
        'B6': [-16918, -2672, -4565],
        'B7': -1026},
 'A4': 409948502436927009,
 'A5': -0.1493712216615677}

(b'wIIBP\xa3\xc8\x00\x00\x00a\x00\x00\x00\x02\x00p>\x7f\xac\xa9>\xbe\xd9'
 b'\xcc\xbf2\xe3\t\xbfI\xdbS?\x11\x1e\x95>\xb0__?\x13\xce+kN\xf0\xfc\xaf\xc3/'
 b'bB;\xde"\xf8W\xc5\x07\x8d=\xda\xaa\x8a\xbdl\xaci|?\xc1U\xf5[b[8\x92'
 b'?\xd5\x7f\xb7\xf7!$\xb4\xb9\xbf\xdf\x1c\xe5 \xff\x8d\x84\xbf\xe6\xd8'
 b'\xe8\x94\xe6\xca\\\x8d\x00F\x00O\x00X\x84*K\x98d\n\xb0,\x8c$\xe2\x99'
 b'\xa5X\x8c\xd8K\xfe\n\xfb')

{'A1': -93,
 'A2': -56,
 'A3': {'B1': {'C1': -0.7139780910714069,
               'C2': -115,
               'C3': [{'D1': 124, 'D2': 0.1354357429706512},
                      {'D1': 146, 'D2': 0.3359203256009764},
                      {'D1': 185, 'D2': -0.4861386129616323}]},
        'B2': [{'E1': 9523507479913869356, 'E2': 140, 'E3': 36},
               {'E1': 16328263723747134462, 'E2': 10, 'E3': 251}],
        'B3': [0.24968208372592926,
               0.37275540828704834,
               -0.6987767815589905,
               -0.7885028719902039,
               0.5668728947639465,
               0.3444776237010956,
               0.5773646235466003],
        'B4': 107,
        'B5': 1324416175,
        'B6': [-15569, 25154, 15326],
        'B7': 8952},
 'A4': 6324469554921253514,
 'A5': -0.057781610637903214}

Вариант №11

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

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

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

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

Поле	Описание
1	int16
2	int32
3	float
4	Структура D
5	uint64

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

(b'PMJ\x02\x00\x00\x00t\x00\x00\x00\x05\x00\x90\x00\x00\x00\x11"\'\xbe\xe0\n^'
 b'\xecZ%N?\xcdL@\xc3\xd2\xf7$\xd96\x84_\x11\xd7\xf6\xf43\x9d\x12\xb3#ZrV'
 b'\xfb>\xf4{\xf1\xbc+ \xd0?\x058\x9a\xbcK\xb5\xbd\x03M\xb9\xe4\x0c|?OaZ9'
 b'-_\xdav~\xe3\x1b\xa8M\xc3\xd9tyt\xb8(z\x83@X\xbe\x94\x9b3\xf0M\xe9\xfb'
 b'f\xf0\x16z.p\x81\xad\xbcD\xe1QB\x00\xaa/\xaa\xe5\xaf\xe3\xc7oJ\x8d(\xb2[\x00'
 b'|\xcd\xf7\x96\xa5\xb3\xc7Anhhja')

{'A1': [{'B1': 1373717692,
         'B2': {'C1': -19125,
                'C2': -1186135107,
                'C3': 0.9845716953277588,
                'C4': {'D1': 79, 'D2': 23137, 'D3': [57, 45, 95, -38]},
                'C5': 15691470911106678390},
         'B3': 8054656803187339178},
        {'B1': 2989002058,
         'B2': {'C1': 31092,
                'C2': 2049489012,
                'C3': -0.2111835926771164,
                'C4': {'D1': -108, 'D2': 13211, 'D3': [-16, 77, -23, -5]},
                'C5': 12502397385476337766},
         'B3': 4739954656614534524}],
 'A2': 'nhhja',
 'A3': [-1104731631,
        -329381152,
        1062085978,
        -1019196211,
        -651888686,
        291472438,
        871691991,
        598938269],
 'A4': 4216746586,
 'A5': 62,
 'A6': 0.25196355296605977,
 'A7': -0.01882554031908512}

(b'PMJ\x02\x00\x00\x00t\x00\x00\x00\x03\x00\x90\x00\x00\x00\xb0da\xe6K\xda\xda'
 b'\x8eNx\x14Ymxg\xd0\x15\x1c\xdc;\xd0\xa6T\xdf`\xc9y\xa7\x92O"v0\x9b\xa9'
 b'\x9e-\xf0\x95\x86\xb1\x177\xcd?u\x00\xa4>`\n\xd1\xe4\xc6\x83\x18{\xd5\xbd'
 b'7uKu\xec\xdf\xe7A\x1d\xf4(\x82>>\xdd\x0ee\x03\xc6\x96\xba+2$?\x08D\x0f'
 b'\xcb\xf5\x0f\xc0\xf35\x07\xab\xcbX\xe9\x8e\xae\xab-\\B\x00y\xa7\x17T\xa0+'
 b'\xb7\xaf\\\xd9[\xc9[\x00\xbf\x07B"\x84_\xba\xf6yvd')

{'A1': [{'B1': 1546496942,
         'B2': {'C1': 2656,
                'C2': -2084117295,
                'C3': -0.10423868894577026,
                'C4': {'D1': 55, 'D2': 19317, 'D3': [117, -20, -33, -25]},
                'C5': 15942248459691892033},
         'B3': 12661636844981036921},
        {'B1': 3378239836,
         'B2': {'C1': 25870,
                'C2': -1164524029,
                'C3': 0.6413905024528503,
                'C4': {'D1': 8, 'D2': 3908, 'D3': [-53, -11, 15, -64]},
                'C5': 10297859654730331635},
         'B3': 17778627500113528767}],
 'A2': 'yvd',
 'A3': [-429824848,
        -1898259893,
        1494513742,
        -798525331,
        1004280853,
        -548100400,
        -1485190816,
        1981960082],
 'A4': 2661915440,
 'A5': 45,
 'A6': 0.22824379127739247,
 'A7': 0.32031598687171936}

Вариант №12

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

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

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

(b'VQJU\x0f!\xb0\xec\xda\xb9\xbf>h\xdb\x84\x9c\xe8\x1c\x94\xf6Um\x80\x83'
 b'\x02\x00X\x00\xb8@\\:* \xe2?\xb9\xc5h-\x02\x00\x00\x00~\x00\x00\x00zwqnnvdd'
 b'\xe5"\x9d\x86!\xec\x9d\x9a"\x00\xd0\'\xf3$\x9f\xad\x15AP\xa9\xac$\x92\x90'
 b'|\xf6\x0eJ\xadem:vdUFP\xe1\x03d\xb6\xf9\x1d?t(|?Z\x00\x00\x00\xa36H4\xb53^Q'
 b'\x08\xbf\x1c\xbd{?l\x00\x00\x00d\x00v\x00')

{'A1': {'B1': 4521536900828242191,
        'B2': 17767858215267392360,
        'B3': -2088735403,
        'B4': 'vd',
        'B5': 0.5664263858652907},
 'A2': 761841081,
 'A3': [{'C1': 0.984992265701294,
         'C2': {'D1': 18005, 'D2': 1677975888, 'D3': 0.6170915365219116}},
        {'C1': 0.9833543300628662,
         'C2': {'D1': 13987, 'D2': 867513416, 'D3': -0.5324915647506714}}],
 'A4': 'zwqnnvdd',
 'A5': [-2036522267,
        -1700926431,
        667942946,
        -1382079245,
        -1454358251,
        -1869470548],
 'A6': 4210133021607523964}

(b"VQJU\x908r'q\xd0y#\xf9\xc1\x19\xc0 \x06Z\xf8h\xd4\xc0\xcb\x02\x00X\x00"
 b'\xac\x83\xcb\xfd\xd6\xdf\xe8?\xda\x06;\xc7\x02\x00\x00\x00~\x00\x00\x00caso'
 b'bjceJ\xd6X-\xbb\x88{<\xaa(\xe4\xa9<\xbb\xa1\xac\x9eKf/\xfc\xa4\xe6\xfe'
 b'\xecD\x98+\xeaP\xa9\xfarzAK\x05\x94\x98D\xcc}\xe7>\x0bl\x14?Z\x00\x00\x00'
 b'r\xe1\xceM\xe0N\x84\x9eX\xbf\xf3\xd2[\xbfl\x00\x00\x00d\x00v\x00')

{'A1': {'B1': 2556303447921146000,
        'B2': 17895622807041720825,
        'B3': -876555160,
        'B4': 'rz',
        'B5': 0.77732419556934},
 'A2': -952432934,
 'A3': [{'C1': 0.5797736048698425,
         'C2': {'D1': 19265, 'D2': 1150850053, 'D3': 0.45213162899017334}},
        {'C1': -0.8586875796318054,
         'C2': {'D1': -7822, 'D2': 1323322830, 'D3': -0.8461687564849854}}],
 'A4': 'casobjce',
 'A5': [760796746, 1014728891, -1444665174, -1398686916, 795233182, -18438916],
 'A6': 18062056747230053612}

Вариант №13

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

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

(b'OMWR\x9c\xba\x12\x923Y\x92\x06\x01\x1f\x00K\x00\x00\x006]\xcd\xbb\xa7'
 b'\xadu\xdd\xfd\xa2\x8b4`\x1b\xe47\xcd\x97\x14\x01\x19\x00\x00\x00\n'
 b'\x02\xe8\xcd\xaa\xa8\xd1\x85\x19\x88 u\x0c\x1e\xc6\x0e\xbdb\xec\x08]'
 b'\x04Q\xf8"\xe3R\xad\x8d\xf4\xa4\xfbJ\xf3\\\xd0\x03~? }\xa8N\xea\xd2'
 b'\x16Z\x9e\x08\x04\xa4q1\xac>\xbb\xe8\xd5\x05D%\xefu22\x92\x8d)*v\xbe\x1e\xfa'
 b'\xf4\x11C\xf7')

{'A1': 156,
 'A2': {'B1': 73907355713147578,
        'B2': {'C1': 77854001233927008,
               'C2': {'D1': 117, 'D2': 2342714845, 'D3': 52},
               'C3': [{'E1': [3454534154, 2245109930, 1965066265],
                       'E2': [12, 30, 198, 14]},
                      {'E1': [149709501, 4166059101, 2907890466],
                       'E2': [141, 244, 164, 251]}]},
        'B3': {'F1': [3495752522,
                      541031939,
                      3931023485,
                      2656704210,
                      1906574344],
               'F2': [-1153520591,
                      1141233128,
                      846589733,
                      697143858,
                      515798570,
                      1125250298],
               'F3': -9},
        'B4': 54,
        'B5': 93,
        'B6': 2913450957}}

(b'OMWRmnj\xceM\xc0\x85z\xd5\x1f\x00K\x00\x00\x00\x98z\x93D\x9cb\x85\xe7\xd5'
 b'w\xf7Ro$\x06}\x1a\xca6_\x19\x00\x00\x00xS@F4\x83\xa2\xbb\xe28\x9aG\xa0'
 b'\xc6\xd7\x19\xc1\xd5\xb1@\x02fo\x80\xae*\xdc\x9cb\x85\xd3\xe5\x83Qd\xael'
 b'\xdd\x17_.\t\x00\x99,\xbb\xdci\xe7\xa35U.\xc7\xc2X\xf1E\x12\x96Z\x84p(\xa5'
 b'\x05X\x8a\x91pK8&\xa5\t\x81\xb7')

{'A1': 109,
 'A2': {'B1': 15382754538222938734,
        'B2': {'C1': 6860893297461044335,
               'C2': {'D1': 133, 'D2': 4151825895, 'D3': 82},
               'C3': [{'E1': [1178620792, 3147989812, 1201289442],
                       'E2': [160, 198, 215, 25]},
                      {'E1': [1085396417, 2154784258, 2631674542],
                       'E2': [98, 133, 211, 229]}]},
        'B3': {'F1': [2925810051,
                      1595399532,
                      2566916398,
                      1776073516,
                      1429578727],
               'F2': [1489159982,
                      -1777187343,
                      678462554,
                      -1973942875,
                      944468113,
                      -2130074330],
               'F3': -73},
        'B4': 152,
        'B5': 122,
        'B6': 1654408339}}

Вариант №14

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

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

(b'RJH\xa2a\xb7\\U\x86\xb6\xfaW\x119\xa1\xa8*LoR\x00\x00\x00_\x00\x00\x00{'
 b"\x00\x00\x00\x85\x00\x00\x00\x8f\x00\x00\x00\x99\x00\xe0UPy\xd0C\x0c?\x0e?'"
 b'\x00\x00\x00\x04\x00\x00\x00\xa3?g`Jj{\xf5\xd4}\x10x\xd13\xd6}k0\xad\n\xde'
 b'%(\x8e\x08\x1b}<s\x00\x00\x00\xa7+O\t\xa1\xe1\xe3*uwtdex\x00\\\xe1'
 b'\xd8\xca\xa4\xa4\xe6\xa6E\xae\x1b\xcd<\xbd #O\xcf\xebWO\xab\xc3|H\x1a'
 b'\x1cK\x9f\x01=%\xb4?_\xab\xba\xb3\xd7>\x8c\x8d9-^\x98\t\x05\x9a\xab'
 b'dI\x0b\xc7\xe6\x0eQjV\xe8:\x1c\xb6\x15\xe5n\x83\x9f\xb2p\xa1^%\x10'
 b'\xf2?\xb3\x86I\x92\xc1L\x12?2V\xcd')

{'A1': -6745909159624526086,
 'A2': 87,
 'A3': {'B1': 288989608,
        'B2': 709652306,
        'B3': {'C1': 2715935530,
               'C2': 'uwtde',
               'C3': 120,
               'C4': {'D1': 11087, 'D2': 9},
               'C5': -505886044,
               'C6': -6564376588641907396,
               'C7': -0.0390961728990078},
        'B4': [{'E1': -806660273, 'E2': 171, 'E3': 195, 'E4': 2085100060},
               {'E1': 1268711741, 'E2': 37, 'E3': 180, 'E4': 1063234490},
               {'E1': -1277739380, 'E2': 141, 'E3': 57, 'E4': 761174025},
               {'E1': 94022500, 'E2': 73, 'E3': 11, 'E4': 3353742929}],
        'B5': 63144198912623372,
        'B6': 0.5556511282920837,
        'B7': [106, 86, 232, 58]},
 'A4': 0.9038130044937134,
 'A5': [27259, -2604, 32016, 30929, 13270, 32107],
 'A6': {'F1': 3507471634013916680, 'F2': 27, 'F3': 32060},
 'A7': 115,
 'A8': {'G1': 481695205,
        'G2': 1854119858,
        'G3': 8115871516789456819,
        'G4': 134,
        'G5': 18834,
        'G6': -63,
        'G7': 19474,
        'G8': 0.696636974811554}}

(b'RJH/\x8d\x99\xba\x8ck\xf6\xe3o\x95\x0etg\xb0/\xfeH\x00\x00\x00_\x00\x00\x00{'
 b'\x00\x00\x00\x85\x00\x00\x00\x8f\x00\x00\x00\x99\xbbe\xdf>M\x9fk\xc6>|:\x8d'
 b'\x00\x00\x00\x03\x00\x00\x00\xa3=\x83\xea5\x0b3\x00Hp\x83\xfe\xd2'
 b'\xd6\xc2\x98\xed\xe5\x7f7\xa6\xad\xf9\x0e\xecI\xc7\x10\xd3\x00\x00\x00\xa6'
 b'u+o\xdc\xcdHqsvklx\xff\x00\\\xa5\xeb\\\xcfJu\xac\x17\xeb5\xfc\x01?'
 b" \xe7\xfb\xf0b^\x0b8g'\x1f\xea\xff\x83E\x85\xee}5\xad\xd3\x06\xbe\xb2"
 b'\xe2\x95q\xa7\xd7\xac\xe9\x8a\x04\x07\xaa\xf3\xcd%NL:\xbb\xa5\xa4T\xfeD\xab'
 b'\xbb\xaaNV\x162\x82\x88$z\x83}\xad\x0eB\x16\xa3\\pi\xbf~\x11p')

{'A1': 3426563917997668067,
 'A2': 111,
 'A3': {'B1': 2500752487,
        'B2': 2955935304,
        'B3': {'C1': 3704440945,
               'C2': 'svklx',
               'C3': -1,
               'C4': {'D1': 29995, 'D2': 111},
               'C5': -1511301937,
               'C6': 5365383749812222977,
               'C7': 0.6285397410392761},
        'B4': [{'E1': -261988853, 'E2': 56, 'E3': 103, 'E4': 656403199},
               {'E1': -2092595730, 'E2': 125, 'E3': 53, 'E4': 2916288190},
               {'E1': -1293773455, 'E2': 167, 'E3': 215, 'E4': 2900986372},
               {'E1': 128644045, 'E2': 37, 'E3': 78, 'E4': 1278917541}],
        'B5': 13503444516423560134,
        'B6': 0.24631710350513458,
        'B7': [164, 84, 254]},
 'A4': 0.06441155821084976,
 'A5': [2867, 72, 28803, -302, -10558, -26387],
 'A6': {'F1': 16536997545750630124, 'F2': 73, 'F3': 50960},
 'A7': 211,
 'A8': {'G1': 1152105386,
        'G2': 1314264626,
        'G3': 9405807930373942542,
        'G4': 66,
        'G5': 5795,
        'G6': 92,
        'G7': 28777,
        'G8': -0.9924535751342773}}

Вариант №15

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

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

(b'0BSB\x13c\x9ct i\x1f<\x81\xb8\x0f\x96\xc9\x8b\x8d\xb1pS\xb5\x06\xe00\xd3?'
 b'\x966\xc3-\x03\x00\x00\x00]\x00\x00\x00\x87\xb1~#H\x97\x02\x00`\x00\x00\x00'
 b'\xbaT\\\xfd\xb5\xd2\xd1\xd4\x02\x06\x00\x00\x00\xb6\x00\t\xbbC\x98K'
 b'\n&\x15\x93\xc5pvp;\x127\x8a9X{P^@\xa7^\x1dfxxbn\xf6U\x06?\xca\x8d\xa8\xb4yQ'
 b'\xcb\x91\xc5?\x8a\xdf\x0e/\xa5\x194O\x88\x81\xbdO\xee\xbf3zB\xe91\xb2\xc4S-.'
 b'\xdb\xcb\xe3?k\xa5\x1c\xee@\xfd\x9c\xc3\xaa+!\xbc\xd7\xbfF\xe1\xbfJ\x04\x9a'
 b'@;2\xacG\xbb\xd8?I\xfb;v\x86\x16\x1a\x89\xf7\xd2!\x00\xe6\xbfb\x00p\x00~\x00'
 b'\x8c\x00\x9a\x00\xa8\x00')

{'A1': {'B1': 4332296954669982483,
        'B2': -5652708259357804415,
        'B3': 0.2998580995093141},
 'A2': {'C1': 767768214,
        'C2': 'fxx',
        'C3': -20089,
        'C4': -1756880002,
        'C5': 'bn',
        'C6': 15335269885254849722,
        'C7': 2},
 'A3': [{'D1': 22006, 'D2': -1916125434, 'D3': 0.16851178625384944},
        {'D1': 57226, 'D2': 430255886, 'D3': -0.947233918183406},
        {'D1': 31283, 'D2': -1305351870, 'D3': 0.6186347867866222},
        {'D1': 42347, 'D2': -46076388, 'D3': -0.37085751785621723},
        {'D1': 57670, 'D2': -1710994753, 'D3': 0.38643066230809},
        {'D1': 64329, 'D2': 377910843, 'D3': -0.6875161285827602}],
 'A4': -17655,
 'A5': -4209997973535614909,
 'A6': [30320, 15216, 14098, 14730, 31576, 24144, -22720],
 'A7': 7518}

(b'0BSB\xb2\xa2u\xaf\xfc\x9c\xfdK\xa6p\xe2\xadnm\x08x\x00\xbd\xf0\x1f.\xb9\xee?'
 b'i!\xb63\x03\x00\x00\x00]\x00\x00\x00\xabF\xaeo\x1dJ\x03\x00`\x00\x00\x00'
 b'(\x8c\xc4bj\x0cjy\x1a\x02\x00\x00\x00\x7f\x00\xc1\x9f\xc4N\xb0\xf7\xf91J'
 b'\xa1\xf9\xd8\xd9\xb3\x17>\x8a\xa6\x9f{\x8f\x1e\x9dMv\xadgsuvaf\xde\x89\xaeO%'
 b']\xde\x02J\xeb\xe7\xfd\xe2\xbf\xeez\x9c\xef\xa1SH\x96\x01<)s\xe4\xbfc'
 b'\x00q\x00')

{'A1': {'B1': 5475705331041804978,
        'B2': 8649283406496166054,
        'B3': 0.9601050018153785},
 'A2': {'C1': 867574121,
        'C2': 'gsu',
        'C3': 18091,
        'C4': 1243443118,
        'C5': 'vaf',
        'C6': 8748818877183724584,
        'C7': 26},
 'A3': [{'D1': 35294, 'D2': 1562726318, 'D3': -0.5934943767061573},
        {'D1': 31470, 'D2': 1403121564, 'D3': -0.6390577480312425}],
 'A4': -24639,
 'A5': -6824587335654420796,
 'A6': [-9991, -19495, 15895, -22902, 31647, 7823, 19869],
 'A7': -21130}

Вариант №16

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

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

(b'OHUVFtq\x1f\x0c\xbf\x1eN\x00T\x00Z\x00`\x00f\x00l\x00r\x00\xf4C(76\xf5`'
 b"N\xf8|\x7fFF$\xc7\xbf?\xb9\xfb\x9b\xe3'\xc0&A\x9at\xf6\x0ew\xbf\xcbDdr"
 b'_X\xeb\x8e\x95\xab\xf9\x84~_\xbd\x11b\x07\xeb\x86a\xc4\xba\x89>\xcc\xc0\xdd'
 b'~\xec\x1d`\x0cU|R\x1fU>\x025GD\xcdq\x9f\xe7%\xb9f\x8bZ\x0f#$\x98'
 b'\x99\xf1\xccJ\xbc\x0c[\xee')

{'A1': 'tq',
 'A2': {'B1': 515836959,
        'B2': [{'C1': -70, 'C2': -119, 'C3': -574567362},
               {'C1': 126, 'C2': -20, 'C3': 1426874397},
               {'C1': 124, 'C2': 82, 'C3': 37639455},
               {'C1': 53, 'C2': 71, 'C3': -1619931836},
               {'C1': -25, 'C2': 37, 'C3': 1519085241},
               {'C1': 15, 'C2': 35, 'C3': -241592284},
               {'C1': -52, 'C2': 74, 'C3': -296022852}]},
 'A3': {'D1': 5647783545925026804,
        'D2': -0.18079451029095828,
        'D3': [-18113, -25605, 10211, 9920, -26047],
        'D4': 116},
 'A4': -0.9650720357894897,
 'A5': [-8148321933832469301, 1278282866244561813],
 'A6': -2031417502,
 'A7': -15263}

(b'OHUVFjv\x91@\xf5\xffN\x00T\x00Z\x00`\x00f\x00l\x00r\x00\x11\x8a%'
 b'\x06\xa5\x0b\x8dz\x18\x92\xdc\x01\xa2\xff\xd9?\xbf\x19\x98p]\xb3|'
 b'\xb2\xd0\xcb_\x89,+\xbf\x0e+\x80\x80\x10\xad}KMF\x94\xed~\x91\x0b\n'
 b'/\xa0\x91\xa6\xe0*\x93\xe1\xa40\xbf\x13\xbb\x15\x96\xf4\x99\xd3\x05\xb1'
 b'o\x8b-{Q\xa7y\x99\xac2\xf1\x98wP\xb9\xd4c\x91!\xe6w\xa0\xcf;I\x11\xde\x94')

{'A1': 'jv',
 'A2': {'B1': 4294262929,
        'B2': [{'C1': -109, 'C2': -31, 'C3': 331296932},
               {'C1': -69, 'C2': 21, 'C3': -744885098},
               {'C1': 5, 'C2': -79, 'C3': 2066582383},
               {'C1': 81, 'C2': -89, 'C3': 850172281},
               {'C1': -15, 'C2': -104, 'C3': -726052745},
               {'C1': 99, 'C2': -111, 'C3': -1602755039},
               {'C1': -49, 'C2': 59, 'C3': -1797385911}]},
 'A3': {'D1': 8830727247744043537,
        'D2': 0.4062275903873185,
        'D3': [6591, 28824, -19619, -19844, -13360],
        'D4': 95},
 'A4': -0.6686483025550842,
 'A5': [5439694211320392462, 723832139460920909],
 'A6': -1500405713,
 'A7': 10976}

Вариант №17

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

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

(b'HUAE\xech\x00\x04\x00\xac\x00\x00\x00\xfe\xbe\xd6:\xbdkL1\xe2y\xd6'
 b"\x0b\xc3\x92'\xaa\xd6\xc8\xd5z\xc7\xd2\x17\x8f\xa7\xf0X\xaf\n\x1aB"
 b'\xfb\x8e\xee\x96D\r\x00\x00\x00\x16\x00\x00\x00\x1f\x00\x00\x00(\x00\x00'
 b'\x00\xf7[v\x1d\x9cC nA\x9d \xd9\x95\x03?<:\xe2\xe0\xd7\x93@6*\xb8\x03\x00'
 b'I\x00\x00\x00dA\xfc\x14_C\x8dl}H\xb7\x9d\x04\x001\x00\x02\x00A\x00Yk\x8f\xd9'
 b'\x1ek\xbet\xea\xd3Q\xbfI\xe55\xbc2\xa0\x8f\xea\x01Y\x1c\x07\xb0:?\x0c'
 b'\x0c\x1eM\x94d\xa8\xe7\xebk\xa5\xd3\xd6R\x9ep\xe3L\x00\x00\x00\xf4}/B'
 b'4\xbd\xd7\xf1\xf9\xaf\n@#oGI')

{'A1': {'B1': -1648932739,
        'B2': {'C1': [{'D1': 254, 'D2': -2147851521659054402},
                      {'D1': 121, 'D2': -3974802534165181482},
                      {'D1': 213, 'D2': 6408806502770067322},
                      {'D1': 175, 'D2': 4942399938953878026}],
               'C2': [494296055, 1847608220],
               'C3': 89,
               'C4': 36715,
               'C5': {'E1': -0.22960986196994781,
                      'E2': 116,
                      'E3': -0.8196398019790649,
                      'E4': 58697,
                      'E5': [2687679541,
                             1493297807,
                             984614684,
                             504106047,
                             2825163853,
                             2775313383,
                             2656229075],
                      'E6': 112}},
        'B3': 227,
        'B4': {'F1': 0.5140052437782288,
               'F2': 14908,
               'F3': 13270478902986793186,
               'F4': [65, -99, 32],
               'F5': 7821982203465449828},
        'B5': 17426605315279781364},
 'A2': [45049, 16394, 28451, 18759]}

(b'HUAE\xecQ\x00\x05\x00\x95\x00\x00\x00\xd2>\xcdY{\xb5k\xf3\xc4A\xcb'
 b'\xa1\x89\xa36i5\x07\r\x00\x00\x00\x16\x00\x00\x000\xe1I\xc2Ig\xa8\xe0h'
 b'\xbb}V\xa3\xae\xe3\xadu\xbf[\x05\xbf\xe7{\xc8|<\x9a\x1c\x02\x003\x00\x00'
 b"\x00\x08R_5 `\xb1\x12\x14\x8b\x95\xed\x02\x00\x1f\x00\x03\x00'\x00:r\x98"
 b'\xd8\x15V?\x95:\xeb\x9a<\x12d\xf8\xfe\xdbo\xac\x98\xac\xf5\x8e\x19F\xb9\xe2'
 b'\xb6gdx\xa4Z*\xc8xQN\xe3J\x9c)\xe1\xb95\x00\x00\x008\x8e\xbc\xf0\xba{9'
 b"\x93\x92\x07\xec\xb8\x90'\xd1M\xff\xec")

{'A1': {'B1': -308966636,
        'B2': {'C1': [{'D1': 210, 'D2': -4254938795732251330},
                      {'D1': 65, 'D2': 519437015424016843}],
               'C2': [-1035345616, -525834423, 1451080552],
               'C3': 58,
               'C4': 39026,
               'C5': {'E1': 0.836270809173584,
                      'E2': -107,
                      'E3': 0.01891099289059639,
                      'E4': 25618,
                      'E5': [1876688632,
                             4121729196,
                             3108379022,
                             1684518626,
                             710583416,
                             1313962184,
                             698108643],
                      'E6': -31}},
        'B3': 185,
        'B4': {'F1': -0.9596845507621765,
               'F2': 1371,
               'F3': 2061026286112597951,
               'F4': [-93, -82],
               'F5': 1346963455011148296},
        'B5': 10608646440080936504},
 'A2': [1938, 47340, 10128, 19921, 60671]}

Вариант №18

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

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

(b'UUZSp\x02\x00\x00\x00d\x00uIv\xd0Lm\xbe\x9f\x9f\xce?Yh3#\x96\xb9W?i\xdf'
 b'\xd04V\xbf\x02\xa1\x10t\n\x00\xbb\x1f\xd4?\x14\x84o\x19\x05\x00\x00\x00v\x00'
 b':\xadK\xa6 \xf2\xff\xe0O\xd8j\x8a\x1b\xe8?j\x96\x17\x0e\x8d\xe0\x95d^'
 b'\xd5\xdb\xa8\x183\xfb|--\xa6\x97\xceb\x9a\xeca\x93\xd4\xe9\xbf\xa8"\xedu'
 b'\xebT(\x11\xaf*|4\xf3nl\x92\xd3\xd5\xfeK\xff\x96\x18Un\x92\x16\xe4')

{'A1': {'B1': [{'C1': 1236331467985724072, 'C2': -81},
               {'C1': 15245366912385055786, 'C2': -43}],
        'B2': 117,
        'B3': 30281,
        'B4': {'D1': 0.2392463378733738,
               'D2': 590571609,
               'D3': 1062713750,
               'D4': {'E1': 11602045967034015593,
                      'E2': 0.3144366741560711,
                      'E3': 426738708,
                      'E4': [19454, -26881, 21784, -28050, -7146],
                      'E5': [58, -83, 75, -90, 32, -14, -1],
                      'E6': 0.7533619009795949,
                      'E7': 106,
                      'E8': 6801726128908015510}},
        'B5': [-9259, 6312, -1229, 11644, -22995, -12649]},
 'A2': -0.8071991837103492}

(b'UUZSp\x02\x00\x00\x00d\x00\xf7\xb7\x9e\xa0b\xc8\x99\xe74\xb6?\xb8\xed'
 b'\x89\x15\xb3\rxv\xcbV\xc6P\x11\xde\xc7Vx\n \x92\x91"\xea?\xa0\x18'
 b'\x10\n\x05\x00\x00\x00v\x00\x99s\x9fS~\xed\x16\xfc\x85\x84\xa8\x8d'
 b'\x0b\xe0\xbf\xdd5\xfa\xf8Q\xc5\xfe\x17/F\xbcs\x1f\xd9\xce|\x10w%(\x04'
 b'\xd0\xf7\xe1\xc7\x1d\x84\xd9\xbf+\x8e\x06\xf0f3I0N\x9d\xb4\x98\x95NH\xc5'
 b'}\xa6\x84&|\x87\xa0\x11R\xf3B\xa9')

{'A1': {'B1': [{'C1': 3479368704327061035, 'C2': 78},
               {'C1': 9062729327507453085, 'C2': -90}],
        'B2': 247,
        'B3': 40631,
        'B4': {'D1': 0.08674476150953092,
               'D2': 361360824,
               'D3': 1987579315,
               'D4': {'E1': 6253210773578208971,
                      'E2': 0.8167198041922594,
                      'E3': 168827040,
                      'E4': [9860, -30852, 4512, -3246, -22206],
                      'E5': [-103, 115, -97, 83, 126, -19, 22],
                      'E6': -0.5014103213654262,
                      'E7': 221,
                      'E8': 3393460967684241973}},
        'B5': [-17338, 8051, -12583, 4220, 9591, 1064]},
 'A2': -0.39868874091905315}

Вариант №19

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

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

(b'\xf5OYPCc\xaf\x82F\x8b\x00\x00\x00z\xe6\x1c\xbf\xe6\x95\x8aa\xe9\xee\xaa'
 b'7Dy\xbdL>,`!S\xd6M\xa87\x0fY\xfa\xbe\xd0\x83\xd7_D\x8c~\xdb\xe3\xc9'
 b'\r\xae?\x12\xeel\x89\x1c\xb2\xbc\xf7v{\x85\xe6\xbf#\xff\xaa._\xfaw='
 b's\xc7\xa9\xee\xbf[\xcf\xec\xdet|\xba\xeen,f\xf9\xbe\xe1q:\x8d0KT\xa0\x1d\x9c'
 b'i}\xbf[\x9e(H\x08E>\x80\xc8\x9c\x19\x91\x0b\xb1X&\xac6\x87\x0e\xe0'
 b'\xee\xc9\xba\xae\x06:\xd2\x00!\x00.\x00;\x00H\x00U\x00b\x9b\xd2\x04\xb6\xa3'
 b'/\x01e\x00o^x\x85n(}\x8d\x1cA\x84\xb1T(\xbe\xbfZ\x1e\x8c\xd5<\xdf\xbc\x11-')

{'A1': 99,
 'A2': -1350416757,
 'A3': {'B1': 38,
        'B2': -1405712626,
        'B3': 16208113912573737682,
        'B4': [{'C1': 6041101335037696506, 'C2': -0.4072558581829071, 'C3': 95},
               {'C1': 4939462374203133358, 'C2': 0.5739505290985107, 'C3': 137},
               {'C1': 2067922949947229670, 'C2': -0.6406198740005493, 'C3': 46},
               {'C1': 6915971283599993326,
                'C2': -0.8586413860321045,
                'C3': 222},
               {'C1': 8393789338725148409,
                'C2': -0.44031697511672974,
                'C3': 141},
               {'C1': 3479968183742130557, 'C2': -0.857882022857666, 'C3': 72}],
        'B5': -7218702070253158043,
        'B6': {'D1': [8, 69], 'D2': [1048627356, 428936113], 'D3': 88},
        'B7': 6807337544942718236,
        'B8': [16772, 45396, 10430, 48986, 7820, 54588, 57276, 4397]},
 'A4': -6628,
 'A5': -0.7057544624689929,
 'A6': 55,
 'A7': 4934183001919348769}

(b'\xf5OYPC\xa5\x1b\x843@\x00\x00\x00z\xde\xe6\xbf\xec\n\x17l8d\xfa+\x17\xf6q'
 b'\x19p\\\xea\x1c\xe7]\xcd}\xc4!\x0fY\xbf\x17\xd2\xa1\xa4\xde*\xe5\xa4@}'
 b'\xa5\xa7\xbeH\xdaB\x17)\x99\xd5\xf8O7\x11z\xbf7\xe58k9\x9cD\x7f'
 b'\x96\xab\x1d\x14?D\xc0$p\xeeg\x94\xa2\x17\xab/\x1c\xbf<\x85-\xb3\x1b\xf9'
 b'\xafB(\x90\x8d\x08\xbe\xf0\xa5\xc5`jp\xd5~\xe68\x10\x02\xe2\xb2#\xf0\xe8'
 b'\xf8e\xe2y\xf0Y\xdd\xb4K\x9f\xf4\x00!\x00.\x00;\x00H\x00U\x00bO\xc1=\xba\xe3'
 b',<\n\x00o\xca\xcdaiz\xe0\xe1C}\xb0\xfeyn\x85\x98\xf1\xc9\xff\rB\xc8>5\xac')

{'A1': -91,
 'A2': 461648704,
 'A3': {'B1': 240,
        'B2': -386374174,
        'B3': 8786621681747337204,
        'B4': [{'C1': -1775036738069000359,
                'C2': -0.5930576920509338,
                'C3': 164},
               {'C1': -2437883754648328793,
                'C2': -0.19614508748054504,
                'C3': 23},
               {'C1': 2997662289449390458,
                'C2': -0.7183413505554199,
                'C3': 107},
               {'C1': 4151268271308086548, 'C2': 0.7685568332672119, 'C3': 112},
               {'C1': -1267881346178797796,
                'C2': -0.7364071011543274,
                'C3': 179},
               {'C1': 2015835006908271880,
                'C2': -0.4700147211551666,
                'C3': 96}],
        'B5': 5746942472386001930,
        'B6': {'D1': [106, 112], 'D2': [3581863480, 268624562], 'D3': 35},
        'B7': -3833300602161405629,
        'B8': [32176, 65145, 28293, 39153, 51711, 3394, 51262, 13740]},
 'A4': -8474,
 'A5': -0.8762318719556383,
 'A6': 43,
 'A7': 1726691861216422428}

Вариант №20

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

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

(b'DMDG\x00\x00\x00\x02\x00\x00\x00_\x00\x06\x00c\x88?3P\x9a?\xed$p\xd9\xec\x1f'
 b'v\xab\x89\xfe\x86\x99\xde\xe6\x08\xcb _+\x00\x00\x00\x06\x00i\x8aR\xbf\xeb6'
 b':\xf1\xda\xaf"\xbd\xc3\x05\x8b\xd5\x92P\xd5snvyp\xe8\x15b\xb8\xcf\xf8'
 b'(\xcd"\\\xbf%aorbp\xea\xaf\xc3\x08\xe8\xa1~q\x00=\x00N}$\x85\x0b\x9c'
 b'(\xf3\xed@\xd4<%U\xda\x88X\xa7\xeb')

{'A1': [{'B1': 3583135957, 'B2': 'snvyp', 'B3': 16723381337212856525},
        {'B1': 576503589, 'B2': 'aorbp', 'B3': 16910949568829554289}],
 'A2': {'C1': [125, 36, 133, 11, 156, 40],
        'C2': 136,
        'C3': 0.7004486322402954,
        'C4': 0.9106983429237363},
 'A3': 12360690506355631624,
 'A4': {'D1': -13536, 'D2': 24363},
 'A5': [62445, 16596, 15397, 21978, 34904, 42987],
 'A6': 35410,
 'A7': -0.8503699039187931,
 'A8': -0.09522541612386703}

(b'DMDG\x00\x00\x00\x02\x00\x00\x00_\x00\x04\x00cC\xbe8\x1ae?\xa4\xac'
 b'K\xea\r\xa9\xa0@#\xa2{^\xcd\xa11\x96\xabt\xbc\x00\x00\x00\x05\x00ga'
 b'\x90\xbf\xe6\xda\xee\x99\xa7t\xfc\xbfj\x9b\x1e\xb8\x1f\xe7\x19snocs\xf8\xd5'
 b'\xb3F\xef\xd4W\xf9b\xfdU\x01nslxv\x14B\n\xf0!\xa7\xa3\r\x00=\x00N\x92'
 b',\xd6\xb8UI=R\x9e?\xb5\xe5\xf5\x91')

{'A1': [{'B1': 3089098521, 'B2': 'snocs', 'B3': 17930434608698251257},
        {'B1': 1660769537, 'B2': 'nslxv', 'B3': 1459741255694525197}],
 'A2': {'C1': [146, 44, 214, 184],
        'C2': 67,
        'C3': -0.17978818714618683,
        'C4': 0.040377018280952415},
 'A3': 4621716293367472433,
 'A4': {'D1': -26965, 'D2': 29884},
 'A5': [21833, 15698, 40511, 46565, 62865],
 'A6': 24976,
 'A7': -0.71422510157177,
 'A8': -0.9164294004440308}

Вариант №21

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

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

(b'JOOP\r&\x88\xfbu\xd4MG\xc5[\x00\x00\x00\x83d\x1e\x00\x96\x9bOW\x1b?_'
 b')\xc9\x9f\xfb\xd6\xeb\x83zH\xcfffy\xa0\xc6\xfd\\*\xb2\xa5\x93\xd4\xd2\xd8'
 b'yq\x8e\xb8 C\x8cX\xd8\xe2e\x8f|\xad\xea\xe7#\xebL\x9c!\x0c7\x9e\\\xdfs\x10'
 b'\xc0\x8d\x1c"\xec\xa8\x10\xa8\xe3\xa8Y\xf4\x1fz\xcb9z\xa1\xd1\xb6'
 b'\x1a\xde4\xb0\xa6\xe3\xc3\x00O\x01\xfc\x00\x00\x00)\x00\x00\x007\x00'
 b'\x00\x00E\x00\x00\x00S\x00\x00\x00a,\xb7\x97\x19[\x9f\xac\xf2\x00'
 b'\x00\x00\x03\x00&\x03\x00\x05\x00o4W\xfd?y2\xd5zs\xcb\x0e\xde\xeb`ey\xc6S'
 b'\x83\xcb1w\xb5\x8b\r\x04\x95\xd8OD\xa3Y\x96\xe8\x83\xa9\x9eBa\x85p')

{'A1': 3366,
 'A2': -8576131510706911909,
 'A3': {'B1': 3222210193574046962,
        'B2': 'ffy',
        'B3': 3,
        'B4': [{'C1': [-96, -58, -3, 92, 42, -78, -91, -109],
                'C2': 54482,
                'C3': -663129714},
               {'C1': [-72, 32, 67, -116, 88, -40, -30, 101],
                'C2': 36732,
                'C3': -1377114333},
               {'C1': [-21, 76, -100, 33, 12, 55, -98, 92],
                'C2': 57203,
                'C3': 281054492},
               {'C1': [34, -20, -88, 16, -88, -29, -88, 89],
                'C2': 62495,
                'C3': 2060138874},
               {'C1': [-95, -47, -74, 26, -34, 52, -80, -90],
                'C2': 58307,
                'C3': 5177852}]},
 'A4': 25630,
 'A5': {'D1': [3771761662004221306,
               8343779085228467577,
               -4155833122401307253,
               938039378675278681,
               -7572658008895626875],
        'D2': 112},
 'A6': 2605668123,
 'A7': 0.8717313408851624,
 'A8': -6918700095513147185}

(b'JOOP\x86\r\x81\xa8\xa0}-fX\xb2\x00\x00\x00N\x93\xd6\x00a\xc6\xa8'
 b'\x15\xe9=\x94\x1fQlc#Q\xa9\xf2t.ubzv\xf2\xf1c\x9aI\xab\x83\xdem\x15'
 b'@\xc8`\x13vgp\xee3\xf8\xfc\x1f\xfe\x9a\xe0\xbe\xa5\xf7\x00\x00\x00*\x00\x00'
 b'\x008l\x85\x07\xfe\xe0\x9e<\xba\x00\x00\x00\x04\x00&"\x00\x02\x00F\x82c\x08'
 b'r \x94p\xbbS\xd4U\x01\x1a\xd1\xaep\xaa,h\xc7k}NmF\xd8\xa5\xd3dgW\xe2Y\xf9f'
 b'\xef\xff\xa4\xd5\x82T')

{'A1': -31219,
 'A2': -9103850187236419406,
 'A3': {'B1': 7819665119270288570,
        'B2': 'ubzv',
        'B3': 34,
        'B4': [{'C1': [-14, -15, 99, -102, 73, -85, -125, -34],
                'C2': 27925,
                'C3': 1086873619},
               {'C1': [118, 103, 112, -18, 51, -8, -4, 31],
                'C2': 65178,
                'C3': -524376585}]},
 'A4': -27690,
 'A5': {'D1': [-9051381539818671941,
               6040546463443955312,
               -6184452982575378835,
               5105012504965634018,
               6483326319548749186],
        'D2': 84},
 'A6': 3332904425,
 'A7': 0.07232535630464554,
 'A8': 7810125012441134126}

Вариант №22

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

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

(b'YAWN\n\xa9\x1f?\xb0\xd5\xfa\xf0\x8a\x8f\x1f\x14\xe3 \xd4 \r?@\x8ac\xe6l\xc7'
 b'\xca\xbfv\x80\xa2\x01\xb9\xc3>\xd2\x91\x12H"\x1b\x9c\xf2\xc7\xc9?\x00wE\x9d'
 b'kf\x0c\xd4D\xb4?\xf2\xc6\xa0\x1fqlhlb0\x80<?\x03\x00\x00\x00X\x00\x00\x00'
 b'F\xb4\xe2\xbd,\xd2\r\xbf!\xba\x08')

{'A1': 0.6236730813980103,
 'A2': 176,
 'A3': 213,
 'A4': 2369759954711802106,
 'A5': {'B1': 0.5512821674346924,
        'B2': [{'C1': -0.20921097993330484,
                'C2': 15149761395884720246,
                'C3': 4753},
               {'C1': 0.2014144193874634,
                'C2': 15279700248147359488,
                'C3': 46148}],
        'B3': 63,
        'B4': 530630386,
        'B5': 'qlhlb',
        'B6': 0.7363309860229492},
 'A6': {'D1': [33, 186, 8], 'D2': [-0.11069540679454803, -0.5539882183074951]}}

(b'YAWNm\xa2Q\xbe\x9d\xb7}\x9a\xfa\x13\x15\xee\xd6Z\x9cQj?T\x87\x931\x1e\x1f'
 b'\xdd?\xa7\xd7\x03\x96\x05\x9a\xaa\\\xba|\xe0f1\x0bq\x1c\xab?\n\xe2[\xc0'
 b'\x872\xf34\xb9\xd7\xb2\xdf\xca\xd3\xf1aziwwQVf?\x04\x00\x00\x00X\x00\x00\x00'
 b'\t\x0b7<\xa3l\x10>g\xf8"]')

{'A1': -0.20472116768360138,
 'A2': 157,
 'A3': 183,
 'A4': 6545680882726509181,
 'A5': {'B1': 0.9153077602386475,
        'B2': [{'C1': 0.4550242885726352,
                'C2': 6677318746312529831,
                'C3': 31930},
               {'C1': 0.05295136701233871,
                'C2': 3815448867942162954,
                'C3': 55225}],
        'B3': 178,
        'B4': 4057189087,
        'B5': 'aziww',
        'B6': 0.8997545838356018},
 'A6': {'D1': [103, 248, 34, 93],
        'D2': [0.011172064580023289, 0.1410394161939621]}}

Вариант №23

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

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

(b'UDSX\x94\xf9\x90=\x84U\xc4\x05j\x00u\x00\x80\x00\x8d\x002\x81N\x0f\x17(\x89x'
 b'\x1e\x89\xc6L6\xd3\xe4\x86`+K\xa0\x16\xdfv\x8a\x94*QW\xae\x80\xfa\xe0'
 b'\xfc\xf2)o-A\xfb\xfe\n\xd9\n\xb9r\x04\x00\x94\x00\xdc{WTz:6\xbb\xee\xd3\x12'
 b'0\x1d\xeb\xb9\xe8\x0bq\xf8a\x05@\xff\xfc"H\xdb\xb5>>[\xc4?m\xeb\xae;\xde\x02'
 b'\x00\x00\x00f\x004f\xe8\x01\xb2\x02\x00\x00\x00q\x00^\xe7\xd4\xce'
 b'h\x02\x00\x00\x00|\x00\x1b\xee\x80\xbaT\xcd&\x03\x00\x00\x00\x87\x00'
 b'I\xdd\r\x94\xf61#\xce')

{'A1': 415551092081883540,
 'A2': {'B1': [{'C1': 222, 'C2': [-5267, 15278]},
               {'C1': 178, 'C2': [26164, 488]},
               {'C1': 104, 'C2': [-6306, -12588]},
               {'C1': 38, 'C2': [-4581, -17792, -12972]}],
        'B2': {'D1': 8685517435866874162, 'D2': 1288079646},
        'B3': [11550373362901766966,
               6291856971879866134,
               8010200580175331502,
               13333708288034554157],
        'B4': 114,
        'B5': [56649, 37901, 12790, 52771]},
 'A3': -36,
 'A4': 17202402826460092283,
 'A5': 858140148472222419,
 'A6': 2521170541853931633,
 'A7': 4594897842722954056}

(b'UDSX6\x17p~5\xc6\xdc\xfan\x00{\x00\x86\x00\x93\x00:\xf4\xaf\xce\x94?\x99\xd8'
 b' 7)\x98\x0er\xbdb\xea\x9a`\xb4\xf9\xfe\xbb\xc9`\x82deF\\?\x1b'
 b'\xcc\xa7\x85\xa1\x9e1\xd4\x86\xc1\xa3$m\xe9\x06\x00\x9a\x00\xd1\xa9J'
 b'\xa9\xc0\x11\x9b\xc7\xa4v\n\x99;1\xb4Z\x94\xaa?\xde\xe6\x14W\xfeO\xb9('
 b'\xe91\xd9\xe5&\xb1lt\x01\x9a\xbf\tJ\x8b\xe2\x04\x00\x00\x00f\x00\x10V\xff'
 b'\xc8\x15$$\x03\x00\x00\x00u\x00\xdc"\xe9\xa7\xe2\x02\x00\x00\x00\x82'
 b'\x00\xe4\xc3\xcbu\x9e\xbb\x19\x03\x00\x00\x00\x8d\x00\xb2XD\x17\xc4\xfc'
 b'Xo\x87R\x18\xe7')

{'A1': -370203136294381770,
 'A2': {'B1': [{'C1': 226, 'C2': [29804, -26111, 2495, -29878]},
               {'C1': 36, 'C2': [22032, -14081, 9237]},
               {'C1': 226, 'C2': [8924, -22551]},
               {'C1': 25, 'C2': [-15388, 30155, -17506]}],
        'B2': {'D1': -2839168181725039558, 'D2': -1742129376},
        'B3': [12997558856060858894,
               7306107847714799353,
               11638893307081219142,
               7864590900881797534],
        'B4': -23,
        'B5': [22706, 5956, 64708, 28504, 21127, 59160]},
 'A3': -47,
 'A4': 11873629443134671529,
 'A5': -7756689284645975434,
 'A6': 5764140320365100970,
 'A7': -5681601158873274183}

Вариант №24

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

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

(b'LEH\xfan2\xbc\x07\xd7g\x00\x00\x00\xc6]gnkwio\x03\x00m\x00\xf2<\xe0'
 b'\x1eOf\xed?\xa1Ghdrrgh\x02\x00y\x00\x9c!\x0e&\x91\x8d\xd8\xbf\xf3\xaeyrpne'
 b'q\x02\x00\x81\x00\xac\xf3|\xe9z\x19\xe4\xbfM\xfalqixff\x03\x00\x89'
 b'\x00\xf4\x8b\x86\x98:\xc3\xef?\xf7\xf2\xba\x00\x04\x00\x00\x00\x95\x00O'
 b'AGF\xd5L\x00\xea\x8e\xbdx\xaaq\xbe?`\x13>\x83D1\xbf\xfa"R?\x82\x85\x03'
 b'>\x10p4\xbd#\t\x1d?\x10\n\xfc<\xd4\xaf\xaf>S\x19\xc2\x8d\xf5\xa9d"')

{'A1': -0.010890716686844826,
 'A2': {'B1': -10489, 'B2': {'C1': 1179074895, 'C2': 19669}},
 'A3': [{'D1': -58,
         'D2': 93,
         'D3': 'gnkwio',
         'D4': [-0.06978225708007812, -0.2360018491744995, 0.1439218372106552],
         'D5': 0.9187388995213992},
        {'D1': -95,
         'D2': 71,
         'D3': 'hdrrgh',
         'D4': [-0.6924516558647156, 0.8208461999893188],
         'D5': -0.3836405631668869},
        {'D1': -13,
         'D2': 174,
         'D3': 'yrpneq',
         'D4': [0.12843897938728333, -0.044052183628082275],
         'D5': -0.6281103668512649},
        {'D1': 77,
         'D2': 250,
         'D3': 'lqixff',
         'D4': [0.6134206652641296, 0.03076651692390442, 0.34313833713531494],
         'D5': 0.9925816515936945}],
 'A4': 12251895,
 'A5': [6483, 36290, 43509, 8804]}

(b'LEH\x1c\xb0c>\xee,g\x00\x00\x00_\xcatfzbgq\x02\x00m\x00\xe8w\xc7'
 b'c\x9f\x8d\xc8\xbf$\xecymrbfj\x03\x00u\x00f7\xa6\xe4\x1a\\\xec?\x02\tmhdpj'
 b"a\x03\x00\x81\x00\xd4b\xb0'|g\xe4\xbf\xd7.lovcnn\x03\x00\x8d\x00T\xd7\xda"
 b'I\x03\x8a\xda?\xa7\x05x\x90\x02\x00\x00\x00\x99\x00\xda\xb2\xd4\xc1\xaf'
 b'~\x9d/a>9\x9bv\xbf\x19{\x8d>\x87py?L\\-?\xad\x19!\xbf\x8ah^?\x04r0\xbe33,'
 b'\xbf\xbc\xed7?O?\xea>\xa1\xf6b|')

{'A1': 0.22235149145126343,
 'A2': {'B1': 11502, 'B2': {'C1': -1043025190, 'C2': 32431}},
 'A3': [{'D1': 95,
         'D2': 202,
         'D3': 'tfzbgq',
         'D4': [0.2199081927537918, -0.9633060097694397],
         'D5': -0.1918219792559619},
        {'D1': 36,
         'D2': 236,
         'D3': 'ymrbfj',
         'D4': [0.27632978558540344, 0.9743732810020447, 0.6771895885467529],
         'D5': 0.8862432924085908},
        {'D1': 2,
         'D2': 9,
         'D3': 'mhdpja',
         'D4': [-0.6292980313301086, 0.868782639503479, -0.17230993509292603],
         'D5': -0.6376324439216554},
        {'D1': -41,
         'D2': 46,
         'D3': 'lovcnn',
         'D4': [-0.672656238079071, 0.7184712886810303, 0.4575142562389374],
         'D5': 0.41467363560092463}],
 'A4': 2423784871,
 'A5': [63137, 31842]}

Вариант №25

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

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

(b'CJHCcmztpx_\xa0\xaax?\x00\x00\x00G\x00\x00\x00\xfb\xa86\x91\x94\x9b'
 b'\xab\x95\xb50\xa9\xe7\x98\xe0\x9f\xb0\x9c\xa0\xb2\xe2\xbfp\xaa\xe5>({bq\x8e'
 b'\xe8\xc9?q\xdd\xa5\xe7_\x00\x00\x00\x93\xbe\xf6\xbeI\x00\xcd\x07Zk7?V'
 b"\x1a'\x95}\x93\xa4R\xa1\xd9\x96p\x1cVoC\\\xd3{+\xd6\xa0A\xf3>"
 b'\x11\xee\xbf\x03\x00\x00\x00O\x00\x00\x00{C\x0e\xb3\xbf\x13\xf4\xc8\x90'
 b'\xe0\xdf\xb9\x02\x00\x00\x00U\x00\x00\x00\x02\x00\x00\x00W\x00\xc7]\xfd'
 b'\xbe\x0b\xbd')

{'A1': 'cmztpx',
 'A2': 2024448095,
 'A3': {'B1': [{'C1': -0.4819227159023285, 'C2': 130875465},
               {'C1': 0.7164818048477173, 'C2': 2502367830}],
        'B2': 43259,
        'B3': {'D1': 3509876048887320886, 'D2': 59305},
        'B4': -104,
        'B5': -0.5843051014280682},
 'A4': 0.4485659599304199,
 'A5': 0.20240955864297772,
 'A6': {'E1': 3886407025,
        'E2': {'F1': -0.9396052123165883,
               'F2': [37757, 21156, 55713],
               'F3': -1290910853,
               'F4': -5053073344435055681,
               'F5': [150, 112],
               'F6': [1131370012, 729535324],
               'F7': -0.4948560893535614,
               'F8': 48395}}}

(b'CJHCmradpk\x90\x9fH\x8a?\x00\x00\x00G\x00\x00\x00N\xbb\x88\xad\xd0\xb2'
 b'Y\xb5=\xe2(\x85"|R0u\xec+\xe5?\x8a\x87\xd7\xbe8S\xb1!\x98\xec\xce?\x9e'
 b'\xe6\xda\xa3^\x00\x00\x00\xe7-\xb5\xbcE\xfa\xf1\xdf\xc3!^\xbf\x90 \xd3IV'
 b'\x00@\xa8Y\x97\x8f\xaa\xd3\xc5W\xa3\xe3\xb8\\\xb2\x89i\r\xf4\\'
 b'\xe3\xbf\x02\x00\x00\x00O\x00\x00\x00\x95\x0c:\xd2-[\x08\x100\xec'
 b'\xc8\x03\x03\x00\x00\x00S\x00\x00\x00\x02\x00\x00\x00V\x00\xd6c9\xbf'
 b'\xed\x07')

{'A1': 'mradpk',
 'A2': -1974952048,
 'A3': {'B1': [{'C1': -0.022116614505648613, 'C2': 3757177413},
               {'C1': -0.8677026629447937, 'C2': 1238573200}],
        'B2': 47950,
        'B3': {'D1': -2144358450701750904, 'D2': 34088},
        'B4': 34,
        'B5': 0.6616117752879087},
 'A4': -0.42095595598220825,
 'A5': 0.24159528393888663,
 'A6': {'E1': 2749032094,
        'E2': {'F1': -0.6050968419988776,
               'F2': [86, 43072],
               'F3': -767947627,
               'F4': 272727468627483437,
               'F5': [89, 151, 143],
               'F6': [1472582570, 1555620771],
               'F7': -0.7241796255111694,
               'F8': 2029}}}

Вариант №26

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

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

(b'\xb7IFOL\x8e]\xb4\xc1\xbd\x13\x89\xfc\xf7\xc06D\r\xbf\xe2\x8d\xd1\xc0\xe1'
 b'EX\x00q\xbf\xe1\n\x94\x07\xc0\xc3\xc6)I\x84\xe9E\xe0v\xea\xef\xa8\x80\x84'
 b'r\x92\x1d5\xe1(\xd47\xbf\x14\xff\xd9\x97\xca\x1e\x11\x8b\xa7\x1e\x98'
 b't\xdb\x9bu\r\xb0_\xa5\xc1m\xfe(\xbf\xc7\xd5<\x85\n\xa6\x05a\xd8&Gs\xcaY@'
 b'!\x00\x00\x00\x07\x00)\x7f\r\x9a*\x00\x00\x00\x06\x00EEl<\xa9a?\xe6'
 b'\xf7z\x9eb\x1e&meju\x00\x00\x00\x02\x00]P?\x8e\xff\xce\xfb\xcbk-\x81\xe7\xe8'
 b',\x8a/B\xfe')

{'A1': {'B1': -1906461503, 'B2': 13624385017307215428, 'B3': 13},
 'A2': -0.5798119322954944,
 'A3': {'C1': 69,
        'C2': 1815914849,
        'C3': 0.7177098363326351,
        'C4': 'meju',
        'C5': [{'D1': -900120543,
                'D2': [-529077521,
                       -1467972494,
                       -1843579423,
                       684996543,
                       352311703,
                       -903999093,
                       -1491167116]},
               {'D1': 2131597866,
                'D2': [-610568947,
                       -1335908927,
                       1845373119,
                       -942326651,
                       178652513,
                       -668579981]}],
        'C6': 80,
        'C7': [16270, -50, -1077, 27437, -32281, -6100, -30161, 17150]},
 'A4': -0.5325412894654782,
 'A5': [41, 73, -124, -23, 69]}

(b'\xb7IFOL#\xc5\x94KH\x8e\xc7\x10\xf4\x1bF\xd1\xc8?\xd8\xea%\xa8\x94'
 b'\xaa\xf4\x00U\xbf\xe3\xb9\xaa\xc2\x87@\xf2\x15\x81A\x19b\xcc\xeb\x11/\xc5KV'
 b'\xe2p\x8f\x05\xdf\x18|\xef\xa1W\x12\xc4\x0bT\x1e\x13\xd6\xd2\x81U'
 b'S\x00\x00\x00\x02\x00)\x98\xb6D\xac\x00\x00\x00\x04\x001Z\xa3\xa5\xaf=?\xe3'
 b'\xbcOt\x05#\xb2uxcy\x00\x00\x00\x02\x00A\xfd\x13\x9f\xdb\xae4\x8bD\xeaI+\xbd'
 b'\x89\xfd\t\xfb\xe0')

{'A1': {'B1': 600151115, 'B2': 5228335093052557009, 'B3': -56},
 'A2': 0.38929120505296955,
 'A3': {'C1': 90,
        'C2': 2745544509,
        'C3': 0.6167371049897297,
        'C4': 'uxcy',
        'C5': [{'D1': -763275949, 'D2': [-857009873, -984918302]},
               {'D1': -1732885332,
                'D2': [1888421343, 410840993, 1460847627, 1411257302]}],
        'C6': 253,
        'C7': [5023, -9298, 13451, 17642, 18731, -17015, -759, -1056]},
 'A4': -0.6164144324666536,
 'A5': [21, -127, 65, 25, 98]}

Вариант №27

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

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

(b'\xf2BGIF\x00\x02\x00\x8cR\xf6=#\xbb1MW\x8bic\xdcT1\xc4\x98<L\x11'
 b'e\x0e\x00\x02\x00\x94\x12,X\x16\xf5\xbb\xa6\xcf\xf1\x00&\xf6\xaa\x82'
 b'\x19\xd5\xd8\x19\xfe\x03\xbc\x0c\x1d\x9cb\xfb\xe0\xd7\xe9W\xb7ws\xd5C?^~'
 b'\xb9\xa8\x00\x03\x00\x00\x00,+\x89\xae\xb7\x00\x02\x00D\xf8\x7f\xaa*'
 b'9\xdd\xf0)Ed5\xb1\x8faU\x00\xe0\x99\xec\xda\xdf\xc1\x1064\xb4\xd0\x15'
 b'\xb4q`\x9a\xba9\x00\x03\x00\x00\x00\\R8y\xa6\x00\x02\x00t\xdb\xfd\xe2p'
 b'\x00\x00\x00F\x00\x00\x00v\x1e8\x84\xab')

{'A1': {'B1': [{'C1': 1585363368,
                'C2': [2807618893467998233,
                       18303680070786245371,
                       16201674747438134229],
                'C3': 730443447,
                'C4': [67, 63],
                'C5': -125851094},
               {'C1': 1620752953,
                'C2': [4169752890063467953,
                       10331632482421173466,
                       16123185965961629717],
                'C3': 1379432870,
                'C4': [180, 113],
                'C5': -604118416}],
        'B2': 82,
        'B3': 246,
        'B4': 1025751857,
        'B5': 1297582953,
        'B6': {'D1': 7195718877359651916,
               'D2': [17, 101],
               'D3': 14,
               'D4': [7736, -31573],
               'D5': 1309518447293212367},
        'B7': 241},
 'A2': 0}

(b'\xf2BGIF\x00\x02\x00\x85y>\x0bm\x13,\xeeG\x90z,\xeb\xfd(M\xd4\xe9\x80\x00'
 b'\xf9\xd8\x00\x02\x00\x8d\x9cAy]Z\xc3s\xf1\x17\xdd\x1f\x83\xd3\xc4\x98^\x15m'
 b'5W\xc7\x9cx\x01\xb3MD/\x14\xa8m\x92|\x0b\x99I\xd2\xf8\xcc\xac\x19\x00'
 b'\x03\x00\x00\x00,\t\x12!X\x00\x03\x00D\x81\xfe}\xfc%Qg\x93\xe4C-'
 b'\xf6\x01\x91\x7f\xe6-&U\xb6\x81uN\xd6\r9\x00\x02\x00\x00\x00]\x1f\xdcs'
 b'n\x00\x02\x00m7bs4\x00\x00\x00G\x00\x00\x00o\xde\xf3\x00c')

{'A1': {'B1': [{'C1': 4174162969,
                'C2': [2270891478448215405,
                       3843760281826210637,
                       4913168432109878283],
                'C3': 152183128,
                'C4': [153, 73, 210],
                'C5': -2114028036},
               {'C1': 1322650937,
                'C2': [2689044337404358134, 113012092237665718],
                'C3': 534541166,
                'C4': [129, 117],
                'C5': 929198900}],
        'B2': 121,
        'B3': 62,
        'B4': 191697708,
        'B5': 3997667450,
        'B6': {'D1': 3236959106742151552,
               'D2': [0, -7],
               'D3': -40,
               'D4': [-8461, 99],
               'D5': -7187330088444922895},
        'B7': 23},
 'A2': 221}

Вариант №28

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

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

(b'\rEKOFs/\xc2\x86B\x91[\xbb\xdcf\xd1\x17\xa9y\x02\xd2\x9ai\xbfvu\x05\x00'
 b'k\x00\xbc\xfbC\xf3\xc0G3\x9a\t\x89\xa58\xae\xe3\x811\xd2o\xa6\xb6XY'
 b'7\xc0<\xf3\xe9\xe5\x88\x84%X\xf4bX\xd8\xa0\x06s\xc6S\x11\xe3\xf0\xac`'
 b'I\xaa\xae{\x8a\xba?\xfa\xa7\x92\xe2\xd1}\xa0\x004o\xbb=@\xea\x8c\xeb\xb7'
 b'\x80>\xd5\x81A\x14\xe6\xa1\x89u\x876\xde\xe7\n8\xcct\xe1cJncs:\xb0H\xe7'
 b"#\xd2\xa5D\xa2\x7f\x93\xb1\x02'\xd5\xfd\xd3Zte\xa2a\x1f")

{'A1': [{'B1': 115, 'B2': 1116127791},
        {'B1': -111, 'B2': 1725741915},
        {'B1': -47, 'B2': 41527575}],
 'A2': -0.9125186204910278,
 'A3': {'C1': 'vu',
        'C2': {'D1': [785840985781668257,
                      7164745850037783608,
                      -6498091836078278029,
                      -3087496057832103356,
                      2261267044544205821],
               'D2': 11111303599693757372,
               'D3': [3567382717268330761,
                      -4596106657151946798,
                      6351628572983685948,
                      -4146963543983889676],
               'D4': -253554349,
               'D5': -84},
        'C3': 0.10367558492933915,
        'C4': 250},
 'A4': -89,
 'A5': -7534,
 'A6': 10517969,
 'A7': [16973198657287057204, 16578948154141868215]}

(b'\rEKOF\xc2\xb7\xf0\xa8\xbfs\x84C\xb5\xc7\xa1\xb7\x97\x19Z\xeeO\xe5\xbe'
 b'qm\x04\x00k\x00x\x11\\D\xc5X7\x94\x8ap\xab\xf2\xa3\xc0\t,\x0e6\\\xee\xffc'
 b'y!\'\xc1<\xfa\x93c\xb5\x91\xeb\x16<\xca@"\x91\xdb\x91\xad#\xc1l\xc0'
 b'\r\xcb\x12\x8d\xe3\xbf\xbf\x1f[?\xa8\xd6\x03\x9e\xc6t\xc8\x82\xd4\xf4-\xf8Zd'
 b'\x05\x1a\xf4[Zc\x8bh\xe6\x03\xca\xa8\x9d9\xb3L\x05\xbc\xe2\xba\xc6`\x7f\xc9'
 b'\x89\x980\xbe\xf0\xc8\xaa\x89\xb4\x96\xb3:\xc1\xbd\x0f')

{'A1': [{'B1': -62, 'B2': 3215519927},
        {'B1': 115, 'B2': 3350545284},
        {'B1': -95, 'B2': 1511626679}],
 'A2': -0.447875440120697,
 'A3': {'C1': 'qm',
        'C2': {'D1': [-5532217318978623896,
                      9178554546551260492,
                      -6140393392269915703,
                      1134275139032495241],
               'D2': 10680102645611106680,
               'D3': [3173279222842749066,
                      2412069026300442126,
                      -7947336480215744217,
                      -2625279446114101525],
               'D4': -1054626415,
               'D5': 108},
        'C3': -0.12456590374772869,
        'C4': 31},
 'A4': 91,
 'A5': -22465,
 'A6': -962722858,
 'A7': [6555039787198367860, 10043970944950207844]}

Вариант №29

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

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

(b'LZH\x19\xfaq!W\x02\x00A\x00\x00\x00l\xd59\x80k+\xce\x9a@\xdcK\x00\x04\x00'
 b'\x00\x00f\x00\x00\x00\xee\x02\x1a\x86\x91\xd1o\xe0|\xf4s\xe4\x11\xfc'
 b'\x1c\xdf9=\xebf\xf9Lh\x11\xdf\xc3,\xf4TL\x07-\x007\x00\xdb\xa0\xd9FA\xa3\xe1'
 b'\xc1\x02\x00\x00\x00E\x00\xde\xa7\x19\x04\x00\x00\x00G\x00&r\xe8\xf9'
 b'\x8b\xd7\x18&\x1ds\x04\x97\xfeN')

{'A1': 1461809658,
 'A2': [{'B1': 4580, 'B2': -475434062444552964},
        {'B1': 26700, 'B2': 525888664195292945}],
 'A3': -7291843005953485460,
 'A4': {'C1': -9152,
        'C2': {'D1': 49633,
               'D2': [219, 160],
               'D3': 222,
               'D4': 6567,
               'D5': [217, 70, 65, 163],
               'D6': [29222, -1560, -10357, 9752, 29469]},
        'C3': [4, -105, -2, 78],
        'C4': 750,
        'C5': -778992102,
        'C6': 111,
        'C7': 1945402592}}

(b'LZH\x19td\xfc\x99\x02\x00A\x00\x00\x00~\x18\x99\xdfw\x90\xcb\xb0\xda;'
 b'L\x00\x06\x00\x00\x00g\x00\x00\x00O\x99c\xc19("C*\x04\xed\xd3\xb1O'
 b'\x0e\xc2x\x11\x82R\x7f\x01\x90L{%\xef\xa8\xdcp\xa9-\x007\x00iH\x140\x91>\x95'
 b'/`\x03\x00\x00\x00E\x00\x8a\xa38\x04\x00\x00\x00H\x00\xfe\xa5\xfa'
 b'\x99\xd2\x83n\x9fx\xce\r\xee\x9d\x8c\x05\xc6')

{'A1': 2583454836,
 'A2': [{'B1': -20013, 'B2': 9174538402459160143},
        {'B1': -28671, 'B2': -6237242865783309492}],
 'A3': -5707309258235111298,
 'A4': {'C1': 15322,
        'C2': {'D1': 24623,
               'D2': [105, 72, 20],
               'D3': 138,
               'D4': 14499,
               'D5': [48, 145, 62, 149],
               'D6': [-23042, -26118, -31790, -24722, -12680]},
        'C3': [13, -18, -99, -116, 5, -58],
        'C4': -26289,
        'C5': 674873699,
        'C6': 34,
        'C7': 3976473155}}

Вариант №30

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

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

(b'RQWY\xd9\x05\x1d\xa7ufyF4\x9f\xbaf\xe5\xea?i\xd6\xf9\x16\xf4|\xfeW\x02'
 b'\x00W\x00 \x19$\x94Dx\xcd?\x10\xe3k\xfe#\\\xd5?\x03\x00g\x00\xcc'
 b'\xca\xbb\xd4\xc3\x13\xe4?\x94\x01,\xd3\xf1\x11\xd8?\x02\x00\x7f\x00\x1c'
 b'81\xe0\xfbb\xd9?\xe4\xb8LPK\xda\xec?\x08\x9a\xfc\x02%\xcf\xd6\xbf\x00'
 b'\x95\xba\xae\x96\x1e\x8d\xbf\x9c\xae\xd1L+5\xd4\xbf\x00\xafD\x8f8q\xd0?r'
 b'\xde\xc9\x85\x92Q\xef\xbf\x90\x07^N\xd4\xdb\xb8?\x80>\\\x9b\xff\x1d\xae\xbf')

{'A1': 5,
 'A2': 42781,
 'A3': {'B1': 'ufy',
        'B2': {'C1': 0.8405030865629974, 'C2': 6340642713183573609},
        'B3': [{'D1': [-0.3563931016127815, -0.014218499381352334],
                'D2': [0.23023278459022212, 0.333748815973693]},
               {'D1': [-0.31574518682348596,
                       0.2569104575256773,
                       -0.9787075627381923],
                'D2': [0.6274127154304892, 0.3760952532029702]},
               {'D1': [0.09710432923568946, -0.058822620119937774],
                'D2': [0.39666649717116953, 0.9016472404817049]}]}}

(b'RQWY\xd9U\xb4=vvz\xb0\x91\xcd\xba\xedF\xe9\xbf\xbb5\xbb\xfa\x9e'
 b'\x99\x91\xcb\x03\x00W\x00\x94\xc4\xb5\x0eS\xe1\xe7\xbf\xb4$u\x83\xe9'
 b'\xb2\xe5?\x02\x00o\x00\xac*SX\xf1\x16\xdd?\xa8t\xf1\x05N\xdb\xd0\xbf\x03'
 b'\x00\x7f\x00\xc4\xd0\xfc\xce\n\xc7\xe3\xbf\x9a\xb8\x8dB\xd5\xc5\xe8\xbf\xdc'
 b'}z\xda\xe0=\xdf?x\x8f$\x12\xceK\xe8?\xd0\xe2o\xeac\xdc\xd7\xbfp\xb7\x16g\xcd'
 b'_\xdd?\x8e\x92Z\x83;\x9a\xef?P^K\x82\xea\xb5\xc6?\xd8\xb5,,B\xf3\xd5?\\'
 b'o\xb5$\x17w\xef?')

{'A1': 85,
 'A2': 15796,
 'A3': {'B1': 'vvz',
        'B2': {'C1': -0.7899082802292039, 'C2': -3778069704296680005},
        'B3': [{'D1': [0.488151753766912,
                       0.7592535356857146,
                       -0.37282655615085236],
                'D2': [-0.7462554251961984, 0.6780898635417061]},
               {'D1': [0.45897231166133334, 0.98757720618285],
                'D2': [0.4545253145740087, -0.2633853014029435]},
               {'D1': [0.17742663728744157,
                       0.3429723197358192,
                       0.9832874028174774],
                'D2': [-0.6180471461034576, -0.7741495418429338]}]}}

Вариант №31

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

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

(b';BLL\xa7\x1c]HW\xc2r\xd0\xb7\x81]!R\t\x04CV\x11\x06\xf1\xb9\xbb\x11\xba'
 b'\x96\xc8d\x97\xae\xa2\xf8\x0bz.\xcagO#K\xc4\xe19~\x82\xd1\xf1\x02\x00'
 b'\x00\x00\x8a\x00F!\xf7\xdd8\xa8Qh+\x0c"\x1b\xbd\x14\x974\xff3\xe2\xf7'
 b'\x8a\xb6p\xf8a\xc6$\xe9\xc0\xd2\x9d\xf8?\x15ag\x18\xc1\x17\x8c\xb7\xeax\xb6'
 b'{\xb0\x02\x00\x00\x00\x92\x00(\xd9\x06\x89\x8a\x06\x9br\xf8}%i'
 b'\x11\xf4\xae\x82;\xa0\x9c\xb9N\x1c\xf9r\xbc\xf2\x03\xc3\xce\xa7\r;\xd0oO\x8e'
 b'\xbf{\xeb\xaa\xf7\xf2\xfa|\xdbn')

{'A1': {'B1': 167,
        'B2': 1464360220,
        'B3': [{'C1': [29378, -18480, 23937, 21025, 1033],
                'C2': 101799491,
                'C3': 7262220125040523761,
                'C4': {'D1': -3878028037284778345,
                       'D2': 1260605287,
                       'D3': 2117722564,
                       'D4': 130,
                       'D5': -3631,
                       'D6': [1875917581, 2076151375],
                       'D7': -571006650},
                'C5': 56},
               {'C1': [20904, 11112, 8716, -17125, -26860],
                'C2': 3795058484,
                'C3': 2649913150424910583,
                'C4': {'D1': 6995567933222207721,
                       'D2': 398530663,
                       'D3': 2028648332,
                       'D4': 182,
                       'D5': -20357,
                       'D6': [4076317419, 1859878138],
                       'D7': -1996039896},
                'C5': 138}]},
 'A2': 4168260358,
 'A3': 4288182158497490301,
 'A4': [-96, -100, -71, 78],
 'A5': 14898756333350353180,
 'A6': -89}

(b';BLL\x8f\x90\x90\xd5\xcd:\xd3\x04a\xdb\x9e\xba\xc2\xe3\x8d\x81O\xb1\xe1\xf8'
 b'\xdd\xac4\x9a\xef\x95\x9a\\\x1f\x11\xc4\xa9\xfa\xe2\xe7\xb2\xa1\xc59\xc0'
 b'\x9a\xc9\x02N\x1d\xec\x04\x00\x00\x00\x8a\x00\xa0#\x02\x0f\xa0\x83\xa02'
 b'\xce\xde2\x0e\xfeE\x90\xd7:\x94\xe9g\x9f\xdf\xc8\xbaU\xa06\xfe9\xcdG\xa4'
 b'\xda\xdb\xf2h\xd0\xa1\xeb\x9d=\xef3\x81\xfa\xaa\x04\x00\x00\x00\x9a\x00'
 b'rq\xd9\xc1\xae\x13\xd8\xd1\xd42\xd7\xcb\xdd1\xf7@{\xac\xf2\x93)\xa4\x98\xd9'
 b'\x0f"{\xee\x9d\x01q\xe8\xf8h\xb4\x18\xd5 Z\xbaJ\x06\xb6\xe7\x04\xa8\xea\x03'
 b'\x7f\xa9;,%\xcb\xc9\xb3}\xf3^hjP')

{'A1': {'B1': 143,
        'B2': 3453325456,
        'B3': [{'C1': [-11462, 24836, -24869, -15686, -29213],
                'C2': 3786493825,
                'C3': 11139072698958536184,
                'C4': {'D1': -1737550899165716644,
                       'D2': 969253298,
                       'D3': 46766784,
                       'D4': 78,
                       'D5': -5091,
                       'D6': [1761142897, 550836404, 105560666, 2818893750],
                       'D7': 251798432},
                'C5': 160},
               {'C1': [-24445, -12750, 13022, -498, -28603],
                'C2': 3918805719,
                'C3': 3936240335044190055,
                'C4': {'D1': -946922897517233666,
                       'D2': -341716888,
                       'D3': 871316893,
                       'D4': 129,
                       'D5': -21766,
                       'D6': [2843673578, 3408211003, 4085101513, 1349150814],
                       'D7': -1042714254},
                'C5': 174}]},
 'A2': 3570522131,
 'A3': 8881370258721199922,
 'A4': [-84, -14, -109, 41],
 'A5': 11380168694636845220,
 'A6': 1}

Вариант №32

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

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

(b'\xcaVZD&\x00?\x00X\x00\x88\x98\xc2\xfc\xcf\xe1\xca?h\xed\x0c\x84\x00\x00'
 b'\x00}\xe1\xf2RO{-\x19\xdfbtrj\x14\xd6\x04\x00\x00\x00"\x00#\xce'
 b'\xb1\x8e\x9b\xad\x82\xb3&\xae\xf3\xfccjsusT\xee\x05\x00\x00\x00:\x00$'
 b"\xd8F(\xa2\x1a\x1du&Gl.cyrxm\x99\x8c\x05\x00\x00\x00S\x00\xa8'\xc27\x98yV}"
 b'u\x85\xb1\x80\x9c\xa0CD\xf7W\xfb\x97c\xe59\xe2\xd0\x13\x98\xd5\xef\x00\xcb{'
 b'I\xd36\xe1G\x0cP\xbe\xe2\x07\xef\r\xf0\xcf\xe2?l\x00\x00\x00\xd3\x19Z_'
 b'f\xceXe\x80')

{'A1': [{'B1': 20,
         'B2': -42,
         'B3': 'btrj',
         'B4': -1900949981,
         'B5': -219640475567346277},
        {'B1': 84,
         'B2': -18,
         'B3': 'cjsus',
         'B4': 675731492,
         'B5': 3345126853728606882},
        {'B1': 153,
         'B2': -116,
         'B3': 'cyrxm',
         'B4': 935471016,
         'B5': -9173404226316502632}],
 'A2': 0.21001624910167416,
 'A3': 104,
 'A4': 3309,
 'A5': {'C1': -0.20317183434963226,
        'C2': 0.5878830215590336,
        'C3': {'D1': [-7495300435314237284, -3055670559301311133],
               'D2': 239,
               'D3': 31691,
               'D4': -516500663},
        'C4': 211,
        'C5': -9194845420702967271},
 'A6': [1391649149, 422411087],
 'A7': 223}

(b'\xcaVZD$\x00=\x00S\x00\xd4A,\x05\x03T\xd2?V{\xbf\x7f\x00\x00\x00\xc9\xd4\xdd'
 b'\x19\x91\x9cl\xf9\xcftnin\x02\x00\x00\x00"\x00\x15X\x07T\xd4\xea5\x15'
 b')\x1f\xb4\xc9hxwjaT\xd4\x05\x00\x00\x008\x00\x11o\xfa\x13r\xd7E\x0fZ\xf4\x13'
 b'\x85fl,\x13\x02\x00\x00\x00Q\x00?\xd9\x12\xf1cD\xdf\x90;h\xbf\x10\x10'
 b'\x82\x16;\xf8\x9b\x00;\xc4\xbf\x9a\x0cm\xb4\xf0\xfa\x18I\xef\x1d\t'
 b'\xff\xee\xca\xbc\xd8\x86>vN\xd6\xd8\xd3\x1a\xe4\xbfg\x00\x00\x00\xfb'
 b'\x8a$J\x03:n)\x06')

{'A1': [{'B1': 105,
         'B2': 110,
         'B3': 'tn',
         'B4': 1409767445,
         'B5': -3912467914968143148},
        {'B1': 84,
         'B2': -44,
         'B3': 'hxwja',
         'B4': 335179537,
         'B5': -8857467374467164302},
        {'B1': 44,
         'B2': 19,
         'B3': 'fl',
         'B4': -250422977,
         'B5': 1206797830201492579}],
 'A2': 0.2863776731983567,
 'A3': 86,
 'A4': -16517,
 'A5': {'C1': 0.2633723020553589,
        'C2': -0.628274844656018,
        'C3': {'D1': [4251569538683273744, -364593189361107004],
               'D2': 18712,
               'D3': 7663,
               'D4': -890306807},
        'C4': 251,
        'C5': 444007233715053706},
 'A6': [433968329, -110322543],
 'A7': 207}

Вариант №33

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

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

(b'OYS @\xe5\xd0p\xd2uchgnwum\x00x?2\xc7\x1b\xee<\xbf}_\xfb\xca9=\xae V\xd6'
 b'\x05\xbe\x86Ex\x95\xe8\xbe\xacJ\xd2\xbfC\xeao\xbfh)A\xbf\xda\xc4\xa4\x86'
 b'\xc1\x1a\xf8?\xa081\x9a\x95\x93\x00\xbf\xe7\xa8\xa7\x88n\xfe\n\xbf'
 b'\xdaD\xa1\xbdM\xbe\xe4\xbf\xe8\x0cZ5lL\xca?z\xa7\xbeui\x19\xd8.'
 b'\x00\x00\x00\x03\x00\x00\x00+$K\xf9R\xed\xa9\xb2\xd0\x00\x04\x00\x00'
 b'\x00\x13\x05\x17\x00\x00\x007')

{'A1': 541124048,
 'A2': {'B1': 28882, 'B2': 'uchgnwum'},
 'A3': {'C1': [{'D1': 0.6983506083488464, 'D2': 60988},
               {'D1': -0.9897457957267761, 'D2': 51769},
               {'D1': 0.08502261340618134, 'D2': 54789},
               {'D1': -0.2622487545013428, 'D2': 38376}],
        'C2': 1303,
        'C3': {'E1': [-0.4182521167717108,
                      0.03167872440352504,
                      -0.7393376984327358,
                      -0.41043895231903904],
               'E2': -0.7515078586024171,
               'E3': 0.9791220426559448,
               'E4': 30057,
               'E5': 25,
               'E6': 55342,
               'E7': [-0.3365083336830139,
                      -0.7652959227561951,
                      -0.9068794846534729],
               'E8': 2615458143188660944}}}

(b'OYSSV\t\x99\xf9\xe9eycftnux\x00~\xbfE\xd8\x7f\x82\x91\xbf$>\x0fD4\xbe'
 b'\xc1\x1a=\x9f6\xbe\xf1O\xb5\xbd\x9df@>\xba\xb7\x95\xbfb~\x86\xbc[\x96'
 b'+?\x0c\xc0\xaf\xbf\xedS\xb9Z,Q\xfa?\xec\x91\xf37<7 \xbf\xde\x8c\x88g\x9d\r'
 b'0\xbf\xed\x1fC\x92\xa1\x11\x0e\xbf\xc2[\x9d\xdf\x1c\xde\x10?\x1f\xad'
 b'\xe9\xacs\x11/W\x00\x00\x00\x06\x00\x00\x00%xc\x10\xac"\x97\x17\xf7\x00\x03'
 b'\x00\x00\x00\x13\x113\x00\x00\x00=')

{'A1': 1398147481,
 'A2': {'B1': 63977, 'B2': 'eycftnux'},
 'A3': {'C1': [{'D1': -0.7728347182273865, 'D2': 33425},
               {'D1': -0.6415719389915466, 'D2': 17460},
               {'D1': -0.37715330719947815, 'D2': 40758}],
        'C2': 4403,
        'C3': {'E1': [-0.9164702187723031,
                      0.8928161696255508,
                      -0.4773274432993331,
                      -0.9100664008952053],
               'E2': -0.1434209193628111,
               'E3': 0.6237474083900452,
               'E4': -21389,
               'E5': 17,
               'E6': 12119,
               'E7': [-0.4713112413883209,
                      -0.07685518264770508,
                      0.3646818697452545,
                      -0.8847430944442749,
                      -0.013402502052485943,
                      0.5498151183128357],
               'E8': 8674795638746454007}}}

Вариант №34

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

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

(b'HZC\x1a\x02\x00\x12\x00\x00\x00\x14\x00 \x00,\x00[\x00bb\xdb7A?'
 b'\xe3\x90\x1a\x14\xb4\xb0\xc7\x0b@\x96s?6\x83l\xf2JW~\xd9\n\x83\xa3>'
 b'\xd6\x0f\xf8\xec\x8bh(\xd0C\xa1N\xe3ao\x7fv+z\xa6<>u!\xc1\xf02s\xf4'
 b'.\x8d`\xcc\x03\x008\x00\xcd\x83\xc0\xdf\xfcN)\x9b\xa4\x86\xfeP\x00\x00\x00;'
 b'5s\xbe\xa0\xe7')

{'A1': 26,
 'A2': 'bb',
 'A3': [{'B1': 0.7547585368156433, 'B2': 848841342260515043},
        {'B1': 0.9515113830566406, 'B2': -2774684341007252682},
        {'B1': 0.3193591237068176, 'B2': -3447390564566691882}],
 'A4': {'C1': -24730469,
        'C2': {'D1': [8538665884733841731,
                      13916533233717508651,
                      14726926014310724336],
               'D2': -51,
               'D3': [131, 192],
               'D4': 693042399},
        'C3': -0.23750774562358856,
        'C4': -6240}}

(b'HZCC\x03\x00\x12\x00\x00\x00\x15\x00!\x00-\x00\\\x00fplF\x17u\xbf\xaf\x97m'
 b'1\x97N>\xc1`3:\xbfj/_\x86J\r)4\xf5\xf6\xeb>1\xf9uK+<iB\x96\xee)Q\xc4\xef#'
 b'\xc4O\xc0N\xf5\xc6O"\x95,\xdf\xc2\x92\x85\xde\xa3"\x03\x009\x00\x04\xdc('
 b'v2\xa0#\x13\x04\x13\xd3Q\x00\x00\x00uVb\xbfTX')

{'A1': 67,
 'A2': 'fpl',
 'A3': [{'B1': -0.9573863744735718, 'B2': -4522090564557105233},
        {'B1': -0.7273464202880859, 'B2': 3758549977750515562},
        {'B1': 0.4608685076236725, 'B2': 4785422235705145649}],
 'A4': {'C1': -753728493,
        'C2': {'D1': [14133403682073079446,
                      10746239376797122639,
                      2496083283767648044],
               'D2': 4,
               'D3': [220, 40],
               'D4': 597701238},
        'C3': -0.8841317296028137,
        'C4': 22612}}

Вариант №35

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

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

(b'VZVI\x03\x008\x00\x00\x00;\x00X\x00u\x00\xa3\x82\xa4\xaa\xbe \xe6\x07'
 b'\xd6\xd92\x05b^\x14\xb6\xc4\xe3\t]\xe7\xbc\xba\x14\x07\xdfYK|\xac"\xff'
 b'\r\xcb\xd8\xbf7|\xee\x96<\x0e\xf7\xfdN;\xed\x02\xd4Sb\xa1\xa0\x87\x1e#'
 b'\xf9\x13\xbc\x9bWP]1\xaa\xb7\x15iw\x1c\xd3\xa9h\xe2w\x93\xa4\xd1W\x9f'
 b'id\xf5\xe00H&5\xc3z\x0e\x9d\xba\xc3\x05\xc8\x84?l\x0b6\xa6\xd8\x92'
 b'\x03\x1c\rv\x15\xab\xcf\xebt\nF)\xf8\xdc\xbd\xa4\x0c\xf9\xfa\x82\xbf_cw'
 b'\xfc\x96')

{'A1': [60, 14, 247],
 'A2': [{'B1': 20221,
         'B2': 3556961595,
         'B3': {'C1': -494517966216273325,
                'C2': [19, 188, 155, 87, 80, 93, 49]},
         'B4': -6209588162024065110},
        {'B1': 57960,
         'B2': 3517223799,
         'B3': {'C1': 5201904914169175895,
                'C2': [38, 53, 195, 122, 14, 157, 186]},
         'B4': 3894325322858366403},
        {'B1': 55462,
         'B2': 219939730,
         'B3': {'C1': 5046974888572294518,
                'C2': [41, 248, 220, 189, 164, 12, 249]},
         'B4': -7567042005197421830}],
 'A3': 33443,
 'A4': [549366436, -640284698, 1583482162, -473647596, -1125688055],
 'A5': {'D1': 5306, 'D2': 1264180999, 'D3': -0.3873934737736773},
 'A6': 31799,
 'A7': 38638}

(b'VZVI\x04\x008\x00\x00\x00<\x00Y\x00v\x00\x9d\xab\xa2\x12\x04\x9a\xa3\x97'
 b'\xc7\x8c\xe2\xa6\x95h\x8d\xb1\x19\xdd\x98\xb9\xcd#^Wad!J\xf0\x0f\xa2y@E\xb5?'
 b'\xb6\x88\xb8W\xc6\xd8\xc4\xc8\x15\xbe%:\x98/s\x1f\xde\x00\xfd\x08'
 b'\x82\xf7\xb6\xe9\xa8\x87\xf6\x9a\xc1\xc7\x99\x0c\x1aR\xa8\x00\xa7\xf2\xfd4'
 b'\xea51\x9c\xd2\xa5w\xb0]wo\xd5\x18\x92D\x8f\xd5e\xe4\xd5\x12\xfe=\x14'
 b"[]\xf9\xb0'\x96\xe1\x98P\xe1<l4\x8fJ\xf5\x10\x08\x06\x84\x18\xb3\x7f/Fr\xd3P"
 b'\x04\x84{')

{'A1': [198, 216, 196, 200],
 'A2': [{'B1': 48661,
         'B2': 798505509,
         'B3': {'C1': -611916716634661005,
                'C2': [182, 233, 168, 135, 246, 154, 193]},
         'B4': -6412940798797768249},
        {'B1': 65010,
         'B2': 825616948,
         'B3': {'C1': 8031991472941552284,
                'C2': [213, 24, 146, 68, 143, 213, 101]},
         'B4': 6726992724896175588},
        {'B1': 45305,
         'B2': 2564920871,
         'B3': {'C1': -771646930823618224, 'C2': [16, 8, 6, 132, 24, 179, 127]},
         'B4': 8900243508782319151}],
 'A3': 43933,
 'A4': [-1711009118, -1933076573, 1754638050, -585518707, 600684952],
 'A5': {'D1': 22366, 'D2': 1243702369, 'D3': 0.08308794946248077},
 'A6': -30538,
 'A7': 22456}

Вариант №36

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

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

(b'CVCX\xfcx\x02\x00M\x00\x00\x00\xf1\x9b\xa2\xc4w\xf0wajqlk\x05\x00\x00\x00'
 b'\x8d\x00\xe6\xe9{\xbf\x04\x00\x00\x00\x92\x00\x00\x00\x12\xa4\xf4\xa8\x94v'
 b';j\x1f\xbf\x93S\xa7>m\xd6\xff3\xb2f\xe7\x1d\xc7^X#:\xcec\xfe\xd1\xc5I\x96'
 b"\x00`\x88+\xdd\x9b>\xe9\xbf\xd4\x88\xc4)\xc2'C\x19/\x9co\xaf\x16\xe4;"
 b'\x81\xe1\xf4\xaai\xa2\x13\x9b\x18l\x97z`\xb8\x98\xdb\xbf\xacc\x85'
 b'\x95\xb3\xa2\xb0FF\xb7\x13t\x03\xbe?\x1eC\xe0y\x92\xd3S\xa9y\x8e\x97\t'
 b'o?\xc5\xe2\x9f%\xb5\x1b@\xd5Pl\xe0\x11\xee?\xce\xaa\xaaDZi\x14\xd8EP\t\xb9'
 b'B\xc9\xf5\xdd\xbfS')

{'A1': 30972,
 'A2': [{'B1': -0.7888926810958417,
         'B2': 700745940,
         'B3': -5805249668556052542,
         'B4': 58390,
         'B5': 33083,
         'B6': 1773032466578863329},
        {'B1': -0.4311963026215071,
         'B2': -1786420308,
         'B3': 8364230445418717875,
         'B4': 48643,
         'B5': 7743,
         'B6': 8766630317814046787}],
 'A3': 39921,
 'A4': 4034380962,
 'A5': {'C1': 'wajqlk',
        'C2': [142, 151, 9, 111, 63],
        'C3': -0.9840377569198608,
        'C4': [-59, -30, -97, 37],
        'C5': {'D1': -23534,
               'D2': [-22284, 30356],
               'D3': -0.6227146983146667,
               'D4': 0.32680949568748474,
               'D5': 109,
               'D6': 14347878416134701014},
        'C6': 15131641535401252958},
 'A6': 18885,
 'A7': {'E1': 7093,
        'E2': 0.9396822085897512,
        'E3': -50,
        'E4': 5032795026305100458,
        'E5': -0.46812659755609776,
        'E6': 83}}

(b'CVCX\xa5\xe8\x02\x00M\x00\x00\x00z\x08\x05\xe2\x83\x95ilyrij\x04\x00\x00\x00'
 b'\x8d\x00\xf3\xb9*?\x02\x00\x00\x00\x91\x00\x00\x00\xb0G\xe5\x884I#+\xf3\xbe'
 b'.\xaa\xb6>v:H\xa6Ay\x87\x06\x16!pG\x16\xb6m%J\x13\x90\x93\x00\x00\x06\xef'
 b'{\x8a\x15\xb2?j\xfbHw\x88\x188\xf4UJqi\xa6Ef\x14\xff\xd3*Y\xcd\xe6\x8f'
 b'r\xa0\xf5Pb\t\xd7\xeb?\xc7\xdbV\x1f\xcc\xbc\xf9\xae|#\xed\x1b\xbbJ`'
 b'\x12\xc7\xb2\xa0\x0f\x0e\xba\xc4\xebO\xcedD\x87\xe38-H\x15\xf7\xc7q\xc3\xdd'
 b'?\x1a\x8c]_j1\xc3Pi\x90\x0c\xcb\xeb\xb5Y\xc8?=')

{'A1': -5979,
 'A2': [{'B1': 0.07064118886685122,
         'B2': 2001271658,
         'B3': 7597935779380729992,
         'B4': 17830,
         'B5': 5222,
         'B6': 8255070411632071679},
        {'B1': 0.8699995918502061,
         'B2': 525786055,
         'B3': 2012303626922998988,
         'B4': 19131,
         'B5': 4704,
         'B6': 16988908263902851783}],
 'A3': 2170,
 'A4': 2508448261,
 'A5': {'C1': 'ilyrij',
        'C2': [79, 206, 100, 68],
        'C3': 0.6668998599052429,
        'C4': [-121, -29],
        'C5': {'D1': 18352,
               'D2': [-30491, 18740],
               'D3': -0.4749384820461273,
               'D4': 0.35676711797714233,
               'D5': 118,
               'D6': 1587104873556887610},
        'C6': 5342797161770217505},
 'A6': -28653,
 'A7': {'E1': 11576,
        'E2': 0.465053983000264,
        'E3': 26,
        'E4': 7588779989124734348,
        'E5': 0.19023775113428032,
        'E6': 61}}

Вариант №37

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

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

(b'MAUB\xcb\xa8\x8a\x1b\x04\x00y\x00\x00\x00\xda\x15jP^>\xb6\x11"5[a@\x88'
 b'\x9a\xa5P\x8a\xf3\x14P\x04\x973\xae8\xf5\xdbd\x8d\x00\x00\x009'
 b'\xd5\xef\xb2\xa4\xa0L?\xa1/\xb7<\x03\x940?7X\x08?\xf0\xf6\xb9\x05I'
 b'\xbf`\xef\x03\xbf\xb1R\x13\xbf\x82\x00W>\x05\x1c?<\xcb>;X\x19\xbf\xd9'
 b'\xb6U?\xb4\x86\x90>\x88\x81z\xc9T=\xca.h?\xf3\x912\xbf\x81|\x18\xbf1\x00\x00'
 b'\x00C\x00\x00\x00U\x00\x00\x00g\x00\x00\x00$+\xf5\xa7\x80.\xfd\x84\xfcM\xde'
 b'#\x8aR\xe5\xbf\xeaRr\xa3\x07\x16"U\xec\xbf\x83\xd0\xf8\xa7\x8e'
 b'\x08\xe7\x94\xdd\x02\x00\x89\x00')

{'A1': 43211,
 'A2': {'B1': 7050,
        'B2': [{'C1': {'D1': -17, 'D2': 178},
                'C2': [0.7993261814117432,
                       0.022361578419804573,
                       0.6897584795951843,
                       0.5325960516929626]},
               {'C1': {'D1': -16, 'D2': 246},
                'C2': [-0.785243570804596,
                       -0.5153713226318359,
                       -0.5754805207252502,
                       0.2099628746509552]},
               {'C1': {'D1': 5, 'D2': 28},
                'C2': [0.3969440162181854,
                       -0.5990025401115417,
                       0.8348212838172913,
                       0.2822777032852173]},
               {'C1': {'D1': -120, 'D2': 129},
                'C2': [0.05194995552301407,
                       0.9069639444351196,
                       -0.6975395083427429,
                       -0.595649778842926]}],
        'B3': 5594,
        'B4': [3828642107646431338, 9966648058500374875, 4084258635777053939],
        'B5': -11,
        'B6': 25819,
        'B7': {'E1': -2063782272,
               'E2': -0.6663256359628913,
               'E3': 21226,
               'E4': -0.8853922300596493,
               'E5': 131,
               'E6': [-48, -8, -89, -114, 8, -25, -108, -35],
               'E7': [11044, 42997]}},
 'A3': 57,
 'A4': -43}

(b'MAUB\xd9\x04\xf8\xc3\x05\x00\x8b\x00\x00\x00\xff\x19\x9at\xff\x01'
 b'\xb7\xd0\x0b\xc2\xb2\xa9\xe8\x92\xa1\xb7\xffm\xb4\x9d\xe7R\xb3\xa5 x'
 b'\xf7\xbf\xb5\xa3\x00\x00\x00T\x0e\xd0\x93)_\x04?\n]\xad>\xf2\xaf\xe2>\xbd'
 b'\x04"?G\x90\xb7w\xf1\xbe8S%?\xa81\x08\xbf84\xba>.,v27\xbf\xeb'
 b'\xf3\xa2\xbe\x00\xac\x8b\xbe\xd3\xe52=D\xfdvM\xa2\xbeD\x8f\xab><\xe7\x05'
 b'\xbf\x11a{\xbfN\xce\xe8\xe6Y\xbf\xd07\r\xbf\x1eoV?\x16Aj\xbf1\x00\x00\x00C'
 b'\x00\x00\x00U\x00\x00\x00g\x00\x00\x00y\x00\x00\x00<5H\x97\xbb\xc5\x98|\xa4'
 b'eY\x17\xaf$\xea\xbf\xc9\xca8\xb4\x1e3\x15C\xe6\xbf\xb2\xeb?\x82\\3%'
 b'\xc4\xf7\x02\x00\x9f\x00')

{'A1': 1241,
 'A2': {'B1': -15368,
        'B2': [{'C1': {'D1': -48, 'D2': 147},
                'C2': [0.5170770287513733,
                       0.3386004567146301,
                       0.4427486062049866,
                       0.6328848004341125]},
               {'C1': {'D1': 71, 'D2': 144},
                'C2': [-0.4716164767742157,
                       0.6458010673522949,
                       -0.5320076942443848,
                       0.3636796474456787]},
               {'C1': {'D1': 46, 'D2': 44},
                'C2': [-0.7156137228012085,
                       -0.31826719641685486,
                       -0.272796630859375,
                       0.04367620870471001]},
               {'C1': {'D1': 68, 'D2': 253},
                'C2': [-0.316997230052948,
                       0.3350774049758911,
                       -0.523059606552124,
                       -0.9819498658180237]},
               {'C1': {'D1': 78, 'D2': 206},
                'C2': [-0.8511795997619629,
                       -0.5516328811645508,
                       0.8376330137252808,
                       -0.9150556325912476]}],
        'B3': 6655,
        'B4': [13982498952532948122, 7926255773777701298, 8656100673414733236],
        'B5': -9,
        'B6': -19009,
        'B7': {'E1': 2090386875,
               'E2': -0.816978021243973,
               'E3': 51913,
               'E4': -0.6956888197361257,
               'E5': 178,
               'E6': [-21, 63, -126, 92, 51, 37, -60, -9],
               'E7': [13628, 38728]}},
 'A3': 84,
 'A4': 14}

Вариант №38

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

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

(b'\xa2RPIr\x0f\x83Qu\xaf\xbf\x14\x9e\x1b\x94\xd1\xcc\xe0[mM\xa7\x04s'
 b'\xa6\x8c\xcd\xbf4\x99\xe4\x8aS\xee)\xa5\xd2\xac2\xfd\x9e\x00\x00\x00'
 b'E\xb2\xda\xc1\xfc\xa9nl\xdc\x8d\x90$t\xbf\xad\x02~\xbb\xfa\xb8i\x19D\xe3'
 b'\x03\xe5\xa91\xf6\xbf\xcaA0\xd5\xbc\xba\xf0\xd3K\x00\x02\x00\x00\x0052\xf7}'
 b'\xb3\x95\xaa\x11\xb7\xdd\xdek,>\t\xb3~#?\r\xbac\x99F\x0e\xe7\x84\xaa'
 b'\xa7\x80\x96\xef\x96\xf7oo\x1f7a\xed\xd3\xb0\xf3*\xbfl+\xbf\xbf\x13b)'
 b'>\xb4p\x8a')

{'A1': [{'B1': 29199,
         'B2': -2091813457,
         'B3': -0.5805374979972839,
         'B4': -108,
         'B5': 3519864923,
         'B6': 27981},
        {'B1': -22780,
         'B2': 1940294861,
         'B3': -0.7054731845855713,
         'B4': -118,
         'B5': 1408117157,
         'B6': -11604}],
 'A2': 50,
 'A3': 64926,
 'A4': {'C1': -441896458,
        'C2': -0.2051144641531759,
        'C3': 211,
        'C4': 75,
        'C5': {'D1': [10200693239844766334, 13545341590805209859],
               'D2': 855080371},
        'C6': -7662292334618449108,
        'C7': 0.1344737708568573,
        'C8': {'E1': 35,
               'E2': 0.5536252856254578,
               'E3': 2571505383,
               'E4': [33962, 42880, 38639, 38647, 28527, 7991, 25069, 54192],
               'E5': -3286,
               'E6': [-0.9225425124168396,
                      -0.5757165551185608,
                      0.3524211049079895]}},
 'A5': -1294286340,
 'A6': 2842586332}

(b'\xa2RPIk\x85\x131\xb6\x8b>\x83\xc4=\x10\xdd\x96g\x97\x8b\x9b<+\x95'
 b"\xa8\xf1\x19?@:\xb2p\x07\x1a\xd7v&\x9b\xd8\xb3\xcb\x00\x00\x00E]2%\xc9'9\xca"
 b"\x8d'\x9bz}\x0c\xa7\x93\xbe\x03\xc2P\xd4-(\xd2\x19G'\x9c\xa3?\xe5\xd7"
 b'H\x05\xdb\\\\E\xef\x00\x02\x00\x00\x005\xcenz\xe9k\xb5s\xa2}\xa1)'
 b'\xe7>\x16\x85\xaaX\xbe\x8f\x1cy\xf2\xe8\x04\x884qh=\x0e\x85\n\xaf\xfd\x8f'
 b'\xe7\xdf\x1b\x92\xfc\xe1m\r\xbfp\n\xde?.IO\xbf@\xc2\x8c')

{'A1': [{'B1': 27525,
         'B2': 322025099,
         'B3': 0.25735655426979065,
         'B4': 16,
         'B5': 3717621655,
         'B6': -29797},
        {'B1': 15403,
         'B2': -1784090343,
         'B3': 0.750895619392395,
         'B4': 112,
         'B5': 119199606,
         'B6': 9883}],
 'A2': 216,
 'A3': 46027,
 'A4': {'C1': 1193778339,
        'C2': 0.6825294603721761,
        'C3': 69,
        'C4': -17,
        'C5': {'D1': [2854009466371150782, 270867799816589849],
               'D2': 3463346921},
        'C6': 7761236674572528103,
        'C7': 0.14699426293373108,
        'C8': {'E1': 88,
               'E2': -0.2795141041278839,
               'E3': 4075291784,
               'E4': [13425, 26685, 3717, 2735, 64911, 59359, 7058, 64737],
               'E5': 27917,
               'E6': [-0.9376658201217651,
                      0.6808061003684998,
                      -0.7529685497283936]}},
 'A5': 1563567561,
 'A6': 658098829}

Вариант №39

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

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

(b'QOE\xe2xP\x97\xa1\x0f\xb8\x1a\xd4-\xcd\xb3\xc6?\xc8sH\x07\xd4\x8bZ'
 b'Q\x87\xb9\x88\xf3\xda\xa2_i\x88B\xc6\xaa\xcc\xbe\x02\x00\x94\x00\x00\x002E`'
 b'z\x02\x00\x9c\x00\x00\x00=_\x02J\xfc\x02\x00\xa4\x00\x00\x00\n\xa3\xfa17\xbe'
 b'\x19\xb0\xdf\xa0\xa122\xcfd\xb9\xec4\xdd\x99\xd3\xbf \xd4S?\xe2*\x1b}\xd4bul'
 b"1\xba\x91zGh\xc6H\xee'i{\xdbZqm9&\xdbin\xd1c\xad\xacl\x9e\xd0\x8a\xb5\x1er"
 b'T[\xaf\x1b\xb5\xbb\x1c\x17/7E8jj\xecu\x9cKl\xf0/\xc3\x9d\x88\x81zP\xcd'
 b'2w\x05\x14p]=\xd3\xdb\x02\xe8l\x1e\xe2\xf6\x0f\x8d\xbbR9')

{'A1': 120,
 'A2': 262248272,
 'A3': 0.17736210572930644,
 'A4': -56,
 'A5': 115,
 'A6': {'B1': 72,
        'B2': -11257,
        'B3': 15777104250029562507,
        'B4': 2288607138,
        'B5': 66,
        'B6': {'C1': -0.39974039793014526,
               'C2': [{'D1': [4033629084, 2292040495], 'D2': 2053129522},
                      {'D1': [3444603521, 335902514], 'D2': 1241669437}],
               'C3': -4,
               'C4': [7847525493858196848, 4130570022784786974],
               'C5': -23798,
               'C6': -0.1789015829563141,
               'C7': 2699014169},
        'B7': 3476173473,
        'B8': {'E1': -0.3062661187022029, 'E2': 0.8274555206298828}},
 'A7': [7815261393142885090,
        5243993472327858737,
        7886184321217275886,
        -5952684010301086151,
        8223209577435262124,
        1665412348748192596,
        8497283601384421167]}

(b'QOE\xe2\xfcd\xec\r\x81\xea\xbb\xf7\xac\xd2g\xe2?\xbd\xc1B\xec\x9eG='
 b'\xd0\xb9\xf5\xba\xb9W\xa1\xd5\xb5\xbc\x95\x7fh(>\x02\x00\x94\x00\x00'
 b'\x00r,\x00\x0f\x02\x00\x9c\x00\x00\x00\x9d\x84\x84\xc5\x82\x02\x00\xa4\x00'
 b'\x00\x00\x01\x83 \xdf\xa4\xbb8\x10u\xd7\xa52\x93\xbe@J2\xe1\xbe#\xa9?'
 b'\xe68D\xbe\x93\x174#\xc1\xa7NhlZ#\x80AX\xc8D~l6\xc2\x9e\xb1*\xb4'
 b"\xe9'\x99\xc5U\xb2da\xc2?\xff1\x12\xc1\xe1\xbb\x10\xc8\xfb\x96\xd8\xefRm"
 b'Dk\x83\xc8\x88\x18qj#\xab\x9d\\\x85\xa8Sk\xfbX\xd9\xd6\xf2`\xd7R'
 b'\xadT\xbb\xd4"\xf9-\xa9\xdd\x98Qk\x08\xb8\xe3\x14')

{'A1': 252,
 'A2': -2129793948,
 'A3': 0.5751737001681907,
 'A4': -67,
 'A5': -63,
 'A6': {'B1': 66,
        'B2': -24852,
        'B3': 6321289116538387783,
        'B4': 3166033313,
        'B5': 149,
        'B6': {'C1': 0.16446112096309662,
               'C2': [{'D1': [1553836835, 1800644741], 'D2': 251669618},
                      {'D1': [3604568315, 1389846770], 'D2': -981171043}],
               'C3': -126,
               'C4': [12190673694355051693, 1505249046771636445],
               'C5': -31999,
               'C6': -0.005031481385231018,
               'C7': 3614773304},
        'B7': 3197317797,
        'B8': {'E1': 0.049100842466164085, 'E2': -0.19162330031394958}},
 'A7': [7516129276089079699,
        4956308428267149932,
        -5464359902439379842,
        7017930200807188457,
        -4908429834964746302,
        7877622411749476368,
        7669938616147340100]}

Вариант №40

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

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

(b'SVE\x1f\x00\x00\x00\x86\xc8\x83\x90\xa3\x00\x00\x00\x99\x93\xbe\xd6\x0c'
 b'p\xd6\x14\xbd\xda\xcc\xea\xbcs\x04{\x80\x88\xbf\xdf=\xd2O\xcc\x9f %\xb4v'
 b'\xe6\xbbQ\xb0\x1a\xbe\x878\xc1\xdd\xa4*\xbbo\x15W\x07\x99\xf3s'
 b'\x14\xbf\xd9\xf3\x83\x93j\xd14\xd8s\xf5s\x05I\x1b\xfd\xdd\xe9\xfb'
 b"\xda\xc1X\xa3\x83H\x12\xf2?{\xdf!\xfeH\x00\x00\x00\x02\x00Q\xbf\xd4'\xad"
 b'v\x0eO$ \xc8\xffe?\xef^\xb5\xf6\xec\x01L:\x98\x937\x0c\xa6v8\x84\xcd\x00\x02'
 b'\x00\x00\x00\x11\x00Y\xef\xc0\xc4\x85\x00\x00\x00\x05\x00|H>\x80\xed'
 b'\x15\xbe\x14}W\xbf\\\x10\xdb\xbe\xe7\xa8N\xbfLF\x8f\xbd\xae\x0e[>\xec\x05'
 b'qKO')

{'A1': {'B1': [{'C1': -0.4180636405944824,
                'C2': 3591683546,
                'C3': {'D1': -3680922543239495544, 'D2': -0.4881482867517537},
                'C4': 9652,
                'C5': 1994832721,
                'C6': 45082},
               {'C1': -0.2641048729419708,
                'C2': 3718523579,
                'C3': {'D1': 8004399602880181012, 'D2': -0.4054879130956295},
                'C4': 55411,
                'C5': -177011383,
                'C6': 7165}],
        'B2': {'E1': 72,
               'E2': 1365223438303755848,
               'E3': [3723099098, 3243811715],
               'E4': -0.31492172745605473,
               'E5': 8392,
               'E6': 65381,
               'E7': 0.9803113768285043},
        'B3': 4022387845,
        'B4': [15000, -27849, 3238, 30264, -31539],
        'B5': 72},
 'A2': 3364065443,
 'A3': {'F1': [0.2518087923526764,
               -0.145009383559227,
               -0.8596321940422058,
               -0.45245593786239624,
               -0.7979516386985779,
               -0.0849883183836937,
               0.46097901463508606],
        'F2': 19279},
 'A4': 147}

(b"SVE\x1f\x00\x00\x00\x8a\x16'z\xac\x00\x00\x00\x9d\x96\xbfR\xe2\xf1d\xa2\x19"
 b'\xfb\xd7U\x06\xb6\xcd#_\xd4\xbf\xeb\x1e_\x1b>\x86j\x84\xe0\x0c'
 b'\xec\x93\x01\xb6\xeb>\xd6\x88\xfd#\xdf2\xdb\xef\xfa\x96\xc6 \xb0\xe8'
 b"C\xbf\xc5\xff\xdf\xcfE\xc8`\x90%\xba\x7fr\xaf\xd8'V\xd0c\xf87\t\x1e"
 b'\xe0V\xa4\xc8\x12\x84\x0f\xf5\xe8\x84\x00\x00\x00\x02\x00Q?\xc1\xff#'
 b'6\x13\x8d\xf0\x82\x91R\xd8\xbf\xe7\x06P\xf9\xd6\x1c^\xfb\x89s\xb0'
 b'c\xd0\xd5\x88MUB\x17\x14\xf4\x00\x02\x00\x00\x00\x11\x00Y\xbbq\x06z\x00\x00'
 b'\x00\x07\x00|\x10\xbe\x86\xb2\x13>YWF\xbfm\x1an?O\xac[?qB\x99>P\xc1'
 b'\x85\xbf\x18\x81\xf1\xc9\xb1')

{'A1': {'B1': [{'C1': -0.8237753510475159,
                'C2': 1688345083,
                'C3': {'D1': -2930428600339177516, 'D2': -0.847457459651378},
                'C4': 34016,
                'C5': 216830721,
                'C6': 46827},
               {'C1': 0.4190138876438141,
                'C2': 601830107,
                'C3': {'D1': -1154444576770955197, 'D2': -0.17187116261226532},
                'C4': 36901,
                'C5': -1166052689,
                'C6': 55335}],
        'B2': {'E1': 86,
               'E2': 11873760775975069828,
               'E3': [1456497656, 923344608],
               'E4': 0.14059867992828812,
               'E5': -32111,
               'E6': 21208,
               'E7': -0.7195210342041596},
        'B3': 3144746618,
        'B4': [-1143, 29616, 25552, -10872, 19797, 16919, 5364],
        'B5': 16},
 'A2': 371686060,
 'A3': {'F1': [-0.26307734847068787,
               0.21224698424339294,
               -0.9261845350265503,
               0.8112236857414246,
               0.9424224495887756,
               0.2038632184267044,
               -0.5957327485084534],
        'F2': -13903},
 'A4': 150}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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