ИКБО-01-22

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

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

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

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

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

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

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

(b'\x90TAK\x05\x00\x00\x00;\x00\x00\x00J\xe4\xb7\x03\x00\x00\x00@\x00cTd\x00o<]'
 b'\t<t\xa7NJ\xc6||\xfa\xc8\x8a\x82\x02\x1d\xff\x97\xacv\x0b\x18\xc9G\xa8'
 b'\x94T\x1c\xfbw\x84\x00mabvv\xd8|HV&]\x0e\xe0\xd1U\xc4=\x1ai\xfb\x8b'
 b'6\x1f\xc9\x94\xcd\x89\x9a=\xa5\x88.\xb2\x98>\x11\x03\x1c\xa6\x1b\xbe'
 b'\xff)\x8a>\x1d\x17\xd5\xbc\xbe\x9e\xb4>\xcd\x91Q?b\x07\x82\xbe\xfa`\x1d?'
 b':\xdd\x11\xbe\xe4}\x95\xbe]Si\x12\\\x0cO\x1e\x14\xba\xbc>\xb8\xf3\xa0\xa5'
 b'\xdf\x11\xd8\xbfz\x88 d?\x98u\x9d\xa0\xe1\xbc\xe5?\x06\x00l\x00\x00\x00\xb9'
 b'\r\xa7\xa4x\xa7\xbeS')

{'A1': 'mabvv',
 'A2': -7094,
 'A3': -73,
 'A4': [{'B1': [31960, 22088, 23846, 57358], 'B2': 0.09586680680513382},
        {'B1': [26906, 35835, 7990, 38089], 'B2': 0.07545814663171768},
        {'B1': [34981, 45614, 16024, 785], 'B2': -0.15200084447860718}],
 'A5': 21603,
 'A6': {'C1': 1049242111, 'C2': -0.026011997833848},
 'A7': {'D1': 5667626457273023599,
        'D2': [2088552010,
               -2104833798,
               -1744888574,
               403404460,
               -1800910903,
               2012945492]},
 'A8': {'E1': 2183977933883396957,
        'E2': 0.36860716342926025,
        'E3': -0.3760909192531545,
        'E4': 122,
        'E5': 0.8911213874816895,
        'E6': 0.6793068062794871,
        'E7': [0.35277360677719116,
               0.8186309933662415,
               -0.25396257638931274,
               0.6147609949111938,
               -0.14244547486305237,
               -0.29197609424591064],
        'E8': 6034444687323368889}}

(b'\x90TAK\x05\x00\x00\x00;\x00\x00\x00\xeb\x87\xef\x03\x00\x00\x00@\x00~\xf1d'
 b'\x00\x06cF.\x13TGt{ ,\xc3Ga\xe4\xa1\x87\xf7[\x89{\x0f>\xd7\x18T\x17'
 b"\x0b\xf1~C\xc0x\x00qncod,\xbd\x15'$jy\xd5\x0fTM>'\x9f\x16\xe6\x14W\xd7/"
 b'7\xc7\x83>u@a\xadz\x8e\xe3\x8a\x08\xbef?1:\x8bf\xb4jv\xbcU~\xb0\xbe'
 b"\x03\xb0\xee\xbe\xab\xf28?\xa5\xabP\xc5lP\x1b\xdc\x9d\xd8\xf2\xbe\xa0O'h"
 b'\x86@\xd9\xbf\xe8\x06\xbb ?0\x9bi\xd35\xf3\xe7\xbf\x03\x00l\x00\x00\x00\t'
 b'\xdd\x1epn\x82K\x12')

{'A1': 'qncod',
 'A2': -30741,
 'A3': -17,
 'A4': [{'B1': [48428, 10005, 27172, 54649], 'B2': 0.2005159705877304},
        {'B1': [40743, 58902, 22292, 12247], 'B2': 0.2573792636394501},
        {'B1': [16501, 44385, 36474, 35555], 'B2': 0.9013371467590332}],
 'A5': -3714,
 'A6': {'C1': 1720400433, 'C2': -0.015040088444948196},
 'A7': {'D1': 8378758073103573766,
        'D2': [-1020518277,
               -1578868409,
               -1990461561,
               -683798661,
               186078232,
               -1069318415]},
 'A8': {'E1': -2586385132897129563,
        'E2': -0.47430887818336487,
        'E3': -0.3945632950901601,
        'E4': 232,
        'E5': 0.6278537511825562,
        'E6': -0.7484387520933975,
        'E7': [-0.34471383690834045, -0.46618661284446716, 0.7224528193473816],
        'E8': 1318290726775086345}}

Вариант №2

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

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

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

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

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

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

(b'LMF\x08\x00\x00\x00\x11\x00\x00\x00m\x8e\x1f\x00\x00\x00cgylfejb>\x90O'
 b'L?\x01\xdd\r||2\xf0\xce\x14\xc1v5\x91\xb3\x9e\xa7\xf2Zu\x84\xbb{'
 b"4\xda\x9a\x9f5\xb9zX-\xb4d>\xfb'\x1d\x8e\xf6\xcd;\xd5\xd3\xab\xd8\x0e"
 b'\x13\x1e\x0eqU\xaa\xbe\x91~EB/\xc0\xd4\xd5\xa7\x08\x88\x84\x7f'
 b'\x06\xdc\xa3\xc8\x87\n\xeb9\x03\x00\x00\x00\x19\x00\x00\x00')

{'A1': 'cgylfejb',
 'A2': 36461,
 'A3': {'B1': [{'C1': 3549, 'C2': 8557143646006312060, 'C3': 53, 'C4': -111},
               {'C1': 40627, 'C2': 3781822489686635175, 'C3': 218, 'C4': -102}],
        'B2': 2058958239,
        'B3': 1689529688,
        'B4': 489159486,
        'B5': [1003353742,
               -659827755,
               236851982,
               -1096133263,
               1111850641,
               -707477457,
               -2071459673,
               -1545861505],
        'B6': {'D1': -351631416, 'D2': 57, 'D3': [-28610, 19535, 319]}}}

(b'LMF\x05\x00\x00\x00\x11\x00\x00\x00\xfa\xc8\x1e\x00\x00\x00eaaod\xb5\xc3'
 b'\xd0\xa2\x02\xf8bY@I\x06p\xec"\x9aV\'~\xf9FT\xc7\x88\xe3\n\xd4\xdeS5\x1f'
 b'[\xb2\xea%KR\xb6]u3\xe9\x0bh\xc0\xd7\x84(\xa2\xba:\xce\xe7K\xc1\xd65\xbd\xce'
 b'":%\xd2\x90\xef\x19v\xf6\xa8.\x16\xfa\x06\xf0\xf9\xa8\xac\x19['
 b'\xf4\x18\xd9\x04\x00\x00\x00\x16\x00\x00\x00')

{'A1': 'eaaod',
 'A2': 51450,
 'A3': {'B1': [{'C1': 18752, 'C2': 9090329592881508358, 'C3': 249, 'C4': 70},
               {'C1': 51028, 'C2': 2248795805446759304, 'C3': 91, 'C4': -78}],
        'B2': 1380656618,
        'B3': 863329718,
        'B4': 3228044265,
        'B5': [-1574402857,
               -405914950,
               903266635,
               975359677,
               -275721691,
               -1460242919,
               117052974,
               -1398212112],
        'B6': {'D1': 418667289,
               'D2': 217,
               'D3': [-15435, -23856, -2046, 22882]}}}

Вариант №3

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

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

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

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

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

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

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

(b'NLUZ\x05\x00\x1f\x00\x00\x00\xfa\xc07\x00mfq;B\xf3\xd3\xb3[-\xf3\x02\x00Y'
 b'\x00\x00\x00mylcuQ\x9d \x0f\xdf\xc6\x137\xe8>$\x00\x00\x00\x7fs'
 b'\x95\xb3\xdd\xe3\xbbO.\xb0\x893\xed\xf1\xe7N\xe1\x06Wu\x8f\xeb\xbf\xc3)\xc2'
 b'% \x92<\x99l\xc7.\x00\x00\x00P\x01rR\x82\x81\n\x0ca\xf1\xce!\xfe'
 b'\xb3\xd2A\xd3\xc6\x1e\x1cI?on"\x9aL\x9bga\x03\xdc\xb4\xd4_\x0c\xad\xc2\x014b'
 b'?')

{'A1': 'mylcu',
 'A2': 49402,
 'A3': {'B1': -17437,
        'B2': 16713400497757761103,
        'B3': -0.861262006735197,
        'B4': 10691,
        'B5': 14370028996461077954,
        'B6': {'C1': {'D1': 81,
                      'D2': 157,
                      'D3': -958460128,
                      'D4': 0.4535451829433441},
               'C2': 127,
               'C3': -575433357},
        'B7': 336},
 'A4': 'mfq',
 'A5': -923981520627875269,
 'A6': [{'E1': -1053547598565977486,
         'E2': [-50, 33, -2, -77, -46, 65],
         'E3': -14637,
         'E4': 0.7855852842330933},
        {'E1': 7018749297585974895,
         'E2': [3, -36, -76, -44, 95, 12],
         'E3': -15699,
         'E4': 0.8836060166358948}]}

(b'NLUZ\x02\x00\x1f\x00\x00\x00UT4\x00mlx\x90\x05\xa9w\xe5u\x11\xd7\x04\x00V'
 b'\x00\x00\x00svK\x10\xe4\x06\x0c+\xfa!n?!\x00\x00\x00q\x0fu\xc7+Y\x9c\xac\xc6'
 b'\x9e) \xa1\x1d\x92x\xc1a\xe2D4\xea?\xffa.r5\x9e\x13\xd3\xe0@+\x00\x00\x00'
 b'\xae2/\xe0\x0e\xd5*~v\xc2\x0c8\xb4\xc3x)\xe8\x95+L\x99\xbe\xad3\x97C\x06\xf7'
 b'\xa4\\\xe9\xf8\x99\n\xcc\xba_\x9cL\x80\xf8\xbc\x02\r\xfb\r~\xaf'
 b'\x15\xdc\xeb\n\x01\xac\xadD>j\xe0\xe8{\xbf\xe3\xe3\xbeQ\xc4\x92p\xe4a-'
 b'4RX\xedW\xb1\xf0(u\xbd')

{'A1': 'sv',
 'A2': 21589,
 'A3': {'B1': -25511,
        'B2': 10528748663371384492,
        'B3': 0.8188805028458281,
        'B4': 25087,
        'B5': 4674968494422716974,
        'B6': {'C1': {'D1': 75,
                      'D2': 16,
                      'D3': 722208484,
                      'D4': 0.9302059412002563},
               'C2': 113,
               'C3': 734491919},
        'B7': 12974},
 'A4': 'mlx',
 'A5': -2949446652535437936,
 'A6': [{'E1': -4434218060671426513,
         'E2': [12, 56, -76, -61, 120, 41],
         'E3': -27160,
         'E4': -0.29940924048423767},
        {'E1': 6675732153945764781,
         'E2': [-23, -8, -103, 10, -52, -70],
         'E3': -25505,
         'E4': -0.03033461421728134},
        {'E1': -2587969454919185150,
         'E2': [-21, 10, 1, -84, -83, 68],
         'E3': 27198,
         'E4': -0.9840221405029297},
        {'E1': -1985926063787678749,
         'E2': [97, 45, 52, 82, 88, -19],
         'E3': -20137,
         'E4': -0.05985349416732788}]}

Вариант №4

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

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

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

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

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

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

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

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

(b'YZR\x9b\x9d\x1f\x00\x00\x00\x04\x00\x00\x00)\x00T\x02\x00\x00\x00'
 b'-\x00\x02\x00A\x00C\x00\x9c7\xe8\x1c\x00\xc91%\x1d\x9b\xd7\xef\xc0luj'
 b'a\xda\xc7\x87\x1f\xf2\x1c\x93%l?\xb3\x93.\xf9e\xb8bI\xb5\xd1cnO`V\x1c\xd9'
 b'\xce!\x1f\x08\xbb\xb8\xc56\x7f\xde\xdb\x18\x18\x9f\xc3\xfcd\xdb\x9a\xe3X')

{'A1': {'B1': 157,
        'B2': {'C1': {'D1': 156, 'D2': -6089}, 'C2': 13902567635924890057},
        'B3': 'luja',
        'B4': 84},
 'A2': [{'E1': 528992218, 'E2': 7410, 'E3': 1064052115},
        {'E1': 4180579251, 'E2': 47205, 'E3': -776648350}],
 'A3': 'cn',
 'A4': {'F1': 2243301521285865551,
        'F2': 3317218056,
        'F3': -606175434,
        'F4': [-1012983784, -1696897796],
        'F5': 22755}}

(b'YZR\x9b\x0c\x1f\x00\x00\x00\x05\x00\x00\x00)\x00?\x02\x00\x00\x00'
 b'.\x00\x02\x00B\x00D\x00\x9d*\x95\x1c\x00\xf5\xe4\xe0Z\xea\x916\xc8cnprxt\xb4'
 b'*\xa2\xbc\xf0m\x97f\xfa!\xd4\xe4\x0b\x94\x7f\xec\xc1\xb9=uw+\xf6?\x95'
 b'\xdbz\xe0Ee\xde#+\xe9\xf2\x10,u\xd7\x81\xd5\xb7\xaf\xb1\x0eIY')

{'A1': {'B1': 12,
        'B2': {'C1': {'D1': 157, 'D2': -27350}, 'C2': 14426878892061025525},
        'B3': 'cnprx',
        'B4': 63},
 'A2': [{'E1': 2720707700, 'E2': 61628, 'E3': -93939859},
        {'E1': 199545889, 'E2': 32660, 'E3': 1035583980}],
 'A3': 'uw',
 'A4': {'F1': 5035159466920637995,
        'F2': 723770981,
        'F3': 739308265,
        'F4': [-712910987, 246525879],
        'F5': 22857}}

Вариант №5

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

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

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

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

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

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

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

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

(b'\xb8TBKV\x02\x00\x00\x00M\x00\x00\x00\xe80C\xb3\xd3Of\xb2a\x00\xf2\x06t\xad.'
 b'\x94\x1dF=\xb9b\x84\x03\x00\x17\x00\xd0\xce\x8cy\xc7\xbc\xed>\xad<|!('
 b'Y{\x9a\xc7\x82\xa4\xf8}\x02\x004\x00\x0bD)\xf4\xa0I\x0f?J\x94\x1d\xbd'
 b'\xae+j\xc4\xb5#\x00\x0eE\xc2W<\x00\xb0J\x1an\xbaV\x90V]\xf6\xa4E\x82\xbe\xd7'
 b'\x1c\x91\xbe\xdewo?\x98i\x06?\xf5\xec??\x92E\xbd\xbeqt@\xbf\xa2*H\xbf\x85'
 b'\xbf\x13\xb7_\xe3\xf68\xcf\xff\x00\x0bF\xf8\xd4\x88K\x8bxB\x02\x00\x00\x00Y'
 b'\x00')

{'A1': [{'B1': 43,
         'B2': -15254,
         'B3': -75,
         'B4': {'C1': [-1384904974, 1176343598, -2073904835],
                'C2': {'D1': 52944,
                       'D2': 31116,
                       'D3': 0.46433088183403015,
                       'D4': 561790125},
                'C3': 40}},
        {'B1': 14,
         'B2': -15803,
         'B3': 87,
         'B4': {'C1': [-946177191, 2113447042],
                'C2': {'D1': 17419,
                       'D2': -3031,
                       'D3': 0.5597171783447266,
                       'D4': -1122134966},
                'C3': -82}}],
 'A2': 12855049957039878376,
 'A3': {'E1': {'F1': 63069,
               'F2': [-0.25443756580352783,
                      -0.28342315554618835,
                      0.9354227781295776,
                      0.5250487327575684,
                      0.74970942735672,
                      -0.36967140436172485],
               'F3': -0.7517767548561096,
               'F4': -0.7819005250930786,
               'F5': 4104718110627708805,
               'F6': -8586965609772679217,
               'F7': 1115196235},
        'E2': [1847216816, 1452299962]}}

(b'\xb8TBKV\x02\x00\x00\x00Y\x00\x00\x00\x9a"E\x94\'\xa2(\xd2m\x00\''
 b'\xa7\x83C\xa6\x87\x9a\xb9\xae\xc7\xf1J\x93\x1c\xe0\xdc\x84sJ\xd6\x05'
 b'\x00\x17\x00\xe6W\x07<\xa7\x12,?\xdd\xbb\xe6}\xae\x10)\x13\xb7V\xef\x00\xd9'
 b'u\xdc \x18\x03\x00<\x001\xd9\xe8O1\xd8\xd2\xbe\xb9\xd6\xd2\x16\r2\x81V'
 b'.+\x00\x85\xe0\\\xa1H\x00\x9e\xd3\xe4o\x11-6\xea\xd2\x9a\xbd\x95C\xbf\x1f'
 b'F\xd3>\xe8\xf6\x00?\xa9\x7f\xe8>\xaaT6?A\x99>\xbf\xeb\xed\x93>\x8cO\xb3=a'
 b"V\x93',\x05\xb6\xf8q\xdd\\\x83Ip|n\xd5v\xc3\xbb\x02\x00\x00\x00e\x00")

{'A1': [{'B1': 50,
         'B2': 22145,
         'B3': 46,
         'B4': {'C1': [1132701479,
                       -1181055066,
                       1257359278,
                       -589292397,
                       -699763836],
                'C2': {'D1': 22502,
                       'D2': 15367,
                       'D3': 0.6721596121788025,
                       'D4': 2112273373},
                'C3': -82}},
        {'B1': -123,
         'B2': 23776,
         'B3': -95,
         'B4': {'C1': [-1223481072, -654250154, 404806773],
                'C2': {'D1': 55601,
                       'D2': 20456,
                       'D3': -0.411805659532547,
                       'D4': 382916281},
                'C3': 13}}],
 'A2': 15143532037908275866,
 'A3': {'E1': {'F1': 39634,
               'F2': [-0.764003574848175,
                      0.4126443564891815,
                      0.5037674903869629,
                      0.45409896969795227,
                      0.7122293710708618,
                      -0.7445259690284729],
               'F3': 0.28892454504966736,
               'F4': 0.08755406737327576,
               'F5': 17921517454368134753,
               'F6': 7961361702323019121,
               'F7': -1144817963},
        'E2': [1877267358, 3929419025]}}

Вариант №6

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

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

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

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

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

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

(b'MLTQ\xb6\x00\x00\x00\xb2\xbd\x02\xf6]\xb7`yP\xfb\x08\xad\xbby\xcf\xbf'
 b'\xa7\xa3\xbf\xaf+Biz\xb0\x11X`V`\xa9\x19\xabR\x08\xc4\xeb\xcb\xea\xaa'
 b'\x04\x00\x00\x00"\x00\x80\x1d\xeeb\xb1X\x1d\x89\x9dVi\xca\xb6\x91'
 b'\x04\x00\x00\x006\x00\xd2\xad\x06 u\xa1;\xcepy\xb0\xab\xd9\x9d'
 b'\x04\x00\x00\x00J\x00\x8eN\x87\x1bxN\x96d\x1e\xcb\x9b\xbb\xe2\x03'
 b'\x00\x00\x00^\x00+3\xcf\x17$\xe9B\xb5\xb6Hj6\x02\x00\x00\x00q\x00D\xd9Wa\x7f'
 b'\xdb\xe6\xfefe`8\xe7\x03\x00\x00\x00\x83\x00\xaa\xb6SA\x99\xbf_\x91z1'
 b'vX\x02\x00\x00\x00\x96\x00&\x00:\x00N\x00a\x00s\x00\x86\x00\x98\x00\x07\x00'
 b'\xa8\x00+d.\xed')

{'A1': {'B1': [{'C1': [6569, 21163, 50184, 52203, 43754],
                'C2': [88, 96, 86, 96]},
               {'C1': [22705, 35101, 22173, 51817, 37302],
                'C2': [128, 29, 238, 98]},
               {'C1': [41333, 52795, 31088, 43952, 40409],
                'C2': [210, 173, 6, 32]},
               {'C1': [30747, 38478, 7780, 39883, 58043], 'C2': [142, 78, 135]},
               {'C1': [6095, 59684, 46402, 18614, 13930], 'C2': [43, 51]},
               {'C1': [32609, 59099, 26366, 24677, 59192], 'C2': [68, 217, 87]},
               {'C1': [16723, 49049, 37215, 12666, 22646], 'C2': [170, 182]}],
        'B2': {'D1': 43, 'D2': 11876},
        'B3': -19},
 'A2': 8746192090540719538,
 'A3': -0.2459024996660113,
 'A4': -23641,
 'A5': -65,
 'A6': 1765944239,
 'A7': [122, -80, 17]}

