ИКБО-08-22

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

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

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

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

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

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

(b'\xe4JRR\x03\x00\x00\x00L\x00(W\x02\x00O\x00\x00\x00)r)>\x03\x00S\x00\x00\x00'
 b'<>\xa3>\x02\x00Y\x00\x00\x00\x81\xe5\x04?\x02\x00]\x00\x00\x00\x02sI?'
 b'\x02\x00a\x00\x00\x00\x1fzi>\x03\x00e\x00\x00\x00\x0f&\x04?m\x00(\xa5bpc\xdc'
 b'\x08\r\xd2[\x93\xf3\xfbk\x8b\xd7\xfb\r}=\xca\xe4\xc3o\xf5\xef'
 b'\xd1\xac\xb0\xa5\x08\xc8)$_sk\xaa#\xde\x02\x00k\x00l\x96\xfcP/p'
 b'\xd7\xbf\xc5\xf1\xba&\xdc\xa4\x82A')

{'A1': 'bpc',
 'A2': {'B1': 22312,
        'B2': [{'C1': [2268, 53773], 'C2': 0.1654745489358902},
               {'C1': [37723, 64499, 35691], 'C2': 0.31883418560028076},
               {'C1': [64471, 32013], 'C2': 0.5191269516944885},
               {'C1': [51773, 50148], 'C2': 0.786911129951477},
               {'C1': [62831, 53743], 'C2': 0.22800491750240326},
               {'C1': [45228, 2213, 10696], 'C2': 0.5162057280540466}],
        'B3': {'D1': 115,
               'D2': 107,
               'D3': -86,
               'D4': [35, -34],
               'D5': [36, 95],
               'D6': -0.366222218597932,
               'D7': 4720516624887247301},
        'B4': -23256}}

(b'\xe4JRR\x02\x00\x00\x00L\x00\x94!\x02\x00N\x00\x00\x00V\xf5q\xbf\x02\x00'
 b'R\x00\x00\x00\xc8\xc2\x15?\x02\x00V\x00\x00\x00\x8e\xb2\r?\x02\x00'
 b'Z\x00\x00\x00\x98\xcd\x80>\x03\x00^\x00\x00\x005\x01!\xbf\x03\x00'
 b'd\x00\x00\x00x6k\xbel\x00I\xf8jz2>\xae\x11`\x92Y\x9bbqH\x96A\xe3'
 b'\xfe\xdb\x1e\x86\x84\x94\xe8j\x9f\xd1[5\xf8\x1a\xcd++\xfdf&6\x02\x00j\x00pR$'
 b'b\xf3\xcc\xee\xbf\x88\t\xa29/\xf6\xb3\xbb')

{'A1': 'jz',
 'A2': {'B1': 8596,
        'B2': [{'C1': [15922, 4526], 'C2': -0.9451497793197632},
               {'C1': [37472, 39769], 'C2': 0.5850033760070801},
               {'C1': [29026, 38472], 'C2': 0.5535057783126831},
               {'C1': [58177, 56318], 'C2': 0.2515685558319092},
               {'C1': [34334, 38020, 27368], 'C2': -0.6289246678352356},
               {'C1': [53663, 13659, 6904], 'C2': -0.229699969291687}],
        'B3': {'D1': 43,
               'D2': 253,
               'D3': 102,
               'D4': [38, 54],
               'D5': [205, 43],
               'D6': -0.9625183979829455,
               'D7': -4921319285095003768},
        'B4': -1975}}

Вариант №2

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

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

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

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

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

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

(b'hWMB\x98\x00\x00\x00\x04\x00\xab\x00\x00\x00g\xca\x8a`\x03\x00'
 b'\x00\x00\xaf\x00\x00\x00\xf7\xcf\xc6\xb7\xe7\xf4\xcc\xf8\x06\x00'
 b'\xbb\x00\x00\x00\x03\xaa\x86\x8c\xcf\t\t<\xde\x08Gf\x14\xb6z$'
 b'\x83\xc1\xe2\xe3&\xef\x07\x00\x00\x00(\x00\x00\x00\xe5\x986\x94\x9c\x12'
 b'\x03\xcc\xbfi\xef\x16\x03\xcb!\xcd\x1e\x15\xb2\xacM\x8dI\x16\xb2\xbc'
 b'o\xce\x80>\xff1\x80\x06\x00\x00\x00S\x00\x00\x00\xb2\x90\t\xe5\x1aqa\xb2\xbf'
 b'\xb1)\x80p6\x00\x00\x00]s\xebg\xb9c\xdb\xb1~|_\x00\x00\x00\x07F\x12!\xac-'
 b'\xc5\xf9>\x83\xe5\xe5n\xab\xa1.hX1\xb1\x00\xd7\x02\x00\x00\x00|\x00\xf5w'
 b'brs\x8e\x1a\x146\xd1\x08s\xba\xf3\x1a\xec\xda\x15a!\x1fc\x05hk\x86H\xad\xf4')

{'A1': {'B1': 2876171749,
        'B2': 15492577543649242785,
        'B3': [{'C1': {'D1': 3246597242,
                       'D2': 4012303330,
                       'D3': [43523, 35974, 2511, 15369, 2270, 26183, 46612],
                       'D4': -27,
                       'D5': -0.21884377141434608,
                       'D6': 51834729},
                'C2': 29533,
                'C3': 8970803063597656043},
               {'C1': {'D1': 2161012668,
                       'D2': 2150760254,
                       'D3': [8651, 7885, 45589, 19884, 18829, 45590],
                       'D4': -78,
                       'D5': -0.07179934412582711,
                       'D6': 1887447473},
                'C2': 17927,
                'C3': -8989473180914802414}],
        'B4': -11},
 'A2': 'wbrs',
 'A3': -13721,
 'A4': 24714,
 'A5': [907287182, -1166866223, -622060813],
 'A6': 17927973492712984567,
 'A7': [24853, 7969, 1379, 27496, 18566, 62637]}

(b'hWMB\x8e\x00\x00\x00\x03\x00\xa1\x00\x00\x00X\x7f!\xaf\x02\x00'
 b'\x00\x00\xa4\x00\x00\x00\xfc\x9e\xeb\xc9\xecG\xdb\x80\x08\x00'
 b'\xac\x00\x00\x00\x84\x8a\x0b\xe2\xa80\xf5H\xdb7C\xe9\xae\x17%\x87'
 b'\x9e!\x05\x00\x00\x00(\x00\x00\x00\x1f\xc0s%\x98\x12\xf1\xa5\xbf\xd6'
 b'"\x92\x1cf\x82\xa9\xbe\xa5S\x8fAg\t:\x0b\xee\xc7\x03\x00\x00\x00O\x00\x00'
 b'\x00\x13\xb6U\x06@\n\x92\xeb\xbf#Q\xb0\x972\x00\x00\x00\xfd\x885U\x88\xa0'
 b'e\x03\x00\xf4U\x00\x00\x00\x1f>\xac\x872!\xcc\x92\x7f\x00L!W\x7f\xa2\x95'
 b'G\xed3x\xe4Z\x02\x00\x00\x00r\x00Mtqa\xee}\xc3\xaf\x0bQ\x9e\xeffxF\x9d'
 b'\x93\x87\\\xf6=7Z\xb9\xd3vzL')

{'A1': {'B1': 2136416588,
        'B2': 6549491922523100578,
        'B3': [{'C1': {'D1': 397338947,
                       'D2': 564037413,
                       'D3': [35460, 57867, 12456, 18677, 14299],
                       'D4': 31,
                       'D5': -0.04285486323599441,
                       'D6': 479339222},
                'C2': -30467,
                'C3': -864687393435265739},
               {'C1': {'D1': 157761935,
                       'D2': 3354266426,
                       'D3': [33382, 48809, 21413],
                       'D4': 19,
                       'D5': -0.8615771532519634,
                       'D6': -1750052573},
                'C2': 15903,
                'C3': 35908727470196652}],
        'B4': 77},
 'A2': 'tqa',
 'A3': 32600,
 'A4': 44833,
 'A5': [-1346142738, -274837237],
 'A6': 9285094139079925500,
 'A7': [30822, 40262, 34707, 63068, 14141, 47450, 30419, 19578]}

Вариант №3

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

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

Поле	Описание
1	int64
2	int16
3	uint8
4	int16
5	Структура B

Поле	Описание
1	Адрес (uint16) структуры C
2	Структура E
3	float
4	Структура F
5	uint64
6	int16
7	uint16
8	int64

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

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

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

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

(b'CQQB\x86L\xff\xfc:Gtb\x83^\x10\xa0\xb3\x00b\x82L\xa5\xbfc\x856\xbf\xe4'
 b'O+\xf9.w>\x01v&4\x0c\x06\xa4\xc4\xd5\xae\xe9\x8b\x81\xe3\x8a\xae>\x07'
 b'\x1ct\x7fE\xad\x1b\xf5\xa3\xc1\xa0w\xed4v\xaf?\xc5\xd09\xbb\xffT;\x00'
 b'C\x00G\xbb\xf9-\x82\xcf\x82\x87\x98\xd0\x05;\xce&\x87\xea\x91#\xb9\xe5?,'
 b'\x96;|O ;\xeb\xf4\x13\x83]\x00\x00\x00\x02\x00\x00\x00K\x00\x00\x00\x03\x00'
 b'\x00\x00O\x00\x00\x00\x04\x00R\xbe\x9cx\xd6')

{'A1': -8769352915622595486,
 'A2': -31906,
 'A3': 16,
 'A4': -24397,
 'A5': {'B1': {'C1': 4552178505597526075,
               'C2': -21,
               'C3': -200047779,
               'C4': [{'D1': 63, 'D2': -59, 'D3': 53305},
                      {'D1': 187, 'D2': -1, 'D3': 21563}],
               'C5': [187, 249, 45],
               'C6': [2194637447, 2563769659, 3458631658, 2435037669],
               'C7': -0.30560940504074097},
        'B2': {'E1': 33356, 'E2': 165},
        'B3': -0.8887513875961304,
        'B4': {'F1': -0.634664522822028,
               'F2': 24520244,
               'F3': [12, 6, -92, -60, -43, -82, -23],
               'F4': -29823},
        'B5': 16396108974826222719,
        'B6': 17837,
        'B7': 7157,
        'B8': -6646855138080950609}}

(b'CQQB\x90\x11\xd7\xcd\xe6\x9bY\xb3\x0f\xfd\x03\x15\xc8\x00\\WR\x1d?R'
 b'\x10\xd7\xbf\xe4M\xce5\xc6\x00\xf6\xb0\xd8_HB3Ro7\xb4\x1d2\x8d\x05o\xfa\xd2.'
 b'\x16\xd2qf\xc6\xcf\x96YW\x92\x84\xbdu(\xdf\xa4St\xd0:\xe5\xc8\xbe\x00'
 b'C\x00G\xb0Z*p\xee#B\xcee]\xd47\x1e\x1a\x9c\xa4\x7f\x99\xab\x1a\xddsw\xad='
 b'\x16\x00\x00\x00\x02\x00\x00\x00K\x00\x00\x00\x05\x00\x00\x00O\x00\x00\x00'
 b'\x02\x00T?>0h')

{'A1': -8065428178306639437,
 'A2': 4093,
 'A3': 3,
 'A4': 5576,
 'A5': {'B1': {'C1': 1917588409298918109,
               'C2': 115,
               'C3': 2007842070,
               'C4': [{'D1': 164, 'D2': 83, 'D3': 29904},
                      {'D1': 58, 'D2': -27, 'D3': 51390}],
               'C5': [176, 90, 42, 112, 238],
               'C6': [591580773, 1574188830],
               'C7': 0.7429261207580566},
        'B2': {'E1': 22354, 'E2': 29},
        'B3': 0.8205694556236267,
        'B4': {'F1': -0.6344977426779497,
               'F2': 2966970184,
               'F3': [66, 51, 82, 111, 55, -76, 29],
               'F4': 12941},
        'B5': 391807473227846257,
        'B6': 26310,
        'B7': 53142,
        'B8': 6437775291161323743}}

Вариант №4

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

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

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

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

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

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

(b'XAZN\xa1\xf2\x15\x11\x07F^\xd4B\n\x00\x06\x001\xf7\x00\x00\x00\x02\x00'
 b'\x00\x00\x91\xbf\xe4\xfeH1z\x13\x80?\x10RT\xceB\xd7A\xb8\x08\xb8\x95T'
 b'4\x9f\x83\x9b\x87\xb5\x11\xda\xa1\x1e\xcf\x0b\xe5\xfe\xcey\xfb\xc3\xe7\x88'
 b'f\xbbF\xd65"\nf\x14~h\xbe\xef\xfb\xb0\x18\xe5T\x94EX\xd7\xd3\x0b'
 b'\x8a\xff\x8a0\x83s6\xbc\xff\x91\xf1\xba\x12\x0c5\xe7\x0c\xfd)\x1d$\\\x07\xb1'
 b'\xe8\x8a\x9f\xee/T\x81&\xe8\xf1\xe5L\xe2\xca\x04\xc7\xbb\xd4\xf8\x02\xfe>[_'
 b'Zw\xfd\x04\xd0\xfc\xfd?\xa8\xd7\xf8\x12wU\xc2fx==(\xcd')

{'A1': {'B1': -14,
        'B2': 1518002548220641802,
        'B3': {'C1': [{'D1': 2676202375,
                       'D2': [181, 17, 218, 161],
                       'D3': 2220006223767304699},
                      {'D1': 3286730854,
                       'D2': [187, 70, 214, 53],
                       'D3': 2452885185262829295},
                      {'D1': 4222621925,
                       'D2': [84, 148, 69, 88],
                       'D3': 15551786629861093507},
                      {'D1': 1932967167,
                       'D2': [145, 241, 186, 18],
                       'D3': 879863345193753892},
                      {'D1': 1544008168,
                       'D2': [138, 159, 238, 47],
                       'D3': 6089190953114225890},
                      {'D1': 3389310907,
                       'D2': [212, 248, 2, 254],
                       'D3': 4493289895396967632}],
               'C2': -9,
               'C3': [-216947212633501065, 6179614305315268813]},
        'B4': -0.656040283808224,
        'B5': 0.5637562274932861},
 'A2': [-12734, -10431, -18424, -18283, 21556]}

(b'XAZN\xa1~\np\xfe&:\xbf\xd3\x1c\x00\x02\x001\xdd\x00\x00\x00\x02\x00'
 b'\x00\x00Q\xbf\xef\xe7ubuc\xae=\xcbqX\t\xcb\xa1\x0b#\x8f\xa2\xfa\xef'
 b'\x07m\xaf\xadn5\xb1\x13*?G\x8a\x15\x05\xcf|7\xb9\xd0\xf9\xf3RqqcO\x00\x9f'
 b'\x87\xd6\xf1\x0b\x16Y\xf6\xde\xdb\xf66\xe3d\x95\x8d.\xca\xdb)9\x13')

{'A1': {'B1': 126,
        'B2': 752380577918735132,
        'B3': {'C1': [{'D1': 1840229742,
                       'D2': [53, 177, 19, 42],
                       'D3': 4559764970632346679},
                      {'D1': 3117480435,
                       'D2': [82, 113, 113, 99],
                       'D3': 5692725334771829526}],
               'C2': -35,
               'C3': [6482613749956404068, -7670423141546903277]},
        'B4': -0.9970042155283545,
        'B5': 0.09933727979660034},
 'A2': [2507, -24309, 9103, -23814, -4345]}

Вариант №5

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

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

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

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

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

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

(b"\xa2URVBn\x17\xf3{rgqaauig\xea\xa5\x06['~\xbee\x18o%\x0f\xed\xbfD"
 b'\x84\x00]\xd80\x18\xe8\xea?\x01\x91\xa8\xdc\x8c\x00_\x96\xc3\xbft'
 b'\r\xd0\t\xa5\xcbsW\xbe?\x96\xab\xc0\xf8\x14+D\n\xa1\xbf;\xd6\xdc\x16k'
 b'7\xab\xdc\xe5?P\x9b\xc6\xfd\xfe\xc0\x8dZ\xe4?\xba:\xa2\xb1\x9b\xe20$\xed'
 b'\xbf\x03\x85\x00\x00\x00\xf3\x8f\x84[\xaf\xea\x9d\xf6\x995\xfc\x19sr"EDO'
 b'\xb7\xc1\xb0\xdfh\x00\xd2\x94\x02>R-)Q,?\xac%\x07Mj6\xbe$\x05\x00\x80\x00'
 b'\x00\x00')

{'A1': 2079528814,
 'A2': 'rgqaau',
 'A3': 2783602537,
 'A4': {'B1': 23302,
        'B2': [{'C1': 32295, 'C2': -0.9080989045934797},
               {'C1': 33860, 'C2': 0.8408318475730141},
               {'C1': 37121, 'C2': -0.1530264618574837},
               {'C1': 3444, 'C2': 0.11852191659730882},
               {'C1': 43926, 'C2': -0.03328145051863052},
               {'C1': 54843, 'C2': 0.6831871111287131},
               {'C1': 39760, 'C2': 0.6360539216474812},
               {'C1': 15034, 'C2': -0.9106678415242195}],
        'B3': 3,
        'B4': {'D1': 62,
               'D2': 11602,
               'D3': 0.6731134057044983,
               'D4': [9644, 19719, 13930, 9406],
               'D5': [104, 0, 210, 148, 2]},
        'B5': -676126330160115725,
        'B6': 4981669976507954585,
        'B7': 68},
 'A5': -1329481905,
 'A6': 223}

(b'\xa2URVBDp\x82\x18yfaswx\xee\x0f\xb2}@\x98Y\xf6\x14\x9c|\x01dO\xea\xbf-'
 b'\xf3\xa8\x93\x85@\xe4<\xcf\xbfQ\xdf\xac\x1c\xb4m.\xf6\xd6\xbf\x80f\xe8\xe4k'
 b'Qy\x87\xc9?\x87\xee\x96\xc5U\xaa\x06\xa5\xe5\xbf\xea\xe6\x18\xc2\xa7'
 b'P\xae\x02\xe0?\xd1<\xc0\xb7,F\xd8\xd5\xab?\xe1O\xb0I\xf5jq\x9b\xed?D\x84\x00'
 b'\x00\x00V7@V*\xac\x1f\\;\tH\xa8\xdf&\xca\x01\xa74\x1a1\xe4\x1ew+qmiP\x0e\x8b'
 b',\xb4\xbey<?Y\xd6\x8e\xecl\x04\x00\x80\x00\x00\x00')

{'A1': 411201604,
 'A2': 'yfaswx',
 'A3': 2108821486,
 'A4': {'B1': 38976,
        'B2': [{'C1': 63065, 'C2': -0.8221912411726202},
               {'C1': 62253, 'C2': -0.24404576445081472},
               {'C1': 57169, 'C2': -0.35877571786154294},
               {'C1': 26240, 'C2': 0.19944683528573326},
               {'C1': 61063, 'C2': -0.6763947798591967},
               {'C1': 59114, 'C2': 0.5003272605227407},
               {'C1': 15569, 'C2': 0.05436588150619981},
               {'C1': 20449, 'C2': 0.9252249802614667}],
        'B3': 68,
        'B4': {'D1': 105,
               'D2': 3664,
               'D3': -0.3519023358821869,
               'D4': [15481, 22847, 36566, 27884],
               'D5': [119, 43, 113, 109]},
        'B5': 6638213673603053398,
        'B6': 128958281376336187,
        'B7': -89},
 'A5': -466544076,
 'A6': 30}

Вариант №6

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

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

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

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

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

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

(b"IRI\xa3\xf6\xbc>,\x00g\x00\xe8{\xc8y_\x10\xec?Mo\xa0\xfa\xdc\xc3\xec'\xab"
 b'^*I\xf8\x9e\x0f\x9d\x18\x88\xb6\x1ab,\x8dr\xc9\x8e,\xe9\x01\x89d/\xf3'
 b'[t\xd8\xf9\x1a\xa7\xe9Dvwh\xef P\xf8 \x81~\xd9?,\xba[\xcb\x03\x00)\x00'
 b'\x00\x00\xd8F\x9f\xdb|A\x15\x04\x8cQ\x06\x9c5\x11\xc4\xf7\x0f\xca'
 b'w\xfa\xda\xcf\xf1\x8ftfR\x03\xbe\xaa\x1c]\xc76\x8a\xc3\xabqlr\xf2\xdc'
 b'\x17\xc7Z\x97\x06\xe2\xbf*J\x10\xcd\x03\x00d\x00\x00\x00C_\x19X\xed\x7f\xee'
 b'\xbf8/\xa9\xa0i`m\xb1\x84\x0e')

{'A1': 0.3690691888332367,
 'A2': [{'B1': -114,
         'B2': {'C1': -5844,
                'C2': 1,
                'C3': -214997879,
                'C4': 4965683798455383131},
         'B3': 'vwh',
         'B4': 239,
         'B5': 0.3983462163898839,
         'B6': {'D1': 44,
                'D2': 23482,
                'D3': 203,
                'D4': [141, 114, 201],
                'D5': [18136, -9313, 16764, 1045, 20876, -25594, 4405, -2108],
                'D6': -13809}},
        {'B1': -49,
         'B2': {'C1': -28687,
                'C2': 116,
                'C3': -1107078554,
                'C4': -6069855904887661398},
         'B3': 'qlr',
         'B4': 242,
         'B5': -0.5633045933725458,
         'B6': {'D1': 42,
                'D2': 4170,
                'D3': 205,
                'D4': [119, 250, 218],
                'D5': [24387,
                       22553,
                       32749,
                       -16402,
                       12088,
                       -24407,
                       24681,
                       -20115],
                'D6': 3716}}],
 'A3': 0.8769986513688055,
 'A4': [4204818253, 669828060, 1227513515],
 'A5': -24840,
 'A6': 2283314447,
 'A7': 744626870}

(b'IRI\x17\xaa\x11?-\x00m\x00`\xf2T\xf9V?\xee?\xa1>\x9ev\x95\xa0}8n'
 b'\x0c\xda\xac"\xdb\rd\x16\xfeR:\xc6\xeb\x84\x99\x0c\xba\xd6/\x9b"uP\xbd'
 b'\xf8x\xe7vW\x0f\xa6\xf4#uxiz\xe6\xc4\xd2\xcb^\x0b\xe1\xbf4%\xdc\x18\x04\x00)'
 b"\x00\x00\x00\x9c\x05\xa8\x84\xa4\x19\xd7\x98'\xbf\xcb\xa2muI\xafu\x8d\x97k0"
 b'\x8f\xe7K\xee\xf2\x95.\nqi%\xb93-Y\xaf\xd5_5_\x0bymfR\xf4\xe1\xea'
 b'\xb7\xc9\x87\xd3?RR"\x8f\x08\x00e\x00\x00\x00\xfaUKW\x95\x8eE\r\x7f'
 b'\xe4\xd5\xce\x83\x15\xc3ro\x18')

{'A1': 0.5690016150474548,
 'A2': [{'B1': -42,
         'B2': {'C1': -25809,
                'C2': 34,
                'C3': -121810827,
                'C4': 2590878270467008376},
         'B3': 'uxi',
         'B4': 122,
         'B5': -0.5326379757808837,
         'B6': {'D1': 52,
                'D2': -9179,
                'D3': 24,
                'D4': [132, 153, 12, 186],
                'D5': [1436,
                       -31576,
                       6564,
                       -26409,
                       -16601,
                       -23861,
                       30061,
                       -20663],
                'D6': -29323}},
        {'B1': -107,
         'B2': {'C1': 2606,
                'C2': 113,
                'C3': 867771753,
                'C4': 819432342927923501},
         'B3': 'ymf',
         'B4': 82,
         'B5': 0.3051628395146786,
         'B6': {'D1': 82,
                'D2': 8786,
                'D3': 143,
                'D4': [151, 107, 48, 143, 231, 75, 238, 242],
                'D5': [22010, 22347, -29035, 3397, -7041, -12587, 5507, 29379],
                'D6': 6255}}],
 'A3': 0.9452319020998168,
 'A4': [1990082209, 947757205, 2899971182],
 'A5': -9438,
 'A6': 4262880269,
 'A7': -339330478}

Вариант №7

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

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

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

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

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

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

(b'\xfaBLX;\xf0TY\xe0s\xce\xf2}\x07\x9c\xb5\xe2}\xd8u\x00\x02\x00\x00\x00L?\xe7'
 b'c\n5\xaa\xe4*W\xfd\xf7,5\xa2\x14\xac\xec\xc8\x00\x00\x00\x03\x00\x00\x00N'
 b'\x00]\x1e\x08\xb0\x89\xd3d\xc3\xd1\xab\xec8l`\xd7\x9c\xe1\xf5\x08\xbfnV\xe9'
 b'ug`\x18\xf1\r\xb9\xb1\xd7\xef\x10\x7f\xc2y\xe4X\xbe\xe9F\xdd\x8a\xab]\x02'
 b'\x15=\xa5\x8c\x1e\x7f\xb24\xb7\xedClR\xa8\xd5^\x7f|y+\x16\xefGb\x10:\xbdb'
 b'\xa3j\xe6e\xa8\x9a\xf6/\xa9\x889\xdb\x18\x17\xb7g\x8f{\xc9_[9\xb1x'
 b'\xf7\x03C\x0fX\xd4\xb8')

{'A1': 4319044787642814194,
 'A2': 9009341884580878453,
 'A3': 'ug',
 'A4': 0.7308398292726725,
 'A5': 6340495619657962668,
 'A6': 60616,
 'A7': {'B1': [{'C1': 96, 'C2': 418450873},
               {'C1': 177, 'C2': -672198529},
               {'C1': 194, 'C2': 2045008062}],
        'B2': {'D1': -5818,
               'D2': -2482983828586152539,
               'D3': [-8350096255732945597,
                      7805486738553404537,
                      3104932082985482941,
                      7107642174701345526,
                      3434425972917016503,
                      7462319212394658225],
               'D4': 2029454147,
               'D5': 257479864},
        'B3': [7688, 45193, 54116, 50129, 44012],
        'B4': 4065731042775004424,
        'B5': -0.9310136437416077}}

(b'\xfaBLX\x17\x8f\x17\x9f\x11\xfb\xc1\xca\xbb\xa2\x04\xfd\x9e\x01T\x9b'
 b'\x00\x03\x00\x00\x00L\xbf\xdb\xa8W\xa8\x983\xd8\xc07\x86>\xa1\x92'
 b'\xdai\x98\xe7\x00\x00\x00\x05\x00\x00\x00O\x00hc>\xab7gZF\x89g5\xe3\xf2y>'
 b'\xa7\xfd\x91i>\x1e\xd8\xf8fca7\x1b\x9b\xeb\xb9\x12\\\x86N\xe1}?\x14&cd\x91'
 b'\xf3\x87;\x03\xdf\x00x.\xf5\x0f\x84\x96\xc2\xa3\xe0\xec\xdbO\x8eG'
 b'\xfd\x14\xc1\xc9w\xbdp\xea\xfa4$\x06\xb8\x83d\xbc\xa2\x02Sk\xad}\x05\xc6'
 b'aE\x13e\x9d\x0cs\xaa\x81Z\xbd\xba8.\xfc\xafL\xde\xb4\xef\x03\xef\xdb\xfa'
 b'y\xf1\x13\x8d]\xe7')

{'A1': 1697601556510917066,
 'A2': 13520374518643774619,
 'A3': 'fca',
 'A4': -0.4321498056822839,
 'A5': 13850686782558100073,
 'A6': 39143,
 'A7': {'B1': [{'C1': 55, 'C2': 463203257},
               {'C1': 18, 'C2': 1552305889},
               {'C1': 125, 'C2': 1058285155},
               {'C1': 100, 'C2': -1846311109},
               {'C1': 3, 'C2': -553617362}],
        'B2': {'D1': -2801,
               'D2': -8892706405087388849,
               'D3': [-8194302731384948803,
                      8136590778647885955,
                      7258854830287596925,
                      416126964884413708,
                      8334616287132661806,
                      -238887735825333265],
               'D4': 3690625521,
               'D5': 328031719},
        'B3': [25406, 43831, 26458, 18057, 26421],
        'B4': -2021419972722585239,
        'B5': 0.15512454509735107}}

Вариант №8

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

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

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

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

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

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

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

(b'UZR\xbf\xec\xfa\xca\xb8\xff\xae\x18\xbf\xe6\xe3\x9b\xfc\xca\xb4\x04\x00'
 b'\x02\x00\x00\x00T\x8bR~\xa8\x1c\x03\xfc\x1b\x9e\x86a\x8f\xdeH\xb8\x94\x03]J'
 b')\xbf~C\xf3\xf1\xaa\xd3-\xa5?TO\x12\xc5k+2\xec_5\x1f \xde\x8f\xafg\xf7'
 b'\x18\x08?\x7f>/\x00\x04\x00\x00\x00f\x94\x86\x7f\x0e\xe9\xbd\xcb\x1f'
 b'{\xe5]\x06\x9512\x0f\x95\x15?E\xf3q\xbePs\xf5\xbf+\x83j\xbfl\xc5\x0c')

{'A1': {'B1': {'C1': -0.9056142438179817,
               'C2': -0.7152843415584589,
               'C3': [{'D1': 2491842318, 'D2': 59837, 'D3': [203, 31, 123]},
                      {'D1': 3848078997, 'D2': 12594, 'D3': [15, 149, 21]}],
               'C4': [-29870, 32424, 7171, -997, -24954, 24975],
               'C5': 3729307796,
               'C6': 242431498114712563,
               'C7': 241,
               'C8': 2865966501},
        'B2': 0.8293315172195435,
        'B3': -982832334,
        'B4': -5025,
        'B5': 13599},
 'A2': 8414,
 'A3': {'E1': 143,
        'E2': -81,
        'E3': 26615,
        'E4': 6152,
        'E5': 0.9970425963401794},
 'A4': [0.7732458710670471,
        -0.20356734097003937,
        -0.6699739694595337,
        -0.9248816967010498]}

(b'UZR\xbf\xe8\x0f\xba\x14?\xff\xd0?\xc5\xac\x84\xa7\xac\x89X\x00'
 b'\x05\x00\x00\x00T55\xfcE\x93\xacE%\xc1\x05\xdcud\x13\x04 \x85\x14\xe0'
 b'b\x14\xe9\x9fAQ0\xdb\xfe\x82\xbe\xd8=\xa0\xfb\xfd\xf8\xf0@\x1e\xfcf]c\x16)R9'
 b'\x1e\x88>{\xd4q\x00\x03\x00\x00\x00\x81m\xb6\x84\xdf\xeca\x83O5Yr\xff'
 b'\xdc]\xf5\xe8\x85G+Y\xa7\x8d\x9f\xb3\r{\xee"\xdc\n\x94V\xfdf\xfd\x1dzn:@'
 b'\x1b\xcf\xf3D\xfe?_^\xec>\xed\xe8\xe5\xbe\xf7H\xcf')

{'A1': {'B1': {'C1': -0.7519197841174847,
               'C2': 0.16932733714299775,
               'C3': [{'D1': 1840678111, 'D2': 60513, 'D3': [131, 79, 53]},
                      {'D1': 1500708828, 'D2': 24053, 'D3': [232, 133, 71]},
                      {'D1': 727295885, 'D2': 40883, 'D3': [13, 123, 238]},
                      {'D1': 584845972, 'D2': 22269, 'D3': [102, 253, 29]},
                      {'D1': 2054044224, 'D2': 7119, 'D3': [243, 68, 254]}],
               'C4': [13621, -955, -27732, 17701, -16123, -9099],
               'C5': 1678967840,
               'C6': -8857207855268651199,
               'C7': 81,
               'C8': 819723906},
        'B2': -0.4223451614379883,
        'B3': -67241744,
        'B4': 16414,
        'B5': -922},
 'A2': 23907,
 'A3': {'E1': 22, 'E2': 41, 'E3': 21049, 'E4': 7816, 'E5': 0.2459275871515274},
 'A4': [0.872542142868042, 0.4646674692630768, -0.48297736048698425]}

Вариант №9

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

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

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

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

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

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

(b'IQG\x00\x05\x00\t\x00\x86nicuk\xd87R\xe9V\xf0\xd8\x1e\x19\x80N\x03\xf3\xbd'
 b'sD\xdf\xab\xb8n\xb84{\x9c\x84\x9e\x1e\xba/r\xf6;,\\<8i\xd1\xa8LC\xa2'
 b'&\xc8/\xb4\xc4\xa2`|A\x85\xc7\xa8\xb08\xe0\xed\xe2\xc3ou\xa3\x98.\x8b'
 b'\xe2\xb8\x15(\x05\x93\x7f.\x031\x97q-b\xc9\xca\x7f\x05\x00\x00'
 b'\x00\x0e\x00\x00\x00\x1c\x00\x00\x00*\x00\x00\x008\x00\x00\x00F\x00\x00'
 b'\x00T?co`?\xef\xcf\xd8\x8b{\xd6R>16+$\xc6\xfd\r\x00\x00\x00\x06\x00b'
 b'\x00z\xa6\x90\xf1UQ\x88\xa8\x9e\x9c\xad&1\xf8\x17V\x19UP\xd8\x87\xae')

{'A1': 'nicuk',
 'A2': {'B1': 0.17305819690227509,
        'B2': 617020685,
        'B3': [{'C1': [-667462935, 1458624542], 'C2': 427838979, 'C3': -3139},
               {'C1': [1933893547, -1200703436], 'C2': 2073855134, 'C3': 7866},
               {'C1': [796063291, 744242232], 'C2': 1775347788, 'C3': 17314},
               {'C1': [650653620, -995991428], 'C2': 1099286440, 'C3': -20424},
               {'C1': [-521280829, 1869980568], 'C2': 780919480, 'C3': 5416},
               {'C1': [93552430, 53581681], 'C2': 761448906, 'C3': 32517}],
        'B4': {'D1': 0.8884181976318359, 'D2': 0.9941218113223818},
        'B5': -6444385718024755042,
        'B6': -100,
        'B7': 2904961528,
        'B8': [391518549, 1356367790]}}

(b'IQG\x00\x03\x00\t\x00\x84fsxQ9<"\xa3\xde\xa3WI\xba\xfd9+\xf1\x08\xca'
 b'u\xc5\xebGj\x05\x1c\xca\x8a+\xc8ryP\xed\x91\xab\x86/\x7f2\xf5@{\xb4\xa46f'
 b'g\xe5\xf8\x96mb\x8aD\x86\xd9\xa1\xaf\xdd2\xd0Uo\xe0\xe4\xed\xd3E\xc2;'
 b'\xde\xcdB1/\x8a\xfb\x7f V\nQ`\xf1\x06\n\x00\x00\x00\x0c\x00\x00\x00\x1a'
 b'\x00\x00\x00(\x00\x00\x006\x00\x00\x00D\x00\x00\x00R\xbfmu2\xbf\xea\x12:'
 b"ID\xc2\xe0>\xea_'d\x99{\x98\x00\x00\x00\x06\x00`\x00xe\x03\x11e\xc6\xe6\x98%"
 b'\x95\x92\x89\x86\xde\xef\xb4|G\x18\xdeO\xe2')

{'A1': 'fsx',
 'A2': {'B1': 0.45775720477104187,
        'B2': 1687780248,
        'B3': [{'C1': [1362705442, -1545690281], 'C2': 1236991289, 'C3': 11249},
               {'C1': [147486149, -347641339], 'C2': 483035691, 'C3': -14222},
               {'C1': [2035346833, -1417269377], 'C2': 854933627, 'C3': -19292},
               {'C1': [912680933, -124359326], 'C2': -1975220519, 'C3': -24145},
               {'C1': [-583872427, 1877009645], 'C2': -750403013, 'C3': -8499},
               {'C1': [1110519690, -75554730], 'C2': 173105393, 'C3': 1546}],
        'B4': {'D1': -0.9275695085525513, 'D2': -0.8147250586535755},
        'B5': 7278680551587223589,
        'B6': -107,
        'B7': 2458486494,
        'B8': [-273384377, 417222626]}}

Вариант №10

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

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

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

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

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

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

(b'\xedWKW\x00\x00\x00\x1c\x00\x02\x00\x9dU\xe51\xd5\x1bp!\x00\x03\x00\r\x92'
 b"%'\x7f\xf1dki\xce\x86\x92\x16H\x84\x8d\x10|\x94T\x14\xc0\x97\xa3\x91\xa3"
 b'\xc7\xd6\x00\xfd\xa9\x00\x00\x00\x13\xe1,\xbfB\xcbv\xbf0\x81\xfe?2\xd1\xb9?'
 b'D\xa8\x08=\xe9p0\xbd\xf9v\x1d\xbd\xe8\xe8\xb7\xbe\xd42\xa3<\xb8\x0c\xa1\x90'
 b'w\x84\x9c\xd5\x14\xe8\xa6\xdb\x12\x98\xc7\xecN\xbf\x0e7X\xbd\xc9\xe6'
 b'V?\x16\x99\xf4>(\xef\xf9>\xdcrm\xbf1!A?)\xa8E?\rp\x95\xc0\x9c\xe5\xf4 <\xc5'
 b"\x85\x87'^\xd6\xe1\xec\x931\x009\x00k")

{'A1': {'B1': 'dki',
        'B2': -830041578,
        'B3': 5225456569605706772,
        'B4': -16233,
        'B5': -23663,
        'B6': -1547184640,
        'B7': 64937,
        'B8': {'C1': [-6863, -10981, 28705], 'C2': -1843058817, 'C3': -15}},
 'A2': [{'D1': -7892,
         'D2': [-0.760917067527771,
                -0.6894835233688354,
                0.698512613773346,
                0.7681889533996582,
                0.11398351192474365,
                -0.12180731445550919,
                -0.11372511833906174,
                -0.4144488275051117],
         'D3': [15544, 3233, 36983, 33948, 54548, 59558, 56082, 39111]},
        {'D1': -5042,
         'D2': [-0.5555319786071777,
                -0.09858386218547821,
                0.5882866382598877,
                0.16497792303562164,
                0.43056049942970276,
                -0.6919136643409729,
                0.6627238392829895,
                0.5524991154670715],
         'D3': [49308, 58868, 8252, 50565, 34599, 24278, 57836, 37681]}],
 'A3': 85}

(b'\xedWKW\x00\x00\x00\x1e\x00\x02\x00\x9fh<\x84\xc0\xdb\x00\xc3qk\x00\x04\x00'
 b'\r\x15\x02[\xbd\x8evne\xb2(\xe9\xe1\xb5\x87\xd8j\x9e\xa7}\xa0l7\x1a'
 b'\xb7\n\x95OY\x01\xaf\x00\x00\x00\x15\xc3\x9f<\xd59\x1a\xbe\xe7G\xda\xbfR%'
 b'l\xbc\xd9\x99l?>\x15S>/\xfb\xd4\xbf\x19\xf1\x06>\xdb\xb3\x98\x08&\x9c'
 b'\x18\x19\x8a^\x16\xe9\xc6\x9d\x8d+\x8e\x8e\x95$\x88?hfy?\x12C3>b\x0f\x95>'
 b'\xf2\xc2">?\xe8s\xbfg\xaa\t\xbe\xf1]\xa4\xbf \xfbX*cE\x0f\xc8X\x9aO\xec'
 b'\xa8V\xc2+\x98Q\xca\x00;\x00m')

{'A1': {'B1': 'vne',
        'B2': -1305941535,
        'B3': -5366082478548746848,
        'B4': 27703,
        'B5': 6839,
        'B6': 177557337,
        'B7': 431,
        'B8': {'C1': [15492, -16165, 195, 29035], 'C2': 352476093, 'C3': -114}},
 'A2': [{'D1': -15457,
         'D2': [0.026028204709291458,
                -0.45172005891799927,
                -0.8208835124969482,
                -0.026562415063381195,
                0.7425128817558289,
                0.17185908555984497,
                -0.6013339757919312,
                0.4291045665740967],
         'D3': [2086, 39960, 6538, 24086, 59846, 40333, 11150, 36501]},
        {'D1': 9352,
         'D2': [0.9078136086463928,
                0.571337878704071,
                0.22076256573200226,
                0.4741373658180237,
                0.1874101608991623,
                -0.904938280582428,
                -0.47141754627227783,
                -0.6288352012634277],
         'D3': [10851, 17679, 51288, 39503, 60584, 22210, 11160, 20938]}],
 'A3': 104}

Вариант №11

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

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

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

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

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

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

(b'PHL?p\xabvL\x00r\x00\x82\x00\x92`\xad\x16\xb0b\x00\x00\x00\x05\x00'
 b'\xa2\xff\xe0\xe3\xff?\xdd\xdf\xea-=\xe0\x08\x00\x00\x00\x04\x00\xa7T'
 b"\x1b\xe9\x9d\xd6\xc0\xdd\xf1':\xe8\xf0\xd12\xb4![\xabR\x11\xec<{\x95\xdf"
 b'l\xeaUE-)L.\x1be\x12H\x9a\xdf\xcfu\x1e\xa7\x0ctT#vr\x84?mL\xa1\x13\x84\x08'
 b'\xd0\xab\xaf;\xbd\xb9\x19\xb7\x1d\xec\xbe\xa3c\x8c\x80\x04\t\xc17\xc0~\xf8cz'
 b'pbftcI\xad_\xd9\xf0\xc3\x8bB\rejcedbm\xf9\xbc\x1f\xc9\xad*\xaf\x9f\xd6vpynwa'
 b'a\xaa\x0f\xd6)\x1f0|\tGN\x91\x8d\x9a\x7f')

{'A1': 0.940116286277771,
 'A2': 76,
 'A3': [{'B1': -9222235411479232776, 'B2': 'czpbftc', 'B3': 73},
        {'B1': -5953800554264444403, 'B2': 'ejcedbm', 'B3': -7},
        {'B1': -4890968924718391338, 'B2': 'vpynwaa', 'B3': -86}],
 'A4': {'C1': {'D1': 1621956272,
               'D2': 98,
               'D3': [15, 214, 41, 31, 48],
               'D4': -32,
               'D5': 58367,
               'D6': 0.466791671925876,
               'D7': [31753, 18254, 37261, 39551],
               'D8': 84},
        'C2': 7145,
        'C3': [-7073254105272599832,
               -1094037485239162030,
               1291473694641581290,
               6144366922011908965,
               1317473177054813863,
               897434737041376319,
               7875846953555775659]},
 'A5': 12626894582961348076,
 'A6': -0.319118857383728}

(b'PHL?0\x15\xda\x91\x00r\x00\x82\x00\x92\xf58+\x0b\x83\x00\x00\x00\x03\x00'
 b'\xa2\x02\xcd\x0c\xbd?\xea\xfc\r\x9f\xee\x9f\xfc\x00\x00\x00\x02\x00\xa5\xfe'
 b'Hz|\xc8IK\x95RT\xf9\x80"\xd8\x03\xe3\xe5\x8aF\xefl)\r\xca\xeex!]\x1d'
 b'1\xcd\xc8c6^\x95\xd0\x9a\x08\x05:\xb6\x8b\x84\xaf\xad\xd7& 41\x82n\xb6B\xf26'
 b'|,\x95\x1c\xde|\xa4\xb6\x82K?(\xce>\x7f\xb6njMY\x8e\x80rbvexrf\xa3\xc0('
 b'\xb2H^Y\x1c+waiumjia\xc0m\xafg\xaf\xfdX\x1bdbnmviy\x1aSO\xef\xddb\xc1\xe2')

{'A1': 0.6878334283828735,
 'A2': -111,
 'A3': [{'B1': 9202664291421490816, 'B2': 'rbvexrf', 'B3': -93},
        {'B1': -4600230995468674005, 'B2': 'waiumji', 'B3': 97},
        {'B1': -4580812386096818149, 'B2': 'dbnmviy', 'B3': 26}],
 'A4': {'C1': {'D1': -180868341,
               'D2': -125,
               'D3': [83, 79, 239],
               'D4': 717,
               'D5': 3261,
               'D6': 0.8432682155298603,
               'D7': [56674, 49634],
               'D8': 254},
        'C2': 18554,
        'C3': [8991517245021771001,
               -9213564376426640826,
               -1194534661944084447,
               6709573779751908958,
               -7651446407664322933,
               -8885692400209480655,
               -9048094202692994004]},
 'A5': 10744707437919896139,
 'A6': 0.6593970060348511}

Вариант №12

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

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

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

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

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

(b'KGOT>\x1f?\xed\xa4\x15+|\xb9\x82\x87?\xd2\x15\xce\xea\xfb\xae\x1c\xe9?\xbdT#'
 b'\xb8\x87\xdb\xb0l\xbf\xc4\x19|\xb2\x8a\xbf\x00\x19?\xe5[\n12\x81r\x00_'
 b'\x8d\xa8\\\xae\x96\x9f\x8e\x8d|\x11?B\x99O{\xf3\x110\x00\x00\x00\x02\x00\x00'
 b'\x004\x1a\x9e\xa0@>\xd7\x99\x93PKH/\x1eB\xa7\xfdF\n\x0c\x1b1\x00'
 b'\x00\x00<\x17\x82\x00\x00\x00X\xa2F\x89\xaa(\xe4\x18\x06\xf8\x96\xc1pv\x9b2'
 b'Kq\xd6\x8f\x9d\xe6\xf6$\xa2\xec\xd7V\xbe\x9b\xcd\xf7\x0b/\x07\t\x1d~T6'
 b')k\xc2\x1a\xac\x1d\x00\x02\x00]')

{'A1': [{'B1': 31, 'B2': 0.9262796258315549},
        {'B1': 135, 'B2': 0.2825810713536343},
        {'B1': 233, 'B2': 0.11456511740821784},
        {'B1': 108, 'B2': -0.1570278045451161},
        {'B1': 25, 'B2': 0.6673632584461713}],
 'A2': {'C1': 168565553,
        'C2': {'D1': 31761,
               'D2': 4558374339513356592,
               'D3': [-1918346066, -1767928179],
               'D4': 446603328,
               'D5': 0.42109355330467224,
               'D6': 20555},
        'C3': 6018,
        'C4': {'E1': 1211047490, 'E2': 167},
        'C5': 162,
        'C6': 1183427112,
        'C7': {'F1': -2010849568870010762,
               'F2': [2603764593,
                      3599736294,
                      4129596140,
                      3612786331,
                      3455519535,
                      118037886,
                      1412835691,
                      3256527901]},
        'C8': [253, 70]}}

(b'KGOT>\xde\xbf\xe5\x08\x12\x15%\xeb\x02\x94\xbf\xc3B4\xc9\xde\xc6@\xac'
 b'?\xc2\x04I^+\x14\x10\x07?\xef)%\xa8q\xc6D\x7f\xbf\xe0[\xdb\x1f\xe8\x92n\x00_'
 b'\xddAo\x9e\xb5H\xf2\xb6\xf1\xfa\x90\xb9\x05\xf8\x8dU\x13\xf1\x00\x00'
 b'\x00\x02\x00\x00\x004\xc4c\xd8}\xbf@\xe9a\xfd\xc7\xb9\xc3\xef\xc4E\x19\xcav'
 b'-\xaf\xab\x00\x00\x00<\r\\\x00\x00\x00XM\x93L\xa7\x1d\x98=N\xaeJ\xd6'
 b'\xfa\x98\x16\x84\x8e\x9e\xfa\xfd\x01\xd5\xaahz\x82\x0c$\xa1\xbaG\xe6'
 b'\xb6\xdfPHb\xd2{\xb5\x0b\xf0\xf0\xabq@\x00\x02\x00]')

{'A1': [{'B1': 222, 'B2': -0.6572351849602855},
        {'B1': 148, 'B2': -0.1504579530424497},
        {'B1': 172, 'B2': 0.1407558164411573},
        {'B1': 7, 'B2': 0.9737728395395568},
        {'B1': 127, 'B2': -0.5112128852093301}],
 'A2': {'C1': 1982705579,
        'C2': {'D1': -3590,
               'D2': 10428372977234285553,
               'D3': [-582914146, -1253510474],
               'D4': -1000089475,
               'D5': -0.7535610795021057,
               'D6': 64967},
        'C3': 3420,
        'C4': {'E1': 3116625860, 'E2': 69},
        'C5': 77,
        'C6': -1823693027,
        'C7': {'F1': -7476733295878276456,
               'F2': [377786014,
                      4210885077,
                      2858973826,
                      203727290,
                      1206302431,
                      1346921170,
                      2075462640,
                      4037767488]},
        'C8': [25, 202]}}

Вариант №13

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

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

(b'\xb9UHVJ\x04\x00]\x00\xf6\xc5\x80\xa4qyr\x06\x00\x00\x00m\x00\x00\x00'
 b"\xee\xde/?A\xcd\x8fZ\xa5\x98'C\xac\xfe\xe6\x14\x17\x04aw\xc1\xc7\xd0\xc7"
 b"Q\x84\x1f\x00\xd3\x9di\x87'\xe4\xc7\xa3HR\x19F\x03\xbd\x9dE\xf0\xeb\xef\xbd"
 b'H\xfe\xd4SA\x03\x00\x00\x00\x9d\x00\x00\x00Q\xa8\xca\x11\x01b\xc7'
 b'\xa0U\x00\x00\x00W\x00\x00\x00Y\x00\x00\x00[\x00\x00\x00\xdaT\xfeb\x9cc\xe6'
 b'?\x10P\th\xf4\xeb\xd4\xbf i\xb1M3\xbd\xa2\xbf\xb6\xd6\xd9C\x97\x00\xe5'
 b"\xbf\xb4'\x1b\x95J\xfd\xe3?P\xd8\x0f\xc3F#\xb8?3\xeem")

{'A1': [{'B1': 81, 'B2': 168},
        {'B1': 202, 'B2': 17},
        {'B1': 1, 'B2': 98},
        {'B1': 199, 'B2': 160}],
 'A2': 2759902710,
 'A3': 'qyr',
 'A4': {'C1': {'D1': [0.6996595319239092,
                      -0.3269015327434781,
                      -0.036599734529504824,
                      -0.6563221287930989,
                      0.6246693527439136,
                      0.0942882753587082],
               'D2': 0.6869953870773315},
        'C2': 65,
        'C3': [12412808534525906893,
               13940717841743668990,
               15204186995170988231,
               5234246974664305053,
               17313417777625045330,
               4707340224139489259],
        'C4': [51, 238, 109]}}

(b'\xb9UHVJ\x06\x00a\x00\x91\xadK^oqv\x07\x00\x00\x00y\x00\x00\x00 \xbb)?'
 b'\xb7\x9b\x8b\xc00&w\xf1ko6\x90\xb9t"\xd1\xd9\x8a\xe4\xfa=\xec\x0f{'
 b'\x18\x1a0\xf7~=>\xb4\x9e}\xcc<\xc7\x149\n,\x0f\xc8f\xd5%\xae\x98'
 b'(\x03\x00\x00\x00\xb1\x00\x00\x00\x9d\xa7O]\xba\x8f\xbf\x9a\xa2\xe5\xbd'
 b'\x0eU\x00\x00\x00W\x00\x00\x00Y\x00\x00\x00[\x00\x00\x00]\x00\x00'
 b'\x00_\x00\x00\x00 j\r>\x95\xd3\xd1\xbf\xba\xf1\xd3F\x8b\xf3\xe4?Z3&'
 b'\xa0n,\xe7?\x04}\xc9\xd1\xde\xf5\xe7\xbf\x18\x99\x88~h\xda\xe4'
 b'\xbf\x86\x90\x1f\xa2<\x93\xee\xbf\x00\xe8\xd6\x1f\xad\xe3\xab?\xe0\x7fy')

{'A1': [{'B1': 157, 'B2': 167},
        {'B1': 79, 'B2': 93},
        {'B1': 186, 'B2': 143},
        {'B1': 191, 'B2': 154},
        {'B1': 162, 'B2': 229},
        {'B1': 189, 'B2': 14}],
 'A2': 1582017937,
 'A3': 'oqv',
 'A4': {'C1': {'D1': [-0.2785390001278376,
                      0.654729498229748,
                      0.7241738441385721,
                      -0.7487634751704779,
                      -0.6516611548766233,
                      -0.9554732481451687,
                      0.054471407066969846],
               'D2': 0.6630115509033203},
        'C2': -73,
        'C3': [7778129037355944859,
               15695364061087676015,
               1764021186372232330,
               11435833787644588058,
               3173411648840715389,
               2925279435494443023],
        'C4': [224, 127, 121]}}

Вариант №14

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

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

(b'XVX\xd1\xbdP\xf4\x9b\xcf\x10\xf7I\xd1~\xa5\xcf?\x02\x00p\x00\xac\xc0~'
 b'z\xc5&\xd7\xb9\xba\xd5\x98\x87\xc7\xc5Mr?\xcb\x1a\xbf\xde\xed\xed\xef+\xb7G'
 b'\x1d\xee1S\xd1b\x80?\x03\x00r\x00\xa7\xfd^\x89\xbf\xdf\x04IPz_\x9e\x94\x1ffZ'
 b'\x9f\xe7{?\xab0\x85\xb0U\x92>X\xf2,+7\xd0\xa5\x17\xe9\xb0q\x82\x94t\x04 \xc4'
 b'b\xb1+&\xc9T\x82\xe5\xfd\x147\xc7\x95')

{'A1': 20669,
 'A2': -12,
 'A3': {'B1': 53147,
        'B2': {'C1': 0.24723801821885916,
               'C2': [{'D1': [253, 20],
                       'D2': [49324, 31358],
                       'D3': 9925,
                       'D4': 14251508636327786967,
                       'D5': 29261,
                       'D6': -0.6046637892723083,
                       'D7': [222, 237, 237, 239, 43, 183, 71],
                       'D8': 4575765872591891997},
                      {'D1': [55, 199, 149],
                       'D2': [64935, 35166],
                       'D3': -8257,
                       'D4': 2275617844640106756,
                       'D5': 23142,
                       'D6': 0.9840030074119568,
                       'D7': [171, 48, 133, 176, 85, 146, 62],
                       'D8': 1703996969395745368}],
               'C3': 45289,
               'C4': 7116848514660074097,
               'C5': 3374721969,
               'C6': -32172},
        'B3': -27}}

(b'XVX\xd1\x1e\xbd\xc4\x02\xb48C\xed$*\xc7\xe0\xbf\x02\x00p\x00T\xfe\xa3'
 b'u]\xd4\xe3\x98s\x96y\x00\xfe\xf00)\x9e\xab\x0e\xbf\xcc\xfcv>D\xe1\xfc'
 b'(\xdf\x90\x97<\x80#\xc3\x03\x00r\x00\xf2\x81D3\xe5\xa7\x88\xc09M\xbe\xba'
 b'\x8d\x12\x01\xf9\xd5\xc5\xd1\xbdm\x89v)\xe0\xf7\n\xedj-}\xad\xe8\xdb^\xda'
 b'\xc3\x01\xc9}\xf3y!\x1cX\xb5B\x9d\xe0\xa8\x18\xddW\x03\xd0\xa8\x9e')

{'A1': 48414,
 'A2': -60,
 'A3': {'B1': 46082,
        'B2': {'C1': -0.5243120881296823,
               'C2': [{'D1': [87, 3],
                       'D2': [65108, 30115],
                       'D3': -11171,
                       'D4': 17365317735402412259,
                       'D5': 10544,
                       'D6': -0.557306170463562,
                       'D7': [204, 252, 118, 62, 68, 225, 252],
                       'D8': 14061223459310067496},
                      {'D1': [208, 168, 158],
                       'D2': [33266, 13124],
                       'D3': -22555,
                       'D4': 1336929990901088392,
                       'D5': 63745,
                       'D6': -0.10242811590433121,
                       'D7': [109, 137, 118, 41, 224, 247, 10],
                       'D8': 6835312691291974381}],
               'C3': 50138,
               'C4': 6348986382345423105,
               'C5': 3768402613,
               'C6': 6312},
        'B3': -35}}

Вариант №15

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

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

(b'\xbdOJHB\x00\x1b\x00"\x00)\x000\x007\x00>\x00E\x00L?\x1a\x00U\x00y\x81'
 b'\xe5\xd5\x9e\xea&\x8e\xb5\x98#\x9d\x91\x8b\x8b\x81\xd8S|\x9e2\x00'
 b'\xa5\x9c9\x03&\x80\xd7\xdcH\xeb\x95:c]\x0c\xc5\x1f\x9f\xa7\x80'
 b'\xe5\xf7\xfd\xa5\xfb\xa4K\xc8\xfa\xec|R>H\x0ccp\x00\x00\x00\x02\x00S\xa3'
 b'\x0b\x1f\x8c\xbf\xcb\x92\xe6\x97\x10\x0fh?\tv\xd4!T\x08TX\x98\xfd\x08 '
 b'\xa5\x8d\x12\x93X\xce\xf3-5k\x00\x00\x00\x02\x00s&\t\x18\xc9R<\x00\x02'
 b'\x00w\xd0\x0f\x7f$\xb4m\xa1\xe9\x15\x89\xc8\xff\x9f\xd2\xce\xf2')

{'A1': [{'B1': -127, 'B2': 229, 'B3': 213, 'B4': 2666145422},
        {'B1': -75, 'B2': 152, 'B3': 35, 'B4': 2643561355},
        {'B1': -127, 'B2': 216, 'B3': 83, 'B4': 2090742272},
        {'B1': -91, 'B2': 156, 'B3': 57, 'B4': 52854999},
        {'B1': -36, 'B2': 72, 'B3': 235, 'B4': 2503631709},
        {'B1': 12, 'B2': 197, 'B3': 31, 'B4': 2678554853},
        {'B1': -9, 'B2': 253, 'B3': 165, 'B4': 4221848520},
        {'B1': -6, 'B2': 236, 'B3': 124, 'B4': 1379813388}],
 'A2': 16154,
 'A3': {'C1': 'cp',
        'C2': -93,
        'C3': 11,
        'C4': 8076,
        'C5': -0.21542055488691436,
        'C6': 0.5369694232940674,
        'C7': 2401553659652013320},
 'A4': {'D1': {'E1': 206,
               'E2': 4079826283,
               'E3': [8357, 36114],
               'E4': [38, 9, 24, -55],
               'E5': 21052,
               'E6': [-109, 88],
               'E7': -3454402593547247127},
        'D2': 1551992546829455090}}

(b'\xbdOJHB\x00\x1b\x00"\x00)\x000\x007\x00>\x00E\x00L\xb7e\x00U\x00\x81\x17'
 b'\xad\xd1\x13\xe2\x7f\x06\xfe\x81 \x85(\xac\xcc\xcc\xee\xb6V\xc6\x17\xdc'
 b'A\x939kf\n\xa2@(\xf6\xabY)3\xd3T`\xd5\xa87\xa9\x8b\xee\xff\xf9s\xe4\x80'
 b'\xfd\xda-\xca\xfa\xa0Lbc\x00\x00\x00\x02\x00S6\x95,g?\xe9\x8b^&\xb0V\x94?'
 b'Z+\xb9\xfa\x03&\x05e\x0f\xb4\x11\x8bQ\xd1\xe8,\x8d"\x08)\x07\xaf\x04|\xe0T{q'
 b's+\x00\x00\x00\x06\x00s\xea\xcf\xb2\xbd=\xf8\x00\x02\x00\x7f\tOd\x82\x81\xa5'
 b'}\x98}\xb7\x18\xa3\xc0\xbbk\x82')

{'A1': [{'B1': 23, 'B2': 173, 'B3': 209, 'B4': 333610758},
        {'B1': -2, 'B2': 129, 'B3': 32, 'B4': 2234035404},
        {'B1': -52, 'B2': 238, 'B3': 182, 'B4': 1455822812},
        {'B1': 65, 'B2': 147, 'B3': 57, 'B4': 1801849506},
        {'B1': 64, 'B2': 40, 'B3': 246, 'B4': 2874747187},
        {'B1': -45, 'B2': 84, 'B3': 96, 'B4': 3584571305},
        {'B1': -117, 'B2': 238, 'B3': 255, 'B4': 4185121920},
        {'B1': -3, 'B2': 218, 'B3': 45, 'B4': 3405422668}],
 'A2': -18587,
 'A3': {'C1': 'bc',
        'C2': 54,
        'C3': -107,
        'C4': 11367,
        'C5': 0.798262668193916,
        'C6': 0.852229654788971,
        'C7': 18015284739024335889},
 'A4': {'D1': {'E1': 84,
               'E2': 2071032619,
               'E3': [35665, 53736, 11405, 8712, 10503, 44804],
               'E4': [-22, -49, -78, -67],
               'E5': 15864,
               'E6': [124, -32],
               'E7': 670865381185125784},
        'D2': 9058736267071286146}}

Вариант №16

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

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

(b'MGKJ\x98a\x00\xf0\x8b}\x07\x14%\xd7?]\xd9\x00TJ\x9b\xad0.m\x0en8\xb61\x801'
 b'p<u\xfe)\x8b}\xc6\x95\xb2\xb1fv\xc5F\xb6\x88\x8b\xe47\x14\x9d\x1c\xdfptrd'
 b'v\x06z\xc4\xc0\xf8n\xef?\xa0\xb4D\xe2\x93\x1d\xc8\xbfNx%\xe7\xb2\x9c%'
 b')\x94\xb85\xdf\x02\x00\x00\x00=\x00\x00\x00\x94nu\x99Y.\xbc\r\x15\x9fT'
 b'M%\xf8\x16\xd0`\xc9\x1d\xb0\xb3\x19\xbecKoG\x05\x00\x00\x008\x00\x00\x00'
 b'M\x00\x00\x00')

{'A1': {'B1': 148,
        'B2': 1503229294,
        'B3': 353221678,
        'B4': [{'C1': 625824927, 'C2': 248}, {'C1': 3378565142, 'C2': 29}],
        'B5': -0.150099515914917,
        'B6': 1198476131,
        'B7': 'ptrdv',
        'B8': {'D1': 2964948221889443918,
               'D2': [-18284, -8395],
               'D3': [0.9822963490476588, -0.1884026388956146]}},
 'A2': 0.36163807612882604,
 'A3': 93,
 'A4': 3328351007105351897,
 'A5': [946736749,
        830484918,
        -25871248,
        -964850903,
        1722921621,
        -1236875914,
        937724808,
        -551772908]}

(b'MGKJ\x98b\x00P:\xb5K\x0cF\xde?Z\x8b\x0b;\x16\xb13\x10\xc3\xec\x13Y\xae'
 b'\xb1c\xc9\xa4\xf7\xc2\xb5Y%\x9e\x18\xe9\xde\xab"g\xba8s\xdd"\xc4\xf9\xa0'
 b'\x83\xe5\x93\x90cimkgvL\xf9M\x11\xe2\x1b\xdd\xbf\xee\x1e7\x8d\xc8\x08'
 b'\xe6\xbf\x0f\x1f\xd3\xf3Q\xd0\xe9\xea\xa9\xbb\xe54\x02\x00\x00\x00>\x00'
 b'\x00\x00\xb2\xe2Tm\x96\xa8~\x11\x10\xd4\xb6\x9b\xaa\x01s\x04\xfe\xbdk\xe3x?'
 b'=\x07\x8aJ\xbf\x06\x00\x00\x008\x00\x00\x00N\x00\x00\x00')

{'A1': {'B1': 178,
        'B2': 2523747554,
        'B3': 269581992,
        'B4': [{'C1': 2862331604, 'C2': 1}, {'C1': 3187541107, 'C2': 107}],
        'B5': 0.0467461459338665,
        'B6': 3209333255,
        'B7': 'cimkgv',
        'B8': {'D1': -1519454348859203825,
               'D2': [-17495, 13541],
               'D3': [-0.4548268479337778, -0.6885721929656634]}},
 'A2': 0.47302539246894515,
 'A3': 90,
 'A4': -4390952801011037301,
 'A5': [-1369893908,
        -1530305615,
        1505084151,
        -384262619,
        1730325470,
        -579651398,
        -1594244062,
        -1869355645]}

Вариант №17

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

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

(b"vKDB\x05\x00m\x00\x00\x00}\x98\xc40\x87Q\nrKMf\x89\xebZ\x0f\x87'\x8f"
 b'n\xc1U\xdak\xb8\x1f\xfb\xe7`\x17\x80\xbd-\x85berpa\x1f\x8f.\x05'
 b'\x7f\x8f\xd0\x84W\x0f\xeb\xe4\xa5\xa9-\n\r\xa6AoTX\x14\x13.\xe6xs'
 b"\x9e\xe5\xf0\xdf\xcbi\x15x\n*\xe7\xc0\x02\x1e\xe6A\xfc\xfai'\\\xf9b\xe7"
 b'\xd3#\xd4\xbfu\xe9\xe1\x8b\x99zfrnm')

{'A1': 'zfrnm',
 'A2': -26499,
 'A3': 1367814340,
 'A4': [{'B1': 6551481155416977930, 'B2': 15},
        {'B1': 7771618396253136775, 'B2': 184},
        {'B1': 3295931340203490079, 'B2': 133}],
 'A5': 'berpa',
 'A6': {'C1': [36639, 1326, 36735, 34000, 3927, 58603],
        'C2': -22107,
        'C3': 2785872429,
        'C4': 28481,
        'C5': 8320653397129975892,
        'C6': -537860706,
        'C7': 203},
 'A7': 175641961,
 'A8': {'D1': 42,
        'D2': -16153,
        'D3': 2840077001378110978,
        'D4': -0.3146867522845207,
        'D5': -1948128907,
        'D6': 153}}

(b'vKDB\x04\x00m\x00\x00\x00^\x03\xfc|i\xa5=}\xfa\x9d\xc6\x12\x91\xcbh)\xa1\x87'
 b't\xf6\x0b\xe4s=\x1a1p\x9e\x83\x0b\xa0qPexyti\xe3\xc6LK\x9d\xabb]'
 b'\xda\xa4\x07\xed\x06\xfa\x16\n\xaag\x98\x94\x17\xd38V\xf10 \xef>\xaf\xef\xe8'
 b'\t\xee\x87m\x8f\xad\r\xeb\x08c\x11\xb8\xe8\x89R\th0k(*\xa4\xd8\xbf[j4@'
 b'\xdfhiqd')

{'A1': 'hiqd',
 'A2': 862,
 'A3': 2775153916,
 'A4': [{'B1': 14668526105585679677, 'B2': 104},
        {'B1': 8350812762196648233, 'B2': 61},
        {'B1': 8187556782486335770, 'B2': 80}],
 'A5': 'exyti',
 'A6': {'C1': [50915, 19276, 43933, 23906, 42202, 60679],
        'C2': -1530,
        'C3': 1739196950,
        'C4': -27496,
        'C5': 17230825987411333911,
        'C6': -386945218,
        'C7': 9},
 'A7': 2406320110,
 'A8': {'D1': -83,
        'D2': -5363,
        'D3': 671750927045190408,
        'D4': -0.3850198168481769,
        'D5': 1077176923,
        'D6': 223}}

Вариант №18

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

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

(b'XUYE\xa5?\xe1p\xca\xe3\x13\xed<\x00\x00\x00X?!oE\xc1\xd3\xa8\xd5\x026\xec'
 b'\xd8\x07A\xea\xb3s@\\hg4@0\\\x18\xff\xba\xa2\x86yj\xc0\xfej_>\xb31'
 b'\xed\xd2\xd3\xc2f\xc3?n0\xe8s\xe5\xdfw\xb3P]\x8a\xa5\xf9\x12d#MQ\xf3\xd8\xa0'
 b'T\x17\x07\x01Ea\x15\xf8\xbf\xdbL\x99\xb8\x966\xa0\x00\x00\x00$\x00\x00\x009'
 b'\x00\x06\x00\x00\x00N\x00T_\xd0\xea\x88S\xd5\x1e\xebx\x81\x0bFv\xd6>$'
 b'\\%\xdb\x9d')

{'A1': 0.5450186190713917,
 'A2': {'B1': 1163990520,
        'B2': -0.42655032182742936,
        'B3': [{'C1': 104,
                'C2': [1731477552, 1545142202, 2726721898, 3237898847],
                'C3': 16051,
                'C4': 12781},
               {'C1': 210,
                'C2': [3552732867, 1064186088, 1944444791, 3008388490],
                'C3': 42489,
                'C4': 4708}],
        'B4': [35, 77, 81, -13, -40, -96],
        'B5': {'D1': 21527, 'D2': 1793},
        'B6': 6904276100001898219,
        'B7': 2021722950,
        'B8': 8563100067377306525},
 'A3': 0.630604088306427,
 'A4': 193,
 'A5': [54184, 54530, 14060, 55303],
 'A6': [65, 234, 179, 115, 64, 92]}

(b'XUYE\xa5\xbf\xd2Hh\x92\xe6\xa3l\x00\x00\x00V?;\xd61\x0e\x8a\x7f@\xc9\xfc '
 b'N0\x9c\xcd\xad\xc9\xc9\x81,\xa2\xc9\xf2\x1b%\xd9\xe8E\x12\xd5#&08\x18'
 b'7\xf8\x95\x10\r\xc5C\x9dz\xb3Wj\x14E\xb3\x80\x0f\x8a\xee\xa48A\t*'
 b'\xd8\xc6&\x9d\x87W\x8a\x0c\xfd$\xb7a`\x8c?\xb9\xe2\x06\xe3\x13'
 b'\xcd\x10\x00\x00\x00$\x00\x00\x009\x00\x04\x00\x00\x00N\x00R\x0b\xfd'
 b'~\x83\xa6\x1b\xb1\xf8A2\xe2@\xf2\x9f\xbd\x01\x19\t\xc7U')

{'A1': -0.28566946359437995,
 'A2': {'B1': 3076612236,
        'B2': 0.10110514682655869,
        'B3': [{'C1': 44,
                'C2': [2731143707, 635037765, 315958054, 808982583],
                'C3': 63637,
                'C4': 4109},
               {'C1': 197,
                'C2': [1134394035, 1466569797, 3011514250, 4003739713],
                'C3': 2346,
                'C4': 55494}],
        'B4': [38, -99, -121, 87],
        'B5': {'D1': -30196, 'D2': 64804},
        'B6': 863985807417651704,
        'B7': 1093853760,
        'B8': -963843982821308587},
 'A3': 0.733737051486969,
 'A4': 14,
 'A5': [35455, 16585, 64544, 20016],
 'A6': [156, 205, 173, 201, 201, 129]}

Вариант №19

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

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

(b'SUK\x00\x05\x00R\x00\x00\x00;r\xc2\xc3\xdb\x0b\x07\x00W\x00\x00\x00\x06\x00'
 b'z\x00\x00\x00\xa2\xaf\xbb\xf9\xd1\xd4#\xe18^\xce\x0b;Y\x97/`\xf8\x93\x14'
 b'\xb8\xbc\xd2\xd4\x88\x86A\xbfL\x9f]\x89\xf99\x95%\xd1\x1b\xc9D'
 b'\xe6\xb4\x91\xdb\xdbi\x93\xa6\xe6)\x8ag\xf9\x12chdvt\x8al\x98 \xd6'
 b'\xc6\xea\xadT\xb8\x03\x10\xe1\xbd(\x92G\xf2\xa8\xc9Q\xf4\x8ae\xd1'
 b'\r\xdc\xc5\xc9\x9aX\xdb\xb4\x1b\x18\xf5\x81\xf1\xe6Ab3\xd4\xa2\xdc'
 b'\x89\x8dJ\xe3G\xbfc\x00<]\xb4\xf6$\xab')

{'A1': {'B1': 'chdvt',
        'B2': -1010666949,
        'B3': 3035,
        'B4': [{'C1': 546860170, 'C2': 214},
               {'C1': 1420683974, 'C2': 184},
               {'C1': 3185643523, 'C2': 40},
               {'C1': 2834450322, 'C2': 201},
               {'C1': 1703605329, 'C2': 209},
               {'C1': 3385187341, 'C2': 154},
               {'C1': 464837464, 'C2': 24}],
        'B5': [3874587125,
               3560137281,
               2374622370,
               3209159498,
               1564213347,
               2871326388],
        'B6': 4189826978,
        'B7': [-517745455, 198073912, 798447931],
        'B8': 96},
 'A2': 248,
 'A3': {'D1': [-1128786797, -2037852974, -1622360255, 972654941, 466691477],
        'D2': 3034989769},
 'A4': 3019283752264915857,
 'A5': 318334858}

(b'SUK\x00\x07\x00R\x00\x00\x00\xbaJ\x02\xe1ED\x06\x00Y\x00\x00\x00\x04\x00'
 b'w\x00\x00\x00\x84f\xfb\x81%\xbcu~\x7f\xfak\xc0\x0c\x8ec;\xf9\xeaQ\xe5'
 b'\xa2[\xdcL0=y\x8f\xecF\x03\xd1\xf7l\xda\xd7L/\xe1\xf6&z\x0e\xe4'
 b'\x10\xfe\xae\r\x98P\xf4/\x1bouyywjos2\xc4\xa7\xc5\xbd\x80\xad\x81\x96\xa7l'
 b'%\xcf\xde\xfa\x82o\xa1\tIl\x1f\xf5e\x95\xcf\xba\xe1\x0b\xcb^\xed\x0c\xafh'
 b'N\x18\x87\x8eR9M\xa2\x85\xc0\xcb')

{'A1': {'B1': 'uyywjos',
        'B2': -519943494,
        'B3': 17477,
        'B4': [{'C1': 3316106290, 'C2': 189},
               {'C1': 2525080960, 'C2': 167},
               {'C1': 3738117484, 'C2': 250},
               {'C1': 161574786, 'C2': 73},
               {'C1': 1710563180, 'C2': 149},
               {'C1': 199342799, 'C2': 203}],
        'B5': [2936859998, 2266517096, 1295602318, 3418391970],
        'B6': 2180736644,
        'B7': [2121645093, -1066665345, 996380172],
        'B8': -7},
 'A2': 234,
 'A3': {'D1': [1537402193, 1026575580, 1189908345, 1828180227, 793565146],
        'D2': 2049373921},
 'A4': 5807406764732245006,
 'A5': 1864052724}

Вариант №20

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

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

(b'KVGU\x03RM=>\x02\x00\x00\x00h\x00\x00\x00\xfd\r\xa1\x0b\x9e\x9de\x058r\xe0'
 b'pL-\x95\xad\xb4\xc9p\x1d\x0cTSE\xe8\xbc\x89F|\xb4#}*\xa5\xce\xe2{\xdeT'
 b'\xceF\r\xc8\xca\x00n\x00\x82\x00Xc\xe2>\xbdt\x88[!\x93\xc6N\xc4-\x19Ed\xa8'
 b"(\x02\xb0\xf2\x17\xfcA]\xae6'\xd7\xd1\x85\xf7\r\x87\xeb\x92;ji>\xcb"
 b'$\xa0\xba\x81~\x04\xa4Q\xf9L\x02\x00j\x00O_I\xbf9\x9a\t\xbd\x0f\xa8'
 b'\x8c\xae:\x02\x00z\x00\x00\x00\xa0<\x14\x12\x06\x8b\xa6R\xee?\xd9\xe5Y\xe1;'
 b'b\x08#')

{'A1': {'B1': 0.18486526608467102,
        'B2': 'ji',
        'B3': -3,
        'B4': [{'C1': 13, 'C2': 8230334253013797793, 'C3': -32, 'C4': 112},
               {'C1': 76, 'C2': 872977914401756461, 'C3': 84, 'C4': 83},
               {'C1': 69, 'C2': 9017249324778241256, 'C3': 42, 'C4': 165},
               {'C1': -50, 'C2': -4031488239425651742, 'C3': -54, 'C4': 0}]},
 'A2': {'D1': 5546554180975362490, 'D2': [-13506, -24540]},
 'A3': {'E1': 15,
        'E2': 984517800,
        'E3': [-0.7866105437278748, -0.033594343811273575],
        'E4': 15520,
        'E5': 0.947589179545107,
        'E6': -514202151,
        'E7': 587751995},
 'A4': {'F1': 0.44216418266296387,
        'F2': [29885, 23432, 37665, 20166, 11716, 17689, 43108]},
 'A5': 6719929298799559208,
 'A6': 1006420178044925614,
 'A7': 0.00448364345356822}

(b'KVGU\x03\xf1,\xd7>\x02\x00\x00\x00h\x00\x00\x00\xe1\x9d\x8d93\x10\xe2'
 b"\xcf'&\xa0\xeb\xe7\xa8\x191\x98\xdfFF\x8e\xec\xb72\xbf\tEI\xe14\xb1"
 b'\x84\xd2*\xf1\xbe(\n\x1e\x13A)>1~n\x00\x8a\x00\xb3\xf6\xb3\xbe=$\xf2\xd5-{'
 b'\xad\xb5\x9ap\xd4\nr1S\xaf\x14L\x08.\x82k\xf4\rlG\x1b\xb0\xc1(y&\xba\xbe'
 b'qu\xcaN\x1a{c\x99d7\x8fn\xe8j\x02\x00j\x00\xe0L\x06\xbf\x7fN\xcf\xbe\x94\x0b'
 b'\x00\xbf\x0b\x08\x19\xbf>@\xd8Z\xba\x04\x00z\x00\x00\x00\xb3:\x9e'
 b'\n\xb8\xb4\xcd\xd3\xef?\xa5k\xc7\xdd\xe9\x11\xed\xbe')

{'A1': {'B1': 0.42026475071907043,
        'B2': 'qu',
        'B3': -31,
        'B4': [{'C1': -99, 'C2': 2749394667374328205, 'C3': -96, 'C4': 235},
               {'C1': -25, 'C2': -8194784545809032792, 'C3': -20, 'C4': 183},
               {'C1': 50, 'C2': -8885262447623730753, 'C3': -46, 'C4': 42},
               {'C1': -15, 'C2': 4479182854760835262, 'C3': 49, 'C4': 126}]},
 'A2': {'D1': 7703528724005951843, 'D2': [20170, 31514]},
 'A3': {'E1': 62,
        'E2': 3126515776,
        'E3': [-0.5246105194091797,
               -0.40489575266838074,
               -0.5001766681671143,
               -0.5977789759635925],
        'E4': 15027,
        'E5': 0.9946049241701365,
        'E6': -574133339,
        'E7': -1091759639},
 'A4': {'F1': -0.3514915406703949,
        'F2': [9277, 54770, 31533, 46509, 28826, 2772, 12658]},
 'A5': 7746804922201714515,
 'A6': 2936822063231143412,
 'A7': -0.3635747730731964}

Вариант №21

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

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

(b'jQDQS"Gs\x9d\xbb\xe3P\xf8\xd5I\xaa\x1b\xc0??\xc7\x8c\x8f\x02\x00\x00\x00l'
 b'\x00\x00\x00+\x9e\x87;\xd8\xdd\x80\xbd\x8e[h\xb2\xdd;\x03\x83r\x00\x00\x00F'
 b'\x02\x00\x00\x00{\x00\xe3\xd4\xfe\x0e;\xbf\xc5J\x0b?\x92\xe8\xec='
 b'{\xca\x8c\xbet\x91\xa4[\x12+\xe7?\x95\xfd\xa1\x10~\xe6\xf8\xa3\x04\x0e\xcej'
 b'[\xa2\xb2\xc7{\xf4\xf8b\xa9\x16\x96\x8d`\x00f\x00\xcc\xc5\x02\x00'
 b'\x00\x00p\x00\x00\x00\x1e\nW')

{'A1': -1653389534,
 'A2': {'B1': 58299,
        'B2': {'C1': 0.12584427457108172,
               'C2': -1886599361,
               'C3': [{'D1': -23973, 'D2': -193214542},
                      {'D1': 25336, 'D2': -1919543639}],
               'C4': -4791586082740789717},
        'B3': 9440455067265686414,
        'B4': {'E1': [204, 197], 'E2': 30},
        'B5': 70,
        'B6': [10, 87],
        'B7': 227,
        'B8': 212},
 'A3': [-0.730697512626648,
        0.5441096425056458,
        0.11567796766757965,
        -0.2749823033809662],
 'A4': 0.7240077772044473,
 'A5': -107,
 'A6': 334384466196734461,
 'A7': 14,
 'A8': 27342}

(b'jQDQS\x95\xdf\x9bS"\xc2\xcc\x10\xc0\xc4\x85\xab\xed?@\xd5\x16\xe6\x05'
 b'\x00\x00\x00~\x00\x00\x00{\x04\x8f\xe4\xfc\xcf\x87;\xa6\xa9\xb2g\xf3'
 b'\x93\x18\x16\x8a\x00\x00\x00\x9f\x02\x00\x00\x00\x93\x00\x7f\xd2\\\xcc\xf7>'
 b'm\x1fz\xbf(\xf8+>/\xb2u\xbf\x80\xc1Uu\xc5\xbc\xb2?\x8dx\xb6f\xb6\x9c\x0c\xae'
 b'\xf0%=\xae\tw\x1c\x00L8\xd4\x92\xdf\xb2Q\xa6R.~H\xfe\n\xba\xa5'
 b'\xf4\x8f\x06\xec\xb8\xadX\xed\xac\xdd`\x00f\x00l\x00r\x00x\x00\x86,\x02\x00'
 b'\x00\x00\x88\x00\x00\x00\x8b\xe8\xab')

{'A1': 1402724245,
 'A2': {'B1': 49698,
        'B2': {'C1': 0.9271878092554515,
               'C2': -434711232,
               'C3': [{'D1': 30473, 'D2': 944504860},
                      {'D1': -27948, 'D2': -1504595233},
                      {'D1': 11858, 'D2': 184436862},
                      {'D1': -23110, 'D2': -335114252},
                      {'D1': -21064, 'D2': -575869608}],
               'C4': 4289625855166973051},
        'B3': 1592185141901568422,
        'B4': {'E1': [134, 44], 'E2': -117},
        'B5': 159,
        'B6': [-24, -85],
        'B7': 127,
        'B8': 210},
 'A3': [0.48398101329803467,
        -0.977042019367218,
        0.16793882846832275,
        -0.9597501158714294],
 'A4': 0.07319292177795056,
 'A5': -115,
 'A6': 17342813082264974968,
 'A7': 37,
 'A8': -20931}

Вариант №22

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

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

(b'NJB!m\x00\x00\x00\x81\xd6\xce\xe4\xc4\x86-Y\xac\xeal\x83\x9a\t\x00E'
 b'\x18\x87\xbe\xbc\x86\xcaY\xb9\xc2\x0b{\xb2\xfeFW\xd8%{N\xc4\x98 \t\xb3'
 b'\x97\xadk:(\x00\xd8\x1ax=\x8cG\x7f\x92;\xaf^\xed\xc43\xcd\x7f6\x15'
 b'\x00\x00\x004\x00\x00\x00\x8f\xc5t\xbfPox?Ky\xaf\x90&\xd7\x02\x00O'
 b'\x00\x00\x00\xce\xb9\xac\xbe\x8aB ?\xe8\xf0\x02\x00G\x00\xd5\x07y\xa18\xfbP'
 b'OW\x00\x00\x00\x1c\xdfT\xbf')

{'A1': {'B1': [{'C1': {'D1': 3303329494, 'D2': 11133862458959670662},
                'C2': -0.26385703682899475,
                'C3': {'E1': -31044,
                       'E2': -1028040246,
                       'E3': [11, 123, -78, -2, 70, 87, -40]}},
               {'C1': {'D1': 3293477669, 'D2': 4209649143763247256},
                'C2': 0.06057247519493103,
                'C3': {'E1': 18316,
                       'E2': -1355050369,
                       'E3': [94, -19, -60, 51, -51, 127, 54]}}],
        'B2': 5715344147778963413,
        'B3': {'F1': 2427418955,
               'F2': 55078,
               'F3': [-0.9561395049095154, 0.9704484939575195],
               'F4': [-0.3373550772666931, 0.626015305519104],
               'F5': -3864},
        'B4': -0.8315293788909912},
 'A2': 129}

(b'NJB!\x90\x00\x00\x00\xff\xaa\xa7\xf6c-\x18,\xc1\xc0\x02\r\x8f\t\x00\xb3'
 b'\xb5\x8a>x\xdd\xbed\xe7N\xc6\xb7\x0feGr\x1b\xaf;N\x15\xae+\xbc$A\xea\x8d\xdc'
 b'(\x00&\xa1)\xbf\xf94\x80\x8eP\x93$\xf9:p\xe6\xcd:l9;\t\x87\xd2\xd6{\n[-|G'
 b'\x00\x877E\xbf\xcf`\x18\xef5\x0c\x85\r2\xfa\xc4\xbd\x15\x15\x00\x00\x004\x00'
 b'\x00\x00S\x00\x00\x00\x89\xd4\x84>\xf0\xd3\xd0>\x9d\x1b\x0f\x11"\x91'
 b'\x02\x00r\x00\x00\x00CY\xf1\xbe\xde\x92L>+\xb7\x03\x00f\x00\xdd?\xa6\xb4'
 b'\xe5\x04\nuz\x00\x00\x00\x99N\x0f?')

{'A1': {'B1': [{'C1': {'D1': 1677109162, 'D2': 10307898149018802221},
                'C2': 0.27091750502586365,
                'C3': {'E1': -8840,
                       'E2': 1323787454,
                       'E3': [-58, -73, 15, 101, 71, 114, 27]}},
               {'C1': {'D1': 357448623, 'D2': 15892616225570433966},
                'C2': -0.662615180015564,
                'C3': {'E1': 13561,
                       'E2': -1823437184,
                       'E3': [36, -7, 58, 112, -26, -51, 58]}},
               {'C1': {'D1': 154876268, 'D2': 8947908135240520327},
                'C2': -0.7703785300254822,
                'C3': {'E1': 24783,
                       'E2': 204861208,
                       'E3': [-123, 13, 50, -6, -60, -67, 21]}}],
        'B2': 8433558636829491165,
        'B3': {'F1': 286202781,
               'F2': 37154,
               'F3': [0.2594340145587921, 0.4078669548034668],
               'F4': [-0.4713841378688812, 0.19977900385856628],
               'F5': -18645},
        'B4': 0.5597930550575256},
 'A2': 255}

Вариант №23

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

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

(b"\x86BOC\x00\x00\x00y\x00\x06\x00\x9d'D6!\xe2\rB\xe5\xecF\xaf\x17\x87d\x8dV"
 b'X\x82\x976\x93\x00\x02\x00\x00\x00\xa9=\x9c\x7f\x83\xb6\xae\xb1\xf9\x84'
 b'J8\x82)\x99[\x93\nym\xfce\xa9\xec\x82l\r\xb1t\xf3\x1b\xdaHW\xbc\xc2\x04\x8e'
 b"\xd3\xd7|\xa3T\xc8\xf6\xed\x0et\xfa20\xbd\x9f\xc9\xc9\xbf3L\xc3't\xf6"
 b"4\xc0\\\xe9a\x13\xa9\xa6\x90\xd1\xbf'\xc2\xc4\xbf\x06\xa9Iymt\x00\x02\x00"
 b'\x00\x004D\x94>p\x9d\xe9\xa1\xfd\xaf\xbb\xfd\xc5k\xca8\x93\x00RO\xb9U'
 b'\xab\x00\x00\x00\x03\x00\x00\x00v\xb0@t\xe1\xcc\xe8+\x0b\x18\xc1\xd2'
 b'\x80\xfd\x0cW\x08\xb4C\xc5\xd6\xa0\xce\xd6Vw|Ci')

{'A1': {'B1': [{'C1': 39259,
                'C2': 2466937197,
                'C3': -259614570238440015,
                'C4': 116},
               {'C1': 62235,
                'C2': 3662174140,
                'C3': -4466287889940176044,
                'C4': -56}],
        'B2': 1150566000,
        'B3': 2649334269,
        'B4': -5783750272068470637,
        'B5': {'D1': 246,
               'D2': -1365025019113980513,
               'D3': 51657,
               'D4': -0.7003900408744812,
               'D5': 10100,
               'D6': {'E1': -10,
                      'E2': 3801140242926512550,
                      'E3': 37073,
                      'E4': -0.655315637588501,
                      'E5': -0.5260205864906311}},
        'B6': 1337546155,
        'B7': 'ymt'},
 'A2': {'F1': [-20416, 29921, -13080, 11019, 6337, -11648], 'F2': 39},
 'A3': {'G1': 4915153298090288620,
        'G2': 1185879943,
        'G3': 7245542313657054867,
        'G4': [18234044686211990998, 11587434558131028841],
        'G5': 0.07641508430242538,
        'G6': -1230065159,
        'G7': [-31670, 14466]},
 'A4': 41}

(b'\x86BOC\x00\x00\x00z\x00\x03\x00\x9e\xbc\x14jW4\xc1\xdb\x95\x9d\x02\xc1V'
 b'\xdaU\x1fMbi\xa5\xd1_\x00\x02\x00\x00\x00\xa4\xbf}~k9\xef\xf4\xca\xef'
 b'\xe0\xb8\xee\xed\xbc\x89\xce\x82\x8c\xd4}y\xe0\xb4c\x8bO\x81n\x8b'
 b'\xfd\xd0\xe1^\xd9\xe1N\xdc\xad\xc1\xb6\x98\xdcn$\x9f\x9a\xc8l\xdf\rF\xf9\x0e'
 b'r\xbfP\x9cp\xa8\xbf\x86o\x8b\xfd#q\xddz\x9f\x84\xcc?\x03N)>\x96\x15frp'
 b"rd\x00\x02\x00\x00\x004\xca\x10>\xe2\x18|\xa3'\x0e\x92*\xc7J\xbf\xa6&"
 b'\x00R\t\xd0\x7f\x87\x00\x00\x00\x04\x00\x00\x00v\xdfY\x0c\x8e;\xdcG\x89VD'
 b'w\x11\x10\xb6\xfcC\x8b0\xde\x81\x8cJ')

{'A1': {'B1': [{'C1': 48265,
                'C2': 3464662228,
                'C3': 9041504792291790721,
                'C4': 110},
               {'C1': 35837,
                'C2': 3504430809,
                'C3': -2211587728154912548,
                'C4': 110}],
        'B2': -904904990,
        'B3': 410821415,
        'B4': 1049948698571679270,
        'B5': {'D1': 36,
               'D2': -6946019105341356295,
               'D3': 3698,
               'D4': -0.8148870468139648,
               'D5': -22337,
               'D6': {'E1': -122,
                      'E2': 8037796288648805023,
                      'E3': 33996,
                      'E4': 0.5129113793373108,
                      'E5': 0.2931320071220398}},
        'B6': 164659079,
        'B7': 'rprd'},
 'A2': {'F1': [-8359, 3214, 15324], 'F2': 188},
 'A3': {'G1': 1471084112392197533,
        'G2': 46225114,
        'G3': 6133706302576513375,
        'G4': [5154746100557615286, 18177525563005176906],
        'G5': -0.990210235118866,
        'G6': 972027082,
        'G7': [-4128, -18194]},
 'A4': 237}

Вариант №24

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

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

(b'VIKh?\xe7e#aW\xad\xd0\x00QX\xa8\xb0\xbfW\xed\xbb\xdf\xf5?\xe4\x1f\x8bJ'
 b'\x1c\xc1\xa6\x00\x99\xa9M\x15\n\x9a\xfd\xacQR:\xf0n+\xce\xa5\x93\xea\x9e\x00'
 b"\x00\x00!\x00\x00\x00'\x00\x00\x00-\xbf:?\xce\xcd1\xd6\xf3#\xf0\xbf\xe0e"
 b'\x17\x99\xda\xa2\x0c1\x02\xaf\xd1\xe5\xea\x9fnjdtwty\x00\x00\x00\x03\x00'
 b'\x00\x003\x00?\xbe\x82k\xfb\xd8\x0eB\xbc?\xc6\xe3\x82@\xd4\xc1'
 b"\xf0\x00\x02\x00A>\xf4\x13+4q !\xa1*N9\xcbPfH\xf1C\xc6I>\x8d\x89'>\x00\xce"
 b'\xf1\xef\x00\x00\x00\x02\x00\x00\x00\x91\x87"\x19\xb1')

{'A1': 0.731095972177565,
 'A2': {'B1': 49,
        'B2': 45076965,
        'B3': -5473,
        'B4': 'njdtwty',
        'B5': [{'C1': 2840401162, 'C2': 39677},
               {'C1': 2891010618, 'C2': 61550},
               {'C1': 734963091, 'C2': 60062}],
        'B6': {'D1': -65, 'D2': 58},
        'B7': -0.25473007559776306,
        'B8': {'E1': 55310,
               'E2': 17084,
               'E3': 0.17881801763134275,
               'E4': [0.24063704486459825, -0.5123403553926109],
               'E5': 0.4767087399959564,
               'E6': 879829025,
               'E7': 2703904313,
               'E8': -3796422022401898935}},
 'A3': 88,
 'A4': 43184,
 'A5': -0.8434712290763855,
 'A6': -8203,
 'A7': 0.6288505980974619,
 'A8': {'F1': 239,
        'F2': [0.27643701434135437, 0.12578941881656647],
        'F3': 2267158961}}

(b'VIKh?\xe1+\xfe\x00\xc3.>\x00[\x1f\xae\x90?f\x95\xdc!\xe2?\xc9\x8c\x89\x07'
 b'\xde\x12\xf8\x00\xa7\xd7\xc9g\xaa\x8b\x06h\xf1\x17\xe1\xbdjW\xf9\x04'
 b"\xa2=\xb1\xac\xff\x96<8$\x00\x00\x00!\x00\x00\x00'\x00\x00\x00-\x00\x00\x00"
 b'3\xeb\x14?\xec\xed\xee\x90\n\x1bv\xbf\xe7.0\xd4\xee\x8bd\xad@\x0c\x1cN'
 b'9\xc3rlfhsuc\x00\x00\x00\x04\x00\x00\x009\x00I\xbfk:^\xba\x87\x91S\xbf'
 b'\xdb\xb5\xafNKh\x80\x00\x02\x00K\xbe\xad\x8b\x02\x83\xf1k\xee\x9e'
 b'\xa9\xc1\x8a\t"\x1cK<\x81\x1e*\xbe\xd2>\xcc\xbf|\xde\x1d\xbe\x07\x88<\x05'
 b'\x00\x00\x00\x03\x00\x00\x00\x9bM\x05w\x0c')

{'A1': 0.5366201414958096,
 'A2': {'B1': 173,
        'B2': 1074535502,
        'B3': 14787,
        'B4': 'rlfhsuc',
        'B5': [{'C1': 3620300714, 'C2': 35590},
               {'C1': 1760630753, 'C2': 48490},
               {'C1': 1475937442, 'C2': 15793},
               {'C1': 2902431292, 'C2': 14372}],
        'B6': {'D1': -21, 'D2': 20},
        'B7': -0.9188593626022339,
        'B8': {'E1': 47751,
               'E2': 37203,
               'E3': -0.43296415945008704,
               'E4': [0.9040444196005939, -0.724388519175005],
               'E5': -0.3389511704444885,
               'E6': -2081330194,
               'E7': 2661925258,
               'E8': 658119605012733482}},
 'A3': 31,
 'A4': 44688,
 'A5': 0.9007241725921631,
 'A6': 8674,
 'A7': 0.1996012962737479,
 'A8': {'F1': 5,
        'F2': [-0.4106353521347046, -0.9877641797065735, -0.13235563039779663],
        'F3': 1292203788}}

Вариант №25

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

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

(b'OUA\x00\x00\x00i\xf6\xd2N\xa8\x19*\x91\x03\xda\x83\x91\\)\xcc^\xd3\x04'
 b'\x99\xe7A\x90\xaf\x15\xaa\xbe\xcd\x8d^\x1c\xa9\\\xd2\x00\x02\x00\x1bMJ~{\x91'
 b'\xc5q\xa4\rL\x84\xb4\xb8.\xbf}\xf3\xe5J^\xab\xac\x00\x05\x00/mS\xc3'
 b'\x98\x00\x00\x00\x1f\x00\x00\x009\n\xa0?\xdf\xf4[8J\xac\x8c\xbf\xc1\xe7*\x92'
 b'4\xa2\xa0\x00\x02\x00\x00\x00Q\x00\x00\x00\x02\x00I\x00Si')

{'A1': {'B1': [{'C1': -0.4014691710472107,
                'C2': [7337, 23762],
                'C3': [37039, 5546],
                'C4': 1296727675},
               {'C1': -0.9920027852058411,
                'C2': [19038, -21588],
                'C3': [37317, 29092, 3404, 33972, 47150],
                'C4': 1834206104}],
        'B2': {'D1': 0.4992893266414249,
               'D2': -0.13986713541932705,
               'D3': [10, 160]},
        'B3': 105},
 'A2': {'E1': -661379711386349309, 'E2': 15745588547241664211, 'E3': 1177},
 'A3': 59201}

(b'OUA\x00\x00\x00\xc4F=X\xf5\xdbO\xf6Ucy\xc0\n\x06\xcbH\xe5\x1c>\xc4#S4e\x90:'
 b'\xe9\xbfw\x7f\xde\x06\xb8\x1a\xb3\x00\x03\x00\x1b\xa9eu\x8e\xc3\xf0\xac'
 b'\xb9Ju\x9b%\xcac\xbfH\r\xc3\xb3\xf2%\x9c\x00\x05\x001:\xedd\xe4\x90'
 b'3\x01\x8d\x9b\xc2\xf3\xc8?\x10\xf8\xc9\x8b44_\x00\x04\x00K\xdcB\x9a0\x9b'
 b'\x13\xcc\x9f\xa7\x10\xf4B(r\xbf.#0\xb6:\x89\xd1\x00\x05\x00c\x11G:T\xcdrF'
 b'\xac\x02\xf5.\xd4|K\xbe\x1d\x11\xa5zR\x81I\x00\x05\x00}\xcb\x19\xbe\xcc\x00'
 b'\x00\x00!\x00\x00\x00;\x00\x00\x00S\x00\x00\x00m\x00\x00\x00\x87#'
 b'\x12\xa6?\xcd% \xae\xe8\x1c\xa0\xbf\xd1\xec\xa7$\xb6\xa24\x00\x03'
 b'\x00\x00\x00\xab\x00\x00\x00\x05\x00\x97\x00\xae\x84')

{'A1': {'B1': [{'C1': -0.9667948484420776,
                'C2': [1720, 6835],
                'C3': [21300, 26000, 15081],
                'C4': -1452968562},
               {'C1': -0.7814599871635437,
                'C2': [-19470, 9628],
                'C3': [50160, 44217, 19061, 39717, 51811],
                'C4': 988636388},
               {'C1': 0.5662961602210999,
                'C2': [-29900, 13407],
                'C3': [36915, 397, 39874, 62408],
                'C4': -599614928},
               {'C1': -0.6802244186401367,
                'C2': [-18886, -30255],
                'C3': [39699, 52383, 42768, 62530, 10354],
                'C4': 289880660},
               {'C1': -0.1533876210451126,
                'C2': [31314, -32439],
                'C3': [52594, 18092, 757, 11988, 31819],
                'C4': -887505204}],
        'B2': {'D1': 0.22769554653516355,
               'D2': -0.28006914696973984,
               'D3': [35, 18, 166]},
        'B3': 132},
 'A2': {'E1': 5061299369203988053, 'E2': 7167971431233046757, 'E3': 7230},
 'A3': 50211}

Вариант №26

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

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

(b'PYGF\x19x&\xa9\xea\x95\xef\xf9\x10k\x11Rqhdw]\x1aC\x9e\x1a\xe8:\x0c'
 b'\x06\x00=\x00\x9a\x84\x13\x95\xf9\x87\xe4?\xc7\xc8\x8c\xf0\x89r\x97\xef'
 b'\xbfq\x00X\xbag\xaa\x1d\x06\xbf\x9e*.\xe1\xb9!\x8d\xb600\x1b\x85qY@[\xb8?'
 b'f\x8fM\xc7\x14}B\xe1\xe5\xd7\xfe~~(O\xc2\xc0\xd3\x17j\xd8\x88{4"\x03\xdd\xbe'
 b"vrc\xc1\xe6Kn\n\x14\xf4\xa5'\xea\xe6\x07\x00U\x00]\xe2\x15K\xa3\x1a"
 b'\xd1\x11\x11\xd4\xe2\x98\x96\xc1\xe1\xe5\x92-\xd6=O\r\xd4\x99')

{'A1': -1457096679,
 'A2': 5913625506371048938,
 'A3': {'B1': 'qhdw',
        'B2': 881271878126344797,
        'B3': [{'C1': [-31, -71], 'C2': 36129},
               {'C1': [-74, 48], 'C2': 6960},
               {'C1': [-123, 113], 'C2': 16473},
               {'C1': [91, -72], 'C2': 26175},
               {'C1': [-113, 77], 'C2': 5319},
               {'C1': [125, 66], 'C2': 58849}],
        'B4': 0.6415985023160318,
        'B5': -57,
        'B6': -0.9872372335561517,
        'B7': {'D1': 3928466932,
               'D2': 230,
               'D3': [2122251991,
                      -1061007576,
                      -664135725,
                      573864840,
                      1992219907,
                      -423533710,
                      336227915],
               'D4': 1283836657419018845,
               'D5': -1882010316709899247,
               'D6': -7362244856852894318},
        'B8': -7007875770682459560},
 'A4': 11818}

(b'PYGFpr%\xb4\xab\n\xf0\xcc\x04\xdb\xda\x8eedwivY\xa1&\x9a\xd6df\x04\x00=\x00'
 b'J^\x851\x93\xcd\xe5\xbfT\xe8\xc5E\x1e\xf6\x05\xd8\xbf]\x00+;\x06\xce\xdd'
 b'U\xa2\xa7\x03 \xa4\xc3\\\x03@p$\x96\x07\xe6\xc3\xfd\x03\xe7?\xf6\xb1\xf9\xd4'
 b'4\xb4I\x84\xd2/\xfe?\xcd\x1f\x06\x97\xa5\xea\x15\xda+\xfa\x04\x00M\x00\xc46'
 b'\xd2\xa0\xd6\xf79yQ\x83pD\x10\x90\xc6Y\xec\x06\xab\xae\x01\x9cp\xb9')

{'A1': -1272614288,
 'A2': 10293780711973325483,
 'A3': {'B1': 'edwi',
        'B2': 7378258047101131126,
        'B3': [{'C1': [-92, -61], 'C2': 860},
               {'C1': [64, 112], 'C2': 38436},
               {'C1': [7, -26], 'C2': 64963},
               {'C1': [3, -25], 'C2': 63039}],
        'B4': -0.6813446013647504,
        'B5': 84,
        'B6': -0.3753638549452192,
        'B7': {'D1': 735712746,
               'D2': 250,
               'D3': [886372785, -763082316, -851444177, -1516829153],
               'D4': 8735285453454980804,
               'D5': 6469016314306397009,
               'D6': -5084392448261945620},
        'B8': -6367432512015811797},
 'A4': 8195}

Вариант №27

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

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

(b'tXAP\xbe\xc4\x83p\x00\x8c\xcc\t\x9c\xd4\x16\x01\xbf\xa1}\xe8\xed\x1e\xad '
 b'?\xe5K\xd3\xbd\xc0\t\x88\xbf\xddu^\x9d\xc66\xf4?\xbcvN\xcc\x96\xff\x00'
 b'\x05z\xc4/\xccl\x19\x01]\xafh\xb4X\xd8\xbf\xd9=O_\xe2\x1f\xe6F\xe1\xee\x14W1'
 b'\x000\x10\xcd\xc0\x13W\xec\x0b\xe6LrP|02\x1c\xc55w\xc8P^^\x86\xd6\r\xaf'
 b'\n\xff\xbfL}\x9b\xe4S/\xd9\xcdSp\xe5\x00Z\xbdj6>\t\\f{8\xf1\xa4\xa6'
 b'\x00\x00\x00L\x00\x00\x00v\x00\x00\x00\x02\x00\x00\x00\x84E\x81\xe2\xcc'
 b'\xca*t\x7f%\xff\x086\xa3\xc0\xff\xf2\xd3\x1dB\x87\xa3')

{'A1': -0.38381528854370117,
 'A2': {'B1': [{'C1': {'D1': 394843626920483073,
                       'D2': 1571776692,
                       'D3': 1490599897,
                       'D4': 0.050628550350666046,
                       'D5': 535185121,
                       'D6': -4588,
                       'D7': 22321},
                'C2': [281919507, 1475087334, 1282560124]},
               {'C1': {'D1': 3472869895987251280,
                       'D2': 1583253206,
                       'D3': 229575423,
                       'D4': -0.7987915873527527,
                       'D5': 3830656985,
                       'D6': -12973,
                       'D7': 28901},
                'C2': [-1117112770, 157050491, 955360422]}],
        'B2': 5008533629805687935,
        'B3': 637470774,
        'B4': [163, 192, 255],
        'B5': 4073921858,
        'B6': 34723},
 'A3': [52233, 40148, 5633],
 'A4': [-0.03416374105958142,
        0.6655062395150688,
        -0.4602886715664305,
        0.11118023390644893]}

(b'tXAP=\xfc\x0f\x9a\x00\x8c\xc1\xa0?\xf9\xef\x8b?\xeb~\xcd\xff\xff\xbe4'
 b'\xbf\xcc\x84\xbffW\xf2\xc0\xbf\xed\x0e\xddS\x91s\xd0?\xeb\xf2\xc4'
 b'\xe0\x8b"\x98\x90\x1e\xc2\xf2\xf9\x00\xf7\xc4\x0c\xfb\xce\xde\x98VW\xcf'
 b'?\x7f\xd5w\xdc=\x16\xeb\xabe\xd2$\x000\xcdU\xd6\x8b\x11m9\xa3\xc87'
 b'H\x7f\x94\xebd\x83A,#KXr\xa2\xe3\xb9>\x84\xeb?4\x03"i\x1c\x8a\x19\xbb\xa1'
 b'\xbb1\x00Z\xdf\xc9E\xa8\xc9Fsk\x9e\xd5\x13\xd0\x00\x00\x00L\x00\x00\x00v'
 b'\x00\x00\x00\x02\x00\x00\x00\x84\x9f>\x0c\xdeG\x80\x0e\xbf\xd6N\xeaC'
 b'\x93\xc1w\x875\xd9\xfe\xf8\x1b')

{'A1': 0.12307663261890411,
 'A2': {'B1': [{'C1': {'D1': 10384952139578406852,
                       'D2': 217829086,
                       'D3': -1739171889,
                       'D4': 0.9993509650230408,
                       'D5': 3694991083,
                       'D6': -21659,
                       'D7': 53796},
                'C2': [-850012533, 292370851, -935901057]},
               {'C1': {'D1': 10730781052037243723,
                       'D2': 1483907811,
                       'D3': -1187085077,
                       'D4': 0.7031728029251099,
                       'D5': 1763478041,
                       'D6': -17503,
                       'D7': 47921},
                'C2': [-540457560, -918129813, -1630202928]}],
        'B2': -6972121024301101377,
        'B3': 3595496003,
        'B4': [147, 193, 119],
        'B5': 2268453374,
        'B6': 63515},
 'A3': [49568, 16377, 61323],
 'A4': [0.8592290878277198,
        -0.22280113694423243,
        -0.9080645210448157,
        0.8733848939528626]}

Вариант №28

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

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

(b'IBK. M\x98\xc7\xe7\x03l\x00]\x00r\x00\x87\x00\x9c9\x16\x00\xa5\xe7'
 b'\x9e\xe0@\x01\xfd1?E?\xad]\x8d\r\n\xcd\xee\xb6a\xb9E\xee\xf8\xad\x12'
 b'\x97\x97n\x17:\xbf\xea\xc1v\x06\xa3NP\x89O\x95\xbe\x1a9\xe7\xaaa\xea\x95'
 b'\x84\xbc\xf5\x9a\x19\xb9\xe3\xf6\x7f\xdb?0\xdc\x96\xbb\x0e\xf2\x88wK'
 b'\xcc\x00\x02\x00\x00\x00U\xec\xd5\xd5)9m\xad\xdc)\xae\xae\xf66'
 b'\x9c\xc4\x00\x02\x00\x00\x00j\xff\x85\x81\xcb\xecxZ@\xcaN\xd4^v\x10E\x00'
 b'\x02\x00\x00\x00\x7f\xab\xc5qp\x9a\xf5\x8c\x98_j+\xf0\xb8\x89x'
 b'\x00\x02\x00\x00\x00\x94\xb6\x01N\xf5\x15\xf3S')

{'A1': 3323741843583599468,
 'A2': {'B1': [{'C1': [2528841458, 2289519564],
                'C2': 236,
                'C3': -10795,
                'C4': 691629485},
               {'C1': [3693719214, 4130774212],
                'C2': 255,
                'C3': -31359,
                'C4': -873695142},
               {'C1': [1087000276, 1584795717],
                'C2': 171,
                'C3': -14991,
                'C4': 1889203596},
               {'C1': [2556389931, 4038625656],
                'C2': 182,
                'C3': 334,
                'C4': -183110829}],
        'B2': 14614,
        'B3': {'D1': [10872734, 3762291197, 826230079],
               'D2': 44381,
               'D3': -29427,
               'D4': [181268150, 1639532014, -122875241, -1754392774],
               'D5': -0.8361158494612457},
        'B4': -8552452523636955222,
        'B5': 25066,
        'B6': [-27260, -17163, -26087, -17949, -2433, -9409, 12508]}}

(b'IBK\xab\xe7k\xab\xb8\xa4\xd3\xc0\x00]\x00r\x00\x87\x00\x9c\x87\xaa\xa65\x19'
 b'\xf5\xd2\x0eM\x81\x91\x117\xb5b*\xff\xd5\x94\xb8\xe1\xd5\xbeP\xcaV"\x18\xca'
 b'A\xc2\xe0\x82f?\xe8\x8e\xde$I\xf5\xae\xady\x17[\xabp\x0bHI1\xefNo\x03\xfe'
 b'&\xec\xd6\x1f\xff\x97\x85\x95\x8e]\xd69\\I#\xab\xa6\x00\x02\x00\x00\x00U\x83'
 b'5^\xe3 \xd3\xffTCR1\xa6\xe0T\xeb\x00\x02\x00\x00\x00j\x95\x12\xbb%'
 b'\xee\x827\xd2l}AI\x01\xd1\xda\x00\x02\x00\x00\x00\x7f\x18\xa8uN\xd6\xfd;'
 b'\xc4\xd1\xa2\xe6;W~.\x00\x02\x00\x00\x00\x94d<}\x90\xfd\x96\xa4')

{'A1': 12386987685387228096,
 'A2': {'B1': [{'C1': [1574320476, 1227074470],
                'C2': 131,
                'C3': 13662,
                'C4': -484387841},
               {'C1': [1413698097, 2799719659],
                'C2': 149,
                'C3': 4795,
                'C4': 636387895},
               {'C1': [3530325313, 1224856026],
                'C2': 24,
                'C3': -22411,
                'C4': 1322712379},
               {'C1': [3302073062, 995589678],
                'C2': 100,
                'C3': 15485,
                'C4': -1862429020}],
        'B2': -30806,
        'B3': {'D1': [2788497909, 3524152705, 2433824693],
               'D2': 25130,
               'D3': -43,
               'D4': [-1799822891, -1102001578, 572049985, -1025473946],
               'D5': 0.767439909817474},
        'B4': -5946696150480319672,
        'B5': 18737,
        'B6': [-4274, 28419, -474, -4906, 8191, -26747, -27250]}}

Вариант №29

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

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

(b'QIV\xb8\x14~\x00>\x00D\x00J\x00P\x00V\x00\\\x00b\xbfGM.gK+\xd9\x18\x80yp'
 b'Q\x0cm!\x00h$x\xbc\x14H\r\xea\xeb\x00\x00\x00\x03\x00\x00\x00\xa6=\xb2'
 b'\xf4E\xba\xbdP\xd4\xb0N\xa3\xd5\xcd\xf6\x81[\xe4<\x9e\xcf"X\x19\xea\xcf`'
 b"\xe3]\x03{lC\xa6,\xac.\xfb\xa6\x9c\x80\x0bUX\xb0'T\xdd\xb5\x99h\xbf\xc2U."
 b'F\x144\x10\xa2"\x07\x0b\xc1\x16^\x1eP\xe4\x8e\x84n\xefi\xed^\x00\x00\x00'
 b'\x02\x00y\xf4Q\x95\x19\xf2\xa0\xb8\x14\\\x00\x00\x00\x02\x00\x88M\xc3'
 b'\xf31\x1d\xaf\xb0\x92\xdd\x00\x00\x00\x02\x00\x97\xe6\x00}\x00\x8c\x00\x9b')

{'A1': -72,
 'A2': 20,
 'A3': {'B1': 126,
        'B2': [{'C1': 2957943765, 'C2': -12810},
               {'C1': 2170283068, 'C2': -24881},
               {'C1': 576199146, 'C2': -12448},
               {'C1': 3814523771, 'C2': 27715},
               {'C1': 2787945518, 'C2': -1114},
               {'C1': 2625637205, 'C2': 22704},
               {'C1': 659873205, 'C2': -26264}],
        'B3': -0.7785214185714722,
        'B4': 1732979673,
        'B5': 1765544577232301345,
        'B6': {'D1': -0.14322451040098416,
               'D2': 162,
               'D3': [34, 7, 11, 193],
               'D4': 375266896}},
 'A4': 2628057177864923883,
 'A5': [{'E1': -278270626, 'E2': [58510, 33902], 'E3': 244},
        {'E1': -1598548900, 'E2': [20885, 6642], 'E3': 77},
        {'E1': -1347382563, 'E2': [50163, 12573], 'E3': 230}],
 'A6': [15794, -3003, -17731, 20692]}

(b'QIV\xd2\xba[\x00>\x00D\x00J\x00P\x00V\x00\\\x00b?}=\xe5\x1a\x1c\x8f\xc4'
 b'\x9c\xc5\xeeuV\x18\xee\x04\x00h\x9a+f\x90\xa9\xfc\x1aj\x00\x00'
 b'\x00\x02\x00\x00\x00\x977K\x03\xc5]\xbd/\xa8\x8bbmV\x16ne\x93\xd0\x1b'
 b"\x98\xd6\x1a\x92f\xdeg\x17'\x8c\xbeY4\xa9\xf2\x8f\xa1\x11B\x9539\x85\x83"
 b'\xe7\xa1\x9b\xfb\x10=6U\xbf\xe3w\xba\xf3\x8fRf\x7f\xe4\x1b\xcfH\xcb\xc8\\'
 b'\xfc\x12\xc8F*\x8cM\xb4\x1d\x00\x00\x00\x02\x00y\xd6\xf6ZUa\xe7u\x10g'
 b'\x00\x00\x00\x02\x00\x88\xee\x00}\x00\x8c')

{'A1': -46,
 'A2': -70,
 'A3': {'B1': 91,
        'B2': [{'C1': 2338483542, 'C2': 5742},
               {'C1': 1704185883, 'C2': -26410},
               {'C1': 445802206, 'C2': 26391},
               {'C1': 663535193, 'C2': 13481},
               {'C1': 4069499153, 'C2': 17045},
               {'C1': 859407747, 'C2': -6239},
               {'C1': 2616922173, 'C2': 13909}],
        'B3': 0.9892256855964661,
        'B4': 438079428,
        'B5': 11296697428051815940,
        'B6': {'D1': -0.6083655125645009,
               'D2': 127,
               'D3': [228, 27, 207, 72],
               'D4': -876061444}},
 'A4': 11109085677352655466,
 'A5': [{'E1': -1941064675, 'E2': [4808, 17962], 'E3': 214},
        {'E1': -411758489, 'E2': [63066, 21857], 'E3': 238}],
 'A6': [14155, 965, 23997, 12200]}

Вариант №30

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

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

(b'KMM\x926\x00\x00\x00q\x00\x00\x00\xac\x00\x00\x00\x85\xbe\xe2\nW\x93\xcb\x9f'
 b's\\\xa7B@;y\xbb\x83\x11\xc0\xd0-\x03\xd3\xb7\xed\x9e!\x8a\xe2\xdd\x83\xe4'
 b'S,\xb7C\xd6\xe9\x9b2lgwoa\x02\x00\x00\x00 \x00\x00\x00?;\x91>\xfc\xbe\xe7'
 b'\xf7\xf5$\x00\x00\x00\x8em\xce\xb9.A\xdd\x14\xef,\x91F\xed\xafu\xa3\x13\xf9'
 b'\xa0\x05\xf5\xa7\x1e\x18\x06\xcfFn\x9fF\xfda\x1dvfxmf\x02\x00\x00\x00'
 b'[\x00\x00\x00\xe5\xf9p\xbf\xc1\xdcT0\x08_\x00\x00\x00!\x08\xff{\xdf\x81\x85'
 b'\x8f \xc6\x99~\x86Kp^/u\xd6\xa2\xc4\x06\xb6\xdb\xff*7\x12\xb9\x88<\x9f\x83ep'
 b'koz\x02\x00\x00\x00\x96\x00\x00\x00e\x89\x93\xbeZ\xb8\x95\xa7\xe8'
 b'\x9a\x00\x00\x00\xf3\x8f\xc2\x99\x0f\xddj\xbe\xf0')

{'A1': [{'B1': 12955,
         'B2': 'lgwoa',
         'B3': [4483, 53440],
         'B4': {'C1': 0.2836551368236542, 'C2': 48892, 'C3': [231, 247, 245]},
         'B5': {'D1': 9953411395294004013,
                'D2': 4879417460106976738,
                'D3': 59862},
         'B6': -1177653874,
         'B7': 350044462,
         'B8': -17},
        {'B1': 7521,
         'B2': 'vfxmf',
         'B3': [37164, 60742],
         'B4': {'C1': -0.9413130879402161, 'C2': 56513, 'C3': [84, 48, 8]},
         'B5': {'D1': 17655694905812678063,
                'D2': 11488197554443132583,
                'D3': 64838},
         'B6': 2080311329,
         'B7': -1887075873,
         'B8': 32},
        {'B1': 33695,
         'B2': 'epkoz',
         'B3': [39366, 34430],
         'B4': {'C1': -0.2881576120853424, 'C2': 47194, 'C3': [149, 167, 232]},
         'B5': {'D1': 14169123176455237707,
                'D2': 13335782104418203142,
                'D3': 15496},
         'B6': -1715302413,
         'B7': -1100292849,
         'B8': -16}],
 'A2': 182632069,
 'A3': 2680918871,
 'A4': 1118264435,
 'A5': 3145284416}

(b'KMM\x926\x00\x00\x00q\x00\x00\x00\xac\x00\x00\x00\x04\x1b\xa4\x00\xe7\x04S2'
 b'\xbbid\xac$\x9b\x93\xbe\xa6\x87\xe6\x1a\x10\x89\xc3Y\x8a1\xd3\x850\xe9\xfd/'
 b'h5\x93\xff\xba\x9c\xbd\x17dclex\x02\x00\x00\x00 \x00\x00\x00\x7f\xad\xdb'
 b'=\xdc\xf1\x8b\x00\xa1$\x00\x00\x00\xc6o\xd3\x9a\xbfCw\xa0q\xed\x0cb\x1a\xcf'
 b'\x8a\x8d\x9b\xf1\xe3\xef\xfc\xba\xc6\xdf\x11\xeb)\x8a\xf0\x1c\x92k\x08upzgv'
 b'\x02\x00\x00\x00[\x00\x00\x00?\xb9\xa7\xbey=\xffd@_\x00\x00\x00/\xb7\x04'
 b'8\x8c\x04?\xb57\x17\xf8\x0cP\x037W\xdb\xa3\xc3\x07:\x9au+z\x1f\x18'
 b'\xf3\x05\x9d\xeb#\xabooggh\x02\x00\x00\x00\x96\x00\x00\x00V\xcfo?\x98'
 b'\x82\xcf\x90r\x9a\x00\x00\x00\xe5\xa0\x83\x14e\x93\xf8\xbe.')

{'A1': [{'B1': 6077,
         'B2': 'dclex',
         'B3': [34726, 6886],
         'B4': {'C1': 0.10726451128721237, 'C2': 61916, 'C3': [139, 0, 161]},
         'B5': {'D1': 9643105697411598608,
                'D2': 18416122022846130480,
                'D3': 40122},
         'B6': -1697419322,
         'B7': -1602796609,
         'B8': 113},
        {'B1': 2155,
         'B2': 'upzgv',
         'B3': [3309, 6754],
         'B4': {'C1': -0.3275851905345917, 'C2': 15737, 'C3': [255, 100, 64]},
         'B5': {'D1': 18226036843828054735,
                'D2': 17332712205482706618,
                'D3': 37404},
         'B6': 939833135,
         'B7': -1254161268,
         'B8': 55},
        {'B1': 43811,
         'B2': 'ooggh',
         'B3': [63511, 20492],
         'B4': {'C1': 0.9367574453353882, 'C2': 33432, 'C3': [207, 144, 114]},
         'B5': {'D1': 4181525887563806467,
                'D2': 428712913003050394,
                'D3': 60317},
         'B6': 344170725,
         'B7': -1091005595,
         'B8': 46}],
 'A2': 10754820,
 'A3': 844301543,
 'A4': 2892261819,
 'A5': 3197344548}

Вариант №31

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

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

(b'PJN\xb7kpcatmaM\x00\x00\x00Y\x00\x00\x00e\x00\x00\x00q\x00\x00\x00}'
 b"\x00\x00\x00\x89\x00\x00\x00f\x9c\x16\xa1\x00w\xa5\xc7\xbe'F\r\xbe\x85gQ?"
 b'?\x02\x00\xb1\x00\x00\x00\xb6\xfa\xe3x@`C\xac\xa8\x8a\xbe?\x04'
 b"\x00\x00\x00\xb3\x00\xc4\xbc\xd8'\xdfC\xe3?1/@+\x80\xfc\x92\x18\xe9H\xa3"
 b'\xbf\xf63\xa3\xd9\x80p\x9e~\x80\xff\xbf?\xeau\xe3\xe3h\xe9\x01'
 b'\xde\x0e\xfc\xd7?y{\x873\x00\xdf(\x11d\x0e\xbc\xbf\xa9\xc8\xc1G\\\xbb\xcd'
 b'\x81\xbfU\xde?9\xd8\n\xa0kw\xa8\xe6\x07mY\xc0\x86]\x94\xe9\x91\xa8\xde'
 b'\xd0\xc1\xf4\xd5\x7f\x1d:\x06\x00\x00\x00\x95\x00\xf6^\xc0\x8c\xd9`')

{'A1': 'kpcatma',
 'A2': [{'B1': 0.602035119843912, 'B2': 725626673},
        {'B1': -0.0376656382081757, 'B2': 3651351542},
        {'B1': 0.1249924000862297, 'B2': 3823334890},
        {'B1': 0.37475940399567387, 'B2': 864516985},
        {'B1': -0.10959458750664552, 'B2': 1203882153},
        {'B1': 0.4739836471189187, 'B2': 2685065273}],
 'A3': 102,
 'A4': {'C1': 5788,
        'C2': {'D1': 3504253073,
               'D2': 2144728257,
               'D3': 14877,
               'D4': [30571, -6488, 27911, -16295, 23942, -5740]},
        'C3': -0.3899342715740204,
        'C4': {'E1': 17959,
               'E2': 13,
               'E3': -31298,
               'E4': 0.7473358511924744,
               'E5': [-10, 94],
               'E6': 2028206774,
               'E7': 0.11930326657909607,
               'E8': [192, 140, 217, 96]}}}

(b'PJN\xb7dvcrhxeM\x00\x00\x00Y\x00\x00\x00e\x00\x00\x00q\x00\x00\x00}'
 b'\x00\x00\x00\x89\x00\x00\x00\x9f\x94\xb3\x9d\x00\x19.\xd0\xbe'
 b'\xd7\xa7\x9d\x86\x0e\x01)|\xbf\x02\x00\xad\x00\x00\x002\xa6\xcb\x08\x00'
 b'\x17\xeb\x8e\x8c\x9a\x96?\x02\x00\x00\x00\xaf\x00\x10\x1b\x9a60\x07\xd0'
 b'?Zd\x17^p\xec\xef\xd3"\x14\xe6\xbf\x90\x91P\xfc\x0c\xbf\xa5\xd9:\x81\xd8'
 b'\xbf\x1ez\x0c\\p\xf3\xae\x87\xc0\xc6\xdd?r0\x93\x8d.\x00\xd2\xef\x11a\xe9'
 b"?x\xbe'\xden\x0e\x9b\x1f\xfe\xaa\xe8\xbf\xd6\xff\xb1yA\xad0\xf2\x8e\x10\xc0"
 b'\xd2\x06\xe3\xd5F\xa6\xb7g%\xda$\x04\x00\x00\x00\x95\x00\xb5\x03\xd5-')

{'A1': 'dvcrhxe',
 'A2': [{'B1': 0.2504387410375992, 'B2': 1578591322},
        {'B1': -0.6899580134771792, 'B2': 4233138576},
        {'B1': -0.382887566133818, 'B2': 1544321566},
        {'B1': 0.46525586366970284, 'B2': 2375233650},
        {'B1': 0.7930993732443363, 'B2': 3727146616},
        {'B1': -0.7708731286333668, 'B2': 2041708502}],
 'A3': 159,
 'A4': {'C1': 45972,
        'C2': {'D1': 1188422406,
               'D2': 627554214,
               'D3': 9434,
               'D4': [-21183, -3536, 4238, -11584]},
        'C3': -0.4066016972064972,
        'C4': {'E1': 42967,
               'E2': 157,
               'E3': 3718,
               'E4': -0.9850006699562073,
               'E5': [-75, 3],
               'E6': 147564082,
               'E7': 0.02207393286041448,
               'E8': [213, 45]}}}

Вариант №32

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

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

(b'HNU\xbe\x00\x00\x00t|\x02\x0b:?\x15\xbc\xfb\xcb"\xf5\xe7t\xc2P\xcc'
 b'\x00\x04\x00\x00\x00\xb3\xf9A\x9a60\xdc0\x1b_-\xcc\xbf\xff\xa6T\x07\xca\xa5'
 b'\xc0\xa5\xbfK\x1f\x91?F\xc6\xb0\xbfj\xeey<\xe4W\xb9\xbd\x94\xad\x12\xbf='
 b'\xa3\xbc?Q\x85N?b\xdd\x909\xc5Q\xed\xb9\xc5\x0c\xe6\x8as?\xf2\xfeYM\x14\x0f+'
 b'\xea%U\xbb\x90\x9e\xeb\x1d\xcb&\xd3Y\xf0\n\xe6W\x00\x00\x00T\x00\x00\x00Y'
 b'\x00\x00\x00^\x00\x00\x00c\x00\x00\x00h>\x02(m\ty@Lt\xd5\x00\x03'
 b'\x00\x00\x00mB\xber\x08]d\xbf\xd0+\x17\xee\x8fi<\x00\x00\x00\x02\x00\x00'
 b'\x00po\xbfP\xecE>-\x86\x10?)Q!>Pv\xf1\xbf)\x9f\x9c')

{'A1': {'B1': {'C1': [{'D1': 81, 'D2': 3988374796},
                      {'D1': 230, 'D2': 2322808818},
                      {'D1': 254, 'D2': 1498223631},
                      {'D1': 43, 'D2': 3928315323},
                      {'D1': 144, 'D2': 2666208715}],
               'C2': 0.12710733711719513,
               'C3': {'E1': 2425, 'E2': 1078752469, 'E3': [38, -45, 89]},
               'C4': 66,
               'C5': {'F1': -0.23636002838611603,
                      'F2': 100,
                      'F3': -0.25263021752256853,
                      'F4': [-4086, -6569],
                      'F5': 111,
                      'F6': -0.8161051869392395}},
        'B2': 2080508730},
 'A2': 0.5849148631095886,
 'A3': -3809211960356876084,
 'A4': [0.16945672035217285,
        0.6613941788673401,
        0.20357872545719147,
        -0.6625916957855225],
 'A5': 4181826102,
 'A6': {'G1': 3520741902815972543,
        'G2': 18421503718246957221,
        'G3': [-0.7934504151344299,
               0.7764692306518555,
               -0.9177013039588928,
               0.02787386067211628,
               -0.07259573042392731,
               -0.7407796382904053,
               0.818440318107605,
               0.8861932754516602]},
 'A7': 14789}

(b'HNU\xbe\x00\x00\x00s}\xd5\xa7\x18\xbf(\x13\xfaH\xfd\x14\x06\xa3\xc0\xe7\xf5'
 b'\x00\x04\x00\x00\x00\xb2\xd6\x92\x06#\x9e\xf2M\x9a\xc1\x93\xac\xf2\xd1\xf1'
 b'r\xe7\x03\x17n\xa2\xber\x89\xb1\xbf*\xb8q\xbd\xc6\x8a\xc2>\xd5o\xbb>\x15'
 b'c\xe5\xbf0u\xb6>\xe7+\xee?6~\xc9\xce \x9754\x97\x15\xf5>\xad\xda!}\xf4'
 b'R\xfb\xbf\x00\x1dp\x87f\x11\xa6Z\xeb\xd6=\xe49\t\xa9 \x00\x00\x00T\x00'
 b'\x00\x00Y\x00\x00\x00^\x00\x00\x00c\x00\x00\x00h\xbf\x12\xe1,=sL\xda\xf9'
 b'K\x00\x02\x00\x00\x00m\x1a\xbe\xd1\x8be\x82\xbf\xbe\xe9\x1dJ!>'
 b'\xe0\x00\x00\x00\x02\x00\x00\x00o\xea\xbfU\xcf\x85?&\xbe#?\x01\x96M?.'
 b'\x19\xe1?i\xdf\xed')

{'A1': {'B1': {'C1': [{'D1': 151, 'D2': 892638997},
                      {'D1': 245, 'D2': 1051580961},
                      {'D1': 125, 'D2': 4099079103},
                      {'D1': 0, 'D2': 493913958},
                      {'D1': 17, 'D2': 2790976470}],
               'C2': -0.5737483501434326,
               'C3': {'E1': 15731, 'E2': 1289419083, 'E3': [61, -28]},
               'C4': 26,
               'C5': {'F1': -0.4092666208744049,
                      'F2': 130,
                      'F3': -0.12074454364596532,
                      'F4': [14601, -22240],
                      'F5': -22,
                      'F6': -0.8351977467536926}},
        'B2': 2111153944},
 'A2': -0.6565548181533813,
 'A3': 5259381958588295157,
 'A4': [0.6513387560844421,
        0.5061996579170227,
        0.680082380771637,
        0.9135730862617493],
 'A5': 3599894051,
 'A6': {'G1': 11453302129424575730,
        'G2': 15127998959829085858,
        'G3': [-0.23685337603092194,
               -0.6668768525123596,
               -0.09694434702396393,
               0.41686806082725525,
               0.14588887989521027,
               -0.6892961263656616,
               0.451507031917572,
               0.7128720879554749]},
 'A7': 52768}

Вариант №33

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

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

(b'ANGG\xfd7\xcd\xe2/\x013\x1a\x04\x00v\x00\x02\x00\x00\x00\x86\x00L\xb3'
 b"\xfb\x85\x88\x00A\xdb>[7\xcf+K\xfd '\x1f\xde\xd6}\xb0\xad\xbanDr|\x13^"
 b';H\xf7\xbb\xe9N\x88rD\xbe\xb2i\xe8\xfd\xa0:5%\x16\x8c\xe6\xbfc\x0e\xf6yY\x81'
 b'\xd9\xf6\xd7j\xdfr%<,\\7\xd5\xc6\xc4\xb51\xf6\xd6\x914&\xa0\xbd\xde'
 b'\xfd \xad\xfd\xf7\x9f\xfb\x82\xbd\x04\xe8^\xb5\xf8J\x00\x00\x00U\x00'
 b'\x00\x00`\x00\x00\x00k\x00\x00\x00ygs\x18f\xbf\xec \x7f\xde*')

{'A1': 1887853973978560509,
 'A2': [{'B1': 17787390424574725731, 'B2': 27351, 'B3': 223},
        {'B1': 14327418658567759218, 'B2': -19004, 'B3': 49},
        {'B1': 16050160732969490166, 'B2': 8445, 'B3': 173},
        {'B1': 16718696086971086845, 'B2': -19106, 'B3': 248}],
 'A3': 'yg',
 'A4': {'C1': 2247865164,
        'C2': {'D1': -0.8988105654716492, 'D2': 236, 'D3': [32, 127, -34, 42]},
        'C3': -9407,
        'C4': [-818455746, 553470763, -690086105, -1163022211, 2087863406],
        'C5': 24083,
        'C6': 8252933082944325691,
        'C7': [48708, 27058]},
 'A5': -536,
 'A6': -0.704600403472643}

(b'ANGG5\xf0\xc1\xb8\xf1\xcdu\x02\x04\x00v\x00\x02\x00\x00\x00\x86\x00\xe7l'
 b'\xd5\xc6\x88\x00\xad\xe1\x85\xf1\xe1\xc6\x00s\x1e\xc9~\xbf\x15\x8f\x16\x9b'
 b'a\x8d"D\x89\x9a\x91VOz\xbf\xbc\x81\x12\x98d\x83\xa5\xae\r%thN\xe1a\xee\xbe'
 b'\xdb?\xca\xd6d\xcd8;`_\xb6\xd7CK{\xe4\x0f\xcfh\xae\xc7\xf6\x96.'
 b'\xdc\x1d\x1a\xb8\xbd\x11+\x83\x19\x99\x8b\x16\xe1\x03\x1f\x8a\x02\xde[/'
 b'h_J\x00\x00\x00U\x00\x00\x00`\x00\x00\x00k\x00\x00\x00zl\x8cB\x1c\xbf'
 b'\x92h&\x8d\x99')

{'A1': 177274198421532725,
 'A2': [{'B1': 6872558146517522122, 'B2': -10314, 'B3': 67},
        {'B1': 14388553098029464395, 'B2': -26890, 'B3': 46},
        {'B1': 9451667749502328284, 'B2': -26343, 'B3': 139},
        {'B1': 6619731294530298134, 'B2': 26671, 'B3': 95}],
 'A3': 'zl',
 'A4': {'C1': 3335875815,
        'C2': {'D1': -0.6103904247283936,
               'D2': 146,
               'D3': [104, 38, -115, -103]},
        'C3': -7763,
        'C4': [-958271099, -920751360, -1894400130, -1922983146, -1702280158],
        'C5': 22161,
        'C6': 7248563948679559759,
        'C7': [42371, 3502]},
 'A5': 29733,
 'A6': 0.43352851446727536}

Вариант №34

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

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

(b'CYVm\x00\x00\x00\x03\x00\x10-\xfb\x00\x00\x009epr?W\xf7\x98\x82\x14WZ\x82'
 b'\x7f7U1\xe2\xba\xbd\xb6\r\t\xd6\xe1\xc3S\n\xdb\x84\x98 :\xce\x8ej\xae'
 b'\xdb\x1e\xac\x86!\x00\x13\xaf\x87\xea\xf6\x00\x02\x00\x19\n\xb9\x18a, |')

{'A1': 109,
 'A2': 'epr',
 'A3': 11771,
 'A4': {'B1': {'C1': 0.8436217308044434, 'C2': -32236},
        'B2': -1350046986,
        'B3': [{'D1': [1465549439, 928330210, 3132995085], 'D2': 165077443},
               {'D1': [1393220484, 2552249038, 2389356251], 'D2': 514623009}],
        'B4': 10,
        'B5': [47384, 24876, 8316]}}

(b'CYV\xc3\x00\x00\x00\x02\x00\x10*\xbb\x00\x00\x00Xku?:\xb0\xfa\xd6\xe5q\xe36)'
 b'\xe5f\x81)f\xe5\xa4A\x054\x0b,\xb9E\xd5\x9f\x86\x96\x07]q+\xd9\xe4'
 b"\xf9\xa27\xda\xe4i\xc4\x19\xbd1'\x08\x899\x13\xb1\xb3\xab\xc4\x021\xc2\xd0c"
 b'\x7f\x07a\xfc\x12g\x9b\xa6Kke\xdf\x00\x12\x9f}\xf7\x83\x00\x04'
 b'\x00\x18\xed\xbd\x18\xdd \xd5\x91')

{'A1': -61,
 'A2': 'ku',
 'A3': 10939,
 'A4': {'B1': {'C1': 0.7292629480361938, 'C2': -10523},
        'B2': -1619134589,
        'B3': [{'D1': [1910715945, 3848700201, 1726325825], 'D2': 87296812},
               {'D1': [3108361631, 2257979229, 1898699236], 'D2': -106809382},
               {'D1': [3832136729, 3174115080, 2302219185], 'D2': -1280588798},
               {'D1': [834850915, 2131190268, 308779942], 'D2': 1265329631}],
        'B4': -19,
        'B5': [48408, 56608, 54673]}}

Вариант №35

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

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

(b'\xb8JDYszpps9\x9f\xcc\x91]\xecE\x03\x00\x00\x00@\x00\x00\x008M^\xbf'
 b'\x11\\\n\xa4\xa3\x80ad\xfb\x0c\'\x08\x03gP\xdb?N\x00\xdfFBm"(q\x02\x90'
 b'\x92\xb3\xb2\xcbP\x97\xf4\x871\x006\x00;\x00n*\xea\xbe\xdfaV?\xe4I'
 b'2\x98\x02\x00\x00\x00F\x00\x8b \x0f?')

{'A1': {'B1': 'szpps',
        'B2': -1848860871,
        'B3': 93,
        'B4': 17900,
        'B5': [{'C1': 66, 'C2': 8813, 'C3': 28968},
               {'C1': 2, 'C2': -28016, 'C3': -19789},
               {'C1': -53, 'C2': -26800, 'C3': -30732}],
        'B6': -0.8683657646179199,
        'B7': 17},
 'A2': 18114710806320122460,
 'A3': 0.4267823724372739,
 'A4': {'D1': [18916, -26574],
        'D2': [-0.45735496282577515, 0.8374308943748474],
        'D3': 0.5590903162956238},
 'A5': -33,
 'A6': 70}

(b'\xb8JDYujoxf,&jk\xe5\x01\xef\x03\x00\x00\x00@\x00\x00\x00_\xef8?_\xee\xd2k'
 b'\xb9c\xd4\x1c\xac\x8a\xe1\xe6\xd5\x91\x86\xea?V\x00\xd3\xdb\x14\xfe\xdc'
 b'\x8bJ\xe9\x93*\xd2\x84)\xaeG\xae\x031\x006\x00;\x00=t\xb0\xbe\xfeL'
 b"\x0e\xbf\x1f`T\xbf0\xdc\x9c\xbd'\xab\xd2\xd5\x04\x00\x00\x00F\x00"
 b'\x99\xcc\xdf\xbe')

{'A1': {'B1': 'ujoxf',
        'B2': 1802118700,
        'B3': -27,
        'B4': -4351,
        'B5': [{'C1': 20, 'C2': -8962, 'C3': 19083},
               {'C1': -23, 'C2': 10899, 'C3': -31534},
               {'C1': 41, 'C2': 18350, 'C3': 942}],
        'B6': 0.7224025130271912,
        'B7': 95},
 'A2': 12402020998649205486,
 'A3': 0.8289269616862367,
 'A4': {'D1': [-21721, -10798],
        'D2': [-0.34463682770729065,
               -0.555862307548523,
               -0.829591691493988,
               -0.0765918493270874],
        'D3': -0.4371078312397003},
 'A5': -45,
 'A6': -37}

Вариант №36

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

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

(b'ADKMgT\x85\xfd\x02\x00l\x00<\xcbO\xd0\xab\xbe\xe7\xbf\xc5gn\xf1d\xbb,b'
 b'g\xc1hF\xd7\x03\x03\x00\x80\x00\x07\x00\x83\x00\x00\x00\xa8H\x00\x01'
 b'\x06\x00\x00\x00\x8a\x00\x00\x00\x17\xd2LN\xba\xea\xfbz%\x19\x7f\xbf'
 b'\xde\xd4\x02\xf9M\xf3\xa5\xcc`\xd6\xe8\xe1\xf8\xd5\x19\n\xa0\xd6\xa5_'
 b'}\xa9\xab\xbf{\xf9)eW\x95\xb9\xf0\x08\x00\x00\x00\x90\x00\x00\x00v\x04zm'
 b'\xd35\xe8\xbf\xc4\x92\xe0\x11\xf0\xad\x82\x02\xe0?89qfhWzHj\xce\xbbe\xad1'
 b'\xb3U\xa8\x9a\x1c\xed\xf9\x87*\xdfS\x13q\xae\xcf*\xf6\x8b\\\x0f')

{'A1': 21607,
 'A2': -635,
 'A3': [{'B1': -0.7565705431189957, 'B2': 37572},
        {'B1': 0.5003064534399151, 'B2': 14648}],
 'A4': {'C1': -0.7420252865398207,
        'C2': 4050544581,
        'C3': 5073517630005754724,
        'C4': 983,
        'C5': 'qfh',
        'C6': [87, 122, 72, 106, -50, -69, 101],
        'C7': 16795816},
 'A5': [173, 49, 179, 85, 168, 154],
 'A6': 8861934777680056855,
 'A7': {'D1': -0.9964774250984192,
        'D2': 4177712350,
        'D3': -2168247509340261555,
        'D4': 54776,
        'D5': 2585,
        'D6': -0.05402747910094985,
        'D7': 17346059642386119035,
        'D8': [60700, 34809, 57130, 4947, 44657, 10959, 35830, 3932]}}

(b'ADKM\xfe\xa36T\x02\x00l\x00\x8c\x07\x18\xcc8k\xd8?\xb6\x90s\xeb'
 b'\x8a\xe9\xce\xb4$\xe4\x9c\xb6\xe7T\x04\x00\x80\x00\x05\x00\x84\x00\x00\x00'
 b'\xd5\xa4\xbc~\x07\x00\x00\x00\x89\x00\x00\x00xr3\x17~\xfc\x99\x93'
 b'\x8eR\x92\xbd\xae;\xd7\x98\t\x96\xe2z\x00\xa1\xf1A\xe3\xec\xa0\xc5'
 b'\x80\xea\xc9[\xf3\xaf\x8d\xbf\xb0\xb8\x9df\xa9Q\xafH\x02\x00\x00\x00'
 b'\x90\x00\x00\x00\xd0\x01\xcc\xc2L\xac\xcb\xbf\r.`\x0f6w\x05\xe2\xd0\xbf0\x0b'
 b'rlyx\xeaK\xd4\xc0d\x8fY\xc9"\x83<\x9c@S\x9e\x9c')

{'A1': 41982,
 'A2': 21558,
 'A3': [{'B1': -0.21619567405288231, 'B2': 11789},
        {'B1': -0.26379524842945123, 'B2': 2864}],
 'A4': {'C1': 0.38154430323640365,
        'C2': 3950219446,
        'C3': 13158643057573161354,
        'C4': 21735,
        'C5': 'rlyx',
        'C6': [-22, 75, -44, -64, 100],
        'C7': 2126292181},
 'A5': [143, 89, 201, 34, 131, 60, 156],
 'A6': -7810934460212088200,
 'A7': {'D1': -0.07144652307033539,
        'D2': 2564242350,
        'D3': 4751756105286325769,
        'D4': 60643,
        'D5': 50592,
        'D6': -0.014495755423231005,
        'D7': 5237494679668111536,
        'D8': [21312, 40094]}}

Вариант №37

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

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

(b'\xfcYBFU9\x00\x00\x00\xe4~\x8drj\xdc\xd9\xbfn\x00\xb9\x899\x0e\x18'
 b'\xad\x08\x94\xddE\x04\x03\xc1\xfd\xb5!!\x85EU\x17H\xdc=\xbf\xdd\x88\xbfS'
 b'4R\xe83\xcf\t\x0c\xd5$\xdd@\xe7\xdc2\xb7\xcd\xef\xbf\xb5\xbd\x02\x00\x17\x00'
 b'\x00\x00\x03\x00\x00\x00!\x00\x99q\xaa\x1d\xcf\x9d\xf9,HbN=\xec|q\xd0'
 b'\xdc\xfd\x88$\xbd\xf9!%b$N\x19\xf4\xd4=\xa8a\xea\xc1\x1a\\2\xbfB\tm;\xfb'
 b'\xe6g\xbe\x00i\xae\xc8@\x8e\x86\xbfv\xa5')

{'A1': {'B1': 221,
        'B2': -0.9938617700019918,
        'B3': {'C1': 48565,
               'C2': [{'D1': -1811370728, 'D2': -35},
                      {'D1': -1056766907, 'D2': -3}],
               'C3': [5194714452269801909,
                      3770567907595992540,
                      2654040791675299922],
               'C4': 3240794919751283097,
               'C5': 0.0503866970539093,
               'C6': 31980,
               'C7': [113, 208, 220, 253]},
        'B4': 4189922440,
        'B5': 15344917653766677793},
 'A2': -0.4040781134299165,
 'A3': {'E1': 3932268605,
        'E2': [6849, 12892, 17087, 27913],
        'E3': 59,
        'E4': -0.2264670580625534,
        'E5': -0.011013513683611809,
        'E6': 118,
        'E7': -91},
 'A4': 238651833}

(b'\xfcYBFU9\x00\x00\x00@\xb5\x86{V\x13\xa3\xbfn\x00\x94S\xc13n\xff08H'
 b'\xaf\xe56\xa45{\x84\xe5;>#\xad\x9d\xb6\x8e\xf4\xa3FnpG?+\xfa\xac\nQ\x98'
 b'\xa2\x89@\xda\xfbK\x9d>\xdc?\xce\xff\x02\x00\x17\x00\x00\x00\x03\x00'
 b'\x00\x00!\x00\x11O\x0cr3K\x88\xdd>\x12c?\x12\xb0-\x9b\x7f\xc0o\xc0p\x1c\xd7/'
 b'\x12\x16\xe7\x9f\xc7\x03\x87|\xa6\xdd\xef\xf6 \xf7ZB\xd0\xda\xca\xad\xf2X?P'
 b'=d\x94i\xc1\xca?pk')

{'A1': {'B1': 137,
        'B2': 0.44132168216984624,
        'B3': {'C1': 65486,
               'C2': [{'D1': 942735214, 'D2': 72},
                      {'D1': -1539906129, 'D2': 53}],
               'C3': [-7084967888584080261,
                      5147735623761956534,
                      -6730540536811607233],
               'C4': -2483652510166003951,
               'C5': 0.8869971036911011,
               'C6': -20462,
               'C7': [45, 155, 127, 192]},
        'B4': 477151343,
        'B5': 272362117335756759},
 'A2': -0.037256910876161786,
 'A3': {'E1': 3718675591,
        'E2': [63215, 63264, 16986, 56016],
        'E3': -54,
        'E4': 0.8474529385566711,
        'E5': 0.20902747865373295,
        'E6': 112,
        'E7': 107},
 'A4': 868307860}

Вариант №38

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

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

(b'TTIM\xa0\x1f\x000\x00?\x00O\x00\x00\x00\x08\x00d\x00l\x00\x00\x00w'
 b'\x00\x00\x00\xce\xc5\x8bm\x13\xd2\xf1v<C\xbf\x04\x00\x00\x00\x1b\x00'
 b'\xb7\x9d\xe5\x80}\xe3\x83u\xd3y\xbf\x04\x00\x00\x00,\x00\xf2\x16i_z\xaf1'
 b'h?\x02\x00\x00\x00=\x00?\x91\xae\x91\xac_~Q\xa3\x06\x96\x7f$\xc2t\x86'
 b'\x03\x00\x00\x00L\x00\x00\x00D%rE\xd4\x84\x1d\x04\x9cOW\x14\xc1U0\t'
 b'\xb3\xf9"\\\xee')

{'A1': [{'B1': 19,
         'B2': 61906,
         'B3': -0.7626413106918335,
         'B4': [206, 197, 139, 109]},
        {'B1': 125,
         'B2': 33763,
         'B3': -0.9758828282356262,
         'B4': [183, 157, 229, 128]},
        {'B1': 105, 'B2': 31327, 'B3': 0.9070081114768982, 'B4': [242, 22]}],
 'A2': {'C1': -7636236547752219503,
        'C2': 127,
        'C3': -2039168476,
        'C4': [63, -111, -82]},
 'A3': [68, 37, 114, 69, 212, 132, 29, 4],
 'A4': {'D1': 662123432981778332, 'D2': 63923, 'D3': 34},
 'A5': {'E1': 92, 'E2': -18}}

(b'TTIM\xa0\x1e\x00.\x00=\x00L\x00\x00\x00\x07\x00a\x00h\x00\x00\x00s'
 b'\x00\x00\x00\xeec\x13?\xd2f\xc4De\xbf\x03\x00\x00\x00\x1b\x00\x0c\x00DX\xaa'
 b'\xa6\x98\x0c%\xbf\x03\x00\x00\x00+\x00\xe9![\x91wF\x88-?\x02\x00\x00\x00'
 b";\x00y:\xa3k\xb5\x17\x03i\x98\x0e'\xc7\x0c|\xc7\x02\x00\x00\x00J\x00\x00"
 b'\x00$.^\xdf`k\xe0\xa7\xd0\xd2WB\xd5t\xf4X\x04\xdb\xf0\x02')

{'A1': [{'B1': 63, 'B2': 26322, 'B3': -0.895580530166626, 'B4': [238, 99, 19]},
        {'B1': 88, 'B2': 42666, 'B3': -0.6447234153747559, 'B4': [12, 0, 68]},
        {'B1': 91, 'B2': 30609, 'B3': 0.6778606176376343, 'B4': [233, 33]}],
 'A2': {'C1': 1051705974994594723, 'C2': 39, 'C3': -948171577, 'C4': [121, 58]},
 'A3': [36, 46, 94, 223, 96, 107, 224],
 'A4': {'D1': 17614938523470844071, 'D2': 1112, 'D3': -37},
 'A5': {'E1': -16, 'E2': 2}}

Вариант №39

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

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

(b'\xabHFA?\xb91\xe1J\xdb\xf5P\xdb\xa1\xda\r\xf7X73\x00\x00\x00H\xfbw\xe6f'
 b'\xac\x81\x00\x05C\x90|o\xb2\x83Nf_6\xf8@\xeef%\xe4\xbe\x83\xa1\xf1'
 b'\xd2<\xee\xb6\x8a|\xbfv\x06\xf2[\x000\x005\x00:\x1a\xba\x06\x00\x03\x00\x00'
 b'\x00?\x8dr\x16t\x92\xae\xf5\xe3n\x1b\x8b\xfd.4\xdc\x91\xfb\x99\xd8nQ\x9b'
 b'j\x07\x9aO:\x97\xbf\x82`\xc3:\x06\xe3\x00\x00\x00\x03\x00E')

{'A1': 0.09841735913865546,
 'A2': {'B1': 15826170319075817267,
        'B2': {'C1': [{'D1': -0.2570948898792267, 'D2': 210},
                      {'D1': 0.029139775782823563, 'D2': 124},
                      {'D1': -0.9610434770584106, 'D2': 91}],
               'C2': {'E1': [2373064308,
                             2460939747,
                             1847299069,
                             775216273,
                             4221163630,
                             1369139719],
                      'E2': 154,
                      'E3': 20282,
                      'E4': [38847, 33376, 49978, 1763],
                      'E5': [26, -70, 6]}}},
 'A3': [-326539119305883643, 4868528016365669990, 6860944040106796516]}

(b'\xabHFA?\xea\x10\xa9\x90O-\xcc:4uz\x84E\xd5\xd9\x00\x00\x00APg\xf2\xa8'
 b'_4\xe1s\x87-3Oy\xb9\xdcNL\xf1b||\xb0\xf64?\x0c?\x063?\x00g<\x93\x000'
 b'\x005a\x11\xa3\x00\x02\x00\x00\x00:\x18e\x037{\xd8G>\x7f,\xbb\xed7'
 b"'\x8b\x97\x0eBY\x94\x17{\xbf\xc3\xe6\xf5$[\xc1Yz|<\x99\xaa\x00\x00"
 b'\x00\x03\x00>')

{'A1': 0.8145339792767401,
 'A2': {'B1': 4194106322054403545,
        'B2': {'C1': [{'D1': 0.5478366613388062, 'D2': 51},
                      {'D1': 0.501575231552124, 'D2': 147}],
               'C2': {'E1': [409273143,
                             2077771582,
                             2133638125,
                             925338519,
                             239229332,
                             393985987],
                      'E2': 230,
                      'E3': 62756,
                      'E4': [23489, 22906, 31804, 39338],
                      'E5': [97, 17, -93]}}},
 'A3': [5793866250601161075, -8706246088199644082, 5544320903077230132]}

Вариант №40

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

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

(b'DCCU\x03V\x00\x00\x00\xe2#\xf5\xcd%\x0ch\xb8\xac\xe0m`\x00u\x00epr\x8a'
 b'\x00\xc6\x85S\x9d\x19c\xe4\xc9JW\xb8\x04u\x87(\x11\x08\x19\xfc6\x93\xf3\x83'
 b'\x95\xdb\x81ac\xfec<7\xd1J\xf0A\xe7\xd5\xc1\x01>\xa0HE[}r(\xa4\xc5{\x90yo<'
 b'\x8d\x955\x8e\x99\xcb\xdd\xd6\xfaf`{\x95\x10\xe5l\x04+s\xbc?,}\xb3'
 b'\x86\xbdr\x08\xed"\xdd=UL\xde]\xd3\x10>"\xe4\xbf~\x97\xce(0H\x9a\xc5\xce<'
 b'\xb8L\x12\x9f\xe3\xb3\x85k\xe3?\xfb\x87\x8a\xd8\x16')

{'A1': {'B1': -29131, 'B2': -690107495, 'B3': 2069915386},
 'A2': {'C1': -839572510,
        'C2': 3109,
        'C3': 104,
        'C4': 1843440824,
        'C5': [{'D1': 149,
                'D2': {'E1': 0.11113232477227464,
                       'E2': 44,
                       'E3': -1115245699,
                       'E4': 585959538,
                       'E5': -35},
                'D3': 21821},
               {'D1': 76,
                'D2': {'E1': -0.6291799858690259,
                       'E2': 126,
                       'E3': 807980695,
                       'E4': -825910712,
                       'E5': 60},
                'D3': 19640}],
        'C6': 'epr',
        'C7': {'F1': 0.6068752778491862,
               'F2': -30725,
               'F3': -118,
               'F4': 216,
               'F5': 22},
        'C8': {'G1': [-31290, -25261, 25369, -13852, 22346, 1208, -30859, 4392],
               'G2': -7673021526500959992,
               'G3': [1667334619,
                      926704638,
                      1106266833,
                      29480423,
                      1162387518,
                      678591835,
                      -1870936668],
               'G4': 2369548153,
               'G5': 149}}}

(b'DCCU\x03V\x00\x00\x00\xdf\xbb\x81*q\xc8\x18\xc0!\xde\xa1`\x00u\x00cbu\x8a'
 b'\x00\xb4\xb5\xea\x04\x87\x03\xcfK\xda\xec6\xacU&\x91\x95\x8c\x7f`\xc1\xdf:c'
 b"\x8c\x1c\x01\xb7\xf98\xda\x87\xa1'\xc4\xf9i\x1f\xc1\xe7F\x9a\x11@c\x93Y\xae"
 b'|S\xd2\x1e\xa6\xb0Uk\'{$&eu\xfc\x0f\xe3T\x9f\x9d\xdd(\xc8Y"@\x9f\xcd'
 b'?\x98\x7f"\x8f\x04U\x8a\x14\x9b\x9d\xdb\xd2/\\WM\x7f\x0e@\xdc\xbf\x87\xf0'
 b';\xa0\xcf\xee\xd0\x92\x01\x01vY\xe8\xcdw\x1f\x08\x08\xdf?\x0e\xc5M\x1cM')

{'A1': {'B1': 9764, 'B2': 268203365, 'B3': 2644464867},
 'A2': {'C1': 713145311,
        'C2': -14223,
        'C3': 24,
        'C4': 2715689408,
        'C5': [{'D1': 221,
                'D2': {'E1': 0.23142244031220227,
                       'E2': -104,
                       'E3': 76489343,
                       'E4': -1693152683,
                       'E5': -99},
                'D3': 53979},
               {'D1': 47,
                'D2': {'E1': -0.4414097064194402,
                       'E2': -121,
                       'E3': -811582480,
                       'E4': 26398958,
                       'E5': 1},
                'D3': 22902}],
        'C6': 'cbu',
        'C7': {'F1': 0.4848652179054782,
               'F2': -15090,
               'F3': 77,
               'F4': 28,
               'F5': 77},
        'C8': {'G1': [-19020, 1258, 903, 19407, -4902, -21450, 9813, -27247],
               'G2': -8330750153008840820,
               'G3': [-105447140,
                      -1584932296,
                      1777976359,
                      1189593375,
                      1665143194,
                      2091800979,
                      -1507929517],
               'G4': 661345712,
               'G5': 123}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поле	Описание
1	double
2	Структура B
3	Массив int64, размер 3

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

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