ИВБО-08-22

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

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

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

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

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

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

(b'BTE\x95s\xa8`\x1e\x9ff\xa4\x05\x00\x00\x00\xa2\x00\xa5\xe0\xd4\x1cA\xab\xba'
 b'\x8b\xe3?\xba\xd2`\x1d\xc6\xff\x0b\xf3\xc4? l\x0c\xd1\x8d\x9aP5\xde?ffkza'
 b'asx\xdfg\xa9.\xb8b\x8f77\xbc\x97\xcd\xd4k\xb9m\xec\xbaR\xc8Bq\x06l\x1c'
 b'\xd6\xebz\x89\xd3\x13\xef|\xf2[tj\xc9\x7f\x81V\xa5\xda\xeb\xd0'
 b'\x1c\xf3\xea\x1f\x15\xc5v8\x88\xe47\\V\xea\x82\xdc\x06\x083\xdd?_G\xa2'
 b'\x82\x1e9O\xf2[\t\xf7\xf6X&`\x8e{g\xbf\xb7TK|M\xa59\xa1\xf1|\x7f\xb9.\xa7(d'
 b'/\xe7e\xca\xd8\xbfqufek')

{'A1': {'B1': 1621652373, 'B2': 2758188830},
 'A2': 'qufek',
 'A3': [{'C1': -8027, 'C2': 0.6108067841350029},
        {'C1': -11590, 'C2': 0.16366720189055695},
        {'C1': 27680, 'C2': 0.47200408070718036}],
 'A4': 'ffkzaasx',
 'A5': 782854111,
 'A6': -3632227629109648712,
 'A7': {'D1': [14434805280291777492,
               8857408509714002242,
               8384561749681230729,
               16995077934794393962,
               8558269893717466320,
               9433447323555629112,
               5142899518756882140],
        'D2': 162,
        'D3': [1329143426,
               -150381582,
               1613125878,
               -1083737202,
               2085311671,
               -1590057651,
               -1182827279],
        'D4': 42798,
        'D5': -0.3873533971469123}}

(b'BTE%\xe0\x865\xf6\x07\x95\xc0\x04\x00\x00\x00\xa2\x0029t\x82\x91\xc1\x8f'
 b'q\xe1\xbf\xc0\xa8\x0c\x8cd\x00E\x15\xe8?\x81\xe50\x7fJZ\x10#\xb7\xbfhdtqi'
 b"evr'\xa0\xd9q\xf0E\xf5[\xc5\x9c\x8bC\x91\xccP9\x94W\x04lx0-\x1f\x18"
 b'\x86\xd7\x1a\x11M\xb4q\x90\x1d\xb4}\x14]\xa2\xcc\xbf3J\x07\xc9\xf9\xb3)\x0e'
 b'\xe7\xd25z\x1b\xdbo]\x17L\x1d\xc2\xfb\xd3\xb44a\xf8\xa2Zn\x97s\xab\xac;\xbbm'
 b'\x84~\xb3\xb4\x9d\x8bC\xa4\x14kh\x9d\xfc\xba\xc6\x03\xf1e\xe2\xf5'
 b'\xfa\x14\xd0\xc4\x9f\xfdKr\xc8?bdhp')

{'A1': {'B1': 898031653, 'B2': 3230992374},
 'A2': 'bdhp',
 'A3': [{'C1': 14642, 'C2': -0.5451124935753584},
        {'C1': -22336, 'C2': 0.7525963790579921},
        {'C1': -6783, 'C2': -0.0903787823140163}],
 'A4': 'hdtqievr',
 'A5': 1910087719,
 'A6': 4867156193769244144,
 'A7': {'D1': [7783442350131432593,
               1934162003139309688,
               9057897256769047825,
               525289205407046932,
               3878416277134637513,
               2111088015405947770,
               11743242907368553410],
        'D2': 90,
        'D3': [-1418487954,
               1840987052,
               -1263305084,
               -1539077219,
               -1654101228,
               63355644,
               -169712143],
        'D4': 5370,
        'D5': 0.19098806270588975}}

Вариант №2

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

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

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

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

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

Поле	Описание
1	uint64
2	int32
3	int64
4	float
5	double
6	int8
7	int16

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

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

(b'WFEV~\x9d\xae\xd9\xd1Y\x042^\x03\x00=\x00\x00\x00C\x00!\x8b\x05\xbft\x00\x00'
 b'\x00\x92\x00\x00\x00\x1f\xd3d{v\xc4MFoDO\xf3\x7f\xebBqJ.B\xcb0\xea\xef'
 b'?\xb0\x00\x00\x00\xe5\xb3*}p\x81\xfbs\xeeC.0\xbc@)\xf8\xfe\x97{]\xaa\xc17'
 b'\xbb\x11wg\xf5M\xbf\xf8m*p\xb4\x08\xd8\xbf\xce)ec\xe7\xb14@\x124(\x8f\xbe'
 b'\xa8o\xeb\xbe\x02\x00l\x00\x011\x01\xfeE.\xdd\x1c\xcd\xa2\xadp"X\nx'
 b'#\x97\x10S\x8e\xbe\xe9\xfde\xbf\x02\x00\x8a\x00\t\x0e\xea9\xd0\x10'
 b'\x03\xdc\xc3z\x98e\x8dzV\x12en\xf9\xc8\xe2=\xd7\x84i\xb6T\x02\x00\x00'
 b'\x00\xa8\x00')

{'A1': 6787492372220063389,
 'A2': [46053, 32042, 33136],
 'A3': {'B1': {'C1': {'D1': 4664656289315320827,
                      'D2': -1744898007,
                      'D3': 8579844613264268667,
                      'D4': -0.8045257925987244,
                      'D5': -0.3755313010567245,
                      'D6': -50,
                      'D7': 25897},
               'C2': -6301,
               'C3': 306197681},
        'B2': -0.5216541886329651,
        'B3': [{'E1': [-0.27960360050201416, -0.4598362445831299],
                'E2': 12545,
                'E3': 1,
                'E4': 17918,
                'E5': 46,
                'E6': -1563616035,
                'E7': 10890680309735649453},
               {'E1': [-0.27797746658325195, -0.8984056115150452],
                'E2': 3593,
                'E3': 234,
                'E4': -12231,
                'E5': 16,
                'E6': 2059656195,
                'E7': 7954784479452423576}],
        'B4': 5065921169017066271,
        'B5': 8161344409524192367},
 'A4': 0.9973377199070879,
 'A5': {'F1': 84, 'F2': [1038272761, -1234598697]}}

(b'WFEV~\xa4\xb1\xc2\x06\x9d\xa7\x1e\x0e\x02\x00=\x00\x00\x00A\x00\x19\xbdN'
 b'\xbfr\x00\x00\x00\x90\x00\x00\x00\xb1=\xda\x93Qt\xe2\x19\xf4\x9f?\xa4R\xe8"'
 b'\x84\x80\xa0\xfa\x17\x9b<\xdc?\xae\x00\x00\x00\xf5-*\x9b\xb1I8'
 b'\xe4\xa2\xd4\xd4\xdd\x00\xaf^;I@apT\xe9\xad\xc1\x89-n\xbfX\x87A\xbb\x0ey\xc6'
 b"?\xf1\xff'\xdf\x16G\xf9\xd0B\xf3\x12\x11\xbd\xe5&\xae\xbe\x02\x00"
 b'j\x00\x8e\xbbMia3\\zV\xcer\xd3Z\xa3\xb5\x13\xf16\x0f\xec:\xbe\xc6S\xfd\xbe'
 b'\x02\x00\x88\x00?\x88!\xe7\xc1\x93\x96e\xb3\x8f\xd87\x87Z\x05\xfb'
 b"\xf9\xa7.\xa3>\x83\x1a'\x83_\x94\x02\x00\x00\x00\xa6\x00")

{'A1': 1017434858697437604,
 'A2': [11765, 39722],
 'A3': {'B1': {'C1': {'D1': 15984634773523417521,
                      'D2': 996060928,
                      'D3': -4490676704546570167,
                      'D4': -0.9303823113441467,
                      'D5': 0.17556938308103542,
                      'D6': -15,
                      'D7': 10239},
               'C2': 5855,
               'C3': 1120991559},
        'B2': -0.8075729012489319,
        'B3': [{'E1': [-0.03541846200823784, -0.3401404917240143],
                'E2': -17522,
                'E3': 77,
                'E4': 24937,
                'E5': 51,
                'E6': -833193380,
                'E7': 3958967218286023538},
               {'E1': [-0.1825411170721054, -0.4947797656059265],
                'E2': -30657,
                'E3': 33,
                'E4': -15897,
                'E5': 147,
                'E6': -1884068458,
                'E7': 12103981473947138008}],
        'B4': 1865181089406533041,
        'B5': -8925316069854306316},
 'A4': 0.4411990865869555,
 'A5': {'F1': 148, 'F2': [-2093046994, 1602430746]}}

Вариант №3

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

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

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

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

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

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

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

(b'KSCS\xcd0\x00\x06\x00\x00\x00:\x00\x00\x00\x9b6\x81\xb4\x0f\xda\x11C\xd6'
 b'\x02\x00\x9a\x00\x00\x00\x0cTA\xde\x12\x00\x18\x97\xfe\xf5\x0e\xc9C\xdc'
 b'\xc0<zz\x02\x00\x00\x00.\x00\xf8y)\xbf\x02\xe9\x952Q\x1dQ/\x9e\xcc'
 b'\x80\x14<\x8a\x0fI\x0f\x9bVK \x80\x1f\x19k\xb6\x16u\n\xba\t-HUX\xc9\xf8\x82'
 b'\x80-\xb0\xef\r\x0f%\xc2\xa14\xb9\xf1h\x8c\xe8\xad\x95q\xeaw\x9b\xb9\xfbg'
 b'\x919\xc0y\x0c\x9d\x8f\xde\x9dZ\xba\xba\x9e_\x9f\xb5\xccTf\xc9'
 b'\xdd\xe2\xdc\xf0\xd3\xc6/=Vv\xd7\xa4\xca\xceM\x99')

{'A1': {'B1': 'zz', 'B2': -0.6620173454284668},
 'A2': {'C1': [{'D1': [2, -23, -107, 50, 81],
                'D2': 29,
                'D3': 12113,
                'D4': 5264578480066055326},
               {'D1': [15, -101, 86, 75, 32],
                'D2': -128,
                'D3': 6431,
                'D4': 3245329560574015083},
               {'D1': [72, 85, 88, -55, -8],
                'D2': -126,
                'D3': 11648,
                'D4': 3792525825644818352},
               {'D1': [-71, -15, 104, -116, -24],
                'D2': -83,
                'D3': 29077,
                'D4': 4148211062633363434},
               {'D1': [-64, 121, 12, -99, -113],
                'D2': -34,
                'D3': 23197,
                'D4': 6110458490543585978},
               {'D1': [102, -55, -35, -30, -36],
                'D2': -16,
                'D3': 50899,
                'D4': -3545840511290557137}],
        'C2': 4832883636132984475,
        'C3': {'E1': -42, 'E2': [77, -103], 'E3': 10887452180206408716},
        'C4': 4377741021498242558}}

(b'KSCS\xcd0\x00\x07\x00\x00\x00:\x00\x00\x00\x98\xf63\x15\xe08\xce\xba\xa4'
 b'\x02\x00\xaa\x00\x00\x00\x1ciS8C\x1f\x0bL\x9b(\x00\xb7\xba":\x04xe'
 b'\x02\x00\x00\x00.\x00\x00.\x01\xbfEI\xde\xdb\xecV\x80}0\x85\xdf\xda\x1d+'
 b"a\xdeF\x1d.z\xc9},\x8a^\x99\xb8\x1fzC;'\x9d\x9d\xdd\x04\nW\xf3\xb6\xac\xc1"
 b'\x1b\x9e\xebV\xe1eR\xf9o\xe4\xac\xdb\xe5\xfdp\xbf:\xd6\xe9N{\x01\x15\x98'
 b'\x7fL\xef\xa3\xa1.`\xe4,q}*\x85O\xd4\xd9\xb27\x9b\xfe7\x93&\xad\x02Ie9'
 b"k\x82(\x0474\xdf'<\xbd\xc8\xb2\x18\x85\xaf\xa9\x87\x15\x07\x9c")

{'A1': {'B1': 'xe', 'B2': -0.504608154296875},
 'A2': {'C1': [{'D1': [69, 73, -34, -37, -20],
                'D2': 86,
                'D3': 32128,
                'D4': -2422607717322488528},
               {'D1': [70, 29, 46, 122, -55],
                'D2': 125,
                'D3': 35372,
                'D4': 2826927382902380894},
               {'D1': [-99, -99, -35, 4, 10],
                'D2': 87,
                'D3': 46835,
                'D4': 7341244437560541612},
               {'D1': [82, -7, 111, -28, -84],
                'D2': -37,
                'D3': 64997,
                'D4': 106765782401859440},
               {'D1': [21, -104, 127, 76, -17],
                'D2': -93,
                'D3': 11937,
                'D4': 5730032819156870240},
               {'D1': [-44, -39, -78, 55, -101],
                'D2': -2,
                'D3': 37687,
                'D4': -9049075919091487450},
               {'D1': [40, 4, 55, 52, -33],
                'D2': 39,
                'D3': 48444,
                'D4': 1551395167969784520}],
        'C2': 13460758871336547992,
        'C3': {'E1': -92, 'E2': [7, -100], 'E3': 5479507745194600732},
        'C4': 304594110130432155}}

Вариант №4

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

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

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

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

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

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

(b'YATJ\x04\x00\x00\x00\x02\x00\x00\x00\x1d\xbb%\xbc>JU\xbb\xf6\x00\x07\x00'
 b'\x00\x00_\x00\x7f\xb5\x84\xf6\xac\xecrn\xa7n\xb8\xf4\xc5\x0f\x1a\xfe'
 b'=\xa3\xfe\xd5 9\xa5P+@\xfc\xee\xda\x81R\xea\x8d\xd7)t\x0f\xf8\xfc\xc8'
 b'\xcb\x9e]";\xbe\xef\x0f\xed\xb0\x88\xf8\xec\xc8jVi{\xaf@\xa7j\xe9.'
 b'\xdc\xd9y\x0b\xb9^\xd8\xa1\x81\xa4q\x0f\xe4\xed8\xc2\xeb\x83\x98\x1c'
 b'\x15\xe0\xf5\x882\xf6Q\x18\xafC\xad\x18\x8a\x01\xc2\x9d\x00\x00\x00\x02'
 b'\x00{\xa5\x920~')

{'A1': [{'B1': {'C1': [46468, 63148, 60530], 'C2': 7973463405942345498},
         'B2': -451,
         'B3': 11817116806649565227,
         'B4': [64, 252, 238, 218, 129, 82, 234],
         'B5': -29225},
        {'B1': {'C1': [10612, 4088, 64712], 'C2': 14672267037632294671},
         'B2': -4688,
         'B3': 9869898928904104315,
         'B4': [175, 64, 167, 106, 233, 46, 220],
         'B5': -9863}],
 'A2': 3139812414,
 'A3': 19029,
 'A4': -69,
 'A5': 246,
 'A6': [196697816,
        -1585339279,
        266661176,
        -1024752744,
        471195893,
        -2009926063,
        414139309],
 'A7': {'D1': -99, 'D2': [6282, 450], 'D3': 2777821310}}

(b'YATJ\x04\x00\x00\x00\x02\x00\x00\x00\x1d=\xefJ\x9c\x0f\xe26\x8c\x00\x05\x00'
 b'\x00\x00_\x00w\x7fc\x87 \xb9\xf5e\x9c\x98\xaf\x8d\t\xa1\xe4.\xab-\xa1\x12'
 b'2\xc6\xc6\xf9+\xe5\xde\xa2\x16\xf5\xf9\xf0\xaa\xfe\xcc\x0cL\xcez\xfeX\x984i'
 b'\xe2\xec\xb2\xb5\x17;\xf6y2\x11R"\xf8\x1d\xdb\x16\xe9\xf2w\x0c\xf1\xc8]\x12'
 b'Q\xc1\x9dd\xec\x8a0H\xc6\x15\x93\x02\xcd8t)\xcc\xc52QW\x17P\xc2'
 b'\x00\x00\x00\x02\x00s\x1d\xfc\xb3\xa8')

{'A1': [{'B1': {'C1': [32611, 34592, 47605], 'C2': 7321894973950501348},
         'B2': 11947,
         'B3': 3287929212249766187,
         'B4': [229, 222, 162, 22, 245, 249, 240],
         'B5': -21762},
        {'B1': {'C1': [52236, 19662, 31486], 'C2': 6383910101181051573},
         'B2': 5947,
         'B3': 17760281655486117917,
         'B4': [219, 22, 233, 242, 119, 12, 241],
         'B5': -14243}],
 'A2': 1039092380,
 'A3': 4066,
 'A4': 54,
 'A5': 140,
 'A6': [307347869, 1693223472, 1220941203, 47003764, 701285682],
 'A7': {'D1': -62, 'D2': [20823, 5968], 'D3': 503100328}}

Вариант №5

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

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

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

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

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

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

(b'LDWD[3\xees\x00(\x00\x02\x00/\x00g\xb0\x1al\x8c\xaf\xf3QE\xd7gw\xff'
 b'\x1f\xa5\xd5B\x85QUJ\xab\xd6\x8c\x83tef\x00\x03\x00\x10S2\xbc,\x08'
 b'\xd3\x1b\xdb[\xa9\t\x03.`\x96\xfd\x81/DOs\xfe\xe3\xd7\xfbJ\xab\\s'
 b'\xa1\xd1\x99\x97\xfd\xf0&l\xe4\xf7\xd7\x8d\x00\xb7\x9e\xe4\x96\xd5\xcc?'
 b'L\x87]\xbe\xad\x1a1\x00\x00\x00\x05\x007>\xf4\xde\xa9\x00\x02\x00\x00\x00_')

{'A1': 1530130035,
 'A2': {'B1': 'tef',
        'B2': [-5757169822136577723,
               -2925237495322520254,
               -8840190814352667517]},
 'A3': [{'C1': 21298, 'C2': -17364}, {'C1': 2259, 'C2': 7131}],
 'A4': {'D1': [6604820237783176957,
               -9138010010872257577,
               -339270408347725415,
               -7494570157048268841,
               -8286421421293906484],
        'D2': 0.478261262178421,
        'D3': [0.7989404797554016, -0.3380904495716095]}}

(b"LDWD\x11C\x05\x12\x00 \x00\x03\x00'\x00[\xa3\x16\xc6\x0f\xa8I\x84\x08"
 b'\xdb5J\xa0\x88\xcc\xb8\xc6pjj\x00\x02\x00\x10E\xc7\xa8o\x8085\xb1m\xf5zw%'
 b'*c[+\x9a#\xc7 ;^\xa6&\x91\x97T>u\xde\xdb\xb4\x8c/\x92\xb0R4\x8a\x92'
 b'\xe9\xcf<?ZpT\xbe\x0b\xc7\x03\x00\x00\x00\x04\x003\xbdhn\x9d\x00\x02\x00'
 b'\x00\x00S')

{'A1': 289604882,
 'A2': {'B1': 'pjj', 'B2': [-6694946025489464312, -2651130752287328058]},
 'A3': [{'C1': 17863, 'C2': -22417},
        {'C1': 32824, 'C2': 13745},
        {'C1': 28149, 'C2': 31351}],
 'A4': {'D1': [2678062171649876935,
               2322554100544280404,
               4500748437834968978,
               -5741468805169033412],
        'D2': -0.056746114045381546,
        'D3': [0.8532764911651611, -0.13650135695934296]}}