(b'MLTQa\x00\x00\x00,\xa8\xcd\xc1\x90\x1e\xee\xad`n\xfe\xbb\xcb\x1d\xc2?'
 b'\xe2\x80\xefK\n\xf8\x13\xfe\x8a+\xc5V\xf0\xb0\x94\x1bFrC\xfbr\x01\x02\x00'
 b'\x00\x00"\x00\x7f\x97\x06\x83\xfb\xac \x19Sm\xd3\xd6\x8b\x03\x00\x00'
 b'\x004\x00\x8a\x01\xc8W\xc8\xb5c\xa1\xca\x9b\xa5\x9b\x9fc\x04\x00\x00'
 b'\x00G\x00$\x007\x00K\x00\x03\x00[\x00TQ\xa6\xd9')

{'A1': {'B1': [{'C1': [45296, 7060, 29254, 64323, 370], 'C2': [197, 86]},
               {'C1': [64387, 8364, 21273, 54125, 35798], 'C2': [127, 151, 6]},
               {'C1': [46536, 41315, 39882, 39845, 25503],
                'C2': [138, 1, 200, 87]}],
        'B2': {'D1': 84, 'D2': 42577},
        'B3': -39},
 'A2': 12532988420094273580,
 'A3': 0.1415342967928721,
 'A4': -32542,
 'A5': -17,
 'A6': 335022667,
 'A7': [-2, -118, 43]}

Вариант №7

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

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

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

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

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

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

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

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

(b'SBDI\x00\x00\x005\x00\x02\x00\x89\x00\x00\x00\x8du\xaa\x99\x89\xc1\x0cWt'
 b'\xbd9?\xb0?\x056$%\x0b\x14\x91V\xb2Q\xef?\xc5AX\x92\xc0y\x18\xdc\x89\x9f\xda'
 b'\xa1\x1c\xbf\xb4\xe2R\x06+fm4o\x86\x00\x05\x00\x00\x000S\xeaH\xf4\x00'
 b'G\xb8b\x06\xc0\x949\xbb\xdf\x1f\x93\x9b\xa2\x0e\x87\x86\x08\xd6\xf3\x94'
 b'b\x83\xb5\xcb\x14\x9e\x8b\x8fE\xdak\x88\x00h\x16\xf9M\x9at\xb3Iz\x1d\x06'
 b'9\xd4\xb6\xd4l\xaa" &\xf3H\xbb\xe0h\xbe\xa3\x02\x00K\x00l%\xa84n\xbf\xb0\x88'
 b'\xba\xaf\xee;\xa0\xd8\x1fb\xd5\xca\xfa\x96e\xfa\xe7\xab\x96Eh\xa8\x1b')

{'A1': {'B1': 2071573237745462118,
        'B2': 1832152966,
        'B3': [-36, -119, -97, -38, -95]},
 'A2': [{'C1': {'D1': 83, 'D2': 234, 'D3': 18676},
         'C2': -18334,
         'C3': [486551735442022291, 11214541997338056435, 10692253282150424203],
         'C4': 143},
        {'C1': {'D1': 69, 'D2': 218, 'D3': 27528},
         'C2': 5881,
         'C3': [5591910200714599686, 4167156578696962592, 2806666964542996131],
         'C4': 2}],
 'A3': {'E1': 631780462,
        'E2': -0.06458632273846243,
        'E3': 15573274706843440741,
        'E4': -367136182709475301},
 'A4': {'F1': 30122,
        'F2': -26231,
        'F3': -1056155788,
        'F4': [-17095, 16304],
        'F5': 0.5203573703765869,
        'F6': [37, 11, 20, -111, 86, -78, 81, -17],
        'F7': 0.1660567013322598}}

(b'SBDI\x00\x00\x006\x00\x02\x00\x8a\x00\x00\x00\x8e\xc4\xe4H\xa9\xd4\xa1\x9eF'
 b'\x86\x1d\x90\xfb=\r\x052\t\xf1\x18Y\x0e\x02 X?\xe6YC\x07\xd7\xee\xae1iC!'
 b'yDP\xd0\x8d\x01;G/\x04>\xd5+s\x00\x06\x00\x00\x000\x1a\xf9;\x0c\x00H\xf9\xf8'
 b'\xf3\xcf\x9dY\x95\xb9\xf2\x8f\x83\x85\xa6HR\xc9\xa2\xa1\xc7\x8b_\xd7'
 b'e\xca\xbe\xb1\x02\\9&E\x00iid\x17E\xb4dL]o\xc8a4\x89\xa2\xb6R\x14\xaa)%\xda'
 b'\xd60\xe8\x05\xfa\xcb\x00L\x00m\xb6\\9p\xbf\xd22\x89\x1f\xd5\xcd\xec\x07#'
 b'D\nQ\xeaW\xdeB\x9a\x8f\x0e\x7f\x8a\xe0\xbc')

{'A1': {'B1': 5823309354619055876,
        'B2': 1054157683,
        'B3': [49, 105, 67, 33, 121, 68]},
 'A2': [{'C1': {'D1': 26, 'D2': 249, 'D3': 15116},
         'C2': -1544,
         'C3': [17568433679485235855,
                9477163820427879073,
                14378691614040833713],
         'C4': 2},
        {'C1': {'D1': 92, 'D2': 57, 'D3': 9797},
         'C2': 26980,
         'C3': [1676944779136298952, 7004374652404503722, 2965016543171708410],
         'C4': 203}],
 'A3': {'E1': -1235469968,
        'E2': -0.28433445080665254,
        'E3': 514329593565042654,
        'E4': 4799305645348806844},
 'A4': {'F1': 50404,
        'F2': 18601,
        'F3': -727605690,
        'F4': [-31203, -28421],
        'F5': 0.034428782761096954,
        'F6': [9, -15, 24, 89, 14, 2, 32, 88],
        'F7': 0.6983962205117302}}

Вариант №8

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

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

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

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

Поле	Описание
1	uint8
2	double
3	uint32
4	double
5	int16
6	float
7	int16
8	int64

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

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

(b'JAU\x81\xaf\xe8\xc2\xc5\xfd[\xd3\x08d\x00\x00\x00sI\x00\x00\x00\x02\x00\x9e'
 b'~\xbc\xc8\xe6O>\xa5mI\xca\rk\x14\xa2\x89\x8e\xc0\xaa\xbf\xeb\xf9\xe3\xb4}'
 b'\xbf,\\\x19\xb4\xc2\xbf\xb4\xb7,f`j0\xd0#>\xad\xea\xfd3>\x16\r'
 b'\xd5\xa2\x94\xde\x15\xc2.\xbf\xa53\xf1\x85/J\xc0\xea\x86y\xf7?\xe1^\xa3\xa7'
 b'E\x0e\xa2\xaa@>\x9e\x06\x00\x16\xb2A\t\xec\x07\xf3I\x02\x96\xfeeCVsdt\x8cj'
 b'P_\x00)\x00N>\xec;h\xbbR+\x85\x11\xbb\xc7\xd5\xa7\xcb;\xe8\xfb\xe8'
 b'X\x14\x1e\x94\xc14\xf6\xd2\xe3\xb8\x18\x97')

{'A1': 12675595306849260296,
 'A2': 100,
 'A3': {'B1': -26918058,
        'B2': 'sdt',
        'B3': -1939189665,
        'B4': [{'C1': 170,
                'C2': -0.8742540860384671,
                'C3': 1545188546,
                'C4': -0.08092000483922202,
                'C5': -12253,
                'C6': 0.3396834433078766,
                'C7': 13118,
                'C8': 1589161137790653890},
               {'C1': 46,
                'C2': -0.041411921985532896,
                'C3': 3934681591,
                'C4': 0.542802645395984,
                'C5': -21952,
                'C6': 0.3086395263671875,
                'C7': 5810,
                'C8': 4686536406146286230}],
        'B5': {'D1': 0.46139073371887207,
               'D2': [13497898883710961621,
                      12090823496450988052,
                      2203598550914491320]}},
 'A4': 73,
 'A5': [24, -105],
 'A6': {'E1': 9132395035898062189, 'E2': 18890, 'E3': 13},
 'A7': 1796514441,
 'A8': -28992}

(b'JAU\x81S\x89\x97>&\x13\xe4"\x96\x00\x00\x00sj\x00\x00\x00\x02\x00\x9e\xf0YmA'
 b'\n\x9f\xae\xe60\xb0\xa2&\xaf\x90^s\xc2w\xbf\xe0\x16\x08\xd6bx\xfe\xf7\xd6'
 b'\x9a\xe5?\xcf\xefr\x88}\xbc\xb8P%\xbe\x82-:A(\x1e\xd920\xd7\x19\x86\xceK\xbf'
 b'\xcc"/\x00\x97\xe4\xe0G\x98\x937?\xc1=\xee\x83)<p\xf1S\xbe%\xdar\x1e\xc1s'
 b'\xb16\x84k\xc1\xfd\xd2\x1c\x89\xc2\xefkni\xaf\xfe_\xf4\x00)\x00N>\x8c'
 b"\xa1\xdc>n\xd9\x99\x1d\x1b\xcc\x82\x81\x9cB\xe6\xe9K\t\x80\xdb'\xcc\x03?\x1f"
 b'\x95\xf0\xce.')

{'A1': 6019508670139982882,
 'A2': -106,
 'A3': {'B1': 478790383,
        'B2': 'kni',
        'B3': -1342283788,
        'B4': [{'C1': 119,
                'C2': -0.5026897608948102,
                'C3': 4158036709,
                'C4': 0.24949485458953347,
                'C5': 20517,
                'C6': -0.25425130128860474,
                'C7': 16680,
                'C8': 2222863076432643790},
               {'C1': 75,
                'C2': -0.21979320076915254,
                'C3': 1201181495,
                'C4': 0.13470250515317472,
                'C5': -3757,
                'C6': -0.16196611523628235,
                'C7': 7873,
                'C8': 8336504327610957266}],
        'B5': {'D1': 0.27467238903045654,
               'D2': [4498772329431288962,
                      9339413286783486336,
                      15791814932713936368]}},
 'A4': 106,
 'A5': [-50, 46],
 'A6': {'E1': -1127750105561059610, 'E2': 12464, 'E3': -94},
 'A7': 649039966,
 'A8': 29634}

Вариант №9

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

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

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

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

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

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

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

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

(b'NXC\x99[\xb1\xab\x00\x00\x00z\x00\x00\x00\x84\x00\x00\x00\x8e\x00'
 b"\x00\x00\x98\x00\xa6c( Z\xd7\xe3\xc3\x9d'\xd1t$?\xc2\xc2l\xe1\xff\xef"
 b'f\xa9\xaa\xf3\xf7\xf3j\xdb"\xc2?\xb9)^\xd6\xbb\x8fP\xbfp\xb3(\xbf~\xb9\x96>V'
 b'\x141?KJ\x11\xbfn\x0b\x9b>\xfdq\x18\xbf\x0c\xee\x18oY\xd9\xfa\xda\xac'
 b'\x13\xc9\xbf\xe1S\xf0\x15\xf55P\xa0\xc0}\xc8\x00\xe2\xff\xce=\xc41y!-'
 b'\xc5\x8b\xbf\xcd&\xcc-\xbf\x150dw\xbf\xd7\xb6Y\xc4\tD|mq\xbf\xe6\xe3gc\xb1'
 b'\x1d\xfabr\xbf\xed\xff\x1a\xe9k\xc9\xbcdkK\x01D\xcb\xbeF\xc6\x9d\x00\x02'
 b'\x00\x00\x00\xa2>\x7f\x83\xb2}n')

{'A1': -1722043989,
 'A2': [{'B1': -0.2277465079661538, 'B2': 'dw'},
        {'B1': -0.3705048002639797, 'B2': 'mq'},
        {'B1': -0.7152592608553612, 'B2': 'br'},
        {'B1': -0.9373907622341942, 'B2': 'dk'}],
 'A3': {'C1': {'D1': -0.19411702454090118,
               'D2': [19201, 17611],
               'D3': 0.24952581524848938,
               'D4': 125,
               'D5': 110},
        'C2': 1663574106,
        'C3': {'E1': 3622028189,
               'E2': 39,
               'E3': 3514049599,
               'E4': [-1027445535, -1087831, -1426851853],
               'E5': 1792746178,
               'E6': 0.09828751318451379,
               'E7': [-0.9402337074279785,
                      -0.9950193166732788,
                      0.209061399102211,
                      0.7940989136695862,
                      -0.9298645853996277,
                      0.49500346183776855,
                      -0.5505080223083496]}},
 'A4': 8023683882571011017,
 'A5': {'F1': -0.5414963177551417, 'F2': 11583396539558723534},
 'A6': 0.09579748660326004,
 'A7': 556647819}

(b'NXC\xa8s\x0b\xc8\x00\x00\x00z\x00\x00\x00\x84\x00\x00\x00\x8e\x00'
 b'\x00\x00\x98\x00\xa6\x91:\xc4$\x1f\xcc.\x9bx\xc8\xd6\xb8\xdbe+'
 b'\xf2\x88\xf1\xde\xf1uHz\xe6\xfb{@5o?\xeb\t^\xfe\x12e\xbe\xbe\xb6'
 b'\x86\xbe\xbd\x00\x01i?c.\x0b\xbe\xd9\x8f\x8a?g\xff\xaf\xbe\xe5\x9d\xfd?\x19'
 b'\xa8v,\xd4\xc4\xb1\x19[\xc8\x92\xbf\xe9\xc7\x83\xfe`z\x8a\x8f\xaa]Q\xbfa'
 b'\x1b\xbc?\x1fFE"Tu\x0c\xbf\xdb\x1a\x0e%r\xb2dfi\xbf\xb9\x08\xdc:$#\x90'
 b'ko?\xe8\xd2^\xbc\x9aa\xd4vl\xbf\xe3\xbe&N\x9cJ\xc8pv\xc9\x07\xe6\xbd\xbe\xb7'
 b'l\x11\x00\x02\x00\x00\x00\xa2\xbe\x06Y\xb0\x1c\x0c')

{'A1': -1468855352,
 'A2': [{'B1': -0.42346528679880735, 'B2': 'fi'},
        {'B1': -0.09779144687139607, 'B2': 'ko'},
        {'B1': 0.7756799396184371, 'B2': 'vl'},
        {'B1': -0.6169616256105082, 'B2': 'pv'}],
 'A3': {'C1': {'D1': -0.3582463562488556,
               'D2': [51463, 59069],
               'D3': -0.13120150566101074,
               'D4': 28,
               'D5': 12},
        'C2': 2436547620,
        'C3': {'E1': 533474971,
               'E2': 120,
               'E3': 3369515227,
               'E4': [1697378952, -237047435, 1216014075],
               'E5': 2067805551,
               'E6': 0.8448939287510979,
               'E7': [-0.35649675130844116,
                      -0.031251344829797745,
                      0.8874213099479675,
                      -0.42492324113845825,
                      0.9062451720237732,
                      -0.44847097992897034,
                      0.6002267599105835]}},
 'A4': 3230423097645189266,
 'A5': {'F1': -0.8056049316690672, 'F2': 10352189299149052860},
 'A6': 0.6221659779548645,
 'A7': 575960332}

Вариант №10

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

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

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

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

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

(b'ZFD\xc9\x0c\x00/\x00H\x00a\x00z\xc3\x1e\x00\x02\x00\x8bG\xe6\x11\xf9\xe0'
 b'I\xb3\xae\xf5U\xf3]0\x98\xcf\xeb\x8a\x00\x8d\xad\x08\xda\x7f\xeb\x8b1sS\xaf'
 b"\x17/X\x16\xb2\xf1\xc9D\x070\xb2[\x00\x00\x00'\xb1\x80h\x1c\x14%A."
 b'\xa2\xda\x8d\xac\xc5\xaf\xc5<(({2\x06\x00\x00\x00@\xccW%\xa9\xe6\xe7\xb8'
 b'\xcf\xff\xcf<\xa8\x88\xb3>\xf6\xbd\x18\xbc~~\x00\x00\x00Y\xe98\x8e\x99.\x80'
 b'N\xec\xd4J8\x05A\xc9\x88\x0e\x8a\x13\xd8\xab\x87\x00\x00\x00r^\x18 5\xda'
 b'\xc4u\xdd\x17\x03\xc2\xfc\xdf\xae\xbf\x83\xfbr\x0c{J\x80EC\x92')

{'A1': 12,
 'A2': {'B1': [{'C1': 175,
                'C2': [5935, 22550, -19727, -14012, 1840, -19877],
                'C3': {'D1': 2266, 'D2': 2146143025, 'D3': 29523}},
               {'C1': 162,
                'C2': [-9587, -21307, -20539, 15400, 10363, 12806],
                'C3': {'D1': -20096, 'D2': 1746670629, 'D3': 16686}},
               {'C1': 255,
                'C2': [-12484, -22392, -19650, -2371, 6332, 32382],
                'C3': {'D1': -13225, 'D2': 631891687, 'D3': 47311}},
               {'C1': 212,
                'C2': [19000, 1345, -13944, 3722, 5080, -21625],
                'C3': {'D1': -5832, 'D2': -1902563712, 'D3': 20204}}],
        'B2': {'E1': 195,
               'E2': 30,
               'E3': [94, 24],
               'E4': [18406, 4601, 57417, 45998, 62805, 62301, 12440],
               'E5': -49,
               'E6': 60298}},
 'A3': {'F1': 540400324,
        'F2': 8492969777214316462,
        'F3': -0.009756937986286518,
        'F4': 69,
        'F5': 17298},
 'A4': 173}

(b'ZFD\xc9\xb7\x00/\x00H\x00a\x00z-u\x00\x02\x00\x8b\x0f\xb9.O\x86\x0e\xb03?'
 b' \xc4\xed\xd3\xe5\xf6\xde\xa0\x00\x8d\x89\x9d\xe0x\x07M\x12\xd1\xde\x04'
 b'\x840d9\x0bRp\xc9\xfao\xe0\x08\x00\x00\x00\'"$*\xb9\xe3\xfb%\xbaw\xb8-\xdb'
 b"\x08}`\xac\xa2\x1e\x14(\x95\x00\x00\x00@{J'\xfb&:\xae\x85\xe7\xc9V"
 b'\xf8J\x03\x93U\x1a\x81\x9e4\x9a\x00\x00\x00Y\xb5\xbdg4*\xb3eD>\xaa'
 b'\x90\xef\xae\x0ba\x8cP\xfb\x06g\xb1\x00\x00\x00r\x0bN\x04}\xd8\r\x10\x85\xe6'
 b'0\xa0\xf27\x1d?\xe4p\xf0\x1b\xc5\xb0\x14\x82\xb6\xa0')

{'A1': 183,
 'A2': {'B1': [{'C1': 4,
                'C2': [-31696, 25657, 2898, 28873, -1425, -8184],
                'C3': {'D1': -25120, 'D2': 2013744402, 'D3': 53726}},
               {'C1': 119,
                'C2': [-18387, -9464, 32096, -21342, 7700, 10389],
                'C3': {'D1': 8740, 'D2': 716825595, 'D3': 9658}},
               {'C1': 231,
                'C2': [-13994, -1974, 915, 21786, -32354, 13466],
                'C3': {'D1': 31562, 'D2': 670770746, 'D3': 44677}},
               {'C1': 62,
                'C2': [-21872, -4178, 2913, -29616, -1274, 26545],
                'C3': {'D1': -19011, 'D2': 1731472051, 'D3': 25924}}],
        'B2': {'E1': 45,
               'E2': 117,
               'E3': [11, 78],
               'E4': [4025, 11855, 34318, 45107, 16160, 50413, 54245],
               'E5': -10,
               'E6': 56992}},
 'A3': {'F1': 75356173,
        'F2': 1190610773042411293,
        'F3': 0.6387863676477559,
        'F4': 130,
        'F5': 46752},
 'A4': 137}

Вариант №11

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

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

(b'FRR\x88\x00\xe2\xfc\xc7\x8b\xe7\x92q\x9b\xa8\x96,bR\x93\x82\xdd\x9f\x83\xcb'
 b'\x07b\xbf\xa3>\x9c\xe8J\x99}/\xadj\x96\xbe!o\x1c\xcb<\xf9\n\xaa\xd3'
 b'\x0c\x0b\xbf\x86H\xb5{\xdei\xc2\x99\xe7\xc2q?\x84\xad\xf2a$\xc3\xa9\xf2\x9d'
 b'MJ\xbf\xef\xa6\x92\xe09\x90/yw\x0f\xfd>\xa7R\x9d\x87\x85\xfe\xb3\xf5}'
 b'\x05w\xbf\x98\xf6\xad\xf4<\xdb\xfa\xbc\xd6\x80\xf2~\xc6\x8b\xd6\xbf\xf0'
 b'J\t\xc0\xc4aneCy\x8a\xa3[7\x9f2\x1c\xfc\xa1\x07\xbf\x06\r\x00\x00'
 b'\x00\x03\x00\x00\x00x\x00\x00\x00\x02\x00{\x00\x00\x00}\x00\x00\x00')

{'A1': {'B1': 6,
        'B2': {'C1': 1647089320,
               'C2': [{'D1': 3716322130,
                       'D2': 33695,
                       'D3': -0.8829314112663269,
                       'D4': 163,
                       'D5': 62},
                      {'D1': 2571823260,
                       'D2': 12157,
                       'D3': -0.29378262162208557,
                       'D4': 33,
                       'D5': 111},
                      {'D1': 4181510940,
                       'D2': 43530,
                       'D3': -0.5431644320487976,
                       'D4': 134,
                       'D5': 72},
                      {'D1': 1776188341,
                       'D2': 39362,
                       'D3': 0.9443802237510681,
                       'D4': 132,
                       'D5': 173},
                      {'D1': 3273941490,
                       'D2': 62121,
                       'D3': -0.7902467846870422,
                       'D4': 239,
                       'D5': 166},
                      {'D1': 2419712146,
                       'D2': 31023,
                       'D3': 0.4942586123943329,
                       'D4': 167,
                       'D5': 82},
                      {'D1': 4270163869,
                       'D2': 62899,
                       'D3': -0.9649274945259094,
                       'D4': 152,
                       'D5': 246}],
               'C3': 173,
               'C4': -972541412361159436,
               'C5': 669612201346844286,
               'C6': 192,
               'C7': -60},
        'B3': 'ane',
        'B4': [67, 121],
        'B5': {'E1': [-118, -93, 91, 55, -97, 50, 28],
               'E2': -0.5298154354095459}},
 'A2': -7245848802282177310}

(b'FRR\x87\x00\x9e\xb5\x89\x13;HD\x97C\xdc\x04\xa5\xa6\x8c\xcc(\xe7\xfc\x04'
 b'\xfa\xec>A\x1f\x84\xb4\xb7\xf2o\x92\xf5\xa5;\xbft\xb9J\x15)\n`T\x1a'
 b't\xec\xbdK\xbb\xb2l\xcd\xeb\x8e\x16\xb8~}\xbf\x95K\xb9\x08\x1a\x0b\x1a\xb3h'
 b'*I\xbei\x04\xcf20\x1bO\xa7Q\xf2/\xbf\x19:\xcb7J\xf1I\x90.l\xbb>L\xf7\xda]c'
 b'[ \x17\xa4\xb4\xf6~k\x88fAX\xef\xc6Z8llt\xad\xe8\x16\xb2\xca\xf1\xb8P\x99'
 b'(\xe1\xbdZ\r\x00\x00\x00\x02\x00\x00\x00x\x00\x00\x00\x02\x00z\x00'
 b'\x00\x00|\x00\x00\x00')

{'A1': {'B1': 90,
        'B2': {'C1': -1526408125,
               'C2': [{'D1': 684493990,
                       'D2': 64743,
                       'D3': 0.46284496784210205,
                       'D4': 65,
                       'D5': 31},
                      {'D1': 4072125572,
                       'D2': 37487,
                       'D3': -0.7330010533332825,
                       'D4': 116,
                       'D5': 185},
                      {'D1': 170464586,
                       'D2': 21600,
                       'D3': -0.11545582115650177,
                       'D4': 75,
                       'D5': 187},
                      {'D1': 3956108466,
                       'D2': 5774,
                       'D3': -0.9902148246765137,
                       'D4': 149,
                       'D5': 75},
                      {'D1': 186255545,
                       'D2': 45850,
                       'D3': -0.1964508295059204,
                       'D4': 105,
                       'D5': 4},
                      {'D1': 456143567,
                       'D2': 42831,
                       'D3': -0.6872912049293518,
                       'D4': 25,
                       'D5': 58},
                      {'D1': 4048173003,
                       'D2': 36937,
                       'D3': 0.36605972051620483,
                       'D4': 76,
                       'D5': 247}],
               'C3': 218,
               'C4': -669730025337298083,
               'C5': -4111970896849638530,
               'C6': 90,
               'C7': 56},
        'B3': 'll',
        'B4': [116, -83],
        'B5': {'E1': [-24, 22, -78, -54, -15, -72, 80],
               'E2': -0.10994071513414383}},
 'A2': -7546827656998046306}

Вариант №12

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

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

(b'\xd7GSOE\x03\x00\x00\x000\x00\x00\x00\xe64\xd7I\xa0\xd6\xfe_/\x80M/]\x00l'
 b'izvwu\xb2nxvrfc\x9ckwhskt\x02\x1b\x00"\x00)\x00\xa5H7\xf5M=\xbf\x11s\xe2'
 b'\xcbrI\xfb\x88y{\xcf\xef~\x94\xd6Fz\xa2\xba>\xa3\x9e<\ncM+M\x97\xbe\x07'
 b'N"6\xc1\xafy\x17g\xc7\xbc\xf8\x19\xbe6\x00\x00\x00')

{'A1': [{'B1': 'lizvwu', 'B2': 178},
        {'B1': 'nxvrfc', 'B2': 156},
        {'B1': 'kwhskt', 'B2': 2}],
 'A2': 1238840550,
 'A3': 3408521433951688352,
 'A4': {'C1': -1346292190,
        'C2': [121, 23, 103, 199],
        'C3': -0.15036290884017944,
        'C4': {'D1': 18597,
               'D2': 55,
               'D3': -0.7394707798957825,
               'D4': 29457,
               'D5': [1232260066,
                      2071562491,
                      -1803620401,
                      -1569044778,
                      -1633468742,
                      1298336316],
               'D6': -0.2955106198787689,
               'D7': 19975}}}

(b'\xd7GSOE\x03\x00\x00\x000\x00\x00\x00\xe8\xed\xd9\xfbWa\x05\x00\xbf9m'
 b'\xfa]\x00tincis\x0czzzwwa\x8cljobsu\xa8\x1b\x00"\x00)\x00\x07\x9a*k\xb9\xd9'
 b'\xbe\x0en\xab\x9c?\xbcU\xaf\xba;3\xb1\xca\xb1L\xe0,\xe6\xb8\xe9\x0f\x98-'
 b'\xa0\x00"\x1e\xec]\xbf`\x8a\xe0\xc2\xe5\xdb>\x1c\x1e\x03\xd2\xf0\x05'
 b'\xbf6\x00\x00\x00')

{'A1': [{'B1': 'tincis', 'B2': 12},
        {'B1': 'zzzwwa', 'B2': 140},
        {'B1': 'ljobsu', 'B2': 168}],
 'A2': -69603864,
 'A3': 18045142774445334871,
 'A4': {'C1': -605699360,
        'C2': [62, 28, 30, 3],
        'C3': -0.5232058763504028,
        'C4': {'D1': 39431,
               'D2': 42,
               'D3': -0.42524275183677673,
               'D4': 28174,
               'D5': [-1136681813,
                      1002090325,
                      -1312116429,
                      -433266612,
                      -1743787592,
                      570466349],
               'D6': -0.8668841123580933,
               'D7': 35424}}}

Вариант №13

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

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

(b'GLCJ\xd9\x90%D\x00\x00\x00TS\xaeX%\xbf\xfe\xd3rx\xfb\xfc0\x1e\x01a\xc8'
 b'\xc8\xfa\xac\n\xb6#\xfbi\x00\x0c\x00\x12\x00\x18\x00\x1e\xc8\xc6\x1f\xa7'
 b'?\xc1\xb8\x96\x0b\x00\x00\x00\x02\x00\x00\x003\x7fWs\xe3\x12\x0fu'
 b"\xcc\xc3j\xdfL\x87\\/\xd9\x8d\xe8IJ\x82'`\x7f\r\xf1\xc7\xcf0\x00\x00"
 b'\x00\x04\x00$\x00\x00\x00,H\x8c\xa0{\x95\x8d}\x0c\x00\x02\x001'
 b'\xb6\xe3\x9c\xbb\x1a\x1d7\xdb\x19;\x04\xdd\x06\x19\x0e\\\xd3\xdf\x11\xd3'
 b'?\xeb\xbfoD8\x91`c5C\x005')

{'A1': -644864700,
 'A2': {'B1': 32525,
        'B2': {'C1': -238563536,
               'C2': [{'D1': 1403934757, 'D2': [191, 254]},
                      {'D1': 3547494651, 'D2': [252, 48]},
                      {'D1': 503407048, 'D2': [200, 250]},
                      {'D1': 2886383139, 'D2': [251, 105]}],
               'C3': {'E1': -926539865, 'E2': 63},
               'C4': 5227729720120802572,
               'C5': [193, 184],
               'C6': -5268194811682408485},
        'B3': 423298269,
        'B4': 102305372,
        'B5': -740355629,
        'B6': {'F1': 0.8671184856835161, 'F2': 25397, 'F3': 67},
        'B7': {'G1': [150, 11],
               'G2': 9175930184888448460,
               'G3': 50026,
               'G4': -33,
               'G5': 1283939375,
               'G6': 15676441279426864992}}}

(b'GLCJ!L\xc8\xac\x00\x00\x00L;\xe8\xa5\xaa\xd8W\xb7\xa9\xd6\x81\x06"N$Lt'
 b'\x8c\xfa\x00\x0c\x00\x12\x00\x18\xd0\x92\xd3\xb3\xd7_}\x85=\x00\x00\x00'
 b'\x02\x00\x00\x00+F\xdd\xdc\xab\xd1\xdd\xe7\xe5\xe1z\xccM\xac\x05 \x85n\x8a3'
 b'\x06h\xb3\xef\xfa\x99\xa5\xfb\xb5\xc3\x00\x00\x00\x03\x00\x1e\x00\x00\x00$'
 b'\xd2\xec\xe1;\x0f0\xa9\xbb\x00\x02\x00)\xe3\xcb\xd5G\xb3\x8eX\x0b'
 b'\x14N\xbf\xf2\xddM\x10\xda\xc8\xc7Y\xb8\xbf\xe1\xfd\n\xc9Z{TP[N\x00-')

{'A1': 558680236,
 'A2': {'B1': -1383,
        'B2': {'C1': -1510230589,
               'C2': [{'D1': 1005102506, 'D2': [216, 87]},
                      {'D1': 3081361025, 'D2': [6, 34]},
                      {'D1': 1311001716, 'D2': [140, 250]}],
               'C3': {'E1': -795683917, 'E2': -41},
               'C4': -3247973587466802757,
               'C5': [95, 125],
               'C6': -2032296302895802357},
        'B3': 340705266,
        'B4': -582151974,
        'B5': -926459464,
        'B6': {'F1': -0.5621389324840984, 'F2': 20571, 'F3': 78},
        'B7': {'G1': [133, 61],
               'G2': 5106480183026509797,
               'G3': 57722,
               'G4': -52,
               'G5': 1303119136,
               'G6': 9614774206238077935}}}

Вариант №14

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

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

(b'FWHB\xb0\xc1\x8c}G\xc3\x9e\xec\x00|?\xd2\xben\x15}\x11\xb4\x00\x06'
 b'\x00\x8d\xbd\xe9\xb1\xd9\xbe\xcf@\x06\xbd\xba\xd7m\x00\x00\x00\x03\x00\x1a'
 b'\x8b\xf9\xc1\xa2\xbdG\x14-\x0bJ\xe1\xed4\xe64;>\xda2\n\xbe\x7f\xc7}'
 b'?;\xf8\x86\x00\x00\x00\x03\x00<=c\x1f{H\xcd*6\xberj\xa1\xad\x14G+\xbe)'
 b'\xe3\x05>c\t(\x00\x00\x00\x02\x00^Ee\x1e.\xc5\x18\xf6\x8da\xcb21'
 b'\xd1\xd59\x1d\xce\xc1\x91BR\x99L\xe4m@a\x00&\x00H\x00fZ\xbf\r'
 b"\xe8\x93\xca\xf6='\xa4>U\xd3\xfdX\x8b\xfbBbxJ1$Y")

{'A1': -1329492867,
 'A2': 71,
 'A3': {'B1': 195,
        'B2': 40684,
        'B3': {'C1': -50,
               'C2': -1047444910,
               'C3': -26292,
               'C4': 3832365153,
               'C5': [{'D1': [-0.11410874873399734,
                              -0.4047853350639343,
                              -0.09123120456933975],
                       'D2': [-29703,
                              -15966,
                              -17081,
                              5165,
                              2890,
                              -7699,
                              13542,
                              13371]},
                      {'D1': [0.4261630177497864,
                              -0.2497844249010086,
                              0.7342609167098999],
                       'D2': [15715,
                              8059,
                              18637,
                              10806,
                              -16782,
                              27297,
                              -21228,
                              18219]},
                      {'D1': [-0.16590507328510284, 0.22171461582183838],
                       'D2': [17765,
                              7726,
                              -15080,
                              -2419,
                              25035,
                              12849,
                              -11819,
                              14621]}]},
        'B4': 0.29287292574397417,
        'B5': [1522470376,
               2479552061,
               665075285,
               3556595851,
               4215431800,
               1244734553]}}

(b'FWHBa\xbd\xeaD5\xa6\xcb\xed\x00\x80\xbf\xe7r\xf3\xc2\x0b\x86f\x00\x04'
 b'\x00\x91>\xd7\x07\xd8>\xff\x9a\xc2?\x00ud>\xb8\xe7\xf6\x00\x00'
 b'\x00\x04\x00\x1a\x10\xb4\x00f\xba#\xcf\xb4\xc0\xd6g\x1b\xbb\xb68A'
 b'\xbf\x15I\xf7\xbe\x82\x06\x0b>\x13|\xbc\x00\x00\x00\x03\x00@\xcc\xb1'
 b'\x0b\xa9y\xbc\x844\x06X\x1ePd\xeb\x1c\x84;\\\xcb\x94\xbe\x8b\x0c\xd6\x00\x00'
 b'\x00\x02\x00b\n\xac\xcc\x87\x8e\x1f\x8b\xa5&\x19\x0e\x0c\xaa\x18T\xa1'
 b"\xd7\xd1N*\x0e\xfd3A\x16Z\r\x00*\x00L\x00j\x15\xd6\xd1.'O\xcbF\x9c\xd2/"
 b'\xb6l0\x8a\x18')

{'A1': 1639836228,
 'A2': 53,
 'A3': {'B1': 166,
        'B2': 52205,
        'B3': {'C1': -41,
               'C2': -783406578,
               'C3': -717,
               'C4': 1091983885,
               'C5': [{'D1': [0.4199817180633545,
                              0.4992275834083557,
                              0.50179123878479,
                              0.3611447215080261],
                       'D2': [4276,
                              102,
                              -17885,
                              -12364,
                              -16170,
                              26395,
                              -17482,
                              14401]},
                      {'D1': [-0.583159863948822,
                              -0.25395235419273376,
                              0.14403051137924194],
                       'D2': [-13135,
                              2985,
                              31164,
                              -31692,
                              1624,
                              7760,
                              25835,
                              7300]},
                      {'D1': [0.003369067795574665, -0.27158230543136597],
                       'D2': [2732,
                              -13177,
                              -29153,
                              -29787,
                              9753,
                              3596,
                              -21992,
                              21665]}]},
        'B4': -0.7327822484914577,
        'B5': [366399790, 659540806, 2631020470, 1815120408]}}

Вариант №15

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

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

(b'\xf8FZXE\xe7\x10O\x00\xca\xe8\x96\xb3m\x9c\x05\x00\x00\x00^\x00\x00\x00O'
 b'\x8b\xf2x=\x05\xac\xa1\xe5\x0f%\xc9\xe5!\x91\x18\x10yE?\x02\x00\x17\x00\x00'
 b'\x00\xc9\x19\xfe\xbb{\x87j){\xc1X\xddr>\x02\x00\x1f\x00\x00\x00\x1fT='
 b"w\xb7x\xd2\x97\x92<amg;\xe4i?\xb6\x02\x00'\x00\x00\x00O\\\x9a\xc9\x0b\xf3")

{'A1': 4327,
 'A2': {'B1': {'C1': 996633953, 'C2': [-28, 105, 63, -74]},
        'B2': [{'D1': 0.7713785171508789,
                'D2': [2029161295, 2712405309],
                'D3': 3153992137,
                'D4': 694847355,
                'D5': 49531},
               {'D1': 0.23717248439788818,
                'D2': [3374649317, 412164581],
                'D3': 2000507935,
                'D4': -1747814217,
                'D5': 15506}],
        'B3': 79},
 'A3': -54,
 'A4': -26904,
 'A5': -77,
 'A6': 40045,
 'A7': [92, -102, -55, 11, -13]}

(b'\xf8FZXE[\xa8O\x00\x10\xbag\xfd\xc7\xa6\x04\x00\x00\x00^\x00\x00\x00J'
 b'\x05?/\x19\x03\xad@bd#$\x9d\xc1Y\xa6\x0c\xdd=\xbf\x02\x00\x17\x00\x00'
 b'\x00\x04\x81\xfbfJ\xa3\x08-\xe6>)ty=\x02\x00\x1f\x00\x00\x001\x99\xdd'
 b"\t\x7f\xa0i:\xe7\xc3\xcb4\xa3 \xf7)\n\xc3\x02\x00'\x00\x00\x00\x82\x95\x87"
 b'\xdc/')

{'A1': 43099,
 'A2': {'B1': {'C1': 547566795, 'C2': [-9, 41, 10, -61]},
        'B2': [{'D1': -0.7416541576385498,
                'D2': [792659274, 1085080345],
                'D3': 1727758596,
                'D4': 755540810,
                'D5': 16102},
               {'D1': 0.06090179458260536,
                'D2': [606299234, 2790900125],
                'D3': 165517617,
                'D4': 980000895,
                'D5': 50151}],
        'B3': -126},
 'A3': 16,
 'A4': 26554,
 'A5': -3,
 'A6': 42695,
 'A7': [-107, -121, -36, 47]}

Вариант №16

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

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

(b'kGXHA>\x02\x00\x00\x00\xac\x00\x00\x00\x9fSJv\x99\xec\xdc7\x02\x00'
 b"\xb0\x007\x8b\xee\xe1\xb7\xd95'\xc3\xbcp\xb1\xb2\xbe\x14\x13z\xbe\xec\xc3H`"
 b"b&g\xc7\\'\x01\xf8A\xe0\xa3\xe0\x00\xf8N\xd0\xb5\x1c\xdb?\xd4\x7fe\x9e"
 b'\x80\t\xc7\xdf\xfax(\x06\x8b\xb4Bf\x05\x8d\x0fM\x9f@\x0f\xec\xd2\xc6\xa2\x17'
 b'1\xa4\xfe\xec!CA\x8a\x1f#\xf6 \x86\xb3\xd0\xfb9T\x80\x1bVa\xe1\xc3F0\x8e\x16'
 b'c\xaa\x04\x00\x00\x00n\x00\xd6m\xd9\x98\x0e\x82\x180>V\xfb\xf5\xb2\xc25\x14'
 b'\xa6N\xd6\x03{\xeeI\xf7\xc9\x04\x00\x00\x00\x8d\x00\x8e\xcc\xc5= '
 b'=\xbc\x80\xc3~\x00\x9d\x00\xda\xa5')

{'A1': 62,
 'A2': {'B1': [{'C1': [1413086160, 1633033088, 809944033, 2858620558],
                'C2': -42,
                'C3': 4481108576103356781},
               {'C1': [3002465110, 2786342338, 2063849038, 3388426734],
                'C2': -114,
                'C3': -4359277468574693940}],
        'B2': 4025352310821114783,
        'B3': [-38, -91],
        'B4': -504460489,
        'B5': -9801,
        'B6': {'D1': -4705503562887387339,
               'D2': -0.24421340227127075,
               'D3': 1615381484,
               'D4': 9826,
               'D5': [660391783, 3762419713]},
        'B7': 57507},
 'A3': 0.42362733214019954,
 'A4': {'E1': [16124867438841266132,
               7368650449528322298,
               17009885370538495237,
               17077267367792395986],
        'E2': 2375124471855006497},
 'A5': 45958}

(b'kGXHAP\x02\x00\x00\x00\xa0\x00\x00\x00v\x13\x19\x1e\xe3\xe0\x89q\x04\x00'
 b'\xa4\x00\xdf\xe4X\xc0;\xf9\xfe3\xdc\x9d\x8cW\xca\x17\xe9\xbe\\\xbf:x\x15E'
 b'\r\x0b\x14mI&\xd4\xf5\x8dO\x85\x0fx\x7f\xc7UF\x9d\xdd\xbf\xdd\xb3\xa2\xe1'
 b'G\r\x97L\xba\x91\x83\x9c\x9a\x10\x8b+p\xe2\x19%\x13\xa60\x03QN\x95\xb3'
 b'\xb9\x912\xdf9\xd6F\x9a\x83\xe8\x07\x89\xf6=\x04\x001/\xdd\x96#_\x82\xa3'
 b'1\xc4\x03\x00\x00\x00n\x00H\x87\xfa\x19\xc3!@\x8eYC\xbd\x18\xaa,O\xc3'
 b'\xdf\x02\x00\x00\x00\x89\x00[\x19\x02\xaa,o>\x93\xe9z\x00\x91\x00'
 b'\x84B\x13\xf4')

{'A1': 80,
 'A2': {'B1': [{'C1': [791740420, 1596167901, 3291587458],
                'C2': 72,
                'C3': 6453165829819857543},
               {'C1': [2853748035, 3754118956],
                'C2': 91,
                'C3': -1615879194084244967}],
        'B2': 8181317464162374518,
        'B3': [-124, 66, 19, -12],
        'B4': -1067916065,
        'B5': -1733,
        'B6': {'D1': 1714278869623387134,
               'D2': -0.8622880578041077,
               'D3': 1159034938,
               'D4': 2829,
               'D5': [642346260, 1334703572]},
        'B7': 3973},
 'A3': -0.4627242887199752,
 'A4': {'E1': [5518894470745207773,
               3137619821630558650,
               229866182152938096,
               16083077446061346385],
        'E2': -8572627713749756359},
 'A5': 15862}

Вариант №17

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

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

(b'OBKE\x83\x00\',W"\x97p\xacJ\xa4\xc4\x00[\x00\x916\xdd\x94\xbf\xc33\xce\x13'
 b'\x18\xf5\x88\x0et|T\xa6\x9e\x93"\x07J\xa4\x84\xc9\x9e\x86{\x1cF@vq'
 b'\x0c1\xd6\xdc\xa6%]\xcbi\x1b\xd1\xf9X\x8d\xbc\xebl9\xd6\x91\xf6T\xaa\x1d'
 b'L\x85h\xda\xd3\xf60m\xec\x01\x0e+\xfd\xd3\\\x1b\xc3\x06\x83\xaa\x00V\x0f\xe2'
 b':X\x0c8\x1d\xbf\xe7\xd8\xdf\\\x12\xaf\xe0\x04\x98&\x1d}\xb2\x01\xef\xdf%\x89'
 b'\xac\t\xe6\xb7\xb9ol\x06$\xb3&M"\xcf\rl[\x98\x99y\x8cX\xad\x00'
 b'\x00\x00\x04\x00\x00\x00q?\xc6\x82\x13\x85!\x9fp')

{'A1': {'B1': [{'C1': 1866,
                'C2': [-1534801506,
                       -2038752186,
                       1081504012,
                       836164774,
                       626903913]},
               {'C1': 7121,
                'C2': [-111637060,
                       -345228842,
                       -1846127446,
                       491554152,
                       -623643088]}],
        'B2': 1844183310,
        'B3': [43, 253, 211],
        'B4': 92},
 'A2': 44,
 'A3': 6278747340690597060,
 'A4': {'D1': 465766019,
        'D2': [43520, 22031, 57914, 22540, 14365],
        'D3': -0.7452236936855989},
 'A5': {'E1': 22701,
        'E2': [331056480716456431,
               -2367334657119832135,
               8028798990388972834,
               -3527043792503211636],
        'E3': 0.1758446121268622},
 'A6': 54,
 'A7': 56724,
 'A8': {'F1': -0.15001846249098727, 'F2': 1041594116843934498}}

(b"OBKE\x83\x00'\xaa\xe2=\xd61\xbe)\xc6y\x00[\x00\x91\xf3\xca\xf9?\xb9\xabc{"
 b'\x14\xec`h\xb8\x04\xaa\xba\x90\xa5\xe1\xf2\xb8\xd3\x99\x11\xa3%\x1e\xda'
 b',\xe9\xfcy\x8fH\xea\xe8Fb\x18\xa5\xcd\xb2xH\x02\xf8@\xe7Jw\x1f\xb5'
 b'\xdb\xdf\xea2\x08\xc5\x1b\xb3\xc1p\xe1\xc5d\xda\xb0\x8b\xaa=?\x06I\x1b\xf6S'
 b'\\\x1c\xf9+3\xcc`\xf4\xb4?\xe4\xc2\xd4\x0b\xbb\x9f\x04\x13\x94N|g\x1a\x9c'
 b'\xf4MYK"\xd5\x04U3v \r\nBpD\x95-\xfcw,\xe7\x06\xe3\x03\xb3S\x00'
 b'\x00\x00\x04\x00\x00\x00q\xbfy\\0r\x10v\x00')

{'A1': {'B1': [{'C1': 62136,
                'C2': [-744943197,
                       622778924,
                       -369329777,
                       1223354438,
                       1645782477]},
               {'C1': 45688,
                'C2': [1208154176,
                       -414550241,
                       -1243881494,
                       839435547,
                       -1279168287]}],
        'B2': 3311721136,
        'B3': [139, 170, 61],
        'B4': 63},
 'A2': -86,
 'A3': 16302421735283213945,
 'A4': {'D1': 105454582,
        'D2': [21340, 7417, 11059, 52320, 62644],
        'D3': 0.6487827519567593},
 'A5': {'E1': 45907,
        'E2': [1410838879486516468,
               5573568626822501683,
               8511817633445725333,
               3313654460576097027],
        'E3': -0.006191434135897733},
 'A6': -13,
 'A7': 51961,
 'A8': {'F1': 0.1002714324467191, 'F2': 7545786306980259297}}

Вариант №18

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

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

(b"'MZDS\x94\xf34h\x007\x00`AJ\x9a\xc4\xd9x\xe6h\xba|\xc1\x89n\xde\xbb"
 b'\xbf\n\xaf\x93\x18\x00\x9dU\xa0X\xa5\x07"\xd4\xe1c:{\x84\xe7\xe44\x0eB'
 b'\x83\xf4z\xeb\x8c@TED\xb3U2\xb1r/f\x15\xdc\x03\x00$\xbe\xd8\xe4\xb4\xd9Z\xe7'
 b',e\xea\x8aC.\xb9\x1c\x07\xda\x81\x9b\x0c\xa6\xf1\x10Z\t\x1f\x11\xff\x94s0'
 b"'\x1e\x05Vy\xf4(:\x00M\xbfvd\xd2")

{'A1': [38131, 13416],
 'A2': [{'B1': [60300, 16468, 17732],
         'B2': 45909,
         'B3': 3652826320675920899,
         'B4': {'C1': 160,
                'C2': 22693,
                'C3': 119723233,
                'C4': [99, 58, 123, 132],
                'C5': -1737206320408038278},
         'B5': -0.4236198663711548},
        {'B1': [23049, 7953, 65428],
         'B2': 29488,
         'B3': 2818696285751879738,
         'B4': {'C1': 217,
                'C2': 23271,
                'C3': 744876682,
                'C4': [67, 46, 185, 28],
                'C5': 565907206120599824},
         'B5': -0.9624758958816528}],
 'A3': {'D1': 4704742930994751080, 'D2': -17796},
 'A4': -4500944449668445521,
 'A5': -109,
 'A6': 402693461}

(b"'MZDS%\x8d\xe0\xfe\x007\x00`\x0e\xa4Z\x04\x0b\xdbG\xa9`\x0e(\x16Pp]"
 b'pn\xe9\x1fo\xb5_M\xa8-\xc2R\xde\xdf\x197\xc5\xd5}\x8f\xe8\xa7\xa4X\xbd*@\xfc'
 b'\xa9f\xee\xbb\xa2\x85\x89\xf3\xe7D\xdfE\xda\x05\xd7\x00$\xbf\x0c\xf0\xc0ckI'
 b'\xceT\x8b\xab8\x8b\xe1\x98\xdb\xb9\xb5\xcb\xfbF*:\x02j1t\xf1\xba"/'
 b'\xd2\xb7\xe4\xb7F\x8a!\xae\x00M\xbe\x06\xfe\x93')

{'A1': [9613, 57598],
 'A2': [{'B1': [64681, 26350, 48034],
         'B2': 34185,
         'B3': 17575091796576962007,
         'B4': {'C1': 168,
                'C2': 11714,
                'C3': 1390337817,
                'C4': [55, 197, 213, 125],
                'C5': -8077021607383717312},
         'B5': -0.5505485534667969},
        {'B1': [618, 12660, 61882],
         'B2': 8751,
         'B3': 15183856144516522414,
         'B4': {'C1': 99,
                'C2': 27465,
                'C3': 3461647275,
                'C4': [56, 139, 225, 152],
                'C5': -2613858221013194182},
         'B5': -0.13183049857616425}],
 'A3': {'D1': 1055067186136827817, 'D2': 24590},
 'A4': 2888584654538960617,
 'A5': 31,
 'A6': 1874157389}

Вариант №19

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

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

(b'ZKYkkv\x05g~-Wq\x00H-\x00\x00\x00\x90S\x85\xfa\xc2.b\x859\xb3#VUx\xa07m\xc6'
 b'\xc47k\x1d\x1d>t\xf6(\xce\xe5q\x88\xa7\x8d\xa6\xfeu*\xa5E\x86\xfb\xc7^<!\x00'
 b'\x00\x00\x02\x00)K5\xda\xd4[\x9cq\x8f\xc1\x1a\x1e\xa7\xe7\xbf\xe1'
 b'\xfd>\xcb\xb9E\xb0\x00\x04\x00\x13Z\x00\x02\x00\x17|\x00\x02\x00\x19'
 b'\xd4\x00\x06\x00\x1b\xe9\x00\x05\x00!\xc2\x00\x03\x00&F\xe5H~\x04e6\xd3\xf6'
 b'\x08\x91\x84\x0c\xea\xf5\t7\x07\xa1Y\xf3\x00\x00\x00-\xf1\xed?Q\xb6?=\x8f'
 b"\x01\xc2?+n\xc8\xbf'\x87B>\x8ee\x9e\xbe\xf6\x05[\xbcBaS")

{'A1': 7743382551366817649,
 'A2': {'B1': -11173,
        'B2': -7173794671894812697,
        'B3': -0.5621637324313067,
        'B4': [{'C1': [83, 133, 250, 194], 'C2': 90},
               {'C1': [46, 98], 'C2': 124},
               {'C1': [133, 57], 'C2': 212},
               {'C1': [179, 35, 86, 85, 120, 160], 'C2': 233},
               {'C1': [55, 109, 198, 196, 55], 'C2': 194},
               {'C1': [107, 29, 29], 'C2': 70}],
        'B5': 16521593790351725558,
        'B6': 617419814942869815,
        'B7': 128014835,
        'B8': {'D1': -50,
               'D2': -445544281,
               'D3': 10207125384661910918,
               'D4': [251, 199, 94, 60, 33],
               'D5': [15988, 63016],
               'D6': 19253,
               'D7': 218}},
 'A3': 45,
 'A4': {'E1': -3603,
        'E2': [0.8191871047019958,
               0.06982757151126862,
               0.6696591377258301,
               -0.6544076204299927,
               0.2781190276145935,
               -0.48050960898399353],
        'E3': -0.011864024214446545}}

(b'ZKYk\xd5\x16<\x8b6\xc6\xaa\xbb\x00O\xc1\x00\x00\x00\x97\xb8$\x9dVe\xde,{\x93'
 b"\xf5\x8b\xa7\xef'\xf9\xcb\x05_r\xc2u^\x92\xda\x00\xfd\x1bm\xf5\x17\xbe`5"
 b'^\x1c\xc4\xd7\x8ek\t\xc0g\x13\x8bE\x05>\xaa\xe5$\x86\x00\x00\x00\x02\x000'
 b"\x1c'\x1b\xde\xd6g\xf6\x18<\x87Re3?\xd2u&\x90-z\xdc\x00\x05\x00"
 b'\x13\xdd\x00\x05\x00\x18\x98\x00\x04\x00\x1d\xd9\x00\x05\x00!j\x00\x05\x00'
 b'&-\x00\x05\x00+AB:\xe2\x0fVe\x18\n\xf71\xb1\x99(5\xc9\xec\xa5\x17m\xdb\x00'
 b'\x00\x004\x96\x8d\xbe\r|\xfc\xbe\x05\x82\x81\xbd\x9e\x7f4\xbfC\x85'
 b'\xbd\xbe\x84nb>]\xd8\xeb\xbe\xacB\xe0')

{'A1': 15354526548183395003,
 'A2': {'B1': -8490,
        'B2': 7491201678424827187,
        'B3': 0.2884003074631616,
        'B4': [{'C1': [184, 36, 157, 86, 101], 'C2': 221},
               {'C1': [222, 44, 123, 147, 245], 'C2': 152},
               {'C1': [139, 167, 239, 39], 'C2': 217},
               {'C1': [249, 203, 5, 95, 114], 'C2': 106},
               {'C1': [194, 117, 94, 146, 218], 'C2': 45},
               {'C1': [0, 253, 27, 109, 245], 'C2': 65}],
        'B5': 4772375310654314506,
        'B6': -634530801119802900,
        'B7': 2769776091,
        'B8': {'D1': 94,
               'D2': 482662286,
               'D3': 7712907385790743813,
               'D4': [62, 170, 229, 36, 134],
               'D5': [6078, 24629],
               'D6': 7207,
               'D7': 27}},
 'A3': 193,
 'A4': {'E1': -26995,
        'E2': [-0.13817209005355835,
               -0.13038064539432526,
               -0.07739105820655823,
               -0.763759434223175,
               -0.2586546540260315,
               0.21664778888225555],
        'E3': -0.33644771575927734}}

Вариант №20

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

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

(b'RASK9\xd1\x80\x14\xa4\xfb\xe5S\x94/#\xbf\xcbk\xe4[\x1c?`\x08L?^\xcf}?^\xbd'
 b'\x04<\x17\x9d\x84\x11\x85\x02\x00\xa3\x00\xc6\x06R\xbf\xc9-\xe6\xe3\xd8zc"L'
 b'\x1d\xdf\xf1j8\xf6<\xf6\xf5k\x00\xfeo\x8d\xadU\x9f\x80\xe2\xf0=/\x00\x00'
 b'\x00`#\x93^\x96 R\xc9R\xf2\x08\xbf\x82t\x80,\xc38\x86u\x19>\xe1Uu\x91\x8f'
 b"'\xb6\xdd,\xcc\xb81\xcf\x9f g\xb7\r9\xab~\xcf\x1a\xb6\x16\xf5H\x99+"
 b'\xf52\xbfi\x00\x00\x00\xa2\x92M\xa3>>c\x07\xee\xc3\x8a\x16\x8c'
 b'\xfb\xce\x87\x17\xc4\xe3\xd8\xb9\xbe\x12\xdcM\x00\x87\x00')

{'A1': 6045514756951953721,
 'A2': -0.6374447345733643,
 'A3': {'B1': 27595,
        'B2': [0.6107771396636963, 0.7970027923583984, 0.9914454221725464]},
 'A4': 0.00810178928077221,
 'A5': 293903639,
 'A6': 133,
 'A7': [{'C1': {'D1': 11721,
                'D2': [2061034470,
                       491528803,
                       946532831,
                       4126555382,
                       1878917227],
                'D3': 141,
                'D4': -83,
                'D5': 85,
                'D6': -97,
                'D7': 0.11761951446533203},
         'C2': [9056, 24211, 8342, -13998],
         'C3': 3206691039587398226,
         'C4': 14531,
         'C5': 0.1498623788356781,
         'C6': 21985},
        {'C1': {'D1': -28299,
                'D2': [3719702415,
                       834194476,
                       1730191311,
                       2872642999,
                       3055210366],
                'D3': 22,
                'D4': -11,
                'D5': 72,
                'D6': -103,
                'D7': -0.6990534663200378},
         'C2': [-27998, -23731, 15934, 1891],
         'C3': -8660708454294699026,
         'C4': 50199,
         'C5': -0.362982839345932,
         'C6': 56338}],
 'A8': -0.8204158544540405}

(b'RASK\xc1b\xe76\x0e\xc8\xe7zi\x88y?L\xe9~\xdf\x84>\x81!b>\xeb\xa3\xfd=:}'
 b'\xaa>\x1c\xcbW\x8b\xae\x02\x00\xa3\x00\x144;?\x99\xa0\xc1L\x9eDDMr\x8aT(\x83'
 b'AK\x98\xca\xbd\x00\x88\x98v\x08\xef\x14\x92\x11le\xbf/\x00\x00\x00\xe7\xe4&'
 b'ne\x1d\xd1\xdf\xbd\x0b}\xc9\x1b\xb4\xdb\xcd\x02i\xc0\xf4=>$\x15\xc6n\x0f'
 b'\xdf\x94\xfc\xdfO\x18\x1a\xc0\xe2L\xd7\x9d\xad\x8a\xff\x94}&\x97\r'
 b'\x976\xd8\xfa\xdfk\xbfi\x00\x00\x00\xe4\x8e\x87\x1a7~\x8e-6\xabY\x07\xfa'
 b'\x9eg\xbfH\xf4"\xa6E\xbf0\xf0M\x00\x87\x00')

{'A1': 8856267155623600833,
 'A2': 0.9747377038002014,
 'A3': {'B1': -5812,
        'B2': [0.2595176100730896, 0.22083093225955963, 0.12384780496358871]},
 'A4': 0.33298665285110474,
 'A5': -1957180644,
 'A6': 174,
 'A7': [{'C1': {'D1': -24423,
                'D2': [1151225025,
                       2322746692,
                       1099114580,
                       3184171083,
                       1989707776],
                'D3': 8,
                'D4': -17,
                'D5': 20,
                'D6': -110,
                'D7': -0.8961802124977112},
         'C2': [-6937, 28198, 7525, -8239],
         'C3': -3613096244597158979,
         'C4': 26882,
         'C5': 0.18550395965576172,
         'C6': 5412},
        {'C1': {'D1': 28358,
                'D2': [4237614863,
                       437800927,
                       3612140224,
                       4287278493,
                       2535882132],
                'D3': 13,
                'D4': -105,
                'D5': 54,
                'D6': -40,
                'D7': -0.9213863611221313},
         'C2': [-28956, 6791, 32311, 11662],
         'C3': -4654576893161788618,
         'C4': 62536,
         'C5': -0.7720662355422974,
         'C6': 61488}],
 'A8': 0.7312633991241455}

Вариант №21

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

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

(b'PBX?\xd5\xd7>BE\xeeX\x93\xd5\x0eyQ\xd6\xe3\xba\x0e4\x8e\r\x00'
 b'\x00\x00\x9c\xb3\xd57\xf7\xd1\xe2k`?{\rh\xd1\x8c\x17Is\x11\x92\xce\xfe'
 b';2\xf0\\\xb7*\x07\xbf}B\xee7\xf4\x00@"\x03=\xd5\x00\x00\x00\x1b\x00'
 b'\x00\x00/\xbd\xab\xea\xa4\x87\x10\xcf|\xff_\x03HQ\x80%_K\x13\xd7h_:\x0cP\x01'
 b"\x0c\xb8Ot\x9b\x8b'\xffd>\xaf\xec\x1e\x00\x00\x00\x02\x00K\xd2v\x001\x00"
 b'\x06\x00Sb\x05QpZJb\x00\x00\x00\x05\x00Y\xea\xd0\xd5J-\xdb\xc3\x8a\xd0:X|'
 b'\xef(\xcd\x8f?N\xbb\x13\x00\x02\x00\x00\x00C\x00mX\x9f\xe0\x9d'
 b'\x00\x00\x00\x08\x00\x00\x00\x8c\xe5\xcd\xd6\xf2\xa1\x1f2\x1d.\xbb\xe9\x0b'
 b'\xde0\xa8\xa0')

{'A1': 0.3412624022673518,
 'A2': 10652436407841645498,
 'A3': 238325261,
 'A4': {'B1': 0.8075420260429382,
        'B2': [{'C1': 12958325040346196832,
                'C2': {'D1': 0.9806733131408691,
                       'D2': -779348151,
                       'D3': 1930531534}},
               {'C1': 18319291917188672007,
                'C2': {'D1': -0.9893025159835815,
                       'D2': 938737728,
                       'D3': 570637781}}],
        'B3': {'E1': 0.34359830617904663,
               'E2': [3182160548, 2266025852],
               'E3': {'F1': -764018639,
                      'F2': [-1, 95, 3, 72, 81, -128],
                      'F3': 1644515696,
                      'F4': 23114},
               'E4': 98,
               'E5': [627002131,
                      -681025734,
                      206569740,
                      -1202752357,
                      -1960312988]},
        'B4': {'G1': 1486872733,
               'G2': [-5424,
                      -10934,
                      11739,
                      -15478,
                      -12230,
                      22652,
                      -4312,
                      -12913],
               'G3': -439494926,
               'G4': -95,
               'G5': 7986,
               'G6': 29,
               'G7': 3367541383571220640}}}

(b'PBX?\xd3\xd9\x80\xf9\xdda\x90\xe1\xffK\\\xe1R\xf1\xd5\x04\xf1v\xf8\x00'
 b'\x00\x00\x98m\xdb6\xeaNU\x9ag\xbf\x00\xe8+\xdc+\xc8\x10F\x16b \xc6\r,zk'
 b'=\x1b\xa6\xbfX\x95\tX\xce\x1f\xb4U\xc9\xd3\x14\x00\x00\x00\x1b\x00'
 b'\x00\x00/\xb5\xb2\x85\xbbS\x9aH\xa6\x01X0\xd837\xb6Qgl\xf11\x1c\x80R8)'
 b'\xaa\xc3\xa8\xacu\xbf\x08\xa1\x10\x00\x00\x00\x02\x00KD\xd7\xea\x8e\x00'
 b'\x06\x00S{\xc2G\x0cI\x9f_\x00\x00\x00\x04\x00YP\xcb\xe0\xfe\xed\xa8B\x05'
 b"z\x16\xd9\x94Wm\x9c5\xbf\x1e\x13\xc2\x00\x02\x00\x00\x00C\x00i'M\xd39"
 b'\x00\x00\x00\x08\x00\x00\x00\x88\\\xec\xf2\x9c\xe0=\xdd\xfb\x95\xe0L\x03'
 b'\x00E\t\x8b')

{'A1': 0.31015037918907584,
 'A2': 16284817639884386773,
 'A3': 82933496,
 'A4': {'B1': -0.6174889802932739,
        'B2': [{'C1': 7915981149998258791,
                'C2': {'D1': -0.5035426020622253,
                       'D2': -601110512,
                       'D3': 1175872032}},
               {'C1': 14271111698503768998,
                'C2': {'D1': -0.8460240960121155,
                       'D2': 1489903540,
                       'D3': 1439290132}}],
        'B3': {'E1': -0.5337076187133789,
               'E2': [3048375739, 1402620070],
               'E3': {'F1': 1155000974,
                      'F2': [1, 88, 48, -40, 51, 55],
                      'F3': 2076329740,
                      'F4': 18847},
               'E4': 95,
               'E5': [-1236179092, -248439680, 1379412394, -1012355979]},
        'B4': {'G1': 659411769,
               'G2': [20683, -7938, -4696, 16901, 31254, -9836, 22381, -25547],
               'G3': 1559032476,
               'G4': -32,
               'G5': 15837,
               'G6': -5,
               'G7': -7647028591501964917}}}

Вариант №22

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

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

(b'NUN\xb1$\x00uA\xf5\x1aU\xa4\xed\xba\xdd,\xc9\x88r\x9f\xe5\xcb\x11\x16?\xeb.]'
 b'\xf1\xfd9\n\xc4\xf5&`/v\xb0?\xe2\xceKN-\xbd\xc2s\x8ay\xa7\x81\x1c?\x14\x18'
 b'\xc4\xbf\xd06)m\xac/$\xbfC\xc4\xf9\x00\x02\x00\x00\x00\x17\xe3\xe6\xc7_\xaa'
 b'y\xcb\xd0\xcf\xe6U[\x1dn)?\x10\xe6\xf2\xaf\x1e%7g\xa2J\x15y6W\xd2\xc2\xbe'
 b'OE\n83\xd6p>\xb5\x8a\x1b\x80\xaaZ&\xaed\x8eF\x00\x00\x005\xec\xaf\xcc{\xdf'
 b'\xf5K\xe9\\\x00\x00\x00c')

{'A1': 36,
 'A2': {'B1': 9951689270750522980,
        'B2': 36422,
        'B3': {'C1': 0.578502893447876,
               'C2': -0.25330577573980606,
               'C3': -0.7647243142127991,
               'C4': [{'D1': 22,
                       'D2': 0.8494100309706323,
                       'D3': 50421,
                       'D4': 643837814},
                      {'D1': -80,
                       'D2': 0.5876823927809982,
                       'D3': 29578,
                       'D4': 2041020700}],
               'C5': [-7194,
                      -14497,
                      -21895,
                      -13360,
                      -12314,
                      21851,
                      7534,
                      10559],
               'C6': 1217927583189251943},
        'B4': [236, 175, 204, 123, 223, 245, 75],
        'B5': 59740,
        'B6': {'E1': 162,
               'E2': 5338306207626216126,
               'E3': 5711982938893479998,
               'E4': -75}},
 'A3': 1106582101,
 'A4': [-1527924003, 751405170],
 'A5': -1612330223}

(b'NUN\xb1\xc1\x00\x84\x16\xd9\xf9Q\r\x90\xc3\\;p\x93\xaf\xac\x8c\xabK\x11'
 b'?\xcaq\x08i\x9e\xc1XY}\x05\n\xec\x16\x8e\xbf\xd7\x1d\xf7\x8cg\x9cp\x10'
 b'X\xad\xbcT\x11\x93?\xe9\xd1\x85\xfaI\xe8\xc4\xf9\x92\xad\xd9\xd0\xa9'
 b'\xbe\xc6\x9dI\xbf\xe6\xa9\x0c{A\xf3(\xbd\xefN\x00\x00\x03\x00\x00\x00\x17sK'
 b"\x05:\xbc\x9f@z\xe3\x89\x9fy'\x8b\x93\x93\xd2=ZQZ\x8e\xc8\xa7V6\xd9\xc0./"
 b'H;\x9b\xdd\xeb\xebX\x83.-\xa7\xff\xd0\xf3\xd7\x1e\xea\xc4D\xf7[N\x00\x00'
 b'\x00D\x8f\xd7yE\x98\x84\x05\x8f$\x00\x00\x00r')

{'A1': 193,
 'A2': {'B1': 15056614507017422071,
        'B2': 23374,
        'B3': {'C1': -0.38791874051094055,
               'C2': -0.7081358344436,
               'C3': -0.11684799194335938,
               'C4': [{'D1': 17,
                       'D2': 0.2065744891856507,
                       'D3': 22909,
                       'D4': 84601878},
                      {'D1': -114,
                       'D2': -0.36120403968238346,
                       'D3': 4184,
                       'D4': -1380166639},
                      {'D1': -109,
                       'D2': 0.8068265808535888,
                       'D3': 63890,
                       'D4': -1378234199}],
               'C5': [29515, 1338, -17249, 16506, -7287, -24711, 10123, -27757],
               'C6': -3297380046707177305},
        'B4': [143, 215, 121, 69, 152, 132, 5],
        'B5': 36644,
        'B6': {'E1': 86,
               'E2': 3952401452588612507,
               'E3': -2455610406409982553,
               'E4': -1}},
 'A3': 383383889,
 'A4': [227591004, 997233583],
 'A5': -1400067253}

Вариант №23

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

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

(b'\x98EIFC\x12\x00V\xf5\xcf\xe5\x04\x16\xdb\xdd\xcd2^|WB\xaa\n\xb9\xdb?\xb3e'
 b'\xb1[(\x89\x19\xcf\xa3\x8d\x9e\xf7\x00\xf3\xdcr\x19\xdd\xe1\xbb\x18 '
 b'\xe4\xf3\xd2\xe1\\\xef\xbf\x1a\xc4\x85\x97$\xc6{\x98@\xcd\xb5\xf1\x84'
 b'R\xb9D\xccR\xd5?(\xfb\x7f\xf2[\xc8\xdf?\x04\xb0\xf2\xb1N\x0e\xec\xbf\x8e'
 b';\x16\x9c\x84\xc3_\xc3Z\x18ig\xa1\xc0\x1d\xf9\xe7\x99z\xa2\xbf\r\x95\xf7\r'
 b'd\xf0\xa5&!5\xa2\xdf\xe2\x14V\x8d\x03\x04\xe5?\xaen\xa0\x00\xa9\x05\xee?'
 b'\xe0VO\xbfU\xc8\xa2?')

{'A1': {'B1': 0.43316904665822853,
        'B2': -3523634427010652749,
        'B3': [{'C1': -93,
                'C2': [-115, -98, -9],
                'C3': {'D1': 0,
                       'D2': 426958067,
                       'D3': 414966237,
                       'D4': -0.9800881500406184},
                'C4': -15334,
                'C5': [38789, 50724, 39035, 52544, 61877],
                'C6': [0.3331785842067705,
                       0.49660395318635375,
                       -0.8767465091273157]},
               {'C1': -114,
                'C2': [59, 22, -100],
                'C3': {'D1': 132,
                       'D2': 1522753475,
                       'D3': -1587058408,
                       'D4': -0.036091622893362096},
                'C4': -27379,
                'C5': [3575, 61540, 9893, 13601, 57250],
                'C6': [0.6567399750207665,
                       0.9381909382095353,
                       0.036684684375058785]}]},
 'A2': -2460348561136552618,
 'A3': -51,
 'A4': 50,
 'A5': 94}

(b'\x98EIFC\x12\x00\xe9[\x8c\xc9\xb4\x89\xed\x89\xfa\xf0\xafJ\xf0\x149\x98\xc9'
 b'\xe4\xbf\x8d\x86\xe1\xa3\x00\xe2\xe1h\\\x8d\xf5a%\xf1\x96-(1\xb1W\x80x'
 b'\xdc\x17\x9a\x82\xbd\xd3?sC\xfc\x99 \x97\xd8/+\x9cK\xe9D\xcb\x89c\xc8'
 b'p\xec\xbf\x80 \xdf\x90\xb3\xfd\xd1?(\xc7\xe4H\xcf\r\xe9\xbfG\xac\xc7\x00\xf6'
 b'4J\xa5\r\xc6\x80\xca\\\xb4\xbeD\x9f\xd7)\xdd?O\x12\x160\xc3\xf7\x9c\x1c'
 b'\x1d\xe58`\x00"?h\xbfv\x98\xbf\x00\xb57\xb1\xc8\xdc\x8d\xbf\x00\x18Ly'
 b'\xcf$E\xbf')

{'A1': {'B1': -0.649608718383669,
        'B2': 7557570142081746573,
        'B3': [{'C1': 92,
                'C2': [-115, -11, 97],
                'C3': {'D1': 37,
                       'D2': 674076401,
                       'D3': -2141736655,
                       'D4': 0.30844178245701626},
                'C4': 17267,
                'C5': [39420, 38688, 12248, 39979, 59723],
                'C6': [-0.8887674278360937,
                       0.28110970637909105,
                       -0.7829357551292775]},
               {'C1': 71,
                'C2': [-84, -57, 0],
                'C3': {'D1': 246,
                       'D2': 228936244,
                       'D3': 1556775110,
                       'D4': 0.4556788497311388},
                'C4': 4687,
                'C5': [12310, 63427, 7324, 58653, 24632],
                'C6': [-0.02389048646708325,
                       -0.014581268223049282,
                       -0.0006452572875736973]}]},
 'A2': -8507992711464461335,
 'A3': -6,
 'A4': 240,
 'A5': 175}

Вариант №24

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

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

(b'WPZ\x9d\x00jsexalnd\x00\x04\x00\x00\x00+\xe4\xcf\xfd+t8\xd5\xf2\x0f'
 b"(\x00\x00\x00\x04\x00/\x96L'?\x00\x00\x00gynnt\xc4\xdf\x02fv\x8f\r\xed5"
 b'\x9a\x0f2X\xb2\x83\x89IH\xfb\xd4k\xf1\x1c{\xff\xacp\x01\xe1\x05\xf1H\x11'
 b'\xfb\xe1\xe2\tvI\xfb\xaf"\xa8\x14\xb95\'\xf9\xec\xd2\xfb\xbf\x06'
 b"\xa5\x9f\xa8'\x00\x00\x00\x05\x00C\x00\x00\x00\x02\x00W\xbf\xed\xb4-"
 b'&\x00X\x04')

{'A1': 106,
 'A2': {'B1': 'sexalnd', 'B2': 'ynnt', 'B3': -6961},
 'A3': -203941570658824408,
 'A4': [{'C1': 3302949478, 'C2': 118},
        {'C1': 2400054581, 'C2': 154},
        {'C1': 254957746, 'C2': 131},
        {'C1': 2303281403, 'C2': 212}],
 'A5': 2521573183,
 'A6': {'D1': 39,
        'D2': [1810963579, 4289490945, 3775263048, 301720034, 158747131],
        'D3': [12619833912805631993, 17064978735929073576],
        'D4': -0.9282441847051364}}

(b'WPZ\x9dm\xbbbqwqlaf\x00\x03\x00\x00\x00+<\xe4\xe3\xb8\xb0E5/\x0e'
 b'\x0f\x00\x00\x00\x05\x00.\x92\xa2`_\x00\x00\x00kakb0\x0bc\xa2\x93\xae'
 b'\xd3B\x874\xc20\x86\xd6Iq/\x10\x80\n\x95\xa1X\xeb\xb0\xc9\x8fS\xe0\x96'
 b'!\xb0\x0fWg*\xe3f\x1f\xcb$&\x007j\xf4/??\\\x90\x1c\xeb\xe9l>u\x0b'
 b'\x0c\x98\xbf\x97\x00\x00\x00\x05\x00G\x00\x00\x00\x02\x00[?\x8cj\xcf'
 b'\xb3\x88[\x80')

{'A1': 28091,
 'A2': {'B1': 'bqwqlaf', 'B2': 'akb', 'B3': 15588},
 'A3': -2037685020093641201,
 'A4': [{'C1': 806052770, 'C2': 147},
        {'C1': 2933080711, 'C2': 52},
        {'C1': 3257960150, 'C2': 73},
        {'C1': 1898909824, 'C2': 10},
        {'C1': 2510379243, 'C2': 176}],
 'A5': 2460115039,
 'A6': {'D1': 151,
        'D2': [3381613536, 2518790159, 1466378979, 1713359652, 637548394],
        'D3': [17595351810528255211, 16819887380739430591],
        'D4': 0.013875601450349384}}

Вариант №25

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

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

(b'\xeaEAZG\x00p?\x98\xd7K,\xd8\x8d\x00$\x05\xad\xf3r}Xo\xc6\x88\xbf\xed\x19'
 b'\xe6\xbf\xef0\x80\x1er\xf3\x82\xfc\x02\x0b?\x17\xb0\xbf\xe3\x1dO\x96\xb8 ~['
 b'&\x07\x06\xbf\xe2\x86\x95\x8d\x04d\xfc\xb3P\xeb-\x11_\xd6\xe9\x81\x18&\r\xb5'
 b'f\xa3\x0e\xbf\x86q1uM\x9b\xa2F\x19X\xf6yN3T?\x00\x03\x00\x00\x00C\x00\x00'
 b'\x00\x05\x00F?\x1a\x0b\x98\x00\x17\x00%\x87\x00\x02\x003\xf2R\x00'
 b'\x00\x007\x00\x00\x00Z')

{'A1': {'B1': [{'C1': {'D1': 50824, 'D2': -16403, 'D3': 6630},
                'C2': -0.9746704668719846},
               {'C1': {'D1': 64514, 'D2': 2879, 'D3': 6064},
                'C2': -0.5973279899344701}],
        'B2': 135,
        'B3': [23334, 1798],
        'B4': -3502,
        'B5': {'E1': -0.5789287332765123, 'E2': 179, 'E3': 20715, 'E4': 45},
        'B6': {'F1': [-2439, 20019, 21567],
               'F2': [17, 95, 214],
               'F3': [-377415642, 229992099, 247432817, 829771163, -1572464296],
               'F4': 1058671512}},
 'A2': 0.02425878010957394,
 'A3': 2595672021358434415}

(b'\xeaEAZG\x00g?\xe3\xc8\xccq\xe8\x95Z\xcb~\xc0o;\x87<\xd3\xdf\x99\x15\\\xed'
 b'+?\xee\xfddM\xda(t\xe3PS\x05\xdc\x14\xbf\xea.,\xce\x8b\xae\xc6\x7f'
 b't\xbf\xb8\xbf\xe7\x8f\xff\x90#\x1cLf\xc1,\x17\xf5*"i:\x90#\xae\xf4'
 b'\xe3U\xbb\xd8\x95)\xbaY\x95\x8f\xb2\x00\x02\x00\x00\x00C\x00\x00\x00'
 b'\x03\x00E\xad\xfc\x82,\x00\x17\x00%\xb0\x00\x02\x003D\xbb\x00\x00'
 b'\x007\x00\x00\x00Q')

{'A1': {'B1': [{'C1': {'D1': 57241, 'D2': 5468, 'D3': -4821},
                'C2': 0.9684316177893053},
               {'C1': {'D1': 58192, 'D2': 21253, 'D3': -9196},
                'C2': -0.8181365999311871}],
        'B2': 176,
        'B3': [32628, -16456],
        'B4': 17595,
        'B5': {'E1': -0.736327916639206, 'E2': 102, 'E3': 49452, 'E4': 23},
        'B6': {'F1': [10682, 22933, -28750],
               'F2': [245, 42],
               'F3': [577321616, 598668515, 1438374037],
               'F4': -1375960532}},
 'A2': 0.6182615494514423,
 'A3': 14663369020737535187}

Вариант №26

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

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

(b'MRIAZ}\x964<6\xd2)T=\xd7#\xbfr9*\xe31\xe7\xefy\x9659\xado\xec\xb7'
 b'\xf3\xc3\x8b8\x8b\xd1\x88\xa3\xfd\x17\xfe=G?\xe1o~\xc2O\x95&\x00\x02\x00'
 b'\x00\x00\x8f\x92\'\xe9\xe7X\xd0m\xb0=?\x0c\x8b\xa0\xcd\xaaf\xfa\x98G"w'
 b'\x81\x13jr=\xae\x91\x91\xfe`\x9dY\xf0q\x9f\xcf\x19\xf7\xc7\xe1\xbf\xe0\x8b['
 b"I']V\x00\x03\x00\x00\x00\x91\x94\x82\x9b\x17\x00\x97P\x82!3\xca\xef\x8d>"
 b'1B\xc4?\xb5\xc6\xe8E\xccq`EKc\xd8\x170\xc8\xab\x84')

{'A1': [{'B1': 9049477934470015316,
         'B2': {'C1': 0.10504864901304245,
                'C2': [1916349155,
                       837283705,
                       -1774896723,
                       1877784563,
                       -1014286197,
                       -779574275,
                       402537799]},
         'B3': 0.5448602481016322,
         'B4': [23, 48],
         'B5': 146},
        {'B1': 2876084205692760125,
         'B2': {'C1': 0.5490055084228516,
                'C2': [-844470534,
                       -1740168585,
                       -2129433998,
                       1034850705,
                       -27222695,
                       -260988977,
                       435668961]},
         'B3': -0.5170113018784075,
         'B4': [-56, -85, -124],
         'B5': 148}],
 'A2': -2103765248,
 'A3': [151, 80],
 'A4': 2183214026,
 'A5': {'D1': -4211,
        'D2': 0.17310625314712524,
        'D3': 0.08506633476321701,
        'D4': 1162568664}}

(b'MRIAZ\xc0\x8a\xd3O\x1d5^\xd7?\x01K%\x94gk>\x8f\x15,\xe1\xab\x9e\xee'
 b"\x19P\xd3\xb2\xbb\x10\x84\x19Mi\x91\xa8'y?\xbc\x17?\xe6\xb0;Co\xe9"
 b'\x8c\x00\x03\x00\x00\x00\x8f,\x13\x0c\x02O\xfd_\xe4\x19?\x1c\t\xb5'
 b'\xcc\x81\x933)\x1dZ\x039F\xc2\xf0\xff\x96\x9b\\\x8b3\x9dw\xa4J\x07\xed'
 b'\x83\x14\xd7K\xbf\xe7\xcbRibX\xe8\x00\x04\x00\x00\x00\x92\x80\x92'
 b'\x1a\xfa\x93\xe8HW_\x87\x16\x13\x86>\xe4\xdbL?\xeb\x8a\xa4B[\xad\xceO'
 b"\xcd\xd8\xd7\xf8'\xda9\xf7\xedS")

{'A1': [{'B1': 13874133938814148311,
         'B2': {'C1': 0.5050528645515442,
                'C2': [-1805161666,
                       -1894437663,
                       -1415647719,
                       1356051131,
                       277092685,
                       1771153447,
                       2034220055]},
         'B3': 0.7090126340038281,
         'B4': [-8, 39, -38],
         'B5': 44},
        {'B1': 1372474529017750553,
         'B2': {'C1': 0.6095231175422668,
                'C2': [-863923405,
                       689789443,
                       960938736,
                       -6907044,
                       -1959551625,
                       -1538652179,
                       -2095786165]},
         'B3': -0.743569570377784,
         'B4': [57, -9, -19, 83],
         'B5': 128}],
 'A2': -1843725677,
 'A3': [232, 72],
 'A4': 1465878294,
 'A5': {'D1': 4998,
        'D2': 0.4469856023788452,
        'D3': 0.8606740280205771,
        'D4': 1338890455}}

Вариант №27

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

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

(b'AZDG\x82I\x7f\xc6\xed9\x1b?\xe6\x8c\xe1\xbfNM\xec?\xd2\xe0v\xe1\xd6\x1fl\xdc'
 b'?\x19n\xb1l\x00\x02\x00\x00\x00]\x15\xc5Z\x00\x00\x00\x81yuirwiu?\xd8\xb7'
 b'G\xce!\x05lq\xaa~P\xbf\x19z[?o\xf3\x92m\xde\xae\x90=2\xe0\x9b\xdc\x88\xd7'
 b'\x03\xd5\x0eH$\xab\xf1e]V\xcd\x00\x02\x00\x00\x00I\xe1\x16\x10'
 b'\x1d\x00\x13\x9b\x9c\xbe\xfe\xaa~\x00\x03\x00\x00\x00QG\x8d7x\xd4'
 b'\x84\x8c\xc5\xa8\xab\xdd\xbb2a[\x17\xb5\xea\x8dD\xdf\x91?\x17\x18'
 b'`\xbf\xe6\xd1w\xb8\xdf\xd8\x9e\xba\xeen')

{'A1': {'B1': {'C1': 18815, 'C2': 198, 'C3': 237},
        'B2': 14619,
        'B3': 0.7046974884455586,
        'B4': 0.29495021871888727,
        'B5': -36,
        'B6': 0.5993452668190002,
        'B7': 108,
        'B8': [{'D1': {'E1': 22221,
                       'E2': [1843310224, 1026744475],
                       'E3': -2227575248946750564},
                'D2': -16642},
               {'D1': {'E1': -21890,
                       'E2': [3699955459, 3574482980, 2884724061],
                       'E3': 5155838140510145733},
                'D2': -22357}]},
 'A2': 21,
 'A3': 50522,
 'A4': {'F1': 3720032865,
        'F2': 6563915000912863121,
        'F3': 0.5902156829833984,
        'F4': -0.7130697832897288,
        'F5': 186,
        'F6': -4498},
 'A5': 'yuirwiu',
 'A6': 0.38618655328544693,
 'A7': [113, -86, 126],
 'A8': {'G1': 80, 'G2': -0.5995232462882996, 'G3': 0.9373103380203247}}

(b'AZDG\x82\xf2\xa9\x06\xe9\x18V\xbf\xcd{\xd1\xda\xf0\xb1h?\xbc\xf9\xc7\x8c'
 b'yB\xf0\xb5\xbe\x92\xd0m]\x00\x03\x00\x00\x00iK\xcb\xa7\x00\x00\x00\x9fvdxmoz'
 b'r\xbf\xed>\xba\xd9\x10\xdd\xc4EkI\x06>\xa5\xff\xd2\xbes\xfb";\xf6\xf28p>\xf0'
 b'!\x9a\xa7\t\xf8\xa8\x16)\xc2\xb8ooL_\x9c%\xb8\xfcz\xea\x15+\xc6H'
 b'\x01\xe45\x00\x03\x00\x00\x00I\x15\x91Z"yy\x1f\xea\xfc\x92t\x8b\x00\x02\x00'
 b'\x00\x00UPS\xd6\x8ft\x15\x05\xd3w\xc2\xe2k\x00\x03\x00\x00\x00]U\xd10'
 b'\xc0\xeb*\tk_2j\xcc\x146E\t\x8b\x96F3j9\xbd\xa1\x82\xd8\xbf\xc4j\x81\x9b'
 b'\xa8?h\xffO\xd3')

{'A1': {'B1': {'C1': -3415, 'C2': 6, 'C3': 233},
        'B2': 6230,
        'B3': -0.23034117880286975,
        'B4': 0.11318633250744958,
        'B5': -75,
        'B6': -0.28674641251564026,
        'B7': 93,
        'B8': [{'D1': {'E1': -7115,
                       'E2': [1006039608, 1883172897, 2594638328],
                       'E3': 1554122450532900842},
                'D2': -878},
               {'D1': {'E1': 29835,
                       'E2': [2820024770, 3094310732],
                       'E3': 5788205857717421523},
                'D2': 30658},
               {'D1': {'E1': -7573,
                       'E2': [1604068792, 4235913749, 734414849],
                       'E3': 6183777368493656427},
                'D2': 24370}]},
 'A2': 75,
 'A3': 52135,
 'A4': {'F1': 1791759414,
        'F2': 4974660740946553401,
        'F3': -0.07886284589767456,
        'F4': -0.15950031376314233,
        'F5': 255,
        'F6': 20435},
 'A5': 'vdxmozr',
 'A6': -0.9139074554031414,
 'A7': [69, 107, 73],
 'A8': {'G1': 6, 'G2': 0.32421737909317017, 'G3': -0.23826268315315247}}

Вариант №28

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

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

(b'IAOSI\x00\x02\x00\x00\x00[\x00\x00\x00\x06\x00_\xb6\x12\xc4\x92\xf2\xe0\xdd'
 b'\xc6\x8c:\xbf\x90-\x99\x15\x98\xe6\x02\x9aT\xf98\xce]1\x0c\xcaLmLV'
 b'\x82\xbd\xc8\xa4\x1de\x9f\xfei6\x88\x89\xe1\xb5^\\\xdb\xb9\x90\xdf'
 b'\xb0\x9d\n\xdd\xf2\x00\x00\x00\x03\x00\x00\x00k\x00q\xc2x~0\x82\x0bya\x00'
 b'S\x00W\x15\xfbTq\x03\xd5Y@U\xfc\xe8\xc2\xbd\xb6\xa1\xcf\xc5<\x00\x00\x00'
 b'\x03\x00n\xad\xfb\xd8GA$\xf9m\xc3\xe7l-\x1a\xf5')

{'A1': 21321,
 'A2': {'B1': {'C1': [{'D1': 49784, 'D2': 32304}, {'D1': 33291, 'D2': 31073}],
               'C2': {'E1': [5627, 21617, 981, 22848, 22012, 59586],
                      'E2': -1240284014,
                      'E3': -3360,
                      'E4': 221,
                      'E5': -963888449,
                      'E6': 2418907413,
                      'E7': -104,
                      'E8': 58882}},
        'B2': -26028,
        'B3': -488413659919496628,
        'B4': 7875764967893935133,
        'B5': 1704984169,
        'B6': [54, -120, -119, -31, -75, 94],
        'B7': 23771,
        'B8': -5075310830404575758},
 'A3': [-67, -74, -95],
 'A4': {'F1': [-49, -59, 60],
        'F2': -1376004025,
        'F3': 4694150961460374573,
        'F4': 6901}}

(b'IAO\xfc-\x00\x02\x00\x00\x00[\x00\x00\x00\x06\x00_4\xa9\xf4+\xcew\x95\xf8ZT='
 b"P\xa2\xaa\x95\xcfW\xde<\xab<U\xd0\x8c\x83'\xa1\x8d\xf5p'\xaf;@\xfc"
 b'\xee\xe6\xecV\xf9a\xd0q\xf4\x8c"\x82~\xd8\x84bK[\xb6\'\xe7\x00\x00\x00'
 b'\x03\x00\x00\x00k\x00t\xf1\x03T\x0b\xd5\xbb\x08B\x00S\x00W\xcd\x1d\x8f\t\xaa'
 b'\x16\x18H\x94\xff\xf2O\x05\xc8\x90\x1eJ\xe8\xacV\x02\x00\x00\x00\x06'
 b'\x00n\x0ce\xbd\x9b\x97\xfa\x8f\xdc\xd0\xfc\x7f-d\xdd')

{'A1': 64557,
 'A2': {'B1': {'C1': [{'D1': 61699, 'D2': 21515}, {'D1': 54715, 'D2': 2114}],
               'C2': {'E1': [52509, 36617, 43542, 6216, 38143, 62031],
                      'E2': 883553323,
                      'E3': -12681,
                      'E4': 149,
                      'E5': -128297923,
                      'E6': 1352837781,
                      'E7': -49,
                      'E8': 22494}},
        'B2': 15531,
        'B3': 4347610317210493325,
        'B4': 17685679370250812654,
        'B5': -420718855,
        'B6': [97, -48, 113, -12, -116, 34],
        'B7': 33406,
        'B8': -2845040988790577177},
 'A3': [5, -56, -112],
 'A4': {'F1': [30, 74, -24, -84, 86, 2],
        'F2': 207994267,
        'F3': -7495520451242983635,
        'F4': 25821}}

Вариант №29

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

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

(b'\xfbNWO\xb3Odiii&\xef&\x02\x00[\x00+\x13\xd2[0\xad\x7fky,\xc6z\xee[['
 b'\xa3\x18dj\xbb\x9b\xc0\xea?\x10\xb8\xef\xba_\x00\x00\x00i\x0b@\xcf\x1aSD'
 b"\xf4\xd8\xa0\x83\xc2V\xf9\x17\xce\x80'\x0e\x8b\xd0@;,\xe7?\x80\x1d\x19\xbf8"
 b't\xefN*J\xe5?\xb2\xf5\xa0>C\x00O\x00\x933\xe5\x93\n\xa0\n\xcb\xa8'
 b'\x95\xac\r\xcdz\xc6?\xd0\x06\xa6\x989z\x12c\xefm~8\xf7\xeb\x88\x07u'
 b'Q\xb8 \xed\xc7%\x03\xcd\xc0\xa4\x82\x97')

{'A1': {'B1': 20403,
        'B2': 'dii',
        'B3': 653207145,
        'B4': [{'C1': 0.7241493478689749, 'C2': -0.5981063842773438},
               {'C1': 0.6653033773142232, 'C2': 0.31437450647354126}],
        'B5': 7746100307311072043,
        'B6': [2059807865, 2740673518]},
 'A2': 0.8360117588482607,
 'A3': 47120,
 'A4': -17681,
 'A5': {'D1': 14630682306757866387,
        'D2': 0.1756225888031342,
        'D3': -1733949744,
        'D4': 4070811988116273721,
        'D5': [-9, -21, -120, 7, 117, 81, -72],
        'D6': 633859360,
        'D7': [3, -51, -64, -92, -126, -105]},
 'A6': 17601284618282077033,
 'A7': -3596131626406141736,
 'A8': 10112}

(b"\xfbNWO\xe9\xcdvzc\xbc\x0b\xce%\x02\x00[\x00'd\xee8\x9a:\x8e\xdb#1\x7f"
 b'W\x90\xda\xc2\n@\xee8\xdcN\xb2\xb0\xbf\x0e^\xecl_\x00\x00\x00N\xdf\xdf'
 b'I\xa5S\xab\xbbK^\x9e\xab\xf7\xe3\xdeW\x19\xd4\x00\x03\xeaRz\xd8\x9f\xbf\xaf'
 b'\xbf\x84\xbe\xecq\xc4\x16Db\xd5\xbf\xdb0\x8f\xbeC\x00O\x00\xe7j<\x8f\xba'
 b'tk8\xf0*w\x86\x94\xd6\xbf\xbf\xde\xb9eY\xffVQ\xaeZ-o;\xdd\xa5\xa3\r\xb8'
 b'\xf1JJ\x95\x83\xdd5\xe4"\x8e\x85\xcb')

{'A1': {'B1': -12823,
        'B2': 'vzc',
        'B3': 634260412,
        'B4': [{'C1': -0.03109923487727695, 'C2': -0.2592749297618866},
               {'C1': -0.3341226789796383, 'C2': -0.2796696126461029}],
        'B5': -2626097098655898585,
        'B6': [1467953443, 180542096]},
 'A2': -0.06522076488993722,
 'A3': 24078,
 'A4': 27884,
 'A5': {'D1': 4065471433247845095,
        'D2': -0.12436798365449042,
        'D3': 1499838942,
        'D4': 4282691638147503871,
        'D5': [-35, -91, -93, 13, -72, -15, 74],
        'D6': -578579126,
        'D7': [53, -28, 34, -114, -123, -53]},
 'A6': 13522994275484163918,
 'A7': 6331748779005206091,
 'A8': 54297}

Вариант №30

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

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

(b'NZSq\xd9c!i\xa9\x11\x05\x92\xcc4\x1c\xe6\xb4\x00\xef\xbf\xe6lL\x858\x17P\xf5'
 b'\xb1\xdb\xb1\xf1h\x1fQU\xbd\x9c\x9c\xbd\xf9\n\xc5\xaa\xb3\x96sD'
 b'\x8f\xa7\x12\xee\xbf\xa1l\xe3\xbe\xec\\\xcb\x1dt\xcf(s\xc7r\x89/Of\x00'
 b'\x00\x00{\x00\x00\x00\xbd\xb7\xbe\xf2\xab\xe9$\xbf\xf5$\x93w\xc9\x0b'
 b'c\xc0k\xcbjZ\x02\x00\x90\x00\xd0\x00g?t\xbc)\xe0<\xd8~"\x9c\xb7\xfc\xdf\xdbV'
 b'\xd0?Ub\xd8I\xdd\xec\x86E\x1a\xd7bT\xcf\xa8\xe6(\x18X\xeb\xe0\xbf\xd6f*P\xbd'
 b'\xad-\x12\xbd')

{'A1': {'B1': -7924908549977578535, 'B2': -0.9688362593020883},
 'A2': [-2058588954,
        -179300552,
        -240002127,
        1431379816,
        -1113809731,
        -1429927175],
 'A3': -77,
 'A4': -0.9397771642867265,
 'A5': -0.4441881477832794,
 'A6': {'C1': 23788,
        'C2': -53,
        'C3': 9904197827960992797,
        'C4': 20271,
        'C5': [{'D1': [208, 16231],
                'D2': 2485661800325561460,
                'D3': 0.2553014457106373,
                'D4': 85},
               {'D1': [-10142, -8887],
                'D2': 14939674539893032684,
                'D3': -0.5287285301084994,
                'D4': 214}],
        'C6': 47037},
 'A7': [2663244919919604414, -3788723129870092397],
 'A8': {'E1': 23146, 'E2': [-0.050821684300899506, -0.035688091069459915]}}

(b'NZSqg\xa1\xbb&\xdc\xf9\xb1;@\xdc\xf6\x1c\xa0\x9b\xd1\xbf\x8f\x8c\xf7\x9b'
 b'atS\x07P$D\xe5\xfd\xf3f\n\xe1\xa07\x94(,\xb8\x99\xa6V\n\xad8Z~\xe6'
 b"\xbf'\xf9\xf8\xbd@T\xdc\x84}\xa6\xbe\xc9\xfe\xc0\x99\xa3\xf1f\x00"
 b"\x00\x00{\x00\x00\x00'\x9cE\xa8{f\xef\xef\r-\x8a,rr\xd2Q\xa8\xf1"
 b'\x06\x88\x05\x00\x90\x00\xc7%\xfe\xdc\xd1u\x98\xe7\xc5;K&\xf8\xf3'
 b"\xbeY\x90\xb6\xe6?\x1cB\x04Q\xb9\xfd\x1b\x07'\x93\xf1\x08\x17\xfe"
 b'?\xdb\x9c\x04%\xef?\xaf\xc7\xc3\xca>K\xc7\xd6\xbe^\xa0\x93\xbe5G0\xbf'
 b'\x11\xffH\xbf')

{'A1': {'B1': 4301493843053486439, 'B2': -0.27512362316651107},
 'A2': [-1678275441,
        122909793,
        -448519088,
        174519293,
        -1808293663,
        -1715983320],
 'A3': -90,
 'A4': -0.7029238802864011,
 'A5': -0.12156897038221359,
 'A6': {'C1': 21568,
        'C2': -36,
        'C3': 11079135225771883908,
        'C4': -3677,
        'C5': [{'D1': [9671, -8962],
                'D2': 2759364917874685393,
                'D3': 0.7097856285905655,
                'D4': 28},
               {'D1': [1090, -18095],
                'D2': 1659842077003291645,
                'D3': 0.9732688010790296,
                'D4': 175}],
        'C6': 39975},
 'A7': [3246514717899597893, -1033486150176461686],
 'A8': {'E1': -30714,
        'E2': [0.3960249125957489,
               -0.4194892346858978,
               -0.28833287954330444,
               -0.6885865330696106,
               -0.7851420044898987]}}

Вариант №31

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

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

(b'SJS\xba\x16/\xe7\x0e\\\x07\xa1$\xb2[\xeb:\xbe\xf0{9\xca\x00\x00\x00'
 b'E\x00\x00\x00R\x9buc\xfe?\x070\x94 l!\x00\x00\x00\x02\x00_o\x05|\x0f$A'
 b'\xc6s3\xa8\x00\x04\x00g\x07\x8d\xe0\x82\xc0\xa3\xe7 V?*^\x0f\xb0?\xc1'
 b'\xd1\xe6J\xbb\xe5\xc8=\xfc\xed\xc8\x16\xbf\xbbF2\x059\x10\x90\xd1\xf7}JA'
 b'\x0e\xf69\xf1\xeb\x87$\xf8\xe0W_')

{'A1': 372238094,
 'A2': {'B1': 6631446155309607738,
        'B2': -0.46969011425971985,
        'B3': 202,
        'B4': {'C1': [{'D1': 0.6654977202415466,
                       'D2': -80,
                       'D3': 0.13921812676544065},
                      {'D1': 0.12350040674209595,
                       'D2': 22,
                       'D3': -0.10653984668266703}],
               'C2': 2608161790,
               'C3': 0.5280849933624268,
               'C4': {'E1': 32,
                      'E2': 27681,
                      'E3': [3522657610, 1091499577],
                      'E4': [28421, 31759, 9281, -14733, 13224]},
               'C5': {'F1': [-3605, -30940, -1824, 22367], 'F2': 1933},
               'C6': -528301917}},
 'A3': {'G1': -6368, 'G2': 86}}

(b"SJS\xbao\x9fF'\x04\xed\x89\xaf\x7f\xd2\xe5\xdf>\x16\xff\xf74\x00\x00\x00"
 b'E\x00\x00\x00R\xc8S"=\xbf\rZ\xc4\x91\xe29\x00\x00\x00\x02\x00_\xff\xe4'
 b'\xc5\xeb1\t\x16\x14)\x8f\x00\x02\x00gW\xc2\xbd\xac\x0b\xad\xb7\xaa'
 b'5\xbe\xd5\x17Q\x0f\xbf\xd0O\x14ra\xfd\x98>\xa1\x8c\x8bE?\xef\xc7\x9f\xbf'
 b'-\xb7B\x8a\x14\xa32\xe7\xbe\x8bH(\x0c\x02\x1d')

{'A1': 1872709159,
 'A2': {'B1': 355091332488947167,
        'B2': 0.14746080338954926,
        'B3': 52,
        'B4': {'C1': [{'D1': -0.41619351506233215,
                       'D2': 15,
                       'D3': -0.25482665224259327},
                      {'D1': 0.3155253827571869,
                       'D2': 69,
                       'D3': 0.9931181653935044}],
               'C2': 3360891453,
               'C3': -0.552166223526001,
               'C4': {'E1': 145,
                      'E2': 57913,
                      'E3': [2316608306, 3888024392],
                      'E4': [-28, -14869, 12553, 5652, 10639]},
               'C5': {'F1': [10252, 541], 'F2': 22466},
               'C6': -1112798291}},
 'A3': {'G1': -18518, 'G2': 53}}

Вариант №32

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

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

(b'AREY\xe9p\x98\xbe\xaf\xf9\x17OD(+\xe7\x15\x05\x9a\x18\x80\x02E\x93\x1e4\xac?'
 b'n\xb0)\xb4\xad\x98\x86d\xe7t3\xc1?\x8e\xf5\xb1|\x15\xc6j\x9b\xb9\xce\x88'
 b'\xe2\xbf\xec\xa0:\xe0\xe5>\x15\xd8\x80\xba\xdb\x16\x82T#\xb4\x8b\xa2'
 b'd\xc4Y\xf6GB=\xda,<B<\xe1\xf5\xde"\x9c}\xa9\xc0w\xbf\xb0\xbe\xb6<K\xc0'
 b'\x0b\x89\xd6\xe4\xa2\x80"1e\xa7\'\xa8\xd4\xbc\x1e4\x83\xff\x98=\xad\x1d\x9a6'
 b'\x02\x00\x00\x00\x8d\x00Aq\x9d{=\x9c\xad\\\xa9\xe3@\x91\xcd\xc9\x0e\x07\xact'
 b'\xcf')

{'A1': -0.29773643612861633,
 'A2': 1326971311,
 'A3': 1772734994954528836,
 'A4': 0.05508513972973095,
 'A5': {'B1': {'C1': 110,
               'C2': 10672,
               'C3': 44468,
               'C4': 0.13438283251257555,
               'C5': -114,
               'C6': 360493557,
               'C7': -0.5792001366747506,
               'C8': [{'D1': -24340,
                       'D2': 0.4489763379096985,
                       'D3': 55317,
                       'D4': 383498880,
                       'D5': [21634,
                              46115,
                              41611,
                              50276,
                              63065,
                              16967,
                              55869,
                              15404],
                       'D6': 4125178946,
                       'D7': 8926},
                      {'D1': 32156,
                       'D2': -0.967783510684967,
                       'D3': 48816,
                       'D4': -1068811082,
                       'D5': [35083,
                              58582,
                              32930,
                              12578,
                              42853,
                              43047,
                              48340,
                              13342],
                       'D6': 1033437059,
                       'D7': 7597}]},
        'B2': {'E1': -102,
               'E2': 54,
               'E3': [248106385, 3480529927],
               'E4': 2073915713,
               'E5': 39997,
               'E6': -83},
        'B3': [92, 169, 227, 64]}}

(b'AREYi5\x06?\xe5\x10\x83\x8e;S\xdd\x06+\xd8b\x8b\xb0\x9d\x9ay\x84a\xe3?'
 b'\xab\xcc\xab\x84\xac\xa8\x8e\xadZ"%\xdf?^\x97u\x05\xdb\x1a\xc9{\xa5\x1f?'
 b'\xe0?M\x15=\x97\x1f?\x05\x94\x997\x8b\xfde\xfe]\xd2t\xda\xef\x84\x98\xe4'
 b'\xf0\xd3\x9b,z)\xb7\xed\xb5\x8c\xfd\xb9\xc1{\xc4\xf1O\xbe\xd3\xa1"r\x84)'
 b'\xeb%\xa8\xa3\xecz\xe9B%\x82\xa1\xa4\xbc\x81\xf0\xf5\x95\x0b$\xa5_\xdd\xdbu'
 b'\x02\x00\x00\x00\x8d\x00\xb94b\xaf1\x98\xe4\x11q\x00\x92\xfd\x8a\xb3yxm\x96'
 b'\x06')

{'A1': 0.5242524743080139,
 'A2': -1904013083,
 'A3': 10043827798299988795,
 'A4': 0.6056539893224251,
 'A5': {'B1': {'C1': -85,
               'C2': -21556,
               'C3': 44164,
               'C4': 0.48664149146336877,
               'C5': 94,
               'C6': 3674568087,
               'C7': 0.5077055198765124,
               'C8': [{'D1': 5453,
                       'D2': 0.6234014630317688,
                       'D3': 37893,
                       'D4': -41207911,
                       'D5': [65125,
                              53853,
                              55924,
                              34031,
                              58520,
                              54256,
                              11419,
                              10618],
                       'D6': 2360733111,
                       'D7': -17923},
                      {'D1': 31681,
                       'D2': -0.20307070016860962,
                       'D3': 41427,
                       'D4': 696545826,
                       'D5': [9707,
                              41896,
                              31468,
                              17129,
                              33317,
                              42145,
                              33212,
                              62960],
                       'D6': 2770602901,
                       'D7': -8865}]},
        'B2': {'E1': -37,
               'E2': 117,
               'E3': [2041809661, 110521720],
               'E4': 2942448825,
               'E5': 38961,
               'E6': -28},
        'B3': [17, 113, 0, 146]}}

Вариант №33

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

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

(b'EKYK$?`\xfdq\x9f\x90\xa8\xfd"\xdd\x8eb\x00\x00\x00\x94a\x13\x00'
 b'\x00\x00\x02\x00\xa0\x90\xa5\xee\x9a\xc7\x06\x10P\xd2\x0f\xcf\x88 \xd3\xd3'
 b'\x9f\x05\x90\xbf\xd5t\xdc\x859\x8f\xd0\xfa\xa0\x97AA?\xea_\x1f&\xfb\xcc_'
 b'L\x80\x84\x11I\x00\x00\x00\xa2\xd7\xf1\x00\x00\x00\x02\x00\xae\x9a\x07n'
 b'\xb4\x15\xe6\xb4\x1b\xaa\x08,`\x90\xfd\x12\xd6\x97\x1c?\xd6\xdc~\xf1'
 b'Q\xdf\xac\xb91\xcd\x80\xd1\x99\xce\xc9Y\xc0\x81\xd1\x84\xf3U\x7f\x04'
 b'\x88\xa9\x04\x07\x1e`q\x97\xb0\x00\x00\x00\x03\x00\xb0\xe6\x8d^\xe5\xf6'
 b'\xf1\xbf\xeb\x18=\xceQ\xd1\n\xe8T^tc\xa4?\xe7Y\xf0S\x9bp\xce\xc0\xfd\x05qz'
 b'w\xce\xa6\x07\r\x0e')

{'A1': 0.8788672089576721,
 'A2': -6948868419867537822,
 'A3': [{'B1': {'C1': -15,
                'C2': -0.846709158866845,
                'C3': 232,
                'C4': 84,
                'C5': 94},
         'B2': 24851,
         'B3': 'tc',
         'B4': [37029, 61082, 50950, 4176, 53775, 53128, 8403],
         'B5': {'D1': -45, 'D2': 159},
         'B6': 1424,
         'B7': -0.33525765428771326,
         'B8': {'E1': -90138815,
                'E2': 4701734230263528396,
                'E3': 95,
                'E4': 1283490833,
                'E5': 73}},
        {'B1': {'C1': -92,
                'C2': 0.7297288544609957,
                'C3': 192,
                'C4': -3,
                'C5': 5},
         'B2': -10255,
         'B3': 'qz',
         'B4': [39431, 28340, 5606, 46107, 43528, 11360, 37117],
         'B5': {'D1': 18, 'D2': 214},
         'B6': -26852,
         'B7': 0.35720799986256213,
         'B8': {'E1': -1187918464,
                'E2': -3343413884156345903,
                'E3': -124,
                'E4': -212500732,
                'E5': 136}}],
 'A4': -1459353826,
 'A5': 1618057136,
 'A6': [30670, 42503, 3342],
 'A7': 3868024549,
 'A8': -10}

(b'EKYK$?Rjdeq9P\xd8\xe7A`\x00\x00\x00\x94\xdb\xd3\x00\x00\x00\x02\x00'
 b'\xa0\x8e:\xa3\x0f\x1b\x84\xdc?\xd5d\xef\x0cn\xf3Yz\x84\x90?\xe8B[B6\xc2NS'
 b'^\xb4\xe7\x7f\xe1\xd7\xdf\x08\xc3&e$\x90d\x1az\xcc\x00\x00\x00'
 b'\xa2\x87\x8f\x00\x00\x00\x02\x00\xael(\x08\\\xea\x14j\xfe\x9e\xc8\x1e'
 b'\xb6\x8b\xb8\xa9\x9eW{\xbf\xb5\xf6\xe4%\x03\x1d\x80\x95G\x9b//\xb1z\xd1\xbe'
 b'\xea\xbb\xa8\xc3X{\x05\x17\xb5\xf6\xf3G\x0c\x95\xc9K\xfa\x00\x00\x00'
 b'\x02\x00\xb0l*D8\x14~?\xcf\xb1/\xfa!\x9d\xf0\xc2\xf6\x87rqE?\xd41\xe4\xfc'
 b'\xfa\xb5x\x1a\xe6qze\xb9\x90\x06\x9f')

{'A1': 0.8219358921051025,
 'A2': 7309686689598226784,
 'A3': [{'B1': {'C1': 126,
                'C2': 0.24759483064120458,
                'C3': 194,
                'C4': -10,
                'C5': 135},
         'B2': -9261,
         'B3': 'rq',
         'B4': [36410, 41743, 7044, 56383, 54628, 61196, 28403],
         'B5': {'D1': 89, 'D2': 122},
         'B6': -31600,
         'B7': 0.7581001561394005,
         'B8': {'E1': 1398715623,
                'E2': 9214883665501431397,
                'E3': 36,
                'E4': -1872487814,
                'E5': 204}},
        {'B1': {'C1': 69,
                'C2': 0.3155453176976475,
                'C3': 26,
                'C4': -26,
                'C5': 113},
         'B2': -30833,
         'B3': 'ze',
         'B4': [27688, 2140, 59924, 27390, 40648, 7862, 35768],
         'B5': {'D1': -87, 'D2': 158},
         'B6': 22395,
         'B7': -0.0857985105859509,
         'B8': {'E1': -1790469329,
                'E2': 3436663031930207144,
                'E3': -61,
                'E4': 1484457239,
                'E5': 181}}],
 'A4': -151828724,
 'A5': -1781969926,
 'A6': [47504, 1695],
 'A7': 1814709304,
 'A8': 20}

Вариант №34

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

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

(b'\x8aOEID?F\xf1\x0e\x02\x00\x96?3\xc1\x11;W\x19\xc7\x89\xa0\xc0\xfa&\x1bV,'
 b'u6h\xd9\x8aT\xcc\xd7\xb0V%3\x87\xc4]\xcd\xebr|\xa3\xc2\xb4\xc0\xb0Y\\\xc8 '
 b'j@\xff\xa1\xad\xda\x82\xa2\xf0\x12\x8a{\x9a\xb7\xa4x\x00\x18\x00(\x008\x04"'
 b'\xf9i\x14\x80AS\xa3\xc5\xf6\x05\x04f\xed\xec\xa1\xea\x8d?8?\xc6\xa0\xc7('
 b"\x06\xc6\xf8?\xe7\x9d'\x90\x99v\x18\xbf\xc5\xe7\x1d\x9e_\x86\xa0\xbf"
 b'\xe1!p\x9e-\xae\x9e\x00\x00\x00\x03\x00Z:\x8f3\xe4\t?\xe1T\xa0T\xfd'
 b"Ot\x00\x03\x00\x00\x00H\xc6'\xf3\xad\xcc%\x00\x00\x00N\x00]\x0f")

{'A1': 0.7771157026290894,
 'A2': {'B1': 2,
        'B2': {'C1': [{'D1': 639325740,
                       'D2': 1966500057,
                       'D3': -1974154025,
                       'D4': -80,
                       'D5': 86,
                       'D6': 9523},
                      {'D1': -2017174067,
                       'D2': 3950148771,
                       'D3': -1028341584,
                       'D4': 89,
                       'D5': 92,
                       'D6': -14304},
                      {'D1': 1782644641,
                       'D2': 2916778658,
                       'D3': -267220357,
                       'D4': -102,
                       'D5': 183,
                       'D6': -23432}],
               'C2': 50727,
               'C3': 4088253477,
               'C4': {'E1': [1058, -1687], 'E2': 1477252505263273477},
               'C5': {'F1': [236, 161, 234, 141, 63, 56],
                      'F2': [0.1767815537873998,
                             0.7379339050491494,
                             -0.17111559136451593,
                             -0.5353320207045333],
                      'F3': [4, 102, 237],
                      'F4': 58,
                      'F5': 2402542601,
                      'F6': 0.5415803585005805},
               'C6': 15}},
 'A3': 0.7021647095680237,
 'A4': 4275914716009775354}

(b'\x8aOEID\xbe\x8b\x8f\x0c\xae\x00\xa9?r\n5\xca~\r^\x1b\xdd\xe5R\xca)\xc1m'
 b'J\x9a\xb6#\x93\x87\xf0\xfa\x08f\x05\x91\xba\xae\xfd\x13\xa1\xc0Z$'
 b'u\xfc\x82\xf1%\xd6Zu#\xc39}\xc4&\xea\x9d\xae\x81\xdc\x8e\xa3+\xdf\x12'
 b'\xe4\x80\xe6"\x0f(B*2S\x92L\x80\x8c\x04B\x00\x18\x00(\x008\x00H\x9c~\x89\x84'
 b'\x06\xe7\x8d\xbbr+6\nR?e6\xa7\xc3#Yl\x03?\xeba)\xceXu\xca\xbf\xee'
 b'\xfd\xc7\t\x10\x1f\x1c\xbf\xe5\xfd\xb1P\xbb\xccJ\xbf\xeaXC\x0b\xe4'
 b'\xdeB\x00\x00\x00\x04\x00l\xf4\xf5\xab7\xef\xbf\xd96\x1e\x10\x1c|'
 b'\xe8\x00\x04\x00\x00\x00X\xeeu^-\xfc\x8c\x00\x00\x00`\x00p\xda')

{'A1': -0.2725757360458374,
 'A2': {'B1': 174,
        'B2': {'C1': [{'D1': -903233171,
                       'D2': 1251653155,
                       'D3': -1819807494,
                       'D4': 8,
                       'D5': 102,
                       'D6': 1425},
                      {'D1': -1162937069,
                       'D2': 2713737764,
                       'D3': 1979482865,
                       'D4': 37,
                       'D5': 214,
                       'D6': 23157},
                      {'D1': 599996797,
                       'D2': 3290884765,
                       'D3': -1367221106,
                       'D4': -93,
                       'D5': 43,
                       'D6': -8430},
                      {'D1': -461314526,
                       'D2': 254296618,
                       'D3': 844337740,
                       'D4': -128,
                       'D5': 140,
                       'D6': 1090}],
               'C2': 61045,
               'C3': 1580072076,
               'C4': {'E1': [-25474, -30332], 'E2': 497522120061564426},
               'C5': {'F1': [167, 195, 35, 89, 108, 3],
                      'F2': [0.8556107549845191,
                             -0.9684786965380883,
                             -0.6872183396175242,
                             -0.8232741577439315],
                      'F3': [82, 63, 101, 54],
                      'F4': -12,
                      'F5': 4121638895,
                      'F6': -0.39392806599967267},
               'C6': -38}},
 'A3': 0.9454682469367981,
 'A4': -3855629533136951982}

Вариант №35

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

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

(b'NZT\x14\xd8sWXcp!\x067d\x9a\x95\xad\x93Xb\x04G\x95\xc1?\xad\x16\xe8'
 b'\x0b\xe4\xdb\x96\x0c\x8d\xfc\xc4\\\xee2\xfaD4\xcd<M\n@\xc6|\x9du\x00'
 b'\x00\x00\x05\x00\x8b\x00\x90\x92\xd1\xd6\x19\xf0\x15\x8d\x90\x1a'
 b'&\x7f\xb3\x06/$\x9c\xb9\x85\x9ao\xe3-\xf9\x01\x18x\xc3\x00\x00'
 b'\x00\x03\x00\x99\x00\x9c\xce\x9e\xc2\x9c\xaa\x8f\xe6\xd8\xde\xb5}\x15\xa8 '
 b'\xd3\xb9\x7f\x1a(o\x9b\xa1v\xe5\xf0^\x12\x00\x00\x00\x05\x00\xa5\x00'
 b'\xaa\xbb\x95\x17\xc1\xe5\xd7\xb6A\x00\xfe\x8c]\xe6NA\x0e=\xe3\xfd\x80\xdfYg'
 b'f\xe4\x0e\x92\x96qG\xc4\xdc\x97\x16\xc5>"\xe6\xc3!\x049\xb4Gr\xb1D\xe1L*')

{'A1': -663529640,
 'A2': 'cp',
 'A3': {'B1': 8454, 'B2': 3991485137410021474, 'B3': 1095},
 'A4': 38337,
 'A5': [{'C1': [4588348781248174998, 904657020474241786],
         'C2': 68,
         'C3': [13517, 15437, 2624, 50812, 40309],
         'C4': [140, 93, 230, 78, 65],
         'C5': {'D1': 14, 'D2': 4459686785971742566}},
        {'C1': [10579472406560476560, 1884333900980757660],
         'C2': 185,
         'C3': [34202, 28643, 11769, 280, 30915],
         'C4': [228, 14, 146],
         'C5': {'D1': 150, 'D2': 8162709301339014462}},
        {'C1': [14888551396265682648, 16047870379173139385],
         'C2': 127,
         'C3': [6696, 28571, 41334, 58864, 24082],
         'C4': [34, 230, 195, 33, 4],
         'C5': {'D1': 57, 'D2': 12990477755863878698}}],
 'A6': 13516735978174658113,
 'A7': 254}

(b'NZT\x14um\xf9\x90ht\x07f(ig7Tz1\xedR\x11\xd8\xb9!Da\x0b)j\x88\xb4?\x91"\xdd'
 b'\x9d\x8c\x89)\x8c\xab\xaf0B\xda\x0cg\x90\x9f)\x00\x00\x00\x03\x00'
 b'\x8b\x00\x8e(\xc7\xcdH\x80\xc7G\x8cm\xb1\xb4\x97(\xa7\xc8\x15\xfb/\x19)D'
 b'~\x96\xeex \x1c\x00\x00\x00\x02\x00\x97\x00\x99p*3\xd2\xb2\x9c\x12\xa2m\xf6'
 b'f\xb3\xfa_!\xc8\xa1lG\xcc\xad\xaca\xd4\xb7\xfd\xe9\x00\x00\x00'
 b'\x04\x00\xa2\x00\xa6\xf6I\x9by\xbe\x1b\x86L\xa3z\x07-?j\x0386,\x01'
 b'\xe2!\xef\xf3%*\xff\r\xb3\xe7\xd4\xf6\x8a\xec\xcfFI*\xe9\xb2AO\xe6\x87'
 b"\x0c'\x80")

{'A1': 1970141584,
 'A2': 'ht',
 'A3': {'B1': 1894, 'B2': 2911972121409892845, 'B3': 21009},
 'A4': 55481,
 'A5': [{'C1': [2397147602235328692, 4580480631238854953],
         'C2': 140,
         'C3': [43951, 12354, 55820, 26512, 40745],
         'C4': [7, 45, 63],
         'C5': {'D1': 106, 'D2': 231994943447638511}},
        {'C1': [2938542993164421004, 7904297382327076885],
         'C2': 251,
         'C3': [12057, 10564, 32406, 61048, 8220],
         'C4': [243, 37],
         'C5': {'D1': 42, 'D2': 18378543462660606700}},
        {'C1': [8082329461302497954, 7923633517590684104],
         'C2': 161,
         'C3': [27719, 52397, 44129, 54455, 65001],
         'C4': [207, 70, 73, 42],
         'C5': {'D1': 233, 'D2': 12844635463764158336}}],
 'A6': 17746886753812973132,
 'A7': -23686}

Вариант №36

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

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

(b'+DBHPflws\x10\\>Ee?\xde\xe9y\x02H\xcb\xb4?\x0b\\\x91\x00\x00\x00\x02\x00\x00'
 b"\x006\xbfI\xfbA\xfa4U\xa3k\x87\x00\x00\x00\x02\x00L\x00\x00\x00^'\x12"
 b'?\xd0\xdc7\x1d\xbef\xdc\xce\x14\xbe?\xea\xde\x19\xff\xde@,\xec\xf2z>Z'
 b'\xc2\x15\xbflh\xc1\xbe\xd6J\xf6\xbe\x116\x80\x00\x02\x00N\xfc\\/\xda\x00\x02'
 b'\x00V')

{'A1': {'B1': 'flw', 'B2': 1930452030, 'B3': 17765, 'B4': 0.4830000421817957},
 'A2': 0.5443812012672424,
 'A3': [{'C1': 10002, 'C2': 0.26344087509788294, 'C3': 206},
        {'C1': 5310, 'C2': 0.8396120068955546, 'C3': 236}],
 'A4': -0.7889900803565979,
 'A5': 4197733795,
 'A6': 27527,
 'A7': [-14, 122],
 'A8': {'D1': [0.21363098919391632, -0.9234734177589417],
        'D2': -61067302,
        'D3': [-0.4185406565666199, -0.14180946350097656]}}

(b'+DBHPnsp*u\xb5D\xfb}?\xc0!\xa21BZ >Sa\xa6\x00\x00\x00\x02\x00\x00\x006>\xaa'
 b'\x86\x16x\xea\x1e|%4\x00\x00\x00\x02\x00L\x00\x00\x00b\xbb\xd5?\xd3\xb6/'
 b')\xa1$\x9cV\x87\x1e\xbf\xd1\xafCF\x98\xd8\x90\xe9\x95\xa9\xbf \xb0\x83\xbf9'
 b'\x03!>\xf1<\x91\xbfs\x8fo?(_x\x00\x02\x00N\x00\x15\xc4\xbf\x00\x03\x00V')

{'A1': {'B1': 'nsp', 'B2': 712357188, 'B3': -1155, 'B4': 0.12602641492112898},
 'A2': 0.2064271867275238,
 'A3': [{'C1': 48085, 'C2': 0.30799464288117817, 'C3': 86},
        {'C1': 34590, 'C2': -0.27632219213718034, 'C3': 233}],
 'A4': 0.33305424451828003,
 'A5': 2028609148,
 'A6': 9524,
 'A7': [-107, -87],
 'A8': {'D1': [-0.6276933550834656, -0.7227039933204651],
        'D2': 1426623,
        'D3': [0.4711652100086212, -0.9514073729515076, 0.6577067375183105]}}

Вариант №37

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

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

(b'YOV?\xe1J\x9a8\xa0\xae`\xbaiy*9X\x8b\xb8aIE\x01\x00\x05\x00\x00\x00'
 b'\x97\xa5\xfd\xce~=\xe8\xfd6\x9cZ\xda\x89\x00\x00\x00\xa1@\x8bX'
 b'\x07\x1e\xa2\xeb\x04\xe1\x15\xf2\x04<\x00\x04\x00\x00\x000\xbfT2\xed'
 b'\xb1AG\xbc\xb2\xd4\xcf\xa9\xaa\xe7<\x00\x03\x00\x00\x00G>\xe8\x0b\x8c|\x98K'
 b'\x88W\xd4&2\x0f\x00\x02\x00\x00\x00\\\xbfF\x1c\x05\xd3\x0e\xebD'
 b'\xa7\xba\x18\n\x99\x00\x02\x00\x00\x00o=\x0486\xb7\xaa\x9d\x10\xbc'
 b'\xa6\x91\x88U\xead\x00\x03\x00\x00\x00\x82?h>\xb4\xee\x11\x18\x008\x00M\x00'
 b"`\x00s\x00\x88\xbfp9\xc8\xb1\xdb\xcd'GMYD\xd6t\xbd]\xb6\xdc")

{'A1': 0.5403567415246009,
 'A2': {'B1': -70,
        'B2': 'iy',
        'B3': 3042560380382562629,
        'B4': 1,
        'B5': [{'C1': 1084,
                'C2': [1822, -23829, 1249, 5618],
                'C3': -0.8289020657539368,
                'C4': [177, 65, 71]},
               {'C1': 59196,
                'C2': [-17230, -11057, -22102],
                'C3': 0.453213095664978,
                'C4': [124, 152, 75]},
               {'C1': 12815,
                'C2': [-30633, -11226],
                'C3': -0.7738650441169739,
                'C4': [211, 14, 235]},
               {'C1': 2713,
                'C2': [17575, -17896],
                'C3': 0.03228016942739487,
                'C4': [183, 170, 157]},
               {'C1': 60004,
                'C2': [4284, -22895, -30635],
                'C3': 0.9072067737579346,
                'C4': [238, 17, 24]}],
        'B6': 2784874110,
        'B7': 0.1137642115354538},
 'A3': -1671767415,
 'A4': {'D1': -0.9383816719055176,
        'D2': [-20005, -13017, 18253, 22852, -10636, -17059, -18724]},
 'A5': 16523,
 'A6': 88}

(b'YOV?\xef\xa1\x1e,\xf3\x1b2Apy\xe90\xbfW\xa2m\xb9\xb4\xc2\x00\x04\x00\x00\x00'
 b'\x8a\xe1\xe7b\xdf>w\xe41\xe5 \xf68\x00\x00\x00\x92\xc4\x14\xdf\x91\xc0\xd8E'
 b'\xe90\x00\x02\x00\x00\x000?\x04\xaa\xcaG\x9f\x1f\x13\xc7\xc6\xcfL'
 b'\xb4\r\xb9\xb9\xd8\x00\x04\x00\x00\x00C?B\xbc 6\t\x18N~%\xff\x16\x98'
 b'\xf4\x8a\xd7\xc4\x07]\x00\x05\x00\x00\x00Z\xbd\xbb\xbb\xbf%\xc44\x8b'
 b'\x06\xfa$\x83\x16\n\xf5\xec\xd0\x00\x04\x00\x00\x00s\xbe\xfe\x89\xb4c'
 b'\xfc\xc5\x004\x00K\x00d\x00{\xbf@\xa2c\xb7wn\x1d\xe0!\xc1\xb3\x08Ov/\x91\xee')

{'A1': 0.9884177091524633,
 'A2': {'B1': 65,
        'B2': 'py',
        'B3': -1643603480882071116,
        'B4': -62,
        'B5': [{'C1': 59696,
                'C2': [-28224, -10171],
                'C3': 0.5182310342788696,
                'C4': [71, 159, 31]},
               {'C1': 47576,
                'C2': [5063, -14641, 19636, 3513],
                'C3': 0.7606830596923828,
                'C4': [54, 9, 24]},
               {'C1': 1885,
                'C2': [20094, 9727, 5784, -2934, -10300],
                'C3': -0.09166669100522995,
                'C4': [37, 196, 52]},
               {'C1': 60624,
                'C2': [-29946, -1500, -31978, 2805],
                'C3': -0.49714434146881104,
                'C4': [99, 252, 197]}],
        'B6': 3790037727,
        'B7': 0.242081418633461},
 'A3': -450824648,
 'A4': {'D1': -0.7524778246879578,
        'D2': [-18569, 28189, -8159, -15949, 2127, 30255, -28178]},
 'A5': 50196,
 'A6': 223}

Вариант №38

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

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

(b'EHZ\xc3\xc8\x84\xe9\x90\x07\x82\x12\r\x00T\x00\x94l\xda\xb6\xf0_\xfee@'
 b'\x84\xe1\xc3`\xafw\x14%E\xd1\xa4\xa7\xa01\xbe\x81F\x11\xce\x06'
 b'\x1c\x8d\xc6\xe7\xd6\xf4\x7f\xd1UL\xc3\x01\x92\xfaQ\xc4`\xf3g\x96'
 b'3\xa4\xad\x19\xed[j\xe8c\xa9\xf6\x98\x19\x82:\x9a\xab\xdc\x1b\xd9\x03O\x13X'
 b'\xfc\x9c?\xe0\xb8#\xa9gW\xe4zzgikenz\xee\xf4\xbc\x89\xaa\x00\x00\x00\x02\x00'
 b'\x00\x00k)\x8aT4~\xab9\x80\x00\x00\x00\x06\x00\x00\x00w6\xe5\x9dqE'
 b'\x00\x00\x00\x03\x00\x00\x00\x87\x00\x00\x00m\x00\x00\x00}\x00\x00\x00\x8a'
 b'\x83')

{'A1': 14448930309321921037,
 'A2': {'B1': 3,
        'B2': 20243,
        'B3': 88,
        'B4': -868,
        'B5': 0.522477942339489,
        'B6': 'zzgikenz',
        'B7': 238},
 'A3': {'C1': [{'D1': 35242, 'D2': [244, 188]},
               {'D1': 14720, 'D2': [41, 138, 84, 52, 126, 171]},
               {'D1': 28997, 'D2': [54, 229, 157]}],
        'C2': 131},
 'A4': [7843782844538053952,
        -8871594970915072987,
        5030983298603662977,
        5049043182903215847,
        -2957598518219586815,
        -7855876696112404586,
        3721289518982851304,
        7181542213942393498],
 'A5': 2883328985}

(b'EHZ\xc3\xc2:;\xc8\x88F\x9a\xe9\x00T\x00\x95\x8d\xfe "<\x89\x02N2\xd5E\xe3'
 b'\xcb\xea\xfcv\x99\xab\xe3\xbc\xe6\x18\x05\x03\xafTQ\x88\x9b\x8e8\xed'
 b'\x15\x1f0\xed\x87m\xb9\x03FEU\xaf\x02\xfd\x96W\xd0\x1b\x1eW\xe1\x90c\x1c'
 b'\x89\xee\xceE\xb6T\xf9\x05d\xd8\xfd5N\xadF\x92B\x0b\xbf\xe2\xd9\xa3>\x83OFga'
 b'kzksjs\x82\x8bl\xd1\x90;\x00\x00\x00\x03\x00\x00\x00k\x96z w\x00\x00\x00\x02'
 b'\x00\x00\x00xb5Z\xad4\xad\xa7\xc2g\x00\x00\x00\x07\x00\x00\x00'
 b'\x84\x00\x00\x00n\x00\x00\x00z\x00\x00\x00\x8b$')

{'A1': 13995564524473064169,
 'A2': {'B1': 78,
        'B2': 44358,
        'B3': -110,
        'B4': 16907,
        'B5': -0.5890670987086899,
        'B6': 'gakzksjs',
        'B7': 130},
 'A3': {'C1': [{'D1': 36923, 'D2': [139, 108, 209]},
               {'D1': 8311, 'D2': [150, 122]},
               {'D1': 49767, 'D2': [98, 53, 90, 173, 52, 173, 167]}],
        'C2': 36},
 'A4': [-8215093338860617138,
        3662910716616834166,
        -7373549564435364605,
        -5812931571861276435,
        1521988995812014339,
        5063547566205802071,
        -3451131326654029028,
        -8507635847249200891],
 'A5': 1691942197}

Вариант №39

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

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

(b'QHN|\xac\x9e*\x00]\x00N\xd4\xe7\xecb\x97\xb0]\xa6^I\xf0\xac98\xe5`_~q=\x00'
 b'\x05\x00\x00\x00\x13f\x99\x00\x02\x00\x1d\xaf\xe3\x10\xebrg\xd9h\xda\xbb7"6'
 b'\xde\x8d\xa3\xa4\xec\x1c?\xc2B\xfa\x00\x06\x00\x00\x004\xad\x9b\x00\x02'
 b'\x00@\x0c\x8a\xd92 \xc4M\x88]\xfa"\x92\xf7=\xa0\xe3\xd2\xf3\x0f\xe0\xc0\\'
 b'\x97\x8a\x8f\x00\x00\x00\x04\x00\x00\x00\x0b\x00\x04\x00\x00\x00'
 b'\x0f\xee\x00\x1f\xcfJ?\xee\xd0\xed\xce\x86\x00\x00\x00\x06\x00\x00\x00+'
 b'\x00\x03\x00\x00\x001\xab\x00BmA\x9c\x1c\x05\x9f\x03\xe6`}\xab0L')

{'A1': -84,
 'A2': 40490,
 'A3': 93,
 'A4': {'B1': 903773484562533768,
        'B2': 6771763004313542883,
        'B3': 210,
        'B4': [{'C1': 17514464592658926223,
                'C2': [-44, -25, -20, 98],
                'C3': [-105, -80, 93, -90],
                'C4': 238,
                'C5': {'D1': [24137, -3924, 14648, -6816, 24446],
                       'D2': 26265,
                       'D3': [113, 61]}},
               {'C1': 14936821409067683462,
                'C2': [-81, -29, 16, -21, 114, 103],
                'C3': [-39, 104, -38],
                'C4': 171,
                'C5': {'D1': [-17609, 8758, -8563, -23644, -5092, 16322],
                       'D2': -21093,
                       'D3': [66, 250]}}],
        'B5': 1833016348,
        'B6': 405046779482843952,
        'B7': 76}}

(b'QHN|\xfb\xaa\xa04\x91\x00@\x12\x07H\xf5\x83\x87\xea,L-oa$\x0f\x00\x02\x00'
 b'\x00\x00\x132e\x00\x02\x00\x17\x9c\x91\x88=\xfa\xc1\xbe\xbb\x91)\xeb'
 b'4_\x05\xb9\x00\x04\x00\x00\x00*\xab\x99\x00\x02\x002Y\xae\xb8X'
 b'\xba\xd5\x92\xf1 \x91\x93g\x8b4\xae.\xb8\x80\xd4\xce\xf9\x15buL\x00\x00\x00'
 b'\x05\x00\x00\x00\x0b\x00\x03\x00\x00\x00\x10\x84\x00\x19\xb0[d\xa8\xd9U'
 b"\xc1V\x00\x00\x00\x02\x00\x00\x00%\x00\x03\x00\x00\x00'\xf5\x004J"
 b'j\xb1\xea\x8b3\x82$$\xdf\xa1\xc1\x08')

{'A1': -5,
 'A2': 43680,
 'A3': 13457,
 'A4': {'B1': 6462305206554432241,
        'B2': 2346818953763139118,
        'B3': 184,
        'B4': [{'C1': 9283272301118387532,
                'C2': [18, 7, 72, -11, -125],
                'C3': [-121, -22, 44],
                'C4': 132,
                'C5': {'D1': [19501, 28513], 'D2': 12901, 'D3': [36, 15]}},
               {'C1': 12707861449919545686,
                'C2': [-100, -111],
                'C3': [-120, 61, -6],
                'C4': 245,
                'C5': {'D1': [-15938, -17519, 10731, 13407],
                       'D2': -21607,
                       'D3': [5, 185]}}],
        'B5': 1248506346,
        'B6': 10030503886833295809,
        'B7': 8}}

Вариант №40

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

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

(b'\x8dJSTtq+\x10uj\x00\x00\x00[w\xc3\xbe\xc3z\xd9\x0b\xc2\xc4Sx\xc4\xf2\x0c'
 b',\xdb\xd3V\xea?\xc5 \xfd\xbeW\x85\x11\xbf\x02\x00"\x00\x00\x00\xb7\xa9u\x8e'
 b'\xa4\xbe\xc5\xaf\xc6\xbe\x02\x002\x00\x00\x00\x9d$\x8eH-\xbfo\xe6?>\x02\x00'
 b'B\x00\x00\x00\xbe\rjo}?\xda\xd8\xe4>\x02\x00R\x00\x00\x00\x19\n*\x00'
 b":\x00J\x00Z\x00\x04\x00\x00\x00b\x00\x92\xa7\x14\x049c\x94\xf4'ugF|\xd1Y\xee"
 b'\x00\xaa\xf2"\xdc\xd9\xaa\xd0.\x82:\xf9\xc2')

{'A1': 116,
 'A2': {'B1': 1963993969,
        'B2': {'C1': [{'D1': [-0.4943906366825104, -0.568440854549408],
                       'D2': -22089},
                      {'D1': [-0.32139936089515686, -0.3880597651004791],
                       'D2': 9373},
                      {'D1': [-0.6768883466720581, 0.18740247189998627],
                       'D2': 3518},
                      {'D1': [0.9899812936782837, 0.4469669461250305],
                       'D2': 2585}],
               'C2': [-110, -89, 20, 4, 57, 99, -108, -12],
               'C3': -1271755088068119257,
               'C4': 0,
               'C5': [-3414, -9182, -21799, 11984, 14978, -15623]},
        'B3': -0.38176998496055603,
        'B4': 195,
        'B5': -4289586540536145542},
 'A3': 0.8230990677551786}

(b'\x8dJST\xb2$*\xf3\xe4\xa0\x00\x00\x001jj>|\xba~\x9b\x99\xfc\x95\xe6\xc2\x90F'
 b'\x0e\xc7\xf6-\xdf?\xe7\x1b\xe2>\xa1\xf0\xdc\xbe\x02\x00"\x00\x00\x00'
 b'\x16Th\xef\xa4\xbe\x89]q\xbf\x02\x002\x00\x00\x00`\xd5lQw\xbf\r\x82'
 b'c?\x02\x00B\x00\x00\x00\x9a;{ \x8c\xbde\xc9\x04>\x02\x00R\x00\x00\x00'
 b'\xbb\xe3{{\xf5\xbd\x04\xc6\x1d\xbf\x02\x00b\x00\x00\x00\xf8\xec\xbcV'
 b'\xb2=j\xe5j\xbf\x02\x00r\x00\x00\x008\x0f\x1b\xfa\xa3>?\xa0\xc0\xbd\x02\x00'
 b'\x82\x00\x00\x00\xc2\xe8*\x00:\x00J\x00Z\x00j\x00z\x00\x8a\x00'
 b'\x07\x00\x00\x00\x92\x00\xbc*s\x15\xdf#\xa6\xbe\xf4\x010 \x86\x85'
 b'\xed\x08\x1c\xba\xb0!5_\x99\xf1\xb3;w\x1b\xe0')

{'A1': 178,
 'A2': {'B1': -453826012,
        'B2': {'C1': [{'D1': [0.4416191279888153, -0.4315233528614044],
                       'D2': 21526},
                      {'D1': [-0.32213902473449707, -0.9428334832191467],
                       'D2': -10912},
                      {'D1': [-0.9660861492156982, 0.8887031674385071],
                       'D2': 15258},
                      {'D1': [-0.06842132657766342, 0.1296745091676712],
                       'D2': -7237},
                      {'D1': [-0.11986442655324936, -0.6163027286529541],
                       'D2': -4872},
                      {'D1': [0.0870794951915741, -0.9175630807876587],
                       'D2': 3896},
                      {'D1': [0.32026752829551697, -0.0940556451678276],
                       'D2': -5950}],
               'C2': [-68, 42, 115, 21, -33, 35, -90, -66],
               'C3': 643317132895977972,
               'C4': 28,
               'C5': [-20294, 13601, -26273, -19471, 30523, -8165]},
        'B3': 0.22892071306705475,
        'B4': 124,
        'B5': -4402666673566679366},
 'A3': 0.4871804183868358}

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

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

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

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

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

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

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

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

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

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

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

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

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

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