Вариант №6

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

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

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

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

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

Поле	Описание
1	int16
2	int8
3	float
4	uint64
5	int64
6	uint16
7	int8

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

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

(b'FXTW\x88\x00\x00\x00U\xbf\xe7(\xe9\x8d\x8a\xd8L?\xef\xd9\\\x8c@\xcb'
 b'\xc2\x00\x02\x00i\xf9>\x0e<\xe9d\x17=\x00\x03\x00q}?\x1fU\x06UN\xdf>BE'
 b'\xf9\x9b\x16\xefyuz\xd9QN?/z<\x86x\xde\xf5\x9a7\xb5D\xf4V\r\x15\xc0\x06'
 b'\xc2\xf4\xd4\xe1H\xbf\xd6\x98\xfb*\xa5\xa8\xdc\x00\x03\x00\x00\x008>'
 b'\xb9\x8bN\x00;\xb2\xa5\xa0\xf5\x86\x9d\x0cf\xff\x08zg\x80a\xb7\xc5\x9b%\x81'
 b'\xac')

{'A1': {'B1': -0.35308722653156877,
        'B2': 'yuz',
        'B3': {'C1': 0.36239093542099,
               'C2': {'D1': -9903,
                      'D2': 78,
                      'D3': 0.6854588985443115,
                      'D4': 9689739744723318084,
                      'D5': -840469893390875916,
                      'D6': 54497,
                      'D7': 72}}},
 'A2': -0.723744179201057,
 'A3': {'E1': 0.995283388072828,
        'E2': [{'F1': [-1297768203, -2036528026],
                'F2': 249,
                'F3': 0.13890422880649567,
                'F4': 100,
                'F5': [23, 61]},
               {'F1': [-16221593, -2141079611, -1692040788],
                'F2': 125,
                'F3': 0.6223911046981812,
                'F4': 85,
                'F5': [78, 223]}],
        'E3': 0.1897200495004654,
        'E4': -25834,
        'E5': -17}}

(b'FXTW\x88\x00\x00\x00X\xbf\xa8\x1e\x0e\x84\xeb\xac@\xbf\xbd\x80[<\xe9\xe8'
 b'0\x00\x04\x00l\xd8\xbf\x14\x8e\x0c\xa2\xd7\x87\x00\x02\x00|m?]'
 b'\xe3\xd3\xd8\x1b{\xbe\x1c>DJ\xa3\x1bnjviur\xd2\xb2\x06?_\xbfq=\xd1f'
 b'\xdc\x0b\x98C\xee\xc3J\xf4\xdb.\xc76\xb3\xd8+\xcd?\xb1\xa9\xd1\xd4F\xb5\xc0'
 b'\x00\x06\x00\x00\x008>\xf9.2\x00>\xafXHB`\x95\x89G\x80\x10\xc7\xbeF\x1di\xf0'
 b'\xd9\xf0%\xa30pwY')

{'A1': {'B1': 0.06899749214672735,
        'B2': 'njviur',
        'B3': {'C1': 0.4866805672645569,
               'C2': {'D1': -11598,
                      'D2': 6,
                      'D3': 0.8740149140357971,
                      'D4': 4454454601719497710,
                      'D5': -4374414865817192781,
                      'D6': 55339,
                      'D7': -51}}},
 'A2': -0.047104314542445014,
 'A3': {'E1': -0.11523981320525034,
        'E2': [{'F1': [-1353168830, 1620412743, -2146383938, 1176332784],
                'F2': 216,
                'F3': -0.5802924633026123,
                'F4': -94,
                'F5': [215, 135]},
               {'F1': [-638573149, 812676953],
                'F2': 109,
                'F3': 0.8667575716972351,
                'F4': -40,
                'F5': [27, 123]}],
        'E3': -0.15258127450942993,
        'E4': 19107,
        'E5': 27}}

Вариант №7

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

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

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

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

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

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

(b'TEYF3\x17OtbE\xcc\x1d\xb8\x008gyb\xbe\xbc\xc3\x9e\xa8\xa7\xe5\xae\x93\xd6'
 b'5\x9aA\x15\xff\xe7\rk\xc6\x06\xc8#X\xa3\x89\xed=\x00\x91T\x0c\xe0\xc9\xa3'
 b'\xdc\xa0\xa1*\x00\x00\x00\x0f\x00\x00\x00\x03\x00\x00\x00\x16p#\xaf\x9e'
 b'\xe7p\x05\xe9R\x90\x00\x00\x00\x05\x00\x00\x00\x1c\xb7\xe0\xa2\xe2|\xd1'
 b'o\xd6\xef\xe1\x00\x00\x00\x03\x00\x00\x00&\xdc\xcd%!{\xabf\x02\x07$\x00\x00'
 b"\x00\x06\x00\x00\x00,8|/$\xc3\x83\x9c\xf4^b\x9d'k\x1dNPT\x0b\xda\x89?\xe1"
 b'\xcc\x00\x9d\xb7\xf4"\x14\xd4EN^\x1c\xb4,\xe2\x91')

{'A1': 5058412436489651660,
 'A2': 7608,
 'A3': {'B1': {'C1': 'gyb', 'C2': -0.368679940700531},
        'B2': [{'D1': [43175, 58798, 37846],
                'D2': 28707,
                'D3': 12654806471279202960},
               {'D1': [13722, 16661, 65511, 3435, 50694],
                'D2': 47072,
                'D3': 11737080817847300065},
               {'D1': [51235, 22691, 35309],
                'D2': 56525,
                'D3': 2675555629715818276},
               {'D1': [15616, 37204, 3296, 51619, 56480, 41258],
                'D2': 14460,
                'D3': 3397054988985589346}],
        'B3': [-99, 39, 107, 29, 78, 80, 84, 11],
        'B4': -9591,
        'B5': 0.5561526375237273,
        'B6': 1500900778709922860,
        'B7': [-30, -111]}}

(b'TEY\xaf\xa9\x15\x1c\xda\xa3\xd0\x10Z\x08\x00@yjc\xbe\x9c\x89fSe\x87\x04\xb9s'
 b'\xc8\x18D1\xd8H\xff\xed.\xa4\x06\xba\x88#7\xef\x9a\x93\x15\x83'
 b'\xa9\x1d\x10\x14\xb8\xc7_\xf9\t\x95\x9c\xca\xaf\x1c(V\x00\x00\x00\x0f'
 b'\x00\x00\x00\x02\x00\x00\x00\x16\x91\x8f\xe9FD\xdf\xab\xba\xae8\x00\x00'
 b'\x00\x06\x00\x00\x00\x1a\xc1\xcc\xe1\xdf\x10\xac\xa9\x14\xeb '
 b'\x00\x00\x00\x07\x00\x00\x00&\xbcu\xad\x03z\xb7\x96\xfd7]\x00\x00'
 b'\x00\x06\x00\x00\x004\x92\xc4\x87\xe2L+z\xa1\x93LU\xebu\xd3\x80\xa9\xe8\x1b'
 b'\xd3\xc7?\xeb6z\t!fBH\xd5\xb0\x89\x7f\xd1\xe8]\x8f\xdb')

{'A1': -5789072632336625648,
 'A2': 23048,
 'A3': {'B1': {'C1': 'yjc', 'C2': -0.3057357668876648},
        'B2': [{'D1': [21349, 34564], 'D2': 37263, 'D3': 16809198386656489016},
               {'D1': [47475, 51224, 17457, 55368, 65517, 11940],
                'D2': 49612,
                'D3': 16275745912097401632},
               {'D1': [1722, 34851, 14319, 39571, 5507, 43293, 4116],
                'D2': 48245,
                'D3': 12466943122422445917},
               {'D1': [47303, 24569, 2453, 40138, 44828, 10326],
                'D2': 37572,
                'D3': 9791472289481593676}],
        'B3': [85, -21, 117, -45, -128, -87, -24, 27],
        'B4': -11321,
        'B5': 0.8503999880151201,
        'B6': 5248295045371652189,
        'B7': [-113, -37]}}

Вариант №8

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

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

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

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

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

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

(b'JKT\x1f\x00(\x001\x00:\x00y\x00\xb0\xd8\x80\x96\x8dTL\xd9\xc8\xbf\xe4'
 b'j\x12D\xb4\xf6\xf6\xecnvvnhkwr\xfavxgyfgmc[hkoimfod\xd6rocsfdcs\xf5\\'
 b'6\x0c@\xce\x80y\x93-U\xac\xe3:\xc5\xfe\xf2PAh\xbf\xe647=\x14s.?\xca'
 b'\xd0:?\x0e<\x89\xbe\x04P}>\x06I$\xbf\xfa\x8cJ\xa6\x01\x87\x0eG=\xbfk2W'
 b'T\xbeC\x00\x00\x00P\x7f\x04`')

{'A1': [{'B1': 'nvvnhkwr', 'B2': 250},
        {'B1': 'vxgyfgmc', 'B2': 91},
        {'B1': 'hkoimfod', 'B2': 214},
        {'B1': 'rocsfdcs', 'B2': 245}],
 'A2': {'C1': 107,
        'C2': -0.20736387372016907,
        'C3': {'D1': 10626666419083556444,
               'D2': -937094815727987411,
               'D3': [-0.9072465896606445,
                      0.04472818225622177,
                      0.681443452835083,
                      0.7297483682632446,
                      -0.2680363059043884,
                      0.24737554788589478,
                      -0.6417392492294312],
               'D4': [250, 140, 74, 166, 1, 135],
               'D5': -0.7393654584884644},
        'C4': 1610907472},
 'A3': 55472,
 'A4': -0.19413141373222587,
 'A5': 17075106291318418148}

(b'JKT\x1f\x00(\x001\x00:\x00y\x00\n\xfc\xd2%\xe5&/&\xec\xbf\xf6\x90\x9bO\xa3'
 b'U\xe8Caiguwqzz\xd1lvzsgnta"tmtldqcsfldvxobgh\xdf\xa0Z\xb7\xf15Y\x17&-'
 b'^\xc8\xa7Q\xa9\xe1k\x18\x17W\xbf\x87\xf3\x97>\xf2\x08\x80\xbe\x11\x966?\xb5'
 b'7\xeb\xbd}\x95\xb0\xbe[\xb9B\xbf\xca\x12Nq\xe2\x07\x1b\x17f\xbfx\xc3\r'
 b'#?C\x00\x00\x00\xc1\x06\xc9\xb3')

{'A1': [{'B1': 'aiguwqzz', 'B2': 209},
        {'B1': 'lvzsgnta', 'B2': 34},
        {'B1': 'tmtldqcs', 'B2': 102},
        {'B1': 'ldvxobgh', 'B2': 223}],
 'A2': {'C1': 120,
        'C2': 0.6369287371635437,
        'C3': {'D1': 2744760586129070752,
               'D2': 7773680599990558253,
               'D3': [-0.8401961326599121,
                      0.2967798411846161,
                      -0.2500682473182678,
                      0.7132273316383362,
                      -0.11485234647989273,
                      -0.3448905050754547,
                      -0.7606407999992371],
               'D4': [202, 18, 78, 113, 226, 7],
               'D5': -0.8987900614738464},
        'C4': 3016296129},
 'A3': 64522,
 'A4': -0.8796611556692204,
 'A5': 4893255155041669366}

Вариант №9

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

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

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

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

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

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

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

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

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

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

(b'xCWFO\x00k\xa2e\xd1\xa6\x0fmq\xfe\xdc\xd6_cs\xa9\x80\xf5\x8dd1{0'
 b'\xe4\xcb\xb3\x02"\x00\x00\x00\x8e\x00\x00\x00\xa4\\\xbf\xdc\xe0\roN'
 b'\x85\xfcK\x87\xbf\xec\xbb\xf0\xf5\x06\x7f\nY\xbf\xe3\x8d\x13\x88,\xb7'
 b"\x82\x1e\x10Q\x157'\x1fK}>\x12\x9c>\xe5+D|?\xe2\xfb\x94\xf0f\x07(}x"
 b'\x08S\xe0\\\x00=\x00\x02\x00^\xb9\x06\x00\x02\x00\x00\x00)?\x1bF\x92?\xea'
 b'\x14x\xb1\x90\x1d\x16\xbf\xef\x1eKp\x0f\x14<C\xe7\x96\xab\x00\x00\x00`\xf2u'
 b'\xd1\xb6\xd2\xf8\xd8\x8a(\xa3\xee\xb9P\x8ejd\xf4\xcc\xb2&i\x18q\x07;3'
 b'\x0bB\xef\x90<s\x0c\xa8\xf3Wo\x99\x00\x00\x00\x04\x00\xa0')

{'A1': {'B1': 6,
        'B2': [{'C1': 92, 'C2': -0.4511750781040005, 'C3': 75},
               {'C1': -121, 'C2': -0.8979420457507967, 'C3': 89}],
        'B3': 0.6065455675125122,
        'B4': 0.8149989574457404,
        'B5': {'D1': -0.9724480808878364, 'D2': 1139250859},
        'B6': {'E1': 139714652,
               'E2': {'F1': -0.6109712276136039,
                      'F2': 30,
                      'F3': [273749303, 656362365, 1041407038, 3844818044],
                      'F4': 0.593210668114101},
               'E3': [125, 120],
               'E4': 185}},
 'A2': 11701989717945709054,
 'A3': [-589930653, 1940488437, -1922813573],
 'A4': 820300723,
 'A5': 546,
 'A6': {'G1': 4067807670,
        'G2': 210,
        'G3': -515510250180265648,
        'G4': -114,
        'G5': 1785001164},
 'A7': {'H1': 8144543541541138320,
        'H2': 4355839184374034329,
        'H3': [178, 38, 105, 24]}}

(b'xCWFO\x00kJ\x9d\xca\xdd\x80u\xc5\xa2(>\x03\xd4\xe6\xdf\x8bX-\xa9\xd7\xe7K'
 b'c\xb7\xc0A\xd0\x00\x00\x00\x8e\x00\x00\x00\xa3\xdb\xbf\xa1\x93W;#0@\xe0>'
 b'\xbf\x9eu\xccZ`d\x80\x01\xbf\xd9\x04\x07\xb7\xaf\xf6\x90\xbd\xc0\x9a'
 b'X\xcf\x03O\x0e\xca\x11+\xb6!m\xb5y\xcf?\xd5p\xa1\xfaM\xd0P\n&Cn^\x9c'
 b"\x00=\x00\x02\x00^\xa5\x02\x00\x02\x00\x00\x00)?'p\xbe\xbf\xd6>/\xe9\x8d"
 b'\xdch?\xb6\x94\x86u8\xda`\x8a0\xad^\x00\x00\x00`\xaa\x1el\xbc\r\xa9'
 b"\xbb\xf0/\xe2\xa2;\xfc\t\xf9\x85\xd8\xc3\x9awE/\x0f+\xdc\xe3$'\xd8$"
 b'\x87\x00\x16\xe4\x02\xe7\xd0\x00\x00\x00\x03\x00\xa0')

{'A1': {'B1': 2,
        'B2': [{'C1': -37, 'C2': -0.034327245682647334, 'C3': 224},
               {'C1': 62, 'C2': -0.029746239677568287, 'C3': 1}],
        'B3': 0.6540640592575073,
        'B4': -0.34754560287496483,
        'B5': {'D1': 0.08820381509654274, 'D2': -1976521378},
        'B6': {'E1': 1131306652,
               'E2': {'F1': -0.390870980627235,
                      'F2': 189,
                      'F3': [3231340751, 55512778, 288077345, 1840609743],
                      'F4': 0.3349995560049637},
               'E3': [10, 38],
               'E4': 165}},
 'A2': 5376676582842025378,
 'A3': [675152852, -421557416, 766105575],
 'A4': 1264826304,
 'A5': 16848,
 'A6': {'G1': 2854120636,
        'G2': 13,
        'G3': -6216110772198425604,
        'G4': 9,
        'G5': 4186298563},
 'A7': {'H1': 3390977272136869848,
        'H2': 2632072605536020432,
        'H3': [154, 119, 69]}}

Вариант №10

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

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

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

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

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

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

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

(b'HSE^\x16\xe5\x7f\x87\xffj\x9e\xe0\xad\xd6\xc0c\x00\x02\x00\x00\x00"?\xe4'
 b'\xda\\\xef\x1dOn\x00\x00\x00N\xe4\xbc\xe9\xc0K\x04\xb3\xd3\xcaH'
 b'\x17\xaf\xe2\x12\xd5\xfdx_\x07IY\x0cX$\x8e\x8c\xdek?\xe8\x13\xfc\xf9\xbe'
 b'\xae\x8e\xbf\xed\xcb\xf4]\x88\x16\xb4\x00\x02\x006\xb1a6HY\xb8BH<>\x8bnS\x11'
 b'\xe5$\xbf\xe0p\x01\xf37U\x8c\xbf\xb6\x98\x04\x9c\xe8\x8d\x90\x00\x00'
 b'\x00\x02\x00\x00\x00>Dp\x11s\xbfF\xc5[Q[')

{'A1': 384139143,
 'A2': 4285177568,
 'A3': 2916532323,
 'A4': [{'B1': -6980, 'B2': {'C1': 3921693444, 'C2': [-19501, -13752]}},
        {'B1': 6063, 'B2': {'C1': 3792885245, 'C2': [30815, 1865]}}],
 'A5': 0.6516556425290057,
 'A6': {'D1': [1493981220, 2391596651],
        'D2': {'E1': 12781556901824971336,
               'E2': 0.011629922315478325,
               'E3': 1393681700,
               'E4': [-0.5136728048625385, -0.08825711088916521],
               'E5': [0.7524399640874024, -0.9311467959202759],
               'E6': 1148195187,
               'E7': -0.7764489054679871},
        'D3': 20827}}

(b'HSE^\x8el7r\x84\xc9.\xa3k\xbd\x1c\'\x00\x02\x00\x00\x00"?\xe8\x10c\xf1\x8a'
 b'\x8d\x08\x00\x00\x00fTs\xb7\xfa\x03bO\x93\xa3\xae\xdd\xd9\xe7\xeb\x0c\x1a"C'
 b'[o\xd3\x82\xcf\x14e_\x112\x9f\x8f\xb9\xab\xca\x04\xcc\xe1\x16\xcd'
 b'\xdc\xdb\x8c\xf8\xec\xc7&R\xd3\xa6G\x15\xcc\x16?\xe2\x086\xac\xcbf\xf6?\xe9'
 b'\xb2i%\xeb\xc0f\x00\x08\x006\xa1g\xd1zS~\x85\xdd\xbe\xc0;6\x0b\xdc'
 b'\xa9\xf7\xbf\xdct~\x02W\xd2\xe4\xbf\xc6\xc51\x97\x08=0\x00\x00'
 b'\x00\x02\x00\x00\x00V\x15f\xcfj>\xf8\x96N\x978')

{'A1': -1905510542,
 'A2': 2227777187,
 'A3': 1807555623,
 'A4': [{'B1': 21619, 'B2': {'C1': 3086615394, 'C2': [20371, -23634]}},
        {'B1': -8743, 'B2': {'C1': 3890940954, 'C2': [8771, 23407]}}],
 'A5': 0.7520007817842336,
 'A6': {'D1': [3548565268,
               1700729138,
               2676996523,
               3389312225,
               382590171,
               2365123783,
               642962342,
               1192610838],
        'D2': {'E1': 11630494886024611293,
               'E2': -0.3754517436027527,
               'E3': 199010807,
               'E4': [-0.44461012104811304, -0.17789287447565405],
               'E5': [0.5635026335614544, 0.8030286541598002],
               'E6': 359059306,
               'E7': 0.48552173376083374},
        'D3': -26824}}

Вариант №11

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

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

(b'\xf4RCP\x11(,;\x00\x8e\x00\x03\x00\x00\x00\xb9\x00\x00\x00\x14\x03m>r'
 b'\x87VN\x16!\xd3\x92\x9c!\x1d\x16=\x83\x98#\x84)\x06\x9cY-\x80\xab\xd4'
 b'0\xec\xba\xba<\xeeaH\xe6c]j\xb2\xb83\xdbUt3\xae\xb4JA?\xed\x8e\xa36'
 b'?\xd5\xe6\x07\xf0J\x13\x00\x00\x00\x06n9\x07Ir\xe3\xbf\x03\x00\x00\x00#\x00'
 b'\x00\x00\x17\x19rVD \x85\x19d\xda\xd2\xa5\x7fm\xf3\xe1j\x11cM\xd4\xbc'
 b'\t49\xf8\x91 Al\x1a\x0b\xd9\x15/S7\xec\x0f\xc1\x18f\xd7\xf1z<\x14\xf1^\xe7'
 b'\x0f\x15\xbf\xc6\xad\xf4\x02@\x8fB\x83\xd8jf\x00\x00\x00<\xff\xb4<h \xdd'
 b'?\x03\x00\x00\x00v\x00\x00\x00\xd0G0?\xc0F.\xbf\xc2!\xe0\xbc')

{'A1': 10257,
 'A2': 44,
 'A3': [{'B1': {'C1': 106,
                'C2': 12552504498510346418,
                'C3': 0.7550461292266846},
         'B2': 237,
         'B3': 17296046697502647182,
         'B4': 74,
         'B5': {'D1': 5644848107698848532,
                'D2': 8470,
                'D3': [37587, 8604, 5661]},
         'B6': -0.6077008381939215,
         'B7': [-7204024906422910147,
                -4977549798182736551,
                6729475466776689850]},
        {'B1': {'C1': 24, 'C2': 6841271558945757030, 'C3': -0.5822739005088806},
         'B2': 198,
         'B3': 15601386717163222189,
         'B4': 106,
         'B5': {'D1': 1838911500730898711,
                'D2': -9628,
                'D3': [42450, 28031, 57843]},
         'B6': 0.4551029770700443,
         'B7': [3749735784780075370,
                800070910786795577,
                -4535146577375848999]}],
 'A4': [0.6885957717895508, -0.6807670593261719, -0.027359846979379654]}

(b'\xf4RCP\x04\x85\x843\x00\x86\x00\x03\x00\x00\x00\xb1\x00\x00\x00\x9f'
 b'\xb0m\xcaEl4\x82\xe1\xcb;W9\xb8um7#\xa7\xfd)JsKg,\xb6\x94\xee\xb8Y{\x9d'
 b'\n\xe3\xa5\xfe\x93\xf1H.\xd9\xde\x12\xbf\xaa\x17,\xc3\xe3R\x81P\xdc-\x13\x00'
 b'\x00\x00\xb8&\x9b\xd0p,\xed\xbf\x02\x00\x00\x00#\x00\x00\x00!:'
 b'\xde\x90\xdc\xf2\xce\x853"\xf5~\x0cd\xc0\xb4\xc1\x14\xfc\xc8\xd2\x02'
 b'\x99\xde\xd5t|\x81\xcc1\xda\x98x\x818\xb3i\xd6J\x8e`\x85\xef\x87\x86a'
 b"\x0cw\xf6\xd4q\xff>*\xc9\t'\x90\xeaTd\xc5A^\x00\x00\x00\xb0\xe4\xc6"
 b'\x1a\xa6"\xb9?\x03\x00\x00\x00n\x00\x00\x004>\x1f?\xe9\x0c\x08\xbf\x178\t'
 b'\xbe')

{'A1': 34052,
 'A2': -124,
 'A3': [{'B1': {'C1': 157,
                'C2': 3335181142002623242,
                'C3': -0.5737128853797913},
         'B2': 170,
         'B3': 15875330879489518615,
         'B4': 45,
         'B5': {'D1': 9382242970724315295,
                'D2': -13343,
                'D3': [22331, 47161, 28021]},
         'B6': -0.9116748880707837,
         'B7': [5436770719376024375, 8888338674429078631]},
        {'B1': {'C1': 96,
                'C2': 17759677268567256965,
                'C3': 0.49891531467437744},
         'B2': 42,
         'B3': 14223586889560426953,
         'B4': 65,
         'B5': {'D1': 9641910881384020513,
                'D2': 8755,
                'D3': [32501, 25612, 46272]},
         'B6': 0.09818494943364686,
         'B7': [-2406889421514468159,
                -7432573480606075691,
                -8193500822580461192]}],
 'A4': [0.6220428943634033, -0.5314469933509827, -0.13400302827358246]}

Вариант №12

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

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

(b'NFAP\xada;\xe9\xc6;\xfc\xf4\xdb\x9a\x02\xec\xcc\xbd"\xfbqX\xa4n2\x98G\xb4'
 b'\x07A\x00\x02\x00\x96\x00\x00\x00\x8c\xbci\xf4Z\xf8\x19v\x04\x00\x9e'
 b'\x00\x00\x00\xfb\x16|0\x00\xbe\xd1\xcdR\xec\xb6R*\xfb<xyD\xa2\r>'
 b'\xd5\xdc0\xc7\xe5\xf7b\xe2\xa0\xa3\x1a\xc3^\x17\xbc\xc2"\xb6\x1f-'
 b'\x97w\xa3\xd3\xd5\x06\x10\xb5k\xa0)I\xa3\xbd\xc78\xe3?3\xba@\xc0\xd8\xd6'
 b')s\xf3H\x7f(\x97\xa2w\xac\x95\xfa\x06\x005\x00\x00\x00\xd7\x10\x8fYH\xfe'
 b'\xd3m\xd5\xfa\xbc\xd6w\xb5\x8d\xc5\x1d\xbc\xb1=\x1dh*\xbfX;\x98\x81')

{'A1': -957793439,
 'A2': -604701637,
 'A3': 8213196544022413978,
 'A4': {'B1': 555147373080126552,
        'B2': {'C1': 30780,
               'C2': 121,
               'C3': 68,
               'C4': [{'D1': 3577613730,
                       'D2': 12508,
                       'D3': 1919554760373429703,
                       'D4': 195,
                       'D5': 3251517716397037406,
                       'D6': -744261737,
                       'D7': 1749},
                      {'D1': 2691413264,
                       'D2': 18729,
                       'D3': 13417137960009579939,
                       'D4': 64,
                       'D5': 9171848317088749760,
                       'D6': 2007144232,
                       'D7': 38316}],
               'C5': -6,
               'C6': [12412, -16896, -12847, -5038, 21174, -1238],
               'C7': [4311, 22927, 65096, 28115, 64213, 54972, 46455, 50573]},
        'B3': [0.08678457885980606, -0.6656511425971985],
        'B4': 8510106040424578188},
 'A5': [88, 59, 152, 129],
 'A6': -5,
 'A7': 22}

(b'NFAP\xadA9C\x8b\xc7y\xd4#\xf0% Z\xe6\x8eR\x13\xad\x80\xbb,P\x1f\r'
 b'\x87A\x00\x03\x00\x96\x00\x00\x00\xfa\xd5\xe8\xa5a\xfb;a\x05\x00\xa2'
 b'\x00\x00\x00\xdap\xb1O\x16\xc3F>b\xb9\x05\xa8\x8e\xb1\xf4\x0e\x84'
 b'\xf1\xfb\xa3\xac0W\xc64Z\xbbW$<]\x7fyG\x8fSS\x8c<*\n\x9eZ\xb848\xc62\xef'
 b'V\x97n\xc6S:\x0b\x11\xb98db\x00\x9f;Q)u\xb2\xa2s\x9fWR)\xed)9\x06\x005\x00'
 b'\x00\x00\xb0\x9f7\xe1\xf9\x84^\xa9\xb8\xc6(n\xd6\x91\xdd;\x01\xfd'
 b'Q\xbf\x15\xe15\xbf\x90\xc4\xd6>h\xc4s$\x91')

{'A1': -1958528703,
 'A2': 601127367,
 'A3': 1392332354816583152,
 'A4': {'B1': 9731468799025840301,
        'B2': {'C1': 3828,
               'C2': -124,
               'C3': -15,
               'C4': [{'D1': 816620539,
                       'D2': -14761,
                       'D3': 9177557742439324212,
                       'D4': 121,
                       'D5': 732464462792200007,
                       'D6': 884497054,
                       'D7': 50744},
                      {'D1': 2539056946,
                       'D2': -14738,
                       'D3': 7089854080894057043,
                       'D4': 0,
                       'D5': 8332418476862946207,
                       'D6': 693262239,
                       'D7': 10733}],
               'C5': 57,
               'C6': [20401, -15594, 15942, -18078, -22523, -20082],
               'C7': [40880, 57655, 34041, 43358, 50872, 28200, 37334, 15325]},
        'B3': [-0.8202667832374573, -0.7104657292366028, 0.41946840286254883],
        'B4': 7006470042118837754},
 'A5': [104, 196, 115, 36, 145],
 'A6': -38,
 'A7': 112}

Вариант №13

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

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

(b'LHAM`n\x1a\xe1\x06\x08\xd5r\x1e\x00\x00\x00\x03\x00\x00\x00yC*N'
 b'\xe8\xc8\r\xc2f?\xdc\xb6\x8a\xb5m\xe5\x14>,Q\xb8\x0e\xef\xd3\xe5\xbf\xe1#'
 b'\x98\xa2\x15A\x9e\xb17\xba\x88b\xd87Q?\xc7\x11\xdb\xc3\xb40\x88\x92Ax'
 b'\x0e}i\xd6T\xbf\xd1A\xca5\xb5\x10\x18\x00\x02\x00|\x8fo\xd7jY\x19\x95'
 b'\x04\xf1H&F\xf7?r\xd0V?_\xfc$\xbd\xd5\xeb\xd7?\x0f\xe4]\x8c\x9d\xbdtic'
 b'o\xa7ga\xf9\x86\xf5\x81')

{'A1': 96,
 'A2': {'B1': 7933901109600809502,
        'B2': 'tic',
        'B3': [{'C1': 4839767511258743398, 'C2': 0.4486414691705971},
               {'C1': 4480045580293231589, 'C2': -0.5355952420887211},
               {'C1': 12769880363368986449, 'C2': 0.18023249679425057},
               {'C1': 10538836606652634708, 'C2': -0.26964049572802784}],
        'B4': [1873241953, 4186371457],
        'B5': -113},
 'A3': 8059026989116622065,
 'A4': 1210468087,
 'A5': [0.9484914541244507,
        0.8749411106109619,
        -0.10445373505353928,
        0.5620782971382141],
 'A6': {'D1': 35997, 'D2': 189}}

(b'LHAM\xda5j\x1fn\xf7}\x9ds\x00\x00\x00\x03\x00\x00\x00ydB\x89\x8a\x02~M'
 b'\xe6?\xe9\x8c\xf6\x87\x15V\xf0\xb1s;5b\xaf\xc5\xaa?\xb0\xd6\xe8\x95\xd1C'
 b"@\\^\x81\x06v\x19\xfdp\xbf\xe3\x8b \xe0G\xdd\x0e\x81\xe6#\xd3\x0e'\x1c"
 b'\x84?\xed\xe9i\x97H\x1b\x10\x00\x02\x00|=6 \xd3\xd8D\x9a\x18\x8f\xab\x90'
 b'\x06\xc8?\r\x9b{\xbd\xe7\xbb\xc1>\xbc\x17\x0f?\x1d\x9doQ\xe4\x02qka'
 b'\xb4\xfbr\x10\x91#\x17\xae')

{'A1': -38,
 'A2': {'B1': 3848923393000578419,
        'B2': 'qka',
        'B3': [{'C1': 7224487978096020966, 'C2': 0.7984573973032791},
               {'C1': 12786628867509962154, 'C2': 0.06577924401905211},
               {'C1': 6655899164051373424, 'C2': -0.6107334499819517},
               {'C1': 9360208264918670468, 'C2': 0.934742732498167}],
        'B4': [3036377616, 2434996142],
        'B5': 61},
 'A3': 3900350203120195727,
 'A4': -1416624440,
 'A5': [0.5531536936759949,
        -0.11315108090639114,
        0.36736342310905457,
        0.6156834959983826],
 'A6': {'D1': 20964, 'D2': 2}}

Вариант №14

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

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

(b'OWUD\xbe\xe1yK0\xb7\xbf\xb2\xec\x98\xe2\xee]0wbsxg,*,\x11\xf4\x91\xb1W\x9e'
 b"\x00\x02\x00\x82n\x94\xc9F\xbe\x9d\x8e\x16\xbe)'\x02>\xa5\xe95"
 b'\xf0\x8d\xf0\x00\x03\x00\x00\x00(J\x92\xff\x93\xbf\xb3\x08yF\x10;'
 b'0\xbf\xef\xad\xfb\xf5\xe9\x90Bj\x06\xb9aD*0\x19?(*\xa8>\x83f\xc0?R\xe3'
 b'\x10\xde4%\x00\x03\x00\x00\x00Y\xf6\x9f8l?\xc6\xda\xf4\x94f\x03P\xbf\xdb'
 b'*\xe4\xab@%,\x00\x00\x00\x02\x00\x00\x00$\x004t\x88\xd4\xf8\t\x17\x8d\x8e'
 b'\xab\x00\x00\x00\x04\x00\x00\x00Q\x00e\xab\x1a\x03\xf5\xac\xdapp\xf8')

{'A1': {'B1': -0.4403785169124603,
        'B2': 12471,
        'B3': -0.07392268696127213,
        'B4': 'wbsxg',
        'B5': 3182404542319931735},
 'A2': 158,
 'A3': [{'C1': [28308, 51526],
         'C2': {'D1': 240,
                'D2': -115,
                'D3': -16,
                'D4': [-0.30772465467453003,
                       -0.16518786549568176,
                       0.3240448534488678],
                'D5': [19090, -109],
                'D6': -0.07434804878742507,
                'D7': -0.9899883082366687},
         'C3': 8397195667001806222,
         'C4': 171},
        {'C1': [27142, 47457, 17450, 12313],
         'C2': {'D1': 222,
                'D2': 52,
                'D3': 37,
                'D4': [0.6569008827209473,
                       0.25664329528808594,
                       0.8237771987915039],
                'D5': [-2401, 14444],
                'D6': 0.17855698820133137,
                'D7': -0.4244929954880543},
         'C3': 12329171283582021744,
         'C4': 248}]}

(b"OWUD\xbf4\xb9\xdab\xa3\xbf\xe8\x0c\x11\xe1\x84\x846fvsgq\xcd\xe4A\x86'"
 b'(y/\x82\x00\x02\x00|\xff\x8cF\xc6\xc9\xa4?v\xc1o>\xf02\n>\xfb\xc9\xe0\x1a+'
 b'*\x00\x03\x00\x00\x00*^d\x96\x03?\xc4K\x85l\xbe]\xa0?\xe0\xf0\x84s'
 b'j\xd0\\\x19\xc6"m\xbe\xea\x85>?Z\x9e\xe1\x1dW\xec\x00\x02\x00\x00\x00W'
 b'N\xdb@\xfa?\xef\xdbW\xd0N\xba\xf2\xbf\xef\x16#\x10-8\xb8\x00\x00\x00\x03'
 b'\x00\x00\x00$\x006\xe0b\xa1\xb9\xf5D\xedn\xe1\x00\x00\x00\x02\x00'
 b'\x00\x00S\x00_jP@\xa0H\x99\xa4\x11\xbd')

{'A1': {'B1': -0.7059608697891235,
        'B2': 25251,
        'B3': -0.7514733700410321,
        'B4': 'fvsgq',
        'B5': -3610688956805908177},
 'A2': 130,
 'A3': [{'C1': [65420, 18118, 51620],
         'C2': {'D1': 26,
                'D2': 43,
                'D3': 42,
                'D4': [0.9638890624046326,
                       0.4691317677497864,
                       0.4917745590209961],
                'D5': [24164, -27133],
                'D6': 0.15855472383257752,
                'D7': 0.5293600324862484},
         'C3': 16168663432269458798,
         'C4': 225},
        {'C1': [6598, 8813],
         'C2': {'D1': 29,
                'D2': 87,
                'D3': -20,
                'D4': [-0.4580478072166443, 0.8539867997169495],
                'D5': [20187, 16634],
                'D6': 0.9955252712732927,
                'D7': -0.9714522663068896},
         'C3': 7660694023314187281,
         'C4': 189}]}

Вариант №15

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

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

(b"XOBM)\xb45\x00\x00\x00\x1aLH2\x85\xfa)n\xcf\xbf<\xa6rq\xe6'\xec\xbf"
 b'\x06\x00y\x00\x00\x00\x02\x00\x85\x00\x00\x00j/\xef\xed4\x85\xbaQ|\xb9Z\xd2'
 b'\xa5O\x02\x00\x00\x00(\x00\x8f\xd3\x9e\xc4z\x03\x00\x00\x00*\x00['
 b'\xe0\xa6\xf3\xfa\x06\x00\x00\x00-\x00\x90!\x80r\x02\x9b\x02\x00\x00\x00'
 b'3\x00\x00\x00\xf3\xca\x0c?v\x18\xdf\x92\x17\x00\xf2{p\xcd\xda5/\xec\xbfU'
 b'V\xfb\x15\xd1\xbf\x8e+\xbf\xd6\x04D\xf3\xc1jY\xd4\x1c5\xe2a1\xc4O\x15'
 b'q\xc4J\xf9\xb2\xb6\x0b6 ')

{'A1': 46121,
 'A2': {'B1': [{'C1': 79, 'C2': [106, 47], 'C3': 54159, 'C4': 50334},
               {'C1': 122, 'C2': [239, 237, 52], 'C3': 57435, 'C4': 62374},
               {'C1': -6,
                'C2': [133, 186, 81, 124, 185, 90],
                'C3': 8592,
                'C4': 29312}],
        'B2': -25854,
        'B3': [210, 165],
        'B4': 0.5499717593193054,
        'B5': {'D1': 2464094326, 'D2': 3880639911932592151, 'D3': 47},
        'B6': -0.2669666617503015},
 'A3': 19482,
 'A4': -0.24554943783222627,
 'A5': -0.8798706260469724,
 'A6': [11150, 54975, 17412, 49651, 22890, 7380],
 'A7': [8148506804857463349, 2321055537270704836]}

(b'XOBM{#9\x00\x00\x00\xf3\xde\x8e\xfa\x0f\xc67G\xeb\xbf,\xdeg\xb0$f\xda?'
 b'\x03\x00}\x00\x00\x00\x02\x00\x83\x00\x00\x00.\x10\xed\xdc\x82\\\xb8U'
 b'\x96a\x1cp6\x90#\x14<\xec\x05\x00\x00\x00(\x00\x7f\x84\xc1^k\x05\x00\x00'
 b'\x00-\x00\x86l\xf2\x12{\x04\x00\x00\x002\x00\xa9\x9cb\x02\xe5\xf9'
 b'\x03\x00\x00\x006\x00\x00\x00\xe4\r\xfe>q\xaf2c.?\xd7\xb3pv\xd0\x83'
 b'\x03\x9c\x0ch\x8c\xfe\xfd\xeb\xbf\x00G\xe4\xd5\x10b\x1e\xd3\\\x8f\x19'
 b'\t\xc3\xb1\x1d\xda\x08\xa6\xfd\x90\x04>')

{'A1': 9083,
 'A2': {'B1': [{'C1': -20,
                'C2': [46, 16, 237, 220, 130],
                'C3': 33919,
                'C4': 24257},
               {'C1': 107,
                'C2': [92, 184, 85, 150, 97],
                'C3': 27782,
                'C4': 4850},
               {'C1': 123, 'C2': [28, 112, 54, 144], 'C3': 40105, 'C4': 610}],
        'B2': -1563,
        'B3': [35, 20, 60],
        'B4': 0.49619972705841064,
        'B5': {'D1': 1664266097, 'D2': 9498221840550018862, 'D3': 3},
        'B6': -0.8747551672280625},
 'A3': 57075,
 'A4': -0.8524435871512013,
 'A5': 0.41248433329698986,
 'A6': [18176, 54756, 25104],
 'A7': [-5637652303153671394, 4468856149345098269]}

Вариант №16

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

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

(b'JTDR\x1fi\x7frKy\xe5x\x00\x04\x00R\\\x00\x00\x00\x03\x00\x00\x00'
 b'n\xfa\xf5\xba\x8a\x07\xe4\x0fI\xc3\xd0\x1c\x87?g\x93\xef4\x1b\x00'
 b'\x00\x00\x04\x00t\xe5%57\x82\xe5\xe7\x80\x7f\xca=\x10@\xf0\xd99\xba\xdc\xb0'
 b'\xfc{&\xb5\xbe\x89\x97\x10\xbehG`\x00\x84\xb1\xf3\x88\x8f\xfb#\x96W\xd99'
 b'\x17l\xd2\xa4\xfe\xe8Y\x81\xd8-6b\xe6w\xc4<!\x85=\x9cl\xda\x17\x97'
 b'>\xfe\xd4\xb1\xbf\x0f22\xbe\xad\x97\x92?uNr\xbf\xefa\xa0\xde\xe8#\xd2'
 b'?_\xa3\x94\xd1\xd3\x08wQ\x11;')

{'A1': 2263480416599663992,
 'A2': {'B1': [{'C1': 177, 'C2': 62344, 'C3': -1879366762},
               {'C1': 87, 'C2': 55609, 'C3': 393007780},
               {'C1': 254, 'C2': 59481, 'C3': -2116539082},
               {'C1': 98, 'C2': 58999, 'C3': -1002692219}],
        'B2': {'D1': 92,
               'D2': {'E1': [15772, 27866, 6039],
                      'E2': 4210408074,
                      'E3': 568596262447750279,
                      'E4': 0.9046010375022888,
                      'E5': 13339},
               'D3': [0.4977164566516876,
                      -0.5593596696853638,
                      -0.33904701471328735,
                      0.9582282304763794],
               'D4': 229,
               'D5': 2681110188511428735}},
 'A3': -3873922233364039238,
 'A4': -592380805,
 'A5': 9909,
 'A6': -0.26873064041137695,
 'A7': -0.22683477401733398,
 'A8': {'F1': -0.9806675294540759,
        'F2': 4566548406747727991,
        'F3': 81,
        'F4': [17, 59]}}

(b'JTDRa\xe2 \xd8#M%q\x00\x04\x00R\xf6\x00\x00\x00\x07\x00\x00\x00nR-\xbd'
 b'#\xdb\xa6\x07\xa3\xb4\x80IX?.{LKe\x00\x00\x00\x04\x00|\xcegf\xf1\xf3?\x10'
 b'\x7f\xfd#!\x08\xe1\xbam\xa0I\x11\x7faf\xed\x11=\x81\xdc\x89\xbf\x18\xcaE'
 b'\x00\x8cB\xfeO\xf0N\xc5*[v~\xca%\xb0U\x83\xef#\xff\r^\x1bqF\xbe>nk\xe1-r'
 b'\x0f\xa0\x9b\x17\xd10\x1eR\xcel\x8c\xa2?\x07\x16\x07\xbe\\\x1f"?B-q'
 b'\xbfgh\x1c\xbf\xc4\xb8\xd27\nI`R\xaf9\xb6@HWU;\x1f\xc7')

{'A1': 7053236079092901233,
 'A2': {'B1': [{'C1': 66, 'C2': 65103, 'C3': -263273174},
               {'C1': 91, 'C2': 30334, 'C3': -903499691},
               {'C1': 131, 'C2': 61219, 'C3': -15901157},
               {'C1': 113, 'C2': 18110, 'C3': 1047423969}],
        'B2': {'D1': 246,
               'D2': {'E1': [11634, 4000, -25833, -11984, 7762, -12692, -29534],
                      'E2': 1378729251,
                      'E3': 15827346340129556824,
                      'E4': 0.6815688610076904,
                      'E5': 19301},
               'D3': [0.5276798605918884,
                      -0.21496251225471497,
                      0.7585058808326721,
                      -0.9039323329925537],
               'D4': 206,
               'D5': 7450908660568457213}},
 'A3': 2531314231147339849,
 'A4': 293560678,
 'A5': 60689,
 'A6': 0.06340891867876053,
 'A7': -0.5968363881111145,
 'A8': {'F1': -0.16189029395588772,
        'F2': 5958044286959769429,
        'F3': 59,
        'F4': [31, 199]}}

Вариант №17

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

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

(b'UXQE\x94\x00\x00\x00\x80e\xf5U\x8ba\x08+SZ\xe9\xd8\xeb\x1e\xad\xf2'
 b'\x00\x05\x00\x00\x00\xac\x9c\x9eS\xe1O\xfe?\xc5\xa7\xc9~\x90Q\xb0\x13\x86"H'
 b'?\xe1\xfes\xb4\x05W|\x90q\x0e\x83\xbf\xab\xa8\x9f\xb9\xb6I \r\xac\x15\xf3'
 b'\xbf\xd5\xac\x80\x98\xa2\xf6\xa0\x9e\x90\xe4m?\x8b\x84Jd\xc7X\x00\x00 \x00,'
 b'\x008\x00D\x00PR\x82C\x98\x06\x08\x9e\xff&\x1d\xdf\x08P\x16\xb3\x1a\xd4-'
 b'\xbak\x8fA\xa22\x8acgvgj?\xe7=1i@\x99\xd0\x00\x05\x00\x00\x00\\\x00\x00'
 b'\x00f\xb5\xa17\x19\xa5>S\xaa\x9co\x98\xefw$\xba\xf9\xd5z\x0f\xf5sg'
 b'\x95\x99\xe5A\xd7')

{'A1': {'B1': 'gvgj',
        'B2': 0.7262198501310255,
        'B3': [{'C1': [21473, 20478], 'C2': 0.1691829555499118},
               {'C1': [4998, 8776], 'C2': 0.5623110309631865},
               {'C1': [36977, 3715], 'C2': -0.054020873470238095},
               {'C1': [3500, 5619], 'C2': -0.33865370660701366},
               {'C1': [40592, 58477], 'C2': 0.013435918045541229}],
        'B4': {'D1': 21122,
               'D2': 4870649631098218013,
               'D3': [3741863958, 3004879917, 3127611201, 2721221219]},
        'B5': 3047241497,
        'B6': 11907046457048275183,
        'B7': 8585192371866177525,
        'B8': 29543},
 'A2': 7346872424241572691,
 'A3': 1525274859,
 'A4': 7853,
 'A5': -14,
 'A6': [-107, -103, -27, 65, -41],
 'A7': -25442}

(b'UXQE\x94\x00\x00\x00r\xe8oa\xd7\x02\xb6c\x86\xfd\x8a\x7f\xd7\x84\nA'
 b'\x00\x04\x00\x00\x00\x9e\x10\x0f/\xa9\x9aV?\xab\x06"!\xab@\xc0D\x0b\x12?'
 b'\xbf\xc5l\xcfG\x88\x9b\xe8\xfc\xa5\x10\xa8?\xda\xf8:\x02\xcf}\xa4'
 b'\xc8\xe9\xfd\x8f\xbf\xe1 \xda\x03j1(\x00 \x00,\x008\x00D\x04\x13\xecr'
 b'\xf7p\x9f\x8f\xbdZ\xd6\xa6\x93\x1akD\x04\xc0O\xed~{\xf4PG3uvha\xbf\xe8'
 b'CvW\x0b\x9dd\x00\x04\x00\x00\x00P\x00\x00\x00X4\xd9g\xebt\x90\x7f\xe9'
 b',\x8d\xdbP8\x19\x17E\tq,\xf4\xaa\xcdRU!\x97')

{'A1': {'B1': 'uvha',
        'B2': -0.7582351398568048,
        'B3': [{'C1': [12201, 39510], 'C2': 0.05278116856573112},
               {'C1': [17419, 4671], 'C2': -0.16738310807087875},
               {'C1': [64677, 4264], 'C2': 0.4214005496450801},
               {'C1': [51433, 64911], 'C2': -0.5352602068610723}],
        'B4': {'D1': 1043,
               'D2': 17037952403381402970,
               'D3': [3601240858, 1799619776, 1340964475, 4098901811]},
        'B5': 886663147,
        'B6': 8399353944497576784,
        'B7': 4042287725820325108,
        'B8': 43725},
 'A2': -1698030958404017274,
 'A3': -41254953,
 'A4': 33802,
 'A5': 65,
 'A6': [82, 85, 33, -105],
 'A7': 4111}

Вариант №18

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

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

(b'JZC\xb1\x00\x00\x005B\xce\x07\x9dd\x94 \xea?\x02\x00\xbe\x00\x0e\xbe+'
 b'\x05\x06h\xa1\x8bkH\xaaDgx\xefb>\xc3\x89"\x13_\xda\x97\x16!`\x98m\xaaY'
 b'C\xb3\xa9\xf0\xa0\xe1\x02\xa9jh\xd1\xbfD;\x8dq\x03\x00\x00\x00\x1f\x00,m'
 b'f\xbfW\x88\x07?\x1dD)OxQ\x9d\xda?\x02\x00\x00\x00%\x00\x00\x003 "\xbf$'
 b">'\xbb\xbca\x11p\xaa\xcb$J'\x02\xa2\xdd\x9b\xac@\x89D\xa7\x7f\x08\x93 \xe2@p"
 b'\xda\xf0\xd7\xbfN\xfbV\xff\x03\x00\x00\x00g\x00|&\x7f\xbe\xe4m\x01?O\x9c%amC'
 b'\xcf\xd0?\x02\x00\x00\x00m\x00\x00\x00:\x81g\xbe\x01\xfa\x15\x00-'
 b'\x00u\x00\x02\x00\xaf\x00\x00\x00KhQ\xdd>>t\x1f\xbf')

{'A1': {'B1': {'C1': 10061437417588243982, 'C2': 18539},
        'B2': [{'D1': 8470,
                'D2': 96,
                'D3': {'E1': -1105155131694223976,
                       'E2': -0.27199808602338216,
                       'E3': 68,
                       'E4': 36155,
                       'E5': 113,
                       'E6': [17578, 30823, 25327],
                       'E7': -0.9001033306121826,
                       'E8': 0.5294241309165955},
                'D4': 29,
                'D5': 0.4158519434828529,
                'D6': [579453758, -1747296493],
                'D7': -0.6333038210868835},
               {'D1': -8798,
                'D2': -101,
                'D3': {'E1': -7851885593934348116,
                       'E2': -0.37407551729441657,
                       'E3': 78,
                       'E4': 22267,
                       'E5': -1,
                       'E6': [15908, 47911, 25020],
                       'E7': -0.2491702437400818,
                       'E8': 0.5055830478668213},
                'D4': 79,
                'D5': 0.26265035325612884,
                'D6': [-878022639, 36129316],
                'D7': -0.22607889771461487}],
        'B3': [1, -6],
        'B4': 75},
 'A2': 16949,
 'A3': 0.8164770093064762,
 'A4': [0.43226170539855957, -0.6228674650192261]}

(b'JZC\xb6\x00\x00\x00\xf3\xd5pbeA?.\xb6\xbf\x02\x00\xc3\x00\x91\x82\xf9'
 b'\x88\xf9\xab\x118!\x8c-y#y2\xabEn\xc6\x16ypa\xab\xba\x94\xf4=\xc7\x13|'
 b'\xd8\xa0Vg\xe04H/\xbc\x96\xdb?\xd1\xbc\x9e\xc5\x03\x00\x00\x00\x1f\x00{\x18'
 b'}\xbd\xfe\xa7\xe1>?\x00\x80F\xbb\xc8\xb5d?\x02\x00\x00\x00%\x00\x00\x00\x98'
 b'n\xab>\x8f\x97y\xce\xa4\xfa0}\xf1\xaa\xef\x99 \xee\x9c\x83\xcb^F\xe0\xc1'
 b'\x01\xa8E\xf0\x10\xd6\xdb\x87\x07-\xc5\xbf\xf8\xe8nU\x03\x00\x00\x00'
 b'g\x00\xdf\xf8\xfd\xbe\xca\xae\xb2\xbe\x05\x90a)@\xddJ\xc6\xbf\x02'
 b'\x00\x00\x00m\x00\x00\x005\xf7\x1d=\xa2a}\x90\xbdw\xb3\x15\x00-\x00u\x00'
 b'\x07\x00\xaf\x00\x00\x00\xa9{\xb0\xd4>\xd1\xe4\x7f\xbe')

{'A1': {'B1': {'C1': 4040199428961305233, 'C2': -29663},
        'B2': [{'D1': -27462,
                'D2': -12,
                'D3': {'E1': 7446315885558744893,
                       'E2': 0.431075140165218,
                       'E3': 209,
                       'E4': 40636,
                       'E5': -59,
                       'E6': [31021, 31011, 43826],
                       'E7': -0.06179092451930046,
                       'E8': 0.4407348036766052},
                'D4': 63,
                'D5': 0.002528087667272416,
                'D6': [382103109, -1419677575],
                'D7': 0.33482813835144043},
               {'D1': -31844,
                'D2': -53,
                'D3': {'E1': -1133315005712677282,
                       'E2': -0.16543668874480533,
                       'E3': 248,
                       'E4': 28392,
                       'E5': 85,
                       'E6': [38799, 52857, 64164],
                       'E7': -0.49603936076164246,
                       'E8': -0.3489897847175598},
                'D4': 5,
                'D5': -0.1741596759118349,
                'D6': [-1427014352, -299853329],
                'D7': 0.03856583312153816}],
        'B3': [-94, 97, 125, -112, -67, 119, -77],
        'B4': -87},
 'A2': 54771,
 'A3': -0.08664317461569637,
 'A4': [0.4154089391231537, -0.24989630281925201]}

Вариант №19

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

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

(b'KZBQLbvtosO8\xba_\x8e\xca7\x12oyqil>a\x02\xe7\xc7\x03\x87\xa8gxsoj'
 b'\xd8\xfd\x85\xc6\xe5\x0e\x8f\xe8\xbf\xe9r\xb6\x84"E"\x02F\xfd*'
 b'\xbf\x01\xf0\x9e>\xd7\x0b%\xbez\x17\xa9\xbe\n\xb4\x02\x00\x05\x00\x85'
 b'\x8b\xe5\x95\x0c\xc8\xe6\x90\x04\x03\xf0\xdf\x89\x1e(A\xf5\x90]Q\xcf'
 b'\rG\x1d\xbc\xab\x82\xdbc\xbe\xb0T\xed\xa4%w\xf78V\xf6\x1b?\xe5\x17\xaej(D6'
 b'\xb3\x915\x00\x9c9P\xa3~\xbfD\x02\x8d\xbd\x1e= \xbfV\xcd\xa3\xbfg\xf5'
 b'\xc4?6\xd9/x\x00\x94\xd1\xa0\x00\x03\x00\x99\xfc\xee\x94')

{'A1': [{'B1': 'bvtos', 'B2': 5708517447272380178},
        {'B1': 'oyqil', 'B2': 4494877097592063912},
        {'B1': 'gxsoj', 'B2': 15635800570593185768}],
 'A2': -0.7952530461063001,
 'A3': 2,
 'A4': 70,
 'A5': -726,
 'A6': {'C1': {'D1': [-0.5075777769088745,
                      0.4200069010257721,
                      -0.24423088133335114,
                      -0.1354523003101349],
               'D2': [-0.7656639218330383,
                      -0.03863251209259033,
                      -0.8390752673149109,
                      -0.9060938358306885,
                      0.7142514586448669],
               'D3': 35813,
               'D4': 38156,
               'D5': 14476416399149424521},
        'C2': {'E1': 2173059343151092175,
               'E2': 956766142008056675,
               'E3': -0.3443979322910309},
        'C3': 11827991900044326427,
        'C4': 0.6591407845863901,
        'C5': {'F1': -77, 'F2': -28363},
        'C6': {'G1': 53664, 'G2': [120, 0, -108], 'G3': 64750, 'G4': 148}},
 'A7': 961586046}

(b'KZBQLywbsf\xf7\xd5\xad!sP\xde3tcdal$\xa0H\xa3M-B\xd6rskri\x14\x8e\x96\x91'
 b'l\xc6\x1aG?\xe3\x08h_\xd1\xd8N\x95\x93\x97\x94\xbfX\xab\xbf>RS\x04>\xc5JA'
 b'>\xc2\xd6\xdf\x00\x03\x00\x85\xcdH\x80\x8a\x92\xe7\xce\xa3\xaa\xd7\x80@'
 b"'\xf3\xb3D\x98\xcb\x0bCc\x83\xea\xaa\n\xc4\xa5->\xea\xd87<\xb4c\xef"
 b'E\x1d\xe6\xd6\xbf\xe6\x82)\x87B\xe6\xd2l\xbc\xa4\x00\x94\xf0DjG>\xe4\xa7'
 b'\x1c\xbe\x93\x88\x93>\rOJ\xa5\x10\x9e##\x00\x03\x00\x91\xf3u6')

{'A1': [{'B1': 'ywbsf', 'B2': 17858370256587775539},
        {'B1': 'tcdal', 'B2': 2639189247850791638},
        {'B1': 'rskri', 'B2': 1481286878790818375}],
 'A2': 0.5947763320425652,
 'A3': -107,
 'A4': -109,
 'A5': -26732,
 'A6': {'C1': {'D1': [-0.8463706374168396,
                      0.20539480447769165,
                      0.3853321373462677,
                      0.38054558634757996],
               'D2': [0.4465874433517456,
                      -0.288151353597641,
                      0.13799777626991272],
               'D3': 52552,
               'D4': 32906,
               'D5': 10585656651498881088},
        'C2': {'E1': 2878841694022470467,
               'E2': 7170833047749961005,
               'E3': 0.4586808383464813},
        'C3': 4374231017391515350,
        'C4': -0.703388942892355,
        'C5': {'F1': 108, 'F2': -17244},
        'C6': {'G1': 8995, 'G2': [-91, 16, -98], 'G3': 62325, 'G4': 54}},
 'A7': 4031015495}

Вариант №20

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

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

(b'OMC\x1a\x00\x00\x007\x00\x00\x00t\x00\x00\x00\x03\x00\x00\x00\xa8'
 b'\x00\x00\x00\x86\xe1W\xc7\x19>\xdd\n\x97\xa8+\xabAtC\x87\xfe\xf5\x11X\x96'
 b'\x19\xde\xe8-=\xc7\xa6\x81\x16d>\xf9\x88\xdcL\x04\xc0b\xca\xd4\xc8m\x02\x94'
 b'\xd8\xa4\x1f\x8fP\xcfp$\x0cK\xf1\xdd\x1a\x1d\x14\xbf\x00\xcc\x0e\xf3'
 b'\x885y\x9f \xb5\xb1\xa4\xdf\xb2`\xe3\x15\xd9/\xbeK\xc1\x93\xde'
 b'\xbc\xfe\x8c\xd1\xef\xed\r\x0b|\xd9\xb2*zI\xda\xbf\x80\x9b\xd5\xd7;\xee\xae?'
 b',^B\rui\xdf\xdb\xc4\x05`i\xa8\x95\x90x\xd9V\x8a\xf8`\xd8q?\xb1\x90\xae\xa2'
 b'\xda57\xe4\x04\x00T\x00*\xcb\xa2\x9f\xbaC')

{'A1': [{'B1': {'C1': 6599,
                'C2': 62,
                'C3': 2781,
                'C4': 151,
                'C5': 168,
                'C6': 17725753907159870251},
         'B2': 4408435650875250705,
         'B3': 42695,
         'B4': 0.22274209558963776},
        {'B1': {'C1': 35065,
                'C2': 220,
                'C3': 1100,
                'C4': 192,
                'C5': 98,
                'C6': 11878406755342406858},
         'B2': 5407737319498223391,
         'B3': 56817,
         'B4': -0.5785690546035767}],
 'A2': {'D1': -0.4107346932390994,
        'D2': 0.060411329361889976,
        'D3': [-2603246108142313940,
               8687608231752631748,
               4571673007756039897,
               -2002072296194404175],
        'D4': [-6955469287187362816,
               -2062451955725126368,
               -2408368844655568619,
               796554323383090876]},
 'A3': [-13526, -24670, 17338],
 'A4': 57734,
 'A5': 87}

(b'OMC\x1a\x00\x00\x007\x00\x00\x00l\x00\x00\x00\x06\x00\x00\x00\xa0'
 b'\x00\x00\x00\xfdh\xe9\xc7\xcd\xd9\xb2\x02\xee:\x14\x162\xaf\x84\x94\x9c'
 b'\xa3\x97\xd5h\xf9\x00\xbekrG\x16Cf\xd3\xbe\xd4\t\xfd&\x04L\xe0>F'
 b'\x03\x06\xda\xd5\xbc\xff\x0bMR/\xb7\xea\x99\xc0}\xe8]m\xcd>\xe3r\x83\xa1'
 b'|F\x0f\x02\xa1\xef\x16#\xbc\xb8\x97~%\x9b\x00\x06\xdb\xb6\xfd\xb4`\x07\xcb8'
 b'\xef\xb4\xda\xbf\xee\x91\x9a<$n\xee\xbf\xcb\xd4\xeb!BB=\xe8\x15\xb89|U\x8f7`'
 b'_\xeb\xb4\x8c\xad\xbc\x9a\x06pjH\xca\xc5\x13\xac\xdb\x03\x00T\x00'
 b'\xe2\x05\xbe\x18s5\xe9-u>8\xdb')

{'A1': [{'B1': {'C1': 52679,
                'C2': 217,
                'C3': 690,
                'C4': 238,
                'C5': 58,
                'C6': 11789461222145005076},
         'B2': 8244892454225499543,
         'B3': 5703,
         'B4': -0.4128895699977875},
        {'B1': {'C1': 2516,
                'C2': 253,
                'C3': 1062,
                'C4': 76,
                'C5': 224,
                'C6': 18427838907673691710},
         'B2': 13878381799212731659,
         'B3': 59517,
         'B4': 0.4012250006198883}],
 'A2': {'D1': -0.41729336305808395,
        'D2': -0.9509450133960493,
        'D3': [-1712139431526542133,
               6933167748679317525,
               475900164217039711,
               -2617695543185872272],
        'D4': [148414813826151139, 9121962688444297121, -5404962925959931099]},
 'A3': [1506, 6334, 13683, 11753, 15989, -9416],
 'A4': 26877,
 'A5': -23}

Вариант №21

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

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

(b'HDM\xac\xb0k0\xe9\x98\xa4J y\xe2\xefW\x00\x02\x00\x00\x00F>\xf3\xf8\xc5#v'
 b'\xb7\xd4\x00\x00\x00H\x00\x00\x00c\x00\x00\x00~\x14nd\x04m$\xd1cd\x8a'
 b'\xe4\xe9\x1d")\xc8\x00\x99\x00\x00\x00\x04\x00\x00\x00\xab\xf6\xb0mb'
 b'\xbb\xfb\xbb|\x05\x10\xfa\xff\xd8\x9f\t\xbf\x0c\x89p<\xf9\xf8\xbb\xbfqFa\xbe'
 b'\xbd>U\xe5b\xe9\xaa\x0b\x0b\ty6\xa9\xb0\xbe[\xa0\xf0?A\x1b)?#\x04\xfe>\xe5'
 b'\xc2\x8b\xd8\xc6\xe3-\xcal\xf9wZ\xdb\x83\xbfqso=\x15\xc8O\xbd\x819/\xbe\xec&'
 b',\xe1W\xd4\x96b\xe2\x80~53?\xdcS1\xc4\xdc\xb9\xb8\xab*7\xd2ZC\xba\xbc')

{'A1': -6003180445463174070,
 'A2': 8313,
 'A3': -30,
 'A4': -4265,
 'A5': 'mb',
 'A6': 0.4765073359012604,
 'A7': 594982868,
 'A8': {'B1': [{'C1': 3153836924,
                'C2': 1296,
                'C3': -83896161,
                'C4': 9,
                'C5': [-0.5489721298217773,
                       0.03051411174237728,
                       -0.9424801468849182,
                       -0.36961618065834045]},
               {'C1': 3848464810,
                'C2': 2827,
                'C3': 158938793,
                'C4': -80,
                'C5': [-0.21448111534118652,
                       0.7543206810951233,
                       0.636794924736023,
                       0.4487498700618744]},
               {'C1': 3636912941,
                'C2': 51820,
                'C3': -109618469,
                'C4': -125,
                'C5': [-0.9431676268577576,
                       0.03656798228621483,
                       -0.06309735029935837,
                       -0.46122872829437256]}],
        'B2': 342778884,
        'B3': 1831129443,
        'B4': 7244854640446155208,
        'B5': {'D1': [57687, 54422],
               'D2': 1659011198,
               'D3': 13619,
               'D4': 0.44257778382134516},
        'B6': [-21718, 14290, 23107, -17732],
        'B7': -2384}}

(b'HDM\xdb\xec2\xf4\xacQ\xdf\xbbQk\xdd\xae\xb1\x00\x04\x00\x00\x00F\xbe\xfa'
 b'd\x1b\x90\xe1\xe0@\x00\x00\x00J\x00\x00\x00e\x00\x00\x00\x80lW\x9d(\xb6\x00'
 b'\xfe\xa3H\nAqG#\xd89\x00\x9b\x00\x00\x00\x02\x00\x00\x00\xad\xfe\x96tpav`d'
 b'\x18\xa7}\x00?\x83+\xe1\x08>\x90w\x9c?\x1f\xbb\xb5\xbe\xdb}O\xbe7\xc3'
 b'\xa2\xf3FE/\xa1\xd1\x0bOk\x1a\xdb\xbe\x86Z=\xbf@\xc9\\?1\x0f\xa4\xbe\rKt'
 b'j\xfa[Ob\xe2\x8ctNK\xe3?\x1c\xd9\x0c>\xea0\xde?s\x99\xdf:\xc6\x9b,\x02'
 b'v\xfdqr\x9b\xa6\xac\x14\x90\xbf\xee\x97\x97\x13\x91\xffn\x0ftZ\xd4')

{'A1': -2599646858455162949,
 'A2': 20843,
 'A3': -35,
 'A4': -20815,
 'A5': 'tpav',
 'A6': -0.48904499411582947,
 'A7': 2430722112,
 'A8': {'B1': [{'C1': 1617172647,
                'C2': 32000,
                'C3': 1065561057,
                'C4': 8,
                'C5': [0.28216254711151123,
                       0.6239579319953918,
                       -0.4286904036998749,
                       -0.17945721745491028]},
               {'C1': 4081468719,
                'C2': 41425,
                'C3': 189754138,
                'C4': -37,
                'C5': [-0.26240721344947815,
                       -0.7530725002288818,
                       0.6916449069976807,
                       -0.13798314332962036]},
               {'C1': 1794792271,
                'C2': 25314,
                'C3': -1938534837,
                'C4': -29,
                'C5': [0.6126868724822998,
                       0.45740407705307007,
                       0.9515666365623474,
                       0.0015152445994317532]}],
        'B2': 1817681192,
        'B3': -1241448797,
        'B4': 5191033475278559289,
        'B5': {'D1': [630, 64881],
               'D2': 1922803372,
               'D3': 5264,
               'D4': -0.9560046560509201},
        'B6': [3956, 23252],
        'B7': -362}}

Вариант №22

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

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

(b'\xefRML=Y`\xa0\x13\x02\x00h\x00\xee\xde~1w.\xfc\x04kd\xcfr\xf8\\\xb7\xe7#Lb'
 b'\x83\x92\xfb9_\x87\xe9N\x82D\xabm\xba"\xd5\xfaV\x11\xbb\x8bR\xc5pU'
 b'\x9f\xc1\xab\x15f\x9d\x9dk*\x96nIc\xbd\xa7\x90[\x12\x86\x03\x9e\xad\xbb\xe6'
 b'(hR\x06\xac\xbd\xb6(18N\xcd\x91\x86\xcf\x87yJ\xfb\xb4P\xac\x1dA\xca\x8c\xdc>'
 b'\x0b\x17\x9c\x95\xc5,\xee\xe8\x1a\xcdA\x11uTC\x88\xd6\xbfV\xac\xdd/\xb7?'
 b'C\xb3I\xbf\x04\xae\x05\xfa\xe4\xe5\xa2\xbaV\x99\xe3\x84b\xc8\xa9m'
 b'\x08}\xa9\xc5ia\xf8\x10')

{'A1': {'B1': {'C1': 22845,
               'C2': 96,
               'C3': 5024,
               'C4': [{'D1': 0.4307616353034973,
                       'D2': -1662341985322920181,
                       'D3': -8627959599334306534,
                       'D4': [-42, -65, 86, -84],
                       'D5': 1068969949},
                      {'D1': -0.7878915667533875,
                       'D2': -4998179864817848828,
                       'D3': 7902067346660104534,
                       'D4': [8, 125, -87, -59],
                       'D5': 284713321}]},
        'B2': [359213159749181166,
               -1749827708062309269,
               6861792113963715619,
               -5013162499461158521,
               5948053416020989218,
               7355974414469787845,
               7154371074290589085,
               -7060652377383065667],
        'B3': -17491},
 'A2': 1382557926,
 'A3': [5636308984588512262, 18107418876005749197],
 'A4': [20660, 7596],
 'A5': 65}

(b'\xefRML/\x85N\xd3X\x02\x00h\x00(\xcc\xcfo\xfan\xca\th\xf2f\x0c\xb5,\xdd'
 b'\x8b\xe3Cn@\xf9\x0bM\x90\xfe\xec\xfb\xf8\x8dm\xe3\xb3\xa7\x8a\x1c'
 b'\x9a?\xfa\x94\xfb\x8c5\n-p{a\xa6\xbc\x7f\xa0\xc5\x06\x1d\x0f\x87\x1b\xc7+'
 b'\x9b\xda\xd8K\xe6\xb9/D:\xc3!\xda-\xd0[3\x92\xce\x04tn9\r\x95M\x1a\x04\x9c'
 b'\x9b\x9a\xbf\x91A\xbfF\xbe\x03\x90\x99\x11\x0f\xdb#\xda\xe0\x881A/\x80f\x9c'
 b"@\xac'\xb1`c\xccH\xe2\n\x13\xbdB\xd7\x91\xf6\xda\x83\xa3O\xa2\xb3\xd95"
 b'\xe0A\\,\xbb\x19sY\xe2\x99-\x00')

{'A1': {'B1': {'C1': 34095,
               'C2': 78,
               'C3': 22739,
               'C4': [{'D1': -0.19408895075321198,
                       'D2': -2728096091490119677,
                       'D3': -7176908015722723104,
                       'D4': [64, -84, 39, -79],
                       'D5': 1221354336},
                      {'D1': -0.035899050533771515,
                       'D2': 5738575326663006018,
                       'D3': 3196502266758149026,
                       'D4': [-69, 25, 115, 89],
                       'D5': 2988514}]},
        'B2': [705498313533672488,
               -8368483376475737496,
               -8048763793885477917,
               -5484419464672056066,
               -318354522561017177,
               -6457744668950383220,
               -8714714839015981124,
               -1852148388315019493],
        'B3': 12217},
 'A2': 566442564,
 'A3': [346374970635464154, 295634028113522292],
 'A4': [39836, 49050],
 'A5': -111}

Вариант №23

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

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

(b'\xa9FNR\x02\x00\x00\x00d\x00\x00\x001\x91O\xaf\x02\x00\x00\x00f\x00\x00\x00'
 b'^\xa4\xecc\x97\xa0\xa8\x95TQ\xa9vA\xbb\x7f\xeet\x8d\x16h\x06\x00\x00\x00'
 b'h\x00\x00\x00&J\t?KDw\xef\x001\xfa\x9c2\xaf`\xfc\x82\x90\xad\xf4v?.\xa2'
 b'S\t\xfc\xa1\x8c\x84xQ\xae\xc3&\xbe~1[\xbfR.\x92>\x8f\xf8\x1d\xbfnhtm\x1a6P\t'
 b"\xd2+\x0e\xcc\xe5v\x12\x19?\x1b\xe5G\xb2#\xb4\xe7\xaf'\x9e\xe1\xf9\xa1j,"
 b'\xe5#B\xad\x82V\x0bY\xaeM\xfc\x07n\xb6\x8e\x90j\xeb\xb9\x97')

{'A1': [{'B1': 'nh', 'B2': 2941227313}, {'B1': 'tm', 'B2': 1676452958}],
 'A2': [-24425, -27224],
 'A3': 20820,
 'A4': 30377,
 'A5': {'C1': 7500337762789210945,
        'C2': [-3743006059198925286,
               5180576904177153765,
               -2189268732395379790,
               -5962163489485446663,
               575420263610144386,
               -7513715660366629266],
        'C3': 0.5362876653671265,
        'C4': -7135336779527797685,
        'C5': 44850,
        'C6': 2424503392},
 'A6': 0.9646709561347961,
 'A7': -8895557060103265746,
 'A8': {'D1': 20856,
        'D2': [-0.1628558337688446,
               -0.8562239408493042,
               0.2855096459388733,
               -0.6170739531517029]}}

(b'\xa9FNR\x04\x00\x00\x00d\x00\x00\x00\x1aR\xba\xcd\x02\x00\x00\x00'
 b'h\x00\x00\x00+\x06\x98Nh\x0f\xf2S\xd5\xacG\x07h\x1b\x05\xdf\xa5\xda\xde_'
 b'\x02\x00\x00\x00j\x00\x00\x000\xa9\x0e\xbf@J\xc6\xe7!S\xce\xb2\x1dk(\xd6'
 b"\xd4Sw\xa9b?\x94/'\xe4\x82\xdf@XV\x1e\xfcR4>\x9d\xb7h\xbf\xcb\x99n\xbe"
 b'v\x9fk?iqlupy5\x96aP\xde\x9c.\r\xf4\xd1m\xc8\x0b\xee\xb8+')

{'A1': [{'B1': 'iqlu', 'B2': 3451539994}, {'B1': 'py', 'B2': 1318585899}],
 'A2': [3944, 21490],
 'A3': 44245,
 'A4': 1863,
 'A5': {'C1': 6908199284379032424,
        'C2': [949869050066998837, 3150529673720353268],
        'C3': -0.5572690963745117,
        'C4': -5562417084668425664,
        'C5': 27421,
        'C6': 1406457384},
 'A6': 0.8853983283042908,
 'A7': 6359328427113656212,
 'A8': {'D1': 7766,
        'D2': [0.1760978102684021,
               -0.9090517163276672,
               -0.23300854861736298,
               0.920401930809021]}}

Вариант №24

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

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

(b"ZZBP'\xb4N\x93{\x98]\xda\xbf\xe1\x82\xbf\x1d?-\x93\xb2.\xfd\xdeQ\xdc\x0fK"
 b'\xf8\xaf\x9d\x02\x00\x00\x00Q\x00\x00\x00[\x00k\x00{\x00\x8b\x00\x9b'
 b'\x00\xdd{U\xe1i\xb0\xe5(K\xd3\xda\xc2u\xfb\x0c\x03\x00\xa3\x00\x00\x00<\xda'
 b'\xb6\x9d:I\xfd>\x11\xbd\xd4da\x16\x07\x1f\xa9q\x0c\xa6V\x7f\x02\x00S\x00'
 b'\x00\x00\x03/>\xbf\xb9\xe22\x0f\x99\xbb\x02\x00c\x00\x00\x00\xe5\xc0'
 b"'\xd4\xc6?\xfe\xb6\xbd\xc1\x02\x00s\x00\x00\x00\x94\xc5)\xc0j\xb5|\xf9rD"
 b'\x02\x00\x83\x00\x00\x00\xc5\x14\x1egk\x08\x13\xcb\x90\xdf\x02\x00\x93\x00'
 b'\x00\x00\xf1(C-\xf2\xe73')

{'A1': -0.41196262424385144,
 'A2': {'B1': -31, 'B2': 0.6162034273147583, 'B3': 783455021, 'B4': -3},
 'A3': -7084170687558168098,
 'A4': 'da',
 'A5': [{'C1': 127, 'C2': [-1457584362, 1453722737], 'C3': 3},
        {'C1': 187, 'C2': [-1178649041, -1727057182], 'C3': -27},
        {'C1': 193, 'C2': [-959174720, -1112080833], 'C3': -108},
        {'C1': 68, 'C2': [1790978501, 1928953013], 'C3': -59},
        {'C1': 223, 'C2': [1801920020, -1865739512], 'C3': -15}],
 'A6': -514491427,
 'A7': {'D1': 45161,
        'D2': -327141152810915611,
        'D3': 12,
        'D4': [17192, 61997, 13287],
        'D5': 55868,
        'D6': -74},
 'A8': 15329427668874115741}

(b"ZZBP'\xe09R_\x8e\xa8\xd5\xbf\xd72W\x8d\xbe%M@l=\xd8\xffYWYW\xad\x05\x08"
 b'\x00\x00\x00Q\x00\x00\x00a\x00q\x00\x81\x00\x91\x00\xa1\x00\xbb\x0c^'
 b"\xff\x90\xd2^h\x93\xd0\xd6j\xff\xc4'\x03\x00\xa9\x00\x00\x00\xef\xe8M\xa9&i"
 b'\x82_\xcd\xd8\xe5jxrnewtszHg\x9aYE\x0e\xa2\xd4\x02\x00Y\x00\x00\x00'
 b'AT\xe0\xbc\xaf\xdc\x12\x8b\xa9\xcc\x02\x00i\x00\x00\x00i\xae\xbd\xfd'
 b'\xb7\xce\x879\xf6\x94\x02\x00y\x00\x00\x00\xda@\xc6\xb30\xab\tX1\n\x02\x00'
 b'\x89\x00\x00\x00\xde\x1c\xc0\x8e}\xc4\x92\x948\x93\x02\x00\x99\x00\x00\x00'
 b'\x9e\x1c\x8f\x96`\xfa\x98')

{'A1': -0.3384128504630137,
 'A2': {'B1': -41, 'B2': -0.27605587244033813, 'B3': 1816153381, 'B4': 61},
 'A3': 409079182389805016,
 'A4': 'jxrnewts',
 'A5': [{'C1': 212, 'C2': [-1704507270, -1576123047], 'C3': 65},
        {'C1': 204, 'C2': [-1346576300, -1450503460], 'C3': 105},
        {'C1': 148, 'C2': [-1208107602, -164001842], 'C3': -38},
        {'C1': 10, 'C2': [817088064, 827853227], 'C3': -34},
        {'C1': 147, 'C2': [2106507292, 949260996], 'C3': -98}],
 'A6': -10613573,
 'A7': {'D1': 53904,
        'D2': -4251562052359591842,
        'D3': 39,
        'D4': [36636, 24726, 39162],
        'D5': 59631,
        'D6': 77},
 'A8': 16562213439748515497}

Вариант №25

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

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

(b'TXNY\xd9\xb3\xfb\x88\x16x7\xad\xb0\x00\xc1x\x1f\xf9n\x1a\xd9\x99\xd9\x00'
 b'\x00\x00exrs\xb2\xbd\x12do#\xd7\xbf\x94J7\xe8\x02\x00\x1e\x00\x00\x00'
 b'~\xcb\xfa\xdd>I\x82\x16\x02!!2q\xbf\xad\xfb\x03\x000\x00\x00\x00h\x83&\xfbXB'
 b'r\xf3?\x8c\x8cE\x06\x03\x0c#\x03\x00F\x00\x00\x00\x93\xe1\xc8\xa6'
 b"=\xa2\xae\xea;\xc4\xed'\x02\x00\\\x00\x00\x00\xa80\x17\xedXu\xd5\xad{v"
 b'L\xff\x02\x00n\x00\x00\x00\x1d8\x8e[,{\xea\x02\x93\x038\x1b\xc4\xd8\xf9\xba'
 b'\x03\x00\x80\x00\x00\x00&\x00\x00\x00<\x00\x00\x00R\x00\x00\x00d\x00'
 b'\x00\x00v\x00\x00\x00\x8c\x00\x00\x00\x1ce\xdank\x9a\x87\x83\x8d\x07'
 b'\xdb\xeeY\x10\xe9\xdf\x07\x98"bw\x04\x00\x00\x00\x1a\x00\x00\x00\x06'
 b'\x00\x00\x00\x96\x00\x02\x00\x00\x00\xae\x00\x00\x00\x87>\xbb\n"\xbf')

{'A1': 3996969446885546329,
 'A2': -83,
 'A3': {'B1': 2590731994,
        'B2': 126714759,
        'B3': 61147,
        'B4': 7071381524513886297,
        'B5': 119,
        'B6': 'exrs',
        'B7': [{'C1': -399029612, 'C2': [1678949810, -1076419729]},
               {'C1': -72499343, 'C2': [-570766466, 377637182, 841031938]},
               {'C1': 587989766, 'C2': [-81362072, -210615720, 1166838847]},
               {'C1': 669893691, 'C2': [-1496784493, -357653955]},
               {'C1': -11766149, 'C2': [-317247320, -1378519720]},
               {'C1': -1158031164, 'C2': [1536047133, 48921388, 456655763]}],
        'B8': [28, 101]},
 'A4': -7360823052032051007,
 'A5': {'D1': 16007, 'D2': -0.632976233959198}}

(b'TXNu\x80\xf7?\xa0\xd8\xd1=O\x92\x00P\xe60Yh{\x94\xeb\xbb\x00\x00\x00jg'
 b'rnM\xd4Sf\xc69\xb2n(\xc2\xe4\x1a\x02\x00\x1e\x00\x00\x00\x9c\xf7\x8b\xbc'
 b'\x88\xaeKn{\xe4i\x89\x91\xe2\x10\xcb\x03\x000\x00\x00\x00\xd6\xf3'
 b'\xa8\xc0A\x19\\B\xc2\xb6\xde\x07\x02\x00F\x00\x00\x00x\xd4r\x88\xb5\x8eL\xbf'
 b'\x1f-\xcaM\x02\x00X\x00\x00\x00\xc7d\xd8\x8a\x16\x8c#\xd9P\x0b\x8a\\\x02\x00'
 b'j\x00\x00\x00&\x00\x00\x00<\x00\x00\x00N\x00\x00\x00`\x00\x00\x00'
 b'r\x00\x00\x00}U\x1dj\xee`\x80\xd6SQw\x12]\x98\xca=wR\x17\xed\xb4\x04\x00\x00'
 b'\x00\x1a\x00\x00\x00\x05\x00\x00\x00|\x00\x02\x00\x00\x00\x90\x00\x00\x00*'
 b'?\xd6[a\xbf')

{'A1': 4454579689225683061,
 'A2': 79,
 'A3': {'B1': 1626237469,
        'B2': 1364448896,
        'B3': 4727,
        'B4': 17084214383544539229,
        'B5': 180,
        'B6': 'jgrn',
        'B7': [{'C1': 451199528, 'C2': [1716769869, 1857173958]},
               {'C1': -888085871, 'C2': [-1131677796, 1850453640, -1989548933]},
               {'C1': 132036290, 'C2': [-1062669354, 1113332033]},
               {'C1': 1305095455, 'C2': [-2005740424, -1085501771]},
               {'C1': 1552550736, 'C2': [-1965529913, -651981802]}],
        'B8': [125, 85]},
 'A4': -1471415490140117424,
 'A5': {'D1': 16170, 'D2': -0.8803075551986694}}

Вариант №26

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

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

(b'VKRn\r\xbf\xeb8\x07\x08r\xb7j\x00\x02\x00Aqgpa9\x8f\tiY\xd5\xff\x00\x00\x00I'
 b'\xb9??\xd5mOy\xab\x900\x00\x02\x00\x00\x00 F\xbb?\xbf\xde\x1b\xb8\xeb'
 b'\xa7}\xd4\x00\x03\x00\x00\x000\x00\x00\x00"\x00\x00\x003\xe8i')

{'A1': {'B1': 28173,
        'B2': -0.8505892910959407,
        'B3': [{'C1': 0.33479678041317396, 'C2': [185, 63]},
               {'C1': -0.4704420377074403, 'C2': [70, 187, 63]}]},
 'A2': 'qgpa',
 'A3': 57,
 'A4': 143,
 'A5': 2409,
 'A6': [89, 213],
 'A7': -1,
 'A8': {'D1': -24, 'D2': 105}}

(b'VKR\r\xcf\xbf\xe4%\xfa\x91\x8e\xb2f\x00\x04\x00bhzlr\x98\x04\n'
 b'\x8a\x88\xcc\xf8\x00\x00\x00r\xa6*z\xbf\xd5^J\xb8\xc8S`\x00\x03\x00\x00\x00'
 b' M[?\xe1\xa3\xd8UZ\xd9\xa6\x00\x02\x00\x00\x0014s\x18?\xd4o\x12\xec\xfa+\xec'
 b'\x00\x03\x00\x00\x00A\x88\xd4\xbf\xe8\xd1\x8e\xca\xf2B\x08\x00\x02\x00\x00'
 b'\x00R\x00\x00\x00#\x00\x00\x003\x00\x00\x00D\x00\x00\x00TV\x8d')

{'A1': {'B1': 3535,
        'B2': -0.6296360819738538,
        'B3': [{'C1': -0.33388011975448784, 'C2': [166, 42, 122]},
               {'C1': 0.5512506167495317, 'C2': [77, 91]},
               {'C1': 0.3192794145804203, 'C2': [52, 115, 24]},
               {'C1': -0.7755807842059435, 'C2': [136, 212]}]},
 'A2': 'hzlr',
 'A3': -104,
 'A4': 4,
 'A5': 2698,
 'A6': [136, 204],
 'A7': -8,
 'A8': {'D1': 86, 'D2': 141}}

Вариант №27

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

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

(b'FSXL\xcds\x00\x00\x00\x10?p\xed4)\xdf\xc2\x837\x8c\xb6WZ\xb9\xff\x176m'
 b'S{\xb6B%^\xc0t\xb8\xe9\x80~X\x8b\xea\x1d\xbc\x87\xed\xb2\xd6\xf4\x82\xde'
 b'\xe6E\xe2\xd6m\xca\xda\x15\xca\x83!V\xc2\xdb\x16\xbb;{\xb3j>It\x95'
 b'\xa0a\xad\xf0\xb1\xa2\x86i\x04\x085\nB\x98a/\xbfOy.\xdd)\x0eF\xcf\xe9\x88O'
 b'\xf8D\xed\x87\xac~\xda\x8b\x01z?\xfc\x0bp\xb4x\xe9\xd3?oebd\x9c'
 b'\x06\xbf\xaa\x9d\x1f\x1e\xe2>\x1cE;\xbe\xba4\xe0\x9c(Sc\x00\x00\x00')

{'A1': {'B1': 0.31112496968142955,
        'B2': {'C1': 'oeb',
               'C2': -0.5258238315582275,
               'C3': -25174,
               'C4': {'D1': [0.4416360557079315, -0.18288081884384155],
                      'D2': 2631939258,
                      'D3': 21288},
               'C5': {'E1': -1349680967821177018,
                      'E2': -629232505,
                      'E3': 0.9765860438346863}}},
 'A2': -4404756603246461168,
 'A3': -1232324733,
 'A4': [{'F1': [4290337367, 1399666199, 625129083, 3094659166, 1484685545],
         'F2': -0.009638438932597637},
        {'F1': [3602050439, 3873342196, 1842799173, 3390429898, 3260424579],
         'F2': 0.005709511693567038},
        {'F1': [1047180155, 2694149193, 2985340257, 74024610, 1107965192],
         'F2': -0.6850829124450684}],
 'A5': 79,
 'A6': 702361209,
 'A7': 14}

(b'FSXL\xcds\x00\x00\x00Yk\xb0j5\x1d\x08\x91\xef7\xbc&\xbe\x16\xbb\xcf\xe3}\x11'
 b'\xd6\xb4\xb2\xd37\xe6\xf9\xaa\x80\x01\xf7\xdd\xf2\x8b|\xc6\xbd\x8f\x18\x1e'
 b'\x138\xea^\xc1\xed"\x17\xfbX\xec \x97\xcf\xf3ju\x82\xfb\x05\xbf\x1b?\xd9'
 b';\x83\x10*!S\xfa\xfa=7\xd6\xe2\x19\xb4b\xcd\xc2\x9a@\x16?\x04\xdf\xc2'
 b'}t\xd9\xa5\x1d\xeb\xc4\x05\x8c\x90}\xa9D\x9bU\xd5\xfb\x1d\xbe&\xc4_L\xa1'
 b"t\xea?ack\xf2'\x82\xbe\xf5\x95p\xfd$\xbf\x9e\x18\x1a>;\xed\xa4\x05:\x15c\x00"
 b'\x00\x00')

{'A1': {'B1': 0.8267370692902929,
        'B2': {'C1': 'ack',
               'C2': -0.2542110085487366,
               'C3': -27147,
               'C4': {'D1': [-0.6444921493530273, 0.15048453211784363],
                      'D2': 94694715,
                      'D3': 5434},
               'C5': {'E1': 9047885607793794469,
                      'E2': 1436239017,
                      'E3': -0.15428097546100616}}},
 'A2': -7996109023135896743,
 'A3': 649869295,
 'A4': [{'F1': [3485144766, 3591470563, 936620724, 2158688742, 4074632961],
         'F2': -0.09691723436117172},
        {'F1': [320739471, 3244223032, 4212597485, 2535517272, 1969943503],
         'F2': -0.5233689546585083},
        {'F1': [1004093211, 556404867, 1039858259, 434296375, 3268240052],
         'F2': 0.5869232416152954}],
 'A5': 4,
 'A6': 1954398943,
 'A7': -39}

Вариант №28

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

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

(b'TCH\xa0\x05\x00f\x00\x00\x00(f$\x13-\x11\xa3\x03K\xd8\xb5\xbd\x12\xdc'
 b'\xce\xcd\xe7\xb7\xcc\x8f\xd3\xcdn"jw\xd8\xcdYZR?\xa2\x00\x00\x00\x84\xec'
 b"%\xba1\xf9f%7\xfe[\xa6\x9a!\x95\xc7\x96T'\x9fw\xe9\xa8\x80\xbf8:\xeb.\x06"
 b'\x00\xaa\x00\x00\x00\x99z\x99\xadxgbvtyovnszkpotui+\xd7C\xe3\x03\x00'
 b'U\x00\x00\x00)i\xd6\xb0\x1c\xf6\x04\x00X\x00\x00\x00h\x1a\xf7\t\x97|\x04\x00'
 b'\\\x00\x00\x00\xbb7\x102\x0b\xce\x02\x00`\x00\x00\x00+\xdaW\x81'
 b'\xbf\x04\x04\x00b\x00\x00\x008\xc0t\xf7\xc0f\x17\xfe\xc7\xbdp"\x01S\r-')

{'A1': [{'B1': -482093269, 'B2': 'xgb', 'B3': 26921},
        {'B1': -165891882, 'B2': 'vtyo', 'B3': 6760},
        {'B1': 2090273271, 'B2': 'vnsz', 'B3': 14267},
        {'B1': -838127088, 'B2': 'kp', 'B3': 55851},
        {'B1': 79659351, 'B2': 'otui', 'B3': 49208}],
 'A2': {'C1': 262072088609973800,
        'C2': -0.08879145234823227,
        'C3': 10361859048890883090,
        'C4': 14832736670472654291},
 'A3': 0.82169109582901,
 'A4': {'D1': {'E1': 1723922292, 'E2': -0.0976526066660881},
        'D2': -1171919740,
        'D3': 49},
 'A5': -7303048598329661703,
 'A6': [2529662241, 2006918996, 3212880105, 787167800],
 'A7': [112, 34, 1, 83, 13, 45],
 'A8': 2912516761}

(b'TCH\xa0\x03\x00_\x00\x00\x00~\xc4\xa4\x18U\xce\xac)\x81\x95{?\x84\xda\xd2.&Z'
 b'\x90\x94Y\xff\xc5\xbbc\x88"\xa7\xbd\xe0u?\x83\x00\x00\x00\xa6\xab'
 b'/\x13\x92\x92\xa2=\x06\xf3&:V\t \xa0\x1fY\xe3\x12\xfa\xeen\xef\xa2w'
 b'\xa8\xc8\xd4\x03\x00\x8b\x00\x00\x00t\xbd\xc3&vjwlknimnuN^!2\x04'
 b'\x00U\x00\x00\x00\x88\xce\xccR\x88\xb3\x03\x00Y\x00\x00\x00\x05y\xe4'
 b'\x80\xe6\x1a\x03\x00\\\x00\x00\x00X\x8b\xde\xd6U@.\xcd\\\xbf\xd3\xa1s')

{'A1': [{'B1': 841047630, 'B2': 'vjwl', 'B3': 52872},
        {'B1': -1282911540, 'B2': 'kni', 'B3': 30981},
        {'B1': 451313892, 'B2': 'mnu', 'B3': 35672}],
 'A2': {'C1': 3003001916430271614,
        'C2': 0.9827499985694885,
        'C3': 10705155434300496516,
        'C4': 12043338315475582809},
 'A3': 0.9604604840278625,
 'A4': {'D1': {'E1': 1079367390, 'E2': -0.8625057935714722},
        'D2': 321891238,
        'D3': 146},
 'A5': 6213321461134631570,
 'A6': [530587657, 4195541849, 2733600494, 3569920119],
 'A7': [211, 161, 115],
 'A8': 650362228}

Вариант №29

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

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

(b'IKZ\xca\x90\x88\x9b}\x8d;#\xe6w\x04\x00a\x00\x00\x00\x02\x00\x00\x00y'
 b'\x00\x00\x00S\xfd\xb6\x92Q\xc2$l\xe5?\x04\x00\x00\x00{\x00\x00\x00\xef8\x90'
 b'\x1c\xdc\x11a\x92\xc3\x1c\x02\xd09\xe4\xd4^f\x86\xfb\xbb\xfd\xbdak\xe7\xf78'
 b'!\xbd\x87]\xef\xfd\xdf\x81\xdb"\xd3\xb0\xa0\x87\x9d<\xd0\xe2`0\x1e9K\xb2'
 b'\x01\x04C\x1aK\xc2ER\x97\xe4\x91\xa0D\x02={sw\x8d\xcf\x9e"\xa1\xfe\xf6wg-'
 b'W@\xfe\x9d\x86;\xed')

{'A1': -112,
 'A2': {'B1': 8639631673840737160,
        'B2': [{'C1': 17156, 'C2': 1170361114},
               {'C1': 38738, 'C2': 1151373796},
               {'C1': 15618, 'C2': -1921551493},
               {'C1': 40655, 'C2': -151084766}],
        'B3': 'wg',
        'B4': {'D1': -685,
               'D2': 0.6694511218343766,
               'D3': [22317, -448, -31075, -4805],
               'D4': -7899012634361448209},
        'B5': 6833337471581953219,
        'B6': [7737674532277421670,
               -1198652679434733593,
               -6867757285074935811,
               2175345147292458375]},
 'A3': 28461881}

(b'IKZ\xcaS\x1c\xd5itF\xe9\x0b\xa4\x04\x00a\x00\x00\x00\x02\x00\x00\x00y'
 b'\x00\x00\x00m\xb0\xb8U@\x81\xc3.\xdb?\x04\x00\x00\x00{\x00\x00\x00\x1d56'
 b"j)\x1d>t\xd5\xd6,G\x03\x86l[\nn\xf6\x88v,)\xf1'\xb8\xbd\xb9\xfd\xd9G"
 b'\xb9"\x19\x1fO\x04 \x81\xf8d{\xd6\x04o\x84s\xea\x00\x11\x94K&\xe3\x95'
 b'\xa5\xa0\x1b\x1f\xdf\x15-G<\xe6\x9dO\xc2\xf3\xcc@\x9c\\;\xc7\x0cgw\xab'
 b'\x07\xe9\x8d\xb3\xbe\xb9H')

{'A1': 83,
 'A2': {'B1': -6625945937935477476,
        'B2': [{'C1': 58150, 'C2': 463512981},
               {'C1': 57119, 'C2': 1011297557},
               {'C1': 40422, 'C2': -856440241},
               {'C1': 40000, 'C2': 214383452}],
        'B3': 'gw',
        'B4': {'D1': -20371,
               'D2': 0.4247292291850857,
               'D3': [1963, -29207, -16717, 18617],
               'D4': 8376164420668503325},
        'B5': 6587787703573337813,
        'B6': [-1069274548908167670,
               -5095864769580255193,
               -540115277428352734,
               -1552751834155287708]},
 'A3': 1267994880}

Вариант №30

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

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

(b"'DHQ\xc7\x0c\xbf\xbc6\xf1\xd0\xcf\xc1e\xbd\xf1o\x8d\x00\x94\x00\x9b\x00\x02"
 b'\x00\x00\x00\xa2\x00\xf6\\b\xcbv\x86~8\xbf\xe3\xeb?0\x0e\x98\xc2\xaf<\xe9'
 b'\xbf\x90W]U\xb9i\xe7\xbfF\x19\xab\x82\x8d\xff\xe0\xbf\xf0\x80\x8f'
 b'\x88\xed[\xec\xbfX\xe5,\x82=_H\x02\x92\xbbI\x87[\xe3\xbf\xc6\xa4\x8au'
 b'\x19\x87\x9c\x8e\xcc\xf2\x13-\xb9\x94=\xf6}`\xea\xe9\xb0\xbf\x89\xad'
 b"b\x03\x00\xa6\x00\xf8\xbe\xda\xd5\xb9'\xdf?\xefw=\xc4\xe3\xec\x05\xefU&\xf0"
 b'\x11\x96\x08UB \x9c\x86\xa9q$\xa0\xbcJ\xd1\xc6V\xe45\xb9J\xe9\x1f\x83'
 b'\x1a\xbb\xd9b\x9f\t\xcd\xe4w\x1d\xe4\x15')

{'A1': -0.023321522399783134,
 'A2': {'B1': 54,
        'B2': 8066436652338237681,
        'B3': [{'C1': -25568, 'C2': -22138, 'C3': [113, 36, 160]},
               {'C1': 19132, 'C2': -14639, 'C3': [86, 228, 53]},
               {'C1': 19129, 'C2': 8169, 'C3': [131, 26, 187]}],
        'B4': [25305, 2463],
        'B5': {'D1': 3412221174,
               'D2': [0.8715511420634374,
                      -0.7886580277121933,
                      -0.731655756690758,
                      -0.5311954071155831,
                      -0.886221663207861],
               'D3': -6824,
               'D4': 1597866540}},
 'A3': {'E1': 72,
        'E2': -0.6049229087917072,
        'E3': 42182,
        'E4': -951228618349382262,
        'E5': 19,
        'E6': 0.07261881977319717,
        'E7': -362775050,
        'E8': -20247},
 'A4': 1655540159,
 'A5': [58573, 7543, 5604],
 'A6': 0.4867996776983854,
 'A7': 17223432812942424047,
 'A8': 4779736020162717269}

(b"'DHQ\x1d\xa7.>v\xe1~\xc4\x83\xc1gvC\x8d\x00\x94\x00\x9b\x00\x02"
 b'\x00\x00\x00\xa2\x00\x1e\xf2\x90\xb6fN\x95b\x89\x10\xec\xbf\xfc\x86U'
 b'\xc9\xb8t\xe5?\x80\x05H\x96^\x8b\xd1?\x90\x06\xcd9\x80\xf3\xda?\x9aIb'
 b'p\xcf\xa2\xeb?\x1ar\xa7F\xff\xff^\xf4\x16J\xb3U\xa9\xed?\xefArD\x7fif\xc8'
 b"c\xeb\xb8\xdf\xb3\x02\xbe\xb2U'\x96\xa8T8\xe5\x83\x8c\x02\x00\xa6"
 b'\x00\x88\xe5\xea\x04u\xcb\xe3\xbf3\xc6\xcf\xaa\x1e\x86=r\xff\xb6`\xe6y\x05F'
 b'\xdaj\x0c \x93\x1dbb\x1en\xb6\xdf#6\x9a\x07yK#\xfaZ\x87\x16f\x82]h\xd8'
 b'\xd7\x1f')

{'A1': 0.170559361577034,
 'A2': {'B1': 118,
        'B2': 4861186928630071009,
        'B3': [{'C1': 3178, 'C2': -27872, 'C3': [29, 98, 98]},
               {'C1': 28190, 'C2': -8266, 'C3': [35, 54, 154]},
               {'C1': 30983, 'C2': 9035, 'C3': [250, 90, 135]}],
        'B4': [26134, 23938],
        'B5': {'D1': 3062952478,
               'D2': [-0.8770186353162444,
                      0.6704982693010773,
                      0.2741314380255844,
                      0.42111211437814067,
                      0.8636243052481405],
               'D3': 29210,
               'D4': 4294919847}},
 'A3': {'E1': 94,
        'E2': 0.9269207479235022,
        'E3': 16879,
        'E4': -1485123109919964046,
        'E5': -72,
        'E6': -0.1276392787694931,
        'E7': -1775807054,
        'E8': 21672},
 'A4': 2357454136,
 'A5': [55400, 8151],
 'A6': -0.6185860725446881,
 'A7': 8231883160176018995,
 'A8': -2718479303957235969}

Вариант №31

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

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

(b'EHC\xf3\x10\rDU\x00\x19-Q?\x05\x00\x7f\x00\x00\x00\x7f\x9ei\x08\xa5'
 b'\xc8S\r\xb8\x17%L?\xd4\xf4\x82\x92h\x1b\xdb\x18jgskd\x11p\xbbUek\xa4'
 b'\xb8\r\xbf{\x9f\x1bz\xdca\xbe\xe7\x89\xbd\xda\xbd\xeb\xed\xd1V\xe4\x17$?\x0f'
 b'\xc4a\xa4^\xd6^S\xe2>\x06\xb5\xc8^q\xacR\x8e\xda?\x05\x00(\x00-\x00\x00\x007'
 b'\x00\x00\x00A\x00\x00\x00K\x00\x00\x00/\x12\xda\xfa \x97\x83q\xce'
 b'\xf8\n\xeb\xa2[\x03u,')

{'A1': 1141706995,
 'A2': {'B1': -19194,
        'B2': 0.4149367031109077,
        'B3': 'jgskd',
        'B4': [{'C1': [28689, 21947, 27493], 'C2': -0.5535986423492432},
               {'C1': [40827, 31259, 25052], 'C2': -0.0673365443944931},
               {'C1': [48602, 60907, 22225], 'C2': 0.6409895420074463},
               {'C1': [50191, 42081, 54878], 'C2': 0.4420422911643982}],
        'B5': 8179547516138295855,
        'B6': -351602482},
 'A3': {'D1': 0.8170943856239319,
        'D2': [162, 91, 3, 117, 44],
        'D3': 141139583,
        'D4': 165,
        'D5': -1207086136},
 'A4': 0.7974409461021423,
 'A5': 1791055412758508756}

(b'EHC\x81+\xc4\xe4U\x00\xeftS\xbf\x05\x00\x7f\x00\x00\x00\x15\x90\x82{u{n%\x8e'
 b'\x9b\x92\xd5\xbd,\xd2\xb3k\x00\x81\x1f,kkugo\xd3H\xb9%\xc4\x0b\x16\xdev>\xe3'
 b'\x0f\xb6\t!Y\x94\x87#\xbe\x11\x89|\xd1#\x98\xe5\xdcA\xbe\x86\x87\x94\xffB'
 b'\xf2\xf1\xaa;\xbe\xa5\x8e\x16\x8c\x9bO\xa0\x1f\xe7\xbf\x05\x00(\x00-'
 b'\x00\x00\x007\x00\x00\x00A\x00\x00\x00K\x00\x00\x00\x9bR\xed\x05\xa6*@v\x99'
 b'\xadS{\xdc\x83^\x1f\x13')

{'A1': 3838061441,
 'A2': {'B1': -29019,
        'B2': -0.7226106219135342,
        'B3': 'kkugo',
        'B4': [{'C1': [18643, 9657, 3012], 'C2': 0.24108156561851501},
               {'C1': [4067, 2486, 22817], 'C2': -0.15969687700271606},
               {'C1': [35089, 53628, 38947], 'C2': -0.1893192082643509},
               {'C1': [34694, 65428, 62018], 'C2': -0.18326927721500397}],
        'B5': 8520857387537355419,
        'B6': 2069081497},
 'A3': {'D1': -0.8260030150413513,
        'D2': [220, 131, 94, 31, 19],
        'D3': 2072154133,
        'D4': 117,
        'D5': -1910149509},
 'A4': -0.10428353399038315,
 'A5': 3179401700753789484}

Вариант №32

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

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

(b'\xe1FFPNmr\xa7)\x02]\x82]U\x00m\x00\x00\x00\n/m\xae\xc2kz\x00\x00'
 b'\x00\x00\xa4\xe2\x16S\xa6\x06\x00\x00\x00\x1d\x00U\xbam\x98y\x8b\x13'
 b'B\xb9\xe3\x06\x00\x00\x00-\x00P\r\xfa|0\xb0\x05\x03\x00\x00\x00=\x00$\n'
 b'\x07w#\x003\x00@\x00fVn\xa2-VGY\xd3\x03\x00J\x00\x00\x00P\x00\x00\x00m'
 b'R\x10\xe3\xf3\xb7\xff\xe4\xef\xbf\xf8\xf0r\xd5\xef\x9fH\xc5\xbe\x10\xca'
 b"\xb8\xbeQj\x99\xdc\r\x0e\t\xdaZnY\xa2\t\xf9\xdfUWr'\xbe~\xb06\x0b\xdf\x1a"
 b'\xec?\x02\x00\x00\x00r\x00\x00\x00')

{'A1': {'B1': 698839661,
        'B2': 1568824578,
        'B3': {'C1': 3545843542,
               'C2': [{'D1': [0, -92, -30, 22, 83, -90], 'D2': -1737639339},
                      {'D1': [121, -117, 19, 66, -71, -29], 'D2': 2096762192},
                      {'D1': [48, -80, 5], 'D2': 1996950052}],
               'C3': {'E1': 22118, 'E2': [110, 162, 45]},
               'C4': 21101,
               'C5': -0.9967039673639153}},
 'A2': {'F1': 248, 'F2': 4023743216},
 'A3': 12042,
 'A4': 44653,
 'A5': 27586,
 'A6': {'G1': -2735639845952460207,
        'G2': -1571197350,
        'G3': 1440741641,
        'G4': -0.16352210938930511,
        'G5': 0.8782801836982939,
        'G6': [-0.38531967997550964, -0.3609166145324707]}}

(b"\xe1FFPNu\xd4\x1c},9\x0f\xbbE\x00]\x00\x00\x00\xc5\xa0'X\x8a\xd8j\x00\x00"
 b'\x00\xda08\x03\x00\x00\x00\x1d\x00\xcb=n\xe0f\x1c\x16\xb3/\xc2'
 b'\x83\xc6\x08\x00\x00\x00*\x00\xa2\x12 \xaf \x002\x00m~\xd4\x1b\x16\xff\tJ'
 b'\xc0\x02\x00<\x00\x00\x00@\x00\x00\x00\x82\xc8L9\x82\xb4j\xee\xda'
 b'\xbf\x9a\x17\xbf\x99l\x99\xe7\xf6\xbeQ\xf6&\xbf5\xb9\x10Hnc\x03\xec1\xd4'
 b'\x7f\x07db\xe9(OQ~?\xa6\x16\x88\x04E\x1f\xed\xbf\x02\x00\x00\x00b\x00'
 b'\x00\x00')

{'A1': {'B1': 2099041397,
        'B2': -1156630228,
        'B3': {'C1': 3226077695,
               'C2': [{'D1': [-38, 48, 56], 'D2': -529646133},
                      {'D1': [102, 28, 22, -77, 47, -62, -125, -58],
                       'D2': -1356852574}],
               'C3': {'E1': 32365, 'E2': [212, 27, 22]},
               'C4': 51330,
               'C5': -0.4208018076686997}},
 'A2': {'F1': 154, 'F2': 1822015255},
 'A3': 41157,
 'A4': 22567,
 'A5': 55434,
 'A6': {'G1': -1440198130521818827,
        'G2': 125817905,
        'G3': 686383716,
        'G4': 0.9934281706809998,
        'G5': -0.9100670898921706,
        'G6': [-0.48223569989204407, -0.6521959900856018]}}

Вариант №33

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

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

(b'}ADVFX0\x05\x00\x00\x00M\x00\x00\x00\x9b\xfbB\xed\xcc\x02\x00\x00\x00'
 b'a\x00\x00\x00\x02\x00q\x00\xd7<\xa1+\xd9(\xe4\x0e\n;\xa8\x1a:\x1at,'
 b'\x05\xf6V\xccV\x08\xa2j\xa5\xf3\\$\x87\x08z\xafp\xce\x0bR\xb9\x17\xfag'
 b'\x8aMz\x07\x06%\x00\x00\x00-\x00\x00\x005\x00\x00\x00=\x00\x00\x00E\x00\x00'
 b'\x00`\xc3+\xad"I\xea?\x90\xfaE\xdb\xdcW\xc5\xbf\x91\xcb\xd7\x0e\x0e\xba\xcd'
 b'\x15')

{'A1': {'B1': 12376,
        'B2': [{'C1': [58408, 2574, 43067], 'C2': [26, 58]},
               {'C1': [29722, 1324, 22262], 'C2': [-52, 86]},
               {'C1': [41480, 42346, 23795], 'C2': [36, -121]},
               {'C1': [31240, 28847, 3022], 'C2': [82, -71]},
               {'C1': [64023, 35431, 31309], 'C2': [7, 6]}],
        'B3': -314377317},
 'A2': -52,
 'A3': [0.8214276678319088, -0.16674385744768871],
 'A4': {'D1': [249023377, 365804046], 'D2': 215},
 'A5': -651452100}

(b'}ADVF\x07\xe5\x04\x00\x00\x00E\x00\x00\x00\xbb$\x0eIT\x02\x00\x00\x00'
 b'U\x00\x00\x00\x03\x00e\x00UAi\xbd\xf9\x87[\xbaR\t~\xc4Hj>\xd6'
 b'\xfd\x9f\xd1\xc7\x16\xb7R\xe1\xfa\x91\xe0U\x1f%\xc0\xdc\xea\x82v\xcc'
 b'E%\x00\x00\x00-\x00\x00\x005\x00\x00\x00=\x00\x00\x00\x90\xa9:\x84\x1aD\xb2'
 b'?\xc8M\x88f\x89\x85\xdd?i\xbc\xd9R\xfb\x9e\xa8_\xaaLE\xee')

{'A1': {'B1': -6905,
        'B2': [{'C1': [23431, 21178, 32265], 'C2': [-60, 72]},
               {'C1': [15978, 64982, 53663], 'C2': [-57, 22]},
               {'C1': [21175, 64225, 57489], 'C2': [85, 31]},
               {'C1': [49189, 60124, 30338], 'C2': [-52, 69]}],
        'B3': 1225663675},
 'A2': 84,
 'A3': [0.07135167816401222, 0.46127543461736],
 'A4': {'D1': [1390001257, 1604886267, 3997519018], 'D2': 85},
 'A5': -105027263}

Вариант №34

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

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

(b'EST^\x8a\x02\x00U\x00\xc9\xb4\x02<\x13!f\xcdpouioyfy\xf5\xc6?'
 b'\x84\x1f\xb3\x7f\x97\x87\x0e\x02\x00u\x00\xcf\xbbp?\xbf\xe7h\xbeZ'
 b'\xa8\xb7\xbd\xc7\xd1\xbb\xbe\x84"!?\xf5\x8b\x05\xbd\x03\xfc2?>\xb5\x05)\x12'
 b"\xc2\xe3?\xbfb\x8dc\xfd\x9d\x03Cu\x9e\xb2\x13/\xb6@C'\xe0i\xca3Eq\xe5h"
 b'\xcbZ\xbc\xec\xa99t\x0b\xd3\xbb\xf5\x8f[_\x00!\xad\x0b~')

{'A1': {'B1': -30114,
        'B2': [{'C1': 5042,
                'C2': 14585435327452722735,
                'C3': {'D1': 17715, 'D2': 3412649329}},
               {'C1': 48218,
                'C2': 17706978406085274092,
                'C3': {'D1': 23439, 'D2': 2904621151}}],
        'B3': 0.007977672852575779,
        'B4': 3446022419},
 'A2': {'E1': 'pouioyfy',
        'E2': 50933,
        'E3': [63, 132, 31, 179, 127, 151, 135, 14],
        'E4': [11, 126],
        'E5': {'F1': [0.940365731716156,
                      -0.2274465411901474,
                      -0.08967657387256622,
                      -0.3668348491191864,
                      0.6294329166412354,
                      -0.03260417655110359,
                      0.6991578936576843],
               'F2': 0.6174403001038298,
               'F3': 25279,
               'F4': -7028637960627199091}}}

(b'ESTo\xa5\x02\x00U\x00L\x86N\xbf\xc6u\xb0\x03wqxncmsrL\xdcaG*\xf5\xf4'
 b'\xff\x15S\x03\x00u\x00I\xc1]\xbfn\x81\xf2\xbe\x17\xe7T?\n\x83\xcd\xbe\xb6'
 b'\x86[?\xea\x16\xeb>x\x9eF\xbf\xe4j.\xbe\x94\x81\xea\xbf\x1b\x91\xef>\xed'
 b'\xf2\x91\x15\xcd\xdf\xefTm\xa9\xdd;\xf9Z\xa1\x06l\x1e\xe0yF[\x9d\xd5p'
 b'gv\xbc\x14\xee\xc0,SZV\xe1\xd9M\x0e\x98\x12')

{'A1': {'B1': -23185,
        'B2': [{'C1': 21743,
                'C2': 477763061975722349,
                'C3': {'D1': 7788, 'D2': 1531345376}},
               {'C1': 54685,
                'C2': 3224839106025908080,
                'C3': {'D1': 23123, 'D2': 1306124630}}],
        'B3': -0.8067367076873779,
        'B4': 61896134},
 'A2': {'E1': 'wqxncmsr',
        'E2': 56396,
        'E3': [97, 71, 42, 245, 244, 255, 21, 83],
        'E4': [14, -104, 18],
        'E5': {'F1': [-0.8662305474281311,
                      -0.4736437201499939,
                      0.8316511511802673,
                      -0.4013903737068176,
                      0.8575242757797241,
                      0.4591591954231262,
                      -0.775855541229248],
               'F2': -0.8283179964522245,
               'F3': -28389,
               'F4': -2320174516435861777}}}

Вариант №35

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

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

(b'KRGI\x04\xc5\x00\x00\x00@aog\x00U7\x8a\x95?q\xdb\xb2c\xef\xaeW\x86\xd7'
 b'\x95\xfbL\x97\xea\xbcj\x89rN\xc9K\x93\xe55\xf8\x1d\xa2\x82\xdf'
 b'\xd5\xdc\xf8\xe8\xbd \x95^\xec\xb99\nV"7@\x00\x03\x00\x00\x00\x13\xf3>'
 b'\xa6\x97\x18\xf5.5\x14\x14\x05v\xab\x81P\xde\x0c\x88\x00\x00\x00\x02'
 b'\x00\x00\x00Q')

{'A1': 197,
 'A2': {'B1': [{'C1': 8204347288478177158,
                'C2': 215,
                'C3': [38395, 19607, 60092]},
               {'C1': 7676792722539910117,
                'C2': 53,
                'C3': [63517, 41602, 57301]},
               {'C1': -2524011692148039956,
                'C2': 185,
                'C3': [14602, 22050, 14144]}],
        'B2': 243,
        'B3': 0.32537150382995605,
        'B4': 62766,
        'B5': 890508293},
 'A3': 'aog',
 'A4': {'D1': -34, 'D2': 3208, 'D3': [30379, -32432]},
 'A5': 14218,
 'A6': -27329}

(b'KRGI\x04\x82\x00\x00\x001ecm\x00F\x96\x85GP\x9e\x03\x85K\xa1\x91\xa8\xcb\xa6'
 b'<\xa3{\x1f\tX\xc7#\xa3k\x16\xc4%\x14\xe5\xdf\x952\xad\xe4\xa3\x00\x02\x00'
 b"\x00\x00\x13P\xbeI\x87\xfbW'\xe2,:\x1b\xfeu\x9fn\xdd\xc2\x98\x00\x00\x00"
 b'\x02\x00\x00\x00B')

{'A1': 130,
 'A2': {'B1': [{'C1': -7060653230907086645,
                'C2': 166,
                'C3': [15523, 31519, 2392]},
               {'C1': -4097251555638237932,
                'C2': 229,
                'C3': [57237, 12973, 58531]}],
        'B2': 80,
        'B3': -0.19680778682231903,
        'B4': 22311,
        'B5': -500418021},
 'A3': 'ecm',
 'A4': {'D1': -35, 'D2': 49816, 'D3': [-395, -24722]},
 'A5': 38533,
 'A6': 18256}

Вариант №36

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

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

(b'AVF\xe3_\xa6\xdcq?$\xce\xf2K\xd8P\xe8>\xe8s\xcf\x8a\xdf\x8eM?r\x88\xda'
 b'\x159\xd6\x90\xbe\xf3\xf6~\x9c-\xe3\xb9\xbc\xe7\xdc3\xeaO\x966\xbe\xc5a\xc3'
 b'zu\xaaE>\xfe>z\x00N\x00\x00\x00\x03\x00\x00\x00\xa7\x18\xe9\xf1\x8b\xda\xa5'
 b'\x86\xe2\xdb\xfcm\xc2?\xeb\x94\xf8\x06v\xb8\x80\xe30b\xa1\xa3\x85'
 b'\x08T\xbf\x03\xd97\xbe\x87,U\xbf&?\x8a?g\xbb"?[\xda\xa0\xbe\x8b\x18D\xb8?'
 b'\r\xfa\t\x00\x04\x00FNj\xf2\xe8\xdb\xfa\xae\xc4\xb8\xa1aL\xa4Yi\x9b\x01'
 b'\xb4~n-\xa3:\xd4!\x9b\x8c\x90\x04"z\xd2}\xce-\xa3z;\xde')

{'A1': [{'B1': 1604770929, 'B2': 0.6437827348709106},
        {'B1': 1272467688, 'B2': 0.454008549451828},
        {'B1': 2329906765, 'B2': 0.947400689125061},
        {'B1': 356112016, 'B2': -0.47648996114730835},
        {'B1': 2620253113, 'B2': -0.0283032413572073},
        {'B1': 3931084342, 'B2': -0.38551148772239685},
        {'B1': 2054531653, 'B2': 0.4965704083442688}],
 'A2': {'C1': -604213822,
        'C2': 0.8619346739049121,
        'C3': {'D1': 58160,
               'D2': 25249,
               'D3': -1551562668,
               'D4': [-0.5150331854820251,
                      -0.26401010155677795,
                      -0.6494070291519165,
                      0.9051991701126099,
                      0.8588047027587891,
                      -0.27166950702667236],
               'D5': -72,
               'D6': 0.554596483707428,
               'D7': {'E1': [6377, -3701, -9563, -31006],
                      'E2': 5650595764426682052,
                      'E3': [47265, 24908, 42073, 27035, 436, 32366, 11683]}},
        'C4': 986980763,
        'C5': -29552,
        'C6': 297935569832258979},
 'A3': [122, 59, 222]}

(b'AVF\xe3\xaf\x03Vm<\xbb\n9L+\xb3(=\x05LU\xe0\x7f\t\xd5\xbf1L\x93'
 b'\xa5\x11\xc7\x9f\xbfIy\x99gp\x0b\xeb?.\xd7\xcd\x18\xc6\xda\xdd\xbfC`3'
 b'\xdd\x0eZ\x0f?\x15\xb8\x04\x00P\x00\x00\x00\x03\x00\x00\x00\xa9\xe8\xa3'
 b"\x01\xc8\xdc\x83\xe4\xd0\x9c\xb8'y\xc3\xed\xbf\xd7;1\xf9\xbd\x9f\xd4\\\x9b1v"
 b'\xc7\xc2<:?"A\x8e>\x9f\'{>Se\xa9\xbfM?\xdc>\xa9\xc39>\xab\xfe\xbb\x95?Y\xe7'
 b'\xfb\x00\x05\x00F\xb8\xf67\xbe\xf6a&DX\x89\xc2\xbdB\xb4\xd1\x7f@\xa6\x8c'
 b'e\xea-\x84\x15\xe2\xb1\xa2e\xd1\x13\x1e\xef\xf3\xa7\x7fKc\xda\xc7')

{'A1': [{'B1': 2936231533, 'B2': 0.022832022979855537},
        {'B1': 1277932328, 'B2': 0.032543499022722244},
        {'B1': 3766421973, 'B2': -0.692574679851532},
        {'B1': 2769405855, 'B2': -0.7870116829872131},
        {'B1': 1735396331, 'B2': 0.6829803586006165},
        {'B1': 415685341, 'B2': -0.7631866335868835},
        {'B1': 3708705295, 'B2': 0.5848391056060791}],
 'A2': {'C1': 662291437,
        'C2': -0.36298798931829634,
        'C3': {'D1': 23707,
               'D2': 12662,
               'D3': -943571910,
               'D4': [0.6338127851486206,
                      0.31084808707237244,
                      0.20644249022006989,
                      -0.8017556667327881,
                      0.33156755566596985,
                      0.335927814245224],
               'D5': -107,
               'D6': 0.8511959910392761,
               'D7': {'E1': [-5981, 456, -9085, -6960, -25416],
                      'E2': -5118842633143114172,
                      'E3': [22665, 49853, 17076, 53631, 16550, 35941, 59949]}},
        'C4': -2078940495,
        'C5': -23963,
        'C6': 15065419194418298699},
 'A3': [99, 218, 199]}

Вариант №37

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

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

(b'\xb1VOEW\x8d.!\xa9tgma\x00\x00\x00\x03\x002\x99B\xe4L?\xe0 *\xb4\x90\x9a6?'
 b'j\xc9\x99\x8f\xb5\x8a\x00\x00\x005\x00\x00\x00E\xbfo\x0e\x82iux\x02\x92\x84'
 b";X|\xc7\xcc>\xf3\xb4\xa7\xbf_w\x95\x8c\xb9\xac\x99\xea\x918'>/H\xfe=\x0e\xf9"
 b'\x94')

{'A1': 2368610729,
 'A2': 'tgma',
 'A3': 'iux',
 'A4': 2571297868,
 'A5': {'B1': 0.5039266134888922,
        'B2': {'C1': 0.9171386361122131, 'C2': 36789},
        'B3': -118},
 'A6': [{'D1': 185355925098121164,
         'D2': [0.47598764300346375, -0.872918426990509]},
        {'D1': -8306418260642809817,
         'D2': [0.17117688059806824, 0.03490598499774933]}],
 'A7': -0.9338151216506958}

(b'\xb1VOEW^\xec$\x9azwhw\x00\x00\x00\x04\x002\xa4\x86P\xbf\xbf\xae~\xa2A'
 b'\x8e% \xbe\xb3C\xc6\x05S\xfe\x00\x00\x006\x00\x00\x00F>U\xdb"dgjc8\xc6'
 b'W\xd8\x9b/:\xb9\xbeH\xf6\xf8?\x13M&Ec0\xbe\xf2#\x05\xd9?T\x1a\xd4\xbe\x91'
 b'\xfd\xf1')

{'A1': 1592534170,
 'A2': 'zwhw',
 'A3': 'dgjc',
 'A4': 2760265919,
 'A5': {'B1': -0.059559889318800296,
        'B2': {'C1': -0.3501264452934265, 'C2': 1363},
        'B3': -2},
 'A6': [{'D1': 4091053899340790457,
         'D2': [-0.19625461101531982, 0.575395941734314]},
        {'D1': 4999893607975683545,
         'D2': [0.8285343647003174, -0.2851405441761017]}],
 'A7': 0.20884373784065247}

Вариант №38

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

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

(b'\xb3AEXW\xd3,\xc8\x12\x1c\xe15\xa8pyracih=\xe4j?\x06\x00\x00\x000\x00\xbb\n'
 b'Ce\xee\xba\x1flY\xf2\x03\x00`\x00~\x00\x00\x00E\xc7\xcd\x7f\xdb\x19\x12['
 b'\xb1\x0e\xf6\x1f\xb5\x97\xe1\x18\xc9]\x1b\x96\xff\xc5[\xb4\x07\x0e\xfa\xb7'
 b'\xe3~\xe9-"\x0c9!\xa0\x13\x81\x1d\\\x97\xc1\x83\xcbUj\x0c\x0fF0\xfd\xda"H~'
 b"\xd0?*\x96`6\x1a'\xac\xed\xaf\xbf\xbc\x93\x94b*t\xfc\x8d\xe4\xbf~)\xa0\x19]x"
 b'\xe0=\x81;')

{'A1': {'B1': 12120841482828000467,
        'B2': 'pyracih',
        'B3': 0.9175451397895813,
        'B4': [6562336037564958533,
               1792880930851262129,
               12996198851233406409,
               3308314917789634055,
               2126002077568666658,
               894621808563689308],
        'B5': 7791151413438122683},
 'A2': 62041,
 'A3': [{'C1': 15, 'C2': 70, 'C3': 0.25770762828684024},
        {'C1': 42, 'C2': -106, 'C3': -0.062360172055474505},
        {'C1': -68, 'C2': -109, 'C3': -0.6423322934015965}],
 'A4': {'D1': [126, 41, 160, 25, 93, 120], 'D2': 998325728}}

(b'\xb3AEXW zP\xf8\xff$\xbb\xfasxevivg\xf2/\xc1>\x08\x00\x00\x000\x00;\x0f'
 b';\x0ba\xd5b\xcdI\x14\x04\x00p\x00\x98\x00\x00\x00\x1c\x0b\xc3-\x92I\x83Z'
 b'\xae\xb4T\xc5\xf0\x8b\xee:]i\xde\x00G\x03\x04\x92\x87\x9e\xcfK\xa5\xc5H\xd9'
 b'\x83\\\xcb\x01\xfc\xe5U\xc2\xa5p`\xbb\r\xe3\x14\xfaz0CSj\xf5\x1a$'
 b'\xf33\xe1\x06\x14{\xd0-\xf1Z\x80\x87\xea_o\x0f\x82\xbfo\x80,\xeb\xee%'
 b'\xfau\xe2?\x9a#\xfe+P\x94\x16/\xea?=\xf9 \x0f\xe8f\xd2B\xe7?\x9cT4\x1b'
 b'2<\xd0\xd8m.')

{'A1': {'B1': 18067075011928160800,
        'B2': 'sxevivg',
        'B3': 0.3773189187049866,
        'B4': [6522137577544420124,
               4246485364876031150,
               10521538232936458589,
               15656981418285702791,
               14003351486903049347,
               18020277657133936805,
               2601661571772133498,
               3301273852807558131],
        'B5': 14799625938269835067},
 'A2': 5193,
 'A3': [{'C1': -15, 'C2': 90, 'C3': -0.008818502535465234},
        {'C1': 111, 'C2': -128, 'C3': 0.5769015065082832},
        {'C1': -102, 'C2': 35, 'C3': 0.8182480713597895},
        {'C1': 61, 'C2': -7, 'C3': 0.7269069681064799}],
 'A4': {'D1': [156, 84, 52, 27, 50, 60], 'D2': 778950864}}

Вариант №39

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

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

(b'IEV{\x9c`\x80\x7f\x8eC\xe6\xd8y"\xc2%\x00\x00\x00Q=\x96\xd7J\x00\x00\x00\x87'
 b'\x00\x00\x00\x93<\xcd\x1c\xb1\x00\xc3\x8e\x02dhncf2M\x07mC\xb4\xc8'
 b'\x8b\x19\xd1\xf0\xb5_\xf3\x00\x00\x00\x06\x00\x00\x00-\xbe\xc4\x13<\xbf'
 b'B\x91#G\xe9d\xb53\x88\x95,%\xd8\x06f/\x85\x17~<\x0e\xe8:\x00\x00\x00\x05\x00'
 b'\x00\x00(_m\xc0?\xbb@/\xd0\x12y\x80\x003\xa68\xd5\xdb\x90\xe26\x0f'
 b'\xc1\x9aN\x84m\x94\x99<\xf2!\x89<\x04\xb0\xad7\xae5e\xd5b\x9eM>1\xddL\\'
 b'\x10s\x04C\xce\xf9e')

{'A1': 11268147553016997592,
 'A2': 2032321061,
 'A3': {'B1': 38188,
        'B2': 2726936610326517630,
        'B3': {'C1': 1007609914,
               'C2': 'dhncf',
               'C3': 95,
               'C4': 28096,
               'C5': 0.10644816236388088,
               'C6': {'D1': 14450672218825646067,
                      'D2': [50, 77, 7, 109, 67, 180],
                      'D3': -0.382959246635437,
                      'D4': -0.7600271105766296,
                      'D5': 18409,
                      'D6': 1689596808},
               'C7': 42552},
        'B4': 3587936482,
        'B5': 907002266,
        'B6': 5657767516877681185,
        'B7': 137},
 'A4': 1033295690,
 'A5': [{'E1': 0.008098763413727283, 'E2': 4012203029521669709},
        {'E1': 0.17369574308395386, 'E2': 6633928713271441765}],
 'A6': 0.0250380951911211,
 'A7': [0, 195, 142, 2]}

(b'IEV{\x07\x0c.\xf61\xdb\xf8\x852\xd4k7\x00\x00\x00O\x04w\xdd7\x00\x00\x00\x85'
 b'\x00\x00\x00\x91\xbf8\xc2.\xfa|\x84\xbcwee\xdd\xe4f\x00C\x1ec\xc7\x8f'
 b"\xdd\xdb\x8b\x06t\x00\x00\x00\x06\x00\x00\x00+\xbd\xf1\x07\xcd?'\x13"
 b'\x11\x95?\xbf`\x01\xa7m\xd4\xa7\xf3\x17\n\x84<\x06\x80j\xa1\xfa'
 b'\xef\x00\x00\x00\x03\x00\x00\x00(\x8b\x1f\xaa?\xef\x97\x15\xc7\xa90\x8c'
 b'\x001\x85\x98\x1a)\x8a\xd7\xadw \xc2\xc8\x8d~v\x95\x94\xd2\xdcG\xbf\x12i'
 b"3\xdf\xbc\xda\xe7\xb8c\x06\xb3\xbe\xf1D\xe7,\xaeGg\xa0'CM")

{'A1': 507832492919355525,
 'A2': 852781879,
 'A3': {'B1': 28116,
        'B2': -6344702116099258752,
        'B3': {'C1': 1789000431,
               'C2': 'wee',
               'C3': 139,
               'C4': 8106,
               'C5': 0.9871930026652236,
               'C6': {'D1': 7189873513154152052,
                      'D2': [221, 228, 102, 0, 67, 30],
                      'D3': -0.11769066005945206,
                      'D4': 0.6526346802711487,
                      'D5': -27329,
                      'D6': -1084227161},
               'C7': 34200},
        'B4': 438930135,
        'B5': -1384701758,
        'B6': -3995398246626962724,
        'B7': 71},
 'A4': 74964279,
 'A5': [{'E1': -0.571917712688446, 'E2': -2324742618864220493},
        {'E1': -0.47122880816459656, 'E2': 3219589294010614605}],
 'A6': -0.7217129468917847,
 'A7': [250, 124, 132, 188]}

Вариант №40

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

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

(b'LXVY1\x00\x00\x00OHj8\x02\x00\x00\x00>\x004\xbck\xb3\x81\x9a\t\x1e-\x84'
 b"p\xed\x880|\xa5D\xdf\xa6\xc1\xbf\xf99wWs,\x8b\x04uz\x17\x00>\x04\x00'\x00"
 b"\x02\x00/\x00\x00\x00-d\xf2\xbdurn\x05\x9by\xd4\xe9rDk\x01\xde\xc9^\xa0'\xaf"
 b"\xeb\x19\x91)\xfe\xea7r\x0c\xc5\x05'\xa9q\xdfr\xc4\xbf\xa5\x88jRs\xdf"
 b'\xe8\x81\r|/`\xcb=;\xd7\x8f\x02\x87\xa1U\xce\xb9\x88.p]A\xa6E@\x91S\x1e'
 b'\xe7\x98\xbb\x93\x18\xf8\x7fSk\xd1Y\x8d\xbc2p\r\xf2\xcf&\x1b \xf3s\xc1k\xb1')

{'A1': {'B1': {'C1': 9866666071633562010, 'C2': -0.13790503360630302},
        'B2': 62,
        'B3': [14841, 22391, 11379, 1163],
        'B4': 'uz'},
 'A2': 946489423,
 'A3': [{'D1': -0.11835513263940811,
         'D2': [117, 114, 110, 5, -101, 121, -44, -23],
         'D3': 17522,
         'D4': [-908197525, -1356357538, 697375211, 1916267262],
         'D5': 654689548,
         'D6': 9846487010777199017,
         'D7': 8938943672581575274},
        {'D1': 0.09930454939603806,
         'D2': [59, -41, -113, 2, -121, -95, 85, -50],
         'D3': -30535,
         'D4': [1096642606, -1858058842, -1729683885, -132607045],
         'D5': -781495425,
         'D6': 14984053685753777497,
         'D7': -5662219402743899354}],
 'A4': 52,
 'A5': -2118947908}

(b'LXVY1\x00\x00\x00\xeb\x8c\x880\x02\x00\x00\x00>\x006.&\x86B\x1d'
 b'\xb9\xa1\x97\xad\xe1\xe4\x85.\xd2\x9bQ\xbci\xe1\xbf\xde}\xaf4\x87\x96\x13.x'
 b"p\x17\x00\x88\x04\x00'\x00\x02\x00/\x00\x00\x00fVQ\xbfk#\xa7\x03\x9b\xd2"
 b'=\x10\xc5\xe6\xc7\x97\x03Up\xa97\xc6\x9a\x10\xcfG\xf7\xe3\\\xaay&\xeb\x0e'
 b'\xec#]O\r\xae\xb5\x10\xcd\x0c\xe8Y\xcb\xb1\xb5\x1e#\xa2;?\x9b\xdb\xb5\xee'
 b'y`m2\x93\xc5\x1c\xba\x8f\x02\xdd"}\xac\xa1B\xb3|\xe5\xd2\x17G\xbaw'
 b'\xe5\x96\xdb\x9a\xc8^\xaa\xa0DO\t-)R\x04\xca\xadR')

{'A1': {'B1': {'C1': 9648084437423995165, 'C2': -0.5441571802062464},
        'B2': -120,
        'B3': [32222, 13487, 38535, 11795],
        'B4': 'xp'},
 'A2': 814255339,
 'A3': [{'D1': -0.8177245855331421,
         'D2': [107, 35, -89, 3, -101, -46, 61, 16],
         'D3': -6459,
         'D4': [1426298823, -969430672, 1204752538, -1436752905],
         'D5': 250291833,
         'D6': 1204059847580787692,
         'D7': 2212870278867324109},
        {'D1': 0.7329427599906921,
         'D2': [-101, -37, -75, -18, 121, 96, 109, 50],
         'D3': -14957,
         'D4': [42973724, -1401085219, 2092122785, 1192743653],
         'D5': -1763346502,
         'D6': 5711866881007721179,
         'D7': 5957640001988144393}],
 'A4': 54,
 'A5': 1116087854}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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