ИКБО-21-22

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

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

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

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

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

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

(b'\x81EXI\x00\x02\x00h\x00\x00\x00\x92\x02\x9d\xc9\x0fz*\x01\xcc'
 b'\xe4\x94\x81\xfab@\x1c\x0c\xb2\xe8\xe0$\xfeN1\xc8tnfmk\xed9n0\x1e\x83\xf1'
 b'\xf6\x930\x85\xf5Y\xc4\x11\xdak}\xf86^\xd8\xd0\xd8\x08\xe5\xd7.\xf2\\>'
 b'\xc1\xc1\x121\xc3m:rwcoa\xd1\x8c\x86l\r\x1a\x9a\r4\xcb\xbfq\x16\x10\x81v'
 b'B\xee/+\xb5\x18\x10]a\xa5b\x00\x05\x00$\x00\x04\x00\x00\x00)\x00\x03\x00'
 b'I\x13pN%\xdf\xd6F\x00\x05\x00O\x00\x02\x00\x00\x00T\x00\x02\x00d,uZ\xe52\xea'
 b'\x8aq>\xb9\xfa"<\x0c#\xd6')

{'A1': [{'B1': -1256714147,
         'B2': 24997,
         'B3': 98,
         'B4': 'tnfmk',
         'B5': {'C1': [-1352929060098674186,
                       -7840619662432529958,
                       7745619846550311128,
                       641155118604762817],
                'C2': [-16110, 12739, 27962]}},
        {'B1': 326127141,
         'B2': -8234,
         'B3': 70,
         'B4': 'rwcoa',
         'B5': {'C1': [-3347152624408684019, 3804344802666905974],
                'C2': [17134, 12075]}}],
 'A2': {'D1': 3203566650392218225, 'D2': 0.3632364869117737, 'D3': 1007428566},
 'A3': 188527827730694604,
 'A4': [58516, 33274, 25152, 7180],
 'A5': -5554943690871524920}

(b'\x81EXI\x00\x02\x00j\x00\x00\x00\x94t\xc3\x9d\xee\x12\xfc\xc7%\xbb|&$'
 b'<\x9b\xa0\xefv\xd8\x91\xb7\xafv8\x1aabq\xe7\x9e\xd7X\xbbiNC\xb2\x07C\xc9Q'
 b'\xf1\xa1M\xdd:|\x8b\xac\x83\xfc\x9e6\x88tytthidJO\x13 \xd9\xf9\x85\x06'
 b'Q@\x93\xd9\x8a\x1b_\xfd\xc4$\xda\x80\xa4\x99\xc6\x10\xa65\xedy\x9d\xb4"\x03'
 b"\x0e8\xe6\xadY\xbc\x92%*\x00\x03\x00$\x00\x02\x00\x00\x00'\x00\x05\x007$"
 b'E\xc2\xfc4\x08\x05\x00\x07\x00A\x00\x03\x00\x00\x00H\x00\x05\x00`'
 b'\x1f\xf3\x85I\xb6\x9b\xb3p?a\x07\x03k\xa7_\xff')

{'A1': [{'B1': -424846916,
         'B2': -28123,
         'B3': 42,
         'B4': 'abq',
         'B5': {'C1': [-1756730028526580157, -5618447478179126963],
                'C2': [-8902, 31883, -21373, -866, 13960]}},
        {'B1': 608551676,
         'B2': 13320,
         'B3': 5,
         'B4': 'tytthid',
         'B5': {'C1': [5354519513783698694,
                       5854842078115880957,
                       -4313082297061882352],
                'C2': [-22987, -4743, -25164, 8707, 3640]}}],
 'A2': {'D1': 2302330386159219568, 'D2': 0.8790132403373718, 'D3': 1806131199},
 'A3': 8413742174704551717,
 'A4': [47996, 9764, 15515, 41199],
 'A5': 8563754909553801242}

Вариант №2

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

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

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

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

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

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

(b'\xf1SMJ\x00\x07\x00$\x00\x02\x00\x00\x00?\x00\x00\x00G\x18\x9c\xfe\x08w\x8f'
 b"b\r'\x1c?\xccu\x01\xabd\x03\x18nlgjvam\xe7\xf9\xf7\xce:lw\xf5A*\x8c\xad\x05"
 b'\x1e\x88\x87^\xbd4\xee\x00\x00\x00+\x00\x00\x005\xf2]\x94z\xeay\xfe8?'
 b".\xf1H\xfd\xdd\xfe\xad\xac\x91S\xc6~\xa0\x03\xb2b\xc4\xd6'!\xe9\x0c\xb3l"
 b"\x85\xc7\xdf\xbean\x98t\xb9\xfb>F\xe7\x99\x1e]\xa3'nwS\xe9\xa9\xf5"
 b'\x12\x02\xdf\xbf\xd5\rQ\xdb\xf8\x88\x885\xc8')

{'A1': 'nlgjvam',
 'A2': {'B1': [{'C1': 3891918798, 'C2': [14956, 30709, 16682]},
               {'C1': 2360149278, 'C2': [34951, 24253, 13550]}],
        'B2': {'D1': -982465888056115656,
               'D2': 0.6833691596984863,
               'D3': [-153686790382726202,
                      9124296909748753959,
                      2443498237584590815,
                      -4728376532689880258,
                      5109220657974159214,
                      8598473029750751967],
               'D4': -0.32893797379996004,
               'D5': 53,
               'D6': -56},
        'B3': 6300,
        'B4': [-2, 8, 119, -113, 98, 13, 39, 28],
        'B5': 0.2223207556599156}}

(b'\xf1SMJ\x00\x04\x00$\x00\x03\x00\x00\x00F\x00\x00\x00R\x11)\x1d\xf4>w'
 b'\x9a\x86\xee\xae?\xebj\xc7S\xeb\xb5\xf8xmvc\x074s\x10\xdea\xb4\x9e'
 b'\x074\xee\xf9@\xd6\xbf\xd0\xc5p\xf5\x8f\xb2*\xec\x9d\x16\xa67\xf5'
 b'\xadm\x00\x00\x00(\x00\x00\x002\x00\x00\x00<h\xe0\x7f\xab\xddR\xa2\xf2?\x04'
 b"e\xd2C,'I\x9d\xa1\xb2\x1a\xd2\x7f\x8f\x86\x16*\xe79V(\xa1\xc1}q\x05\xa9+\x88"
 b'(\xaf\x97Z\xebB]\x9a\xea\xbb\xc3\xdd\x1e\x1d\x82\x8f?\x1d\xe2\xd9'
 b'\xdf\xb4\xbf\xe6k\xad\x88J\xbe\xc6\x9f\x9d')

{'A1': 'xmvc',
 'A2': {'B1': [{'C1': 120877840, 'C2': [56929, 46238, 1844]},
               {'C1': 4009312470, 'C2': [49104, 50544, 62863]},
               {'C1': 2989157533, 'C2': [5798, 14325, 44397]}],
        'B2': {'D1': 7557180550857007858,
               'D2': 0.5171786546707153,
               'D3': [4840286896647156250,
                      -3278744197642131655,
                      6208389938735547817,
                      3136801875087256386,
                      6744961484106571293,
                      -9038936529516765260],
               'D4': -0.7006442701294524,
               'D5': -97,
               'D6': -99},
        'B3': 4393,
        'B4': [29, -12, 62, 119, -102, -122, -18, -82],
        'B5': 0.8567845000340517}}

Вариант №3

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

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

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

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

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

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

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

(b'`RXAG*\x00\x1e;\xcc;\xc17\x00Z\x00\xd0\xf7\x18\xd7[\xa4QO~=\x05\x00'
 b't\x00\x02\x00\x00\x00\x9c\x00\x00\x00\x93:\x01\xda\xd0;|\x03t.z?\xdb6'
 b'\xdf\x81\x13.\x00\x00\x00\x1a\x91?\x03\x8a\x1d\x13\xff\xc2\x08p\x99\x9b'
 b'\x02\x00\x00\x003\x00\x00\x00\n]\xc7\x98>\x9b\xbd\xfea\x89Q\x00'
 b'\x00\x00\x95\x05\x9b[\xc9\x85\xa1\x8f\xec\x871[J\x02\x00\x00\x00V'
 b'\x00\x00\x00\xaf\x08f\x9c.8{\xc6?T\xce[eAT\xe8?\x80\xa2\x08\xd0\xf4\xdd\x80?'
 b'\xf8\x00\xf4r\xe0\x02\xe3\xbf(\xfe\x1ay\x1a\xf2\xe9\xbf\x8e\xfd\x0c\xd9'
 b'k\xf6V\xda\rk\xfa\xa4\x16g\xed\x81')

{'A1': {'B1': 15312, 'B2': 892},
 'A2': {'C1': 0.006232633255422115,
        'C2': -63,
        'C3': [{'D1': {'E1': 0.977271318435669, 'E2': -37},
                'D2': 26,
                'D3': -1979498607,
                'D4': 11212115930249106205,
                'D5': [-8394, 4993],
                'D6': 10},
               {'D1': {'E1': 0.2983960211277008, 'E2': -101},
                'D2': -107,
                'D3': -916743419,
                'D4': 5357930641546518917,
                'D5': [-323, -30367],
                'D6': 175}],
        'C4': -2096,
        'C5': 4431066295447574296,
        'C6': [0.17563535953449638,
               0.7602850894604196,
               0.008235848044095606,
               -0.5941011662653457,
               -0.8108036389675748],
        'C7': [15733033291328847246, 9362252547327945485]},
 'A3': 14995,
 'A4': -9727}

(b'`RXAG*\x00\x05%\x07?z7\x00Z\x00\xd1\xdb\xe3\x03\x03\x88\x95\x9d'
 b'\x9b\xc9\x02\x00t\x00\x02\x00\x00\x00\x84\x00\x00\x00o0KhM\xc3\xd4\xb9,\x17'
 b'\x07\xbf"(,\x96\x12.\x00\x00\x00I\x82\xce\xa6\x8b\x87\xf7\x1e\x03'
 b'\x94\x9bE\xda\x02\x00\x00\x003\x00\x00\x00-{\x94\xd0\xbe\xad\xf2\xb2'
 b'\xb4\xf2Q\x00\x00\x00\xb8)\x0bV\x10\xa7\x90F/\xf8\x14\x00\xa7\x02'
 b'\x00\x00\x00V\x00\x00\x00\x9d\xe0\x1d$\xfe\x8f#\xb2\xbf\xec\x11\xf57'
 b'C\x00\xef?:W\x90\xb3\x82M\xda\r\x0b\xcd1\xe2\x8e\x18] ')

{'A1': {'B1': -15539, 'B2': 47572},
 'A2': {'C1': 0.5279086232185364,
        'C2': 122,
        'C3': [{'D1': {'E1': -0.5276973247528076, 'E2': 34},
                'D2': 73,
                'D3': -1952002430,
                'D4': 15728148333671151495,
                'D5': [11304, 4758],
                'D6': 45},
               {'D1': {'E1': -0.4073828160762787, 'E2': -83},
                'D2': -72,
                'D3': 274074409,
                'D4': 12033641260511563943,
                'D5': [-19726, -3404],
                'D6': 157}],
        'C4': -9263,
        'C5': -3919365785138297885,
        'C6': [-0.07085514025322182, 0.9687820523182018],
        'C7': [998195491169654586, 2332047184007122187]},
 'A3': 12399,
 'A4': 26699}

Вариант №4

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

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

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

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

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

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

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

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

(b'\xd4YXI\xafP\xce<\x1e\x00\xcb\xe1z?\x02\x00$\x00\x00\x00rt\x9ez\xbdP\x9f\xcd'
 b'@\x00\xa7\xc9@\xea^?iaG`O\xb4\xb9\x9e\xe2\x8a\x02\x00&\x00\x00\x00\xc3\xdf7I'
 b'Ghw\xf6T\x16i:.7\x07\x05\xcd\xb1\xef\xbf\xc5\x800\xea#\x9c;\xb8\xcd?/\xe9'
 b'p\xbe%_BW\xc1\xbf\xfb\x1e\xb0\xcc>\xb8\x7fO\xc9\xbf\xa7\xfe\x08\xee\x0c\x85'
 b'g \xc4\xbf\x19\xeb\\\xa2\xddAu`\xd9?\xf9L*\x00m[\x02\x00\x00\x00'
 b'<\x00\x00\x00\x02\x00\x00\x00>\x00\x00\x00')

{'A1': 0.025184957310557365,
 'A2': {'B1': {'C1': -13913, 'C2': 0.8707618713378906},
        'B2': 0.9800078272819519},
 'A3': 'ia',
 'A4': -3630093999901084558,
 'A5': {'D1': [{'E1': -0.9904542062956574, 'E2': 197, 'E3': -128},
               {'E1': 0.23218484043157295, 'E2': 47, 'E3': -23},
               {'E1': -0.1354754414164634, 'E2': 251, 'E3': 30},
               {'E1': -0.19773861404755655, 'E2': 167, 'E3': -2},
               {'E1': -0.15723890301329413, 'E2': 25, 'E3': -21},
               {'E1': 0.3965123313160228, 'E2': 249, 'E3': 76}],
        'D2': {'F1': 2330107577,
               'F2': [24647, 46159],
               'F3': -686965762770346045},
        'D3': 109,
        'D4': 91,
        'D5': [84, 22],
        'D6': [105, 58]}}

(b'\xd4YXI\xc5\xcbv>\x1e\x00\x07\x1e_?\x02\x00$\x00\x00\x00\xa8)d\x87'
 b"\xf9\x91\x8c\x9d@\x00\x04\x17Z\xf6E?nch\xcde'\xc3\x19\xb5+\x02\x00"
 b'&\x00\x00\x00\xc5v\x0e\xf6\xf61\\\x8b\xc2\x14W\x03L\xd0\xc3$\xab\xbc\xd3?'
 b'\xec\x07\xc0\x9f+C\xf0Z\x92\xbf\xb7\xbd@\x93\xa3\xaf\xb2\x99\xc4\xbf'
 b'\x84\xbb\xa0\x06\xed\xa32\x98\xd6?\x19\xa7\xe4\x93\xf8\x0e\xba\xe2\xde?'
 b'\xc8{\x00\xddZ\x92\x0e\x05\xc3?\xa0\x07*\x00H\xa2\x02\x00\x00\x00'
 b'<\x00\x00\x00\x02\x00\x00\x00>\x00\x00\x00')

{'A1': 0.24101169407367706,
 'A2': {'B1': {'C1': 5892, 'C2': 0.7732902765274048}, 'B2': 0.8715519309043884},
 'A3': 'nc',
 'A4': -7094134812111001176,
 'A5': {'D1': [{'E1': 0.308390413192005, 'E2': 236, 'E3': 7},
               {'E1': -0.01792502794242501, 'E2': 183, 'E3': -67},
               {'E1': -0.16094049049493186, 'E2': 132, 'E3': -69},
               {'E1': 0.35303941734682986, 'E2': 25, 'E3': -89},
               {'E1': 0.48258830511104933, 'E2': 200, 'E3': 123},
               {'E1': 0.148591824972506, 'E2': 160, 'E3': 7}],
        'D2': {'F1': 733288899,
               'F2': [52584, 10085],
               'F3': -8404787867820329275},
        'D3': 72,
        'D4': 162,
        'D5': [-62, 20],
        'D6': [87, 3]}}

Вариант №5

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

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

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

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

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

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

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

(b'GLTY\xaal\t\x13@\xa5\x1a,uY\\\x07\xee\xde\x98\xabm\xa8\xcc\xbf\xd7O\x103'
 b"\xa0\xd3|\x00ER\xfc\xb41YQ\x87\x0e\xd8T'R]\x8dE\x13\xf7\xee\xca\xfe3\xc6\xc6"
 b'l\x10\xdc\x9b\xa0?\xcf\xd3\xe4\xf5\x01\x1bp\x00\x03\x00!\x00\x03\x00'
 b'-\xa1p\x0bS\xe3\xc2#V\x80y_\x1b\x8f\xf0 \xbf\x01\x8a\xc3 \x8e\xc3#'
 b'\xf6\x00\xf4\xf0\tquR8\x8c\xff\x14 \xf8\x85zE\xac\xcb\xbdj/\xd0+\x80 \naG7U`'
 b'*\x08\x01\x9a\x83\xf4\xf3\xa9s\x00\x00\x003')

{'A1': -21908,
 'A2': 2323,
 'A3': {'B1': [{'C1': 16549, 'C2': 26},
               {'C1': 11381, 'C2': 89},
               {'C1': 23559, 'C2': 238},
               {'C1': 56984, 'C2': 171},
               {'C1': 28072, 'C2': 204}],
        'B2': -0.3642006401235489,
        'B3': {'D1': [1392292913, 1498515214, -665573550],
               'D2': [23949, 17683, -2066],
               'D3': -6813933781280218282,
               'D4': [-9189208992689151809,
                      111115685425521654,
                      68943817666286136,
                      -8286882657497417147,
                      -5995490215147328640,
                      2308764717479714858,
                      576912118821136755],
               'D5': {'E1': 14627185568571461852,
                      'E2': -25696,
                      'E3': 0.2486540027914219}}}}

(b'GLTYq\x8aHS\xf0\xae\xa4k\xa3J\x08x\xe7=\x85R\xab\nW?\xeb\x15K\xfa'
 b'6\xb6\x16\x00[\xb7\xa6\xc6\xc2\xad\xe8\x15\n\xb0e\xf1\x1c[\xaa\x14'
 b"W\xb8\xa3\x9c\xbf\xa4'\x861\xa2\xe3\xcc\xfbO\x02\xbb\xddT\x08a\x87\x0f5K"
 b"}\xd0B\xb4/\xc7\x84'\x14=c\xbf\xcb\xc76gWEX\x00\x08\x00!\x00\x04\x00A\xff"
 b'\xf2Q@\x94:q!F\xeb\xa8\x8cfs=\xd1\xd9\xb0\x80\n\xa1\xbf\xb4\xf4\xf5'
 b'>]\xd5\x144\x90\x15\xff\x811\xc9\x19\x83V\xbb\xd1\x14\xd8\x1a\xfe\xc4O]\x84'
 b'I\xfa\xa3\xd1|-\xb1P\x84\x06\x1c\xd7^xn\x00\x00\x00I')

{'A1': 29066,
 'A2': 18515,
 'A3': {'B1': [{'C1': 61614, 'C2': 164},
               {'C1': 27555, 'C2': 74},
               {'C1': 2168, 'C2': 231},
               {'C1': 15749, 'C2': 82},
               {'C1': 43786, 'C2': 87}],
        'B2': 0.8463497054087294,
        'B3': {'D1': [-1213806910,
                      -1377299190,
                      -1335496420,
                      1537872983,
                      -1197237057,
                      -1540913615,
                      -1562129157,
                      1325579229],
               'D2': [21512, 24967, 3893, 19325],
               'D3': -3851311867334367,
               'D4': [5110363523149675985,
                      -2760565788426390284,
                      -775078916112740331,
                      -35692582256027973,
                      -3380839809793372323,
                      -8914318405901996623,
                      5801768940902185070],
               'D5': {'E1': 15006755025655703316,
                      'E2': 15715,
                      'E3': -0.21701698347036813}}}}

Вариант №6

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

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

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

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

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

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

(b"LFCJR-\x00C\x00\\\x00v\x00\x91\x00\xa8\x00\xc2\x00&\xd4\x00\x00\x00q'\\\x9a"
 b"o\\\x84\xf5Q\xe8\x00\x02\x00\xf2\x00obz\xbb7#\\W\x02\x00'\x00\x00"
 b'\x00\x04\x00)\x00\xfa:\x17\x8b:\xbflf\x1f.\x9a\x0c\x02\x00?\x00\x00\x00\x02'
 b'\x00A\x00\xdbr\xa8\x85(`gh\x9a\x92\xa0\xbc!l|\x02\x00U\x00\x00\x00'
 b'\x05\x00W\x00\xe7r`\t\xc4\x91flO\xfdx\xfd\xcb\xe8\xecM\x02\x00n\x00'
 b'\x00\x00\x06\x00p\x00UXw\xd2\xed\x08iwe\xdcOn\xe8\xccmu\x01\x02'
 b'\x00\x88\x00\x00\x00\x07\x00\x8a\x00\xc7U\xbd\xb2\xe2~qzI\xa5A'
 b'\x0f\xdd\x02\x00\xa3\x00\x00\x00\x03\x00\xa5\x00/,.\xfb\xe8\x94en,J\x89\xc8'
 b'\x9b9\x08\x14\x02\x00\xba\x00\x00\x00\x06\x00\xbc\x00\x1d\x0b0\x12\xd1\x8c'
 b'A\xc51u\xe7\x8e#3f\xe35W\xb3\x7fi\x90\xa2\xe1\x15,\xef\r\x03\x00'
 b'\x00\x00\xe2\x00\x00\x00Y 8\xf1\r\x8b6|')

{'A1': [{'B1': 22364,
         'B2': 'ob',
         'B3': [122, -69, 55, 35],
         'B4': 2333555450,
         'B5': -16582},
        {'B1': 3226, 'B2': 'lf', 'B3': [31, 46], 'B4': 2242409179, 'B5': 24616},
        {'B1': 31852,
         'B2': 'gh',
         'B3': [-102, -110, -96, -68, 33],
         'B4': 157315815,
         'B5': -28220},
        {'B1': 19948,
         'B2': 'fl',
         'B3': [79, -3, 120, -3, -53, -24],
         'B4': 3531036757,
         'B5': 2285},
        {'B1': 373,
         'B2': 'iw',
         'B3': [101, -36, 79, 110, -24, -52, 109],
         'B4': 2998752711,
         'B5': 32482},
        {'B1': -8945,
         'B2': 'qz',
         'B3': [73, -91, 65],
         'B4': 4214107183,
         'B5': -27416},
        {'B1': 5128,
         'B2': 'en',
         'B3': [44, 74, -119, -56, -101, 57],
         'B4': 305138461,
         'B5': -29487}],
 'A2': 38,
 'A3': {'C1': -15039,
        'C2': 30001,
        'C3': 857968359,
        'C4': 58214,
        'C5': 22325,
        'C6': 32691},
 'A4': -755377203090544783,
 'A5': 81,
 'A6': {'D1': 3567, 'D2': [-28567, -7774, 11285]},
 'A7': [-247979943, 2083949325]}

(b'LFCJR-\x00F\x00]\x00x\x00\x93\x00\xaa\x00\xc0\x00T\xd2\x00\x00\x00 \x90d\x0b'
 b'T\x03\x03\xc1\x07\xe4\x00\x02\x00\xee\x00ij\xaa\x14\x07\x9bi\xa9\x02'
 b"\x00'\x00\x00\x00\x04\x00)\x00\x8a\x8a\xd8\xfc\x90\x05ic\x85\x83\xa4"
 b'\x8f&\xc6\xfd\x02\x00?\x00\x00\x00\x05\x00A\x00\xec\xce\x0f\xef\xb2\xb2rwF5'
 b'E\xdb\xe3\x02\x00X\x00\x00\x00\x03\x00Z\x00\x06\xa8\xf3\x1b0\x1fpk~\xc8<'
 b'\xaa\x02\xf5\xe1\xe3\x9b\x02\x00o\x00\x00\x00\x07\x00q\x00?\xe8\xf2\x8f'
 b'\xa9\xb3go\xe0\xfd\xe5\xb1\xa2\x17\xd4\xa8\x17\x02\x00\x8a\x00\x00\x00\x07'
 b'\x00\x8c\x00"\x93\xd0\xef-dvy\xad:9\xf4z\x02\x00\xa5\x00\x00\x00\x03\x00'
 b'\xa7\x00\x1c\xcb\x06\x0c\xdb\x07zt\x14\xa4\xaa5\x02\x00\xbc\x00\x00\x00'
 b"\x02\x00\xbe\x00 e\x8b9\x1b\x9b\x8eSM'fD\xba\xe2$b\xba\xde\xcf{"
 b'\x8c\x11\x1e\x18\xb7\x86\x02\x00\x00\x00\xe0\x00\x00\x00?<rZ\xa3\xdd\xba`')

{'A1': [{'B1': -22167,
         'B2': 'ij',
         'B3': [-86, 20, 7, -101],
         'B4': 4242049674,
         'B5': 1424},
        {'B1': -570,
         'B2': 'ic',
         'B3': [-123, -125, -92, -113, 38],
         'B4': 4010790636,
         'B5': -19790},
        {'B1': -7205,
         'B2': 'rw',
         'B3': [70, 53, 69],
         'B4': 468953094,
         'B5': 7984},
        {'B1': -25629,
         'B2': 'pk',
         'B3': [126, -56, 60, -86, 2, -11, -31],
         'B4': 2415061055,
         'B5': -19543},
        {'B1': 6056,
         'B2': 'go',
         'B3': [-32, -3, -27, -79, -94, 23, -44],
         'B4': 4023423778,
         'B5': 25645},
        {'B1': 31476,
         'B2': 'vy',
         'B3': [-83, 58, 57],
         'B4': 201771804,
         'B5': 2011},
        {'B1': 13738,
         'B2': 'zt',
         'B3': [20, -92],
         'B4': 965436704,
         'B5': -25829}],
 'A2': 84,
 'A3': {'C1': 21390,
        'C2': 10061,
        'C3': -491109274,
        'C4': 25124,
        'C5': 57018,
        'C6': 31695},
 'A4': -4538780339956051936,
 'A5': 7,
 'A6': {'D1': 34487, 'D2': [4492, 6174]},
 'A7': [1517435967, 1622859171]}

Вариант №7

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

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

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

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

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

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

(b'AWCI=\x00\x00\x00\x03\x00\x9d\x00\x00\x00z\x86\x97\xd9\xc5\x93o\xd0\x9d>'
 b'\xe3\t\x16>f\x8d\xb5=\x9d\x94\xb8>\xae\xd9\x9b>\xb95\x8e\xbe\x8e5\xbf\xbe'
 b'\xeave?\xf5+\x14\xf0l\x9a\x86p\x1b\xb7\x84 \x80\xb6 y\xefhoifwlug\x98N\xaa'
 b'\x98\xd5.\xb3\xe5?H1[\x99\xe7\xc5\xfa\xc7\x0c\x14\xb3\x1b\x16\xc7'
 b'\x9d\x02\x80\xa2"\xffv\x9d\xb1\xe4\xcf\xdc\x03\x8d<\x04{\\\xd6\xba'
 b'!\x07\x00\x00\x00r\x00\x00\x00\n\x1b\x06\xdd\xe7\xa4\x05\x00\x00\x00\x82'
 b'\x00\x00\x00\x17\xbbxb\x13\x04\x00\x00\x00\x90\x00\x00\x00,y\x00\x00'
 b'\x00\x87\x00\x00\x00\x94\x00\x00\x00')

{'A1': {'B1': 2149614775,
        'B2': -277274442,
        'B3': 'hoifwlug',
        'B4': {'C1': -104,
               'C2': 0.67812291830098,
               'C3': -1722076856,
               'C4': [-939866649,
                      464720908,
                      43894550,
                      -14507392,
                      -458121866,
                      -1929126705]}},
 'A2': [{'D1': [60, 4, 123, 92, -42, -70, 33], 'D2': 10},
        {'D1': [27, 6, -35, -25, -92], 'D2': 23},
        {'D1': [-69, 120, 98, 19], 'D2': 44}],
 'A3': -31110,
 'A4': -1815750249,
 'A5': [0.30823084712028503,
        0.14652208983898163,
        0.08864860236644745,
        0.36050882935523987,
        0.3043951392173767,
        -0.277753621339798,
        -0.3734554648399353,
        0.8963457345962524],
 'A6': 245,
 'A7': 1977228234226406443}

(b'AWCI=\x00\x00\x00\x02\x00\x8d\x00\x00\x00\xd9\xff2\xf9\xe8j\x9an\xb6\xbelVg?'
 b'\xbc\xd9/\xbf\xe3M3\xbf\xce\xbe\x1f?\x97H\xb7>\xe9\x82\xef\xbd\xeef{\xbf'
 b'o\x99D\xe2\x91i\x1c\xaf\r\xed\x02\xcc\xc9\xd3z\x06Clqmvoaef\xcc@W'
 b'3\x13\xd1\x15\xe0\xbf\x90\xdcm\xfd\t\xc4\xe5\xeaW\xe1{\x1cy[\xda\xbc5\xc0'
 b'\x04\xc6+\x19\xab\xdc\x9bP\xf1\x94/\x1c\xc1\xfb:\xabK\x07\x00\x00'
 b'\x00r\x00\x00\x00\xce\x03\xe6\x02\x00\x00\x00\x82\x00\x00\x00\xb2y\x00\x00'
 b'\x00\x84\x00\x00\x00')

{'A1': {'B1': 3385590509,
        'B2': 1124498131,
        'B3': 'lqmvoaef',
        'B4': {'C1': -52,
               'C2': -0.5026631712923759,
               'C3': -43131760,
               'C4': [-354040823,
                      477880663,
                      -1126540423,
                      -972767179,
                      -592766677,
                      -1796124517]}},
 'A2': [{'D1': [47, 28, -63, -5, 58, -85, 75], 'D2': -50},
        {'D1': [3, -26], 'D2': -78}],
 'A3': -39,
 'A4': 1793653042,
 'A5': [-0.3563125729560852,
        0.9036624431610107,
        -0.6869161128997803,
        -0.7004072070121765,
        0.6240051984786987,
        0.35797569155693054,
        -0.11694891005754471,
        -0.9820393323898315],
 'A6': 111,
 'A7': 986038083162096793}

Вариант №8

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

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

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

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

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

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

(b'\xfeAKY\x98\\C\x97[\x18hId\x1b\n\xf3Ck\xef?\xc1\x8a\x8e\x06\xaeRx\x81'
 b'\x88\xac\xe1\xb2?\x92\xcc?v9pK\xa0\x10+U,\xcb\xaa\x93\xa6\x95\xdb\xbf'
 b"\xf3\x1a\xf0\x92X\xd0x\xe5\xe4&t\xee\xde\xe9\xe9\xbfJ'\xa3Q\xe4\xcck\xce"
 b'r\x00\x00\x00\x93\xc0?\x87\x1d\x0c\x02?#\xb2\x13>\xde\xcaV\xbf\xa2r\x1d?'
 b'\xcc-\x89\xbcJ\xbb\x08}c\xcf\x92\x85$\x0fJ\xb6`9l\x14\xaaN\xc6\x11\x80\rp~'
 b'1n\xe1\xf3\x91\x80KB\xa7\xd9\x92W9@O\xa2\xbb\xb0')

{'A1': {'B1': [{'C1': [23704, 38723, 6235],
                'C2': 18792,
                'C3': 0.9818439242234089},
               {'C1': [35521, 1678, 21166],
                'C2': -32392,
                'C3': 0.22321315988969936},
               {'C1': [14710, 19312, 4256],
                'C2': 21803,
                'C3': -0.43100895329114297}],
        'B2': 16535195110731684595,
        'B3': -0.809798684816283,
        'B4': -3572536598394099894,
        'B5': {'D1': [46666, 14688, 5228, 20138, 4550, 3456, 32368, 28209],
               'D2': 15683577119388070881,
               'D3': -5711793241125726318},
        'B6': -2025865069},
 'A2': [0.5079973340034485,
        0.14423422515392303,
        -0.8390330076217651,
        0.6150304079055786,
        -0.016745470464229584],
 'A3': 47946,
 'A4': 3479403784,
 'A5': 254051730}

(b'\xfeAKY+\xb6S\xb9<\xd7;gd\xa0\xed\xd4O\x01\xe0?\xe61\x91>\xde^\x16\x81'
 b'\x98\x06\xc9\x12\x11V\xce?\x0e\x06\x83\x9e\x0e\x1d7\r\xac\xd1\tW'
 b'\x1al\xdd\xbf\xdbw\xd0\x9fv\x84\x0b\xc6\xba\xcb=\x82~\xa6\xef\xbf\x9eLg\x14'
 b'\xdd\xf4qYr\x00\x00\x00U\xad\x15\xe1\xe8\x82\xd1\xbe\x01cm<\xab\xf4i?;$\xd4>'
 b'\x02z\xff\xbc\xd0\xdeX\x8a\x9a\xd6\xea\x98:! \xd0\xd9(,\xeb\xda\x80\x1aL'
 b'\xbeC\\\x898\xd8\x83\x19U+\xd7\xf8\xc9R\xa6\x0f\xa4=I\xe5J\xc7')

{'A1': {'B1': [{'C1': [46635, 47443, 55100],
                'C2': 26427,
                'C3': 0.5001601370577302},
               {'C1': [12774, 16017, 24286],
                'C2': -32490,
                'C3': 0.23700154702423926},
               {'C1': [1550, 40579, 7438],
                'C2': 3383,
                'C3': -0.45972307681884206}],
        'B2': 14270645489275795419,
        'B3': -0.9890739959504267,
        'B4': 6445201772111154334,
        'B5': {'D1': [53280, 10457, 60204, 32986, 19482, 17342, 35164, 55352],
               'D2': 5965572784457587075,
               'D3': -4086201609155768410},
        'B6': -518673067},
 'A2': [-0.40920186042785645,
        0.01448893640190363,
        0.9138895869255066,
        0.4143389165401459,
        -0.03118610754609108],
 'A3': 57040,
 'A4': 3600452184,
 'A5': 557488362}

Вариант №9

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

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

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

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

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

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

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

(b'WTA\xfb\xa5\xbd\xbf\xcd7\xd9\xe1T\x1e\x00\x00\x00\x02\x00\x00\x00'
 b'*\x00\x02\x00\x00\x00\x8d\x00xz\xdc\xb1\xe3@\x17\x11\xea?\x02\x00\x1c\x00Ku'
 b'\xf7\xd0\xdae0\x1cf\xf6\x96\xf7\x06\xaeb\x98<\x10F,\xcd\x95s+\x02\x00'
 b'\x00\x000\x00\x00\x00E}\xe3\xcef\xca\xab\x84\x02\x00@\x00i\xe6f\xb9!\xd1'
 b'\xcb\x88B\\Ta\xe7\xc4\xdbwI\xaf\xf0"\x08_WXKq\xa7\x02\x00\x00\x00^\x00\x00'
 b'\x00!\xb9\xe8\xdf\xcb\r\xfd\x84\x03\x00n\x00R\xd1U\xcc,\x95\xeaQB\x00\x00'
 b'\x00q\x00\x00\x00')

{'A1': {'B1': 6116408602644168101,
        'B2': {'C1': 0.8145862834331257, 'C2': 'xz'},
        'B3': [{'D1': 75, 'D2': -2187}, {'D1': 208, 'D2': 26074}]},
 'A2': [{'E1': [12539982440210766896, 10794332561308686434],
         'E2': -8886786896779051707,
         'E3': [115, 43],
         'E4': 9857202152205117033},
        {'E1': [8636713208462466114, 6365661086862061385],
         'E2': -8863913322309175007,
         'E3': [75, 113, -89],
         'E4': 5902694281261732178}]}

(b'WTA\xfb\x16n\t\x88\r\xd5\xbb\x83\x1e\x00\x00\x00\x02\x00\x00\x00'
 b'*\x00\x02\x00\x00\x00\x93\x00qkf3\x07\xbc\x11\x0e\xed?\x02\x00'
 b"\x1c\x00\x90\xbe\x98\xd3\x13f\x89\xcf\xc4\xf4\x8d\xbf'\xa30\x96\x18\x8e"
 b'\xa7\x1f\x01\x87\xf4\x94Y\xda\xc9\x02\x00\x00\x000\x00\x00\x00%\xd7\x82'
 b'_]\x1c\x1b\x1a\x05\x00@\x00\xb3\x06\x05\xb3P\xb6\x91\xd6\n\xca\x1c\x7f9\x80r'
 b'}O\x8d\x1dr\xb0W\xfa\xeak\x82\xdc\xee\x93\xac\x02\x00\x00\x00a'
 b'\x00\x00\x00\xa3\x1e\x1e\xddz\x88A\xe8\x06\x00q\x00\xf5\x90\x90\xc3q'
 b'\x8b\xf3bE\x00\x00\x00w\x00\x00\x00')

{'A1': {'B1': -8954329180002488810,
        'B2': {'C1': 0.90796744083637, 'C2': 'qk'},
        'B3': [{'D1': 144, 'D2': -26434}, {'D1': 211, 'D2': 26131}]},
 'A2': [{'E1': [11756575968691801993, 9728091474600957488],
         'E2': 1881128456717260581,
         'E3': [-12, -108, 89, -38, -55],
         'E4': 15461339453456713395},
        {'E1': [9039428386520091146, 16931942164393200975],
         'E2': -1710936322146951517,
         'E3': [107, -126, -36, -18, -109, -84],
         'E4': 7130195955786223861}]}

Вариант №10

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

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

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

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

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

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

(b'/UKY\x92\xd0\xc2\x8a\\e\xcd\x83S\xec\xb6\x0f\xad$\x90\xbf\xba\xd1\xfe\x0b'
 b'f\x04 fifeqpfx\x8e\xb9\x03M7\rZ\xa9\xea\xfa\xa2\x80\x9a=\xd9\xc4\xc3'
 b'\xbf\xadb\xd7_\xad\x85q%0\xf1pay\xbe\xd7\xbf\xa8?ySn\xbees\x90=\x88'
 b'XH\xbd\xa1Cs\xbf+\xb1\xf0')

{'A1': -7867574649504805501,
 'A2': {'B1': {'C1': 1408022031,
               'C2': -21212,
               'C3': 144,
               'C4': -0.10476672914775564,
               'C5': 'fifeqpfx',
               'C6': 36537,
               'C7': 845},
        'B2': [{'D1': 923622057, 'D2': -5382},
               {'D1': -1568630211, 'D2': -9788}],
        'B3': 14105183197979454853,
        'B4': 1898262769},
 'A3': 'pay',
 'A4': [-0.4213840961456299,
        0.9739292860031128,
        -0.2240736484527588,
        0.06657463312149048,
        -0.07874193042516708],
 'A5': -0.6706838607788086}

(b'/UKY\xda2\xe1\xbei&\xb1J\xe5?\x8dD[ \xea?\xd7\x7fMH}O diqgczwp\x01'
 b'\x01B\x87\x165G\x82x\xcb=W\x15\xbd\xf9\xd3\x16\x8c]\xc9\x16\xa0\xa0\x8d\xab'
 b'w\x0c.iou\xbf#Jh?w\xc8\xca\xbe2n4?n\x89\xf1?[M\xea>\x1b\x1a\x07')

{'A1': -2723866616681549494,
 'A2': {'B1': {'C1': -448819900,
               'C2': 23328,
               'C3': 234,
               'C4': 0.367144890585438,
               'C5': 'diqgczwp',
               'C6': 257,
               'C7': 17031},
        'B2': [{'D1': 372590466, 'D2': 30923}, {'D1': 1029117373, 'D2': -1581}],
        'B3': 1624776683823341709,
        'B4': -1418261458},
 'A3': 'iou',
 'A4': [-0.6378540992736816,
        0.9679075479507446,
        -0.17424851655960083,
        0.9317923188209534,
        0.8566576242446899],
 'A5': 0.1514664739370346}

Вариант №11

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

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

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

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

Поле	Описание
1	int32
2	float
3	int16
4	uint32
5	int32
6	double
7	Структура D
8	Структура E

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

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

(b'nEDCK\x00\x02\x00\x13\x00\x04\x00U\x00i\xec*%\xafew=\xb8\xf6\xff\xbf`\xfe'
 b'3\xbf\xd4\xb6\x16&\x16\xe8\xbc\xbfZ\xa8\xef?m\xb6\xb4\xbf\xe3:\xc6W\xa9K'
 b'6\xbf|\xaap>\xbaO\xf1?\xdb\xcaA\x8f\x90\xe2<\xbe5\xa3\x9d\xbe\xa6\xa1'
 b'\x84?\xd8\nD!\xcf\xa1\xa4\x00\x15\x00%\x005\x00E\x01`\x0f\xcb\xc5\xf6='
 b'\xffI\x08\xfe\x06c\xd6r\x82\xbd\x19\xb8\xff\xe4\xae\xff\x1d\xa1~\x8e'
 b'|?\x13\xbf\xe5\xe1A\xa32a&@\x9d\xe6\x80B$\r\xc1\xe1du\x16+\xfc\xe1l\xca'
 b'g\xe08\x94U\xdc\xd6H2\x04\x80/\n\x99\x1b\\k\x00\x03\x00\x00\x00]\xdf'
 b'\x85/\xefqN\x15')

{'A1': 'ew',
 'A2': [{'B1': 0.09031485766172409,
         'B2': -0.8788787722587585,
         'B3': -0.32361367911984096},
        {'B1': -0.8541402220726013,
         'B2': 0.9285690784454346,
         'B3': -0.6009246551642267},
        {'B1': -0.9869756698608398,
         'B2': 0.3638911545276642,
         'B3': 0.4342197324763537},
        {'B1': -0.1773819476366043,
         'B2': -0.3254510164260864,
         'B3': 0.37562659551488253}],
 'A3': {'C1': 1674998402,
        'C2': -0.03752994164824486,
        'C3': -6994,
        'C4': 4280131966,
        'C5': -1904460013,
        'C6': -0.6837471187055015,
        'C7': {'D1': 4656131028310822337,
               'D2': 225,
               'D3': [1685394987, 4242631882, 1742747796, 1440536136],
               'D4': 50,
               'D5': 324310895735561323},
        'C8': {'E1': [23072715, -973718017, 1225326086],
               'E2': -33,
               'E3': -31441,
               'E4': 4017180181}},
 'A4': -332782161}

(b'nEDCK\x00\x02\x00\x13\x00\x04\x00U\x00i6\x90*\x06lh\xbe\xef\xbc^?}\x92'
 b'\xae?\xe2j\\\xfc\\E\x96\xbf$\x12f?|\xeeG\xbf\xcc\xfe\xb1\xc3\x1cx'
 b'\xb8>\x0b\x8fO?]\x91\xcd?\xe3g\x90\xce\x15E4?\x1b\x16b>\x9c-\x1b?\xd9\x7f'
 b'3\xdb\x9e\x86\x1c\x00\x15\x00%\x005\x00E\x1b\xe7sQ\x0b\xd8\xe3\xfa\x13-\xf5'
 b'R\x8a\xd2\xf3\xf2\xbd\xb5\xfe\xdb\x99X\xee@sOT\xc2\xf6j\xbf\xe9\xcc\x0fe'
 b'2\xe6x\x99\xf4\xba\x8b_\xc7\xd7\xf4(8\xea\xc8\xaf\x85\xe3\x97\x98'
 b'\xcf\xe8\x00\x86$\xc5\x90\x98\xe7\x8dm\xfc=\xec\xfd(3\x00\x03\x00'
 b'\x00\x00]\xd4\xdb\x1b7\xea/\xc3')

{'A1': 'lh',
 'A2': [{'B1': -0.46823400259017944,
         'B2': 0.9905194044113159,
         'B3': 0.5754837922014981},
        {'B1': -0.6409057378768921,
         'B2': 0.988010823726654,
         'B3': -0.22652265574374097},
        {'B1': 0.1362888664007187,
         'B2': 0.8655059933662415,
         'B3': 0.606392290597944},
        {'B1': 0.605810284614563,
         'B2': 0.3050316274166107,
         'B3': 0.3983888287276345}],
 'A3': {'C1': -1965886478,
        'C2': -0.0888650044798851,
        'C3': -26280,
        'C4': 3997201231,
        'C5': 1422063210,
        'C6': -0.8061596848048813,
        'C7': {'D1': -7353047183819024396,
               'D2': 40,
               'D3': [954910895, 2246285208, 3488088198, 616927384],
               'D4': 231,
               'D5': 10191078874708518963},
        'C8': {'E1': [468153169, 198763514, 321779026],
               'E2': -44,
               'E3': -9445,
               'E4': 938094531}},
 'A4': 915417606}

Вариант №12

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

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

(b'DFG\x91\xf2x\x99:\xe8S\xd1\x19\xa9\x90\xc0\x02\xea`\xd7\xd8\xbf\x1e\xfc\xd7'
 b'\xe0\x10\xea\xcc\xeb\x88\x00\x95\x00w\xbfL\xb3\x07fE\xc3\xa2QO;n\xeb\x11=?ef'
 b'hjqc\xfa\xee\x17\xa0\xeb\xe5\xd1\xf9Sh\xbf\x89\xa9\x9c\x85T\xe0\x0b\x8b<'
 b'\x8f\x93\x02\x00\xa2\x00\x00\x00\xcc\xcezE\x81\x95\xe6\xbf\x1c>\xb8\xd5'
 b'\xda?\xe2\xbf\xbeC\xec\x170w\xeb?\xb4\xe4\x87\xadF\xa2\xd8?\xe8\xe3\xf4\xd9'
 b"\xcb'\xc6\xbfP>\x8a[\xbb4\xb9\xbf}O\xa2ju[\xb3F\x87\xf7\xe1B\xa9\xdfR\xb8"
 b'c\x03\xea\x17\xb8\xad\xd1\xca=\xaa\xa6aF\xa2\xd7\xa1')

{'A1': 15083654915374510737,
 'A2': {'B1': -22247,
        'B2': -0.38814566471683865,
        'B3': 16991212852374666270,
        'B4': [{'C1': 117,
                'C2': 45915,
                'C3': 34630,
                'C4': [-9, -31, 66, -87, -33, 82, -72, 99]},
               {'C1': 3,
                'C2': 6122,
                'C3': 44472,
                'C4': [-47, -54, 61, -86, -90, 97, 70, -94]}],
        'B5': -4375979279661613193,
        'B6': 995053986,
        'B7': 110,
        'B8': 0.7385546565055847},
 'A3': 'efhjqc',
 'A4': 61178,
 'A5': 23,
 'A6': {'D1': 3521506208,
        'D2': -0.9075313210487366,
        'D3': -22135,
        'D4': -100,
        'D5': -7813960260567149435,
        'D6': [-41, -95],
        'D7': [-0.7057501179719678,
               -0.5702947782719465,
               0.8582992999309835,
               0.3849045462262197,
               -0.17308948652660594,
               -0.09846087441314322],
        'D8': 20349},
 'A7': 27298}

(b'DFGI\xb2\x98a\x1fQ6\xa4?\x00\\\xa1S\x1aL\x97\xea?\xc8\xb2\xd2\xcd\xc3x\xe5'
 b'A\x88\x00\x95\x00)x\xde\xbcy\xe2\xe3\xe4I\x00t\xb0\x1d\x0c\xe0\xd4\xbdljrnep'
 b'|\xff\xc4\x8c\xa9\xe2\xfe\x80}6>;\\\x18\xde\xcf<t&\xde2\x11\x02\x00'
 b'\xa2\x00\x00\x00HB\xc92\x1a>\xc5?\x9c4\xd3\x9c\\"\xd3\xbf&n>\xc0~d\xee?'
 b'\xe8\xed|\xde\x94\xfd\xd1\xbf\\.\xb0\xf0\xab\xdd\xd5\xbfn\x8d\xf1G"\xd3\xef?'
 b'\xffx\xbc`Q\xd4\xcb\x1dQ\x92\xad\x9d\xbd\xee\xdd\nq\xdc\xb3|\x9b\xdc\x91:'
 b'A\x901\x990\x05\xcf\xd3')

{'A1': 11832734266185790025,
 'A2': {'B1': 63,
        'B2': 0.8309689058487879,
        'B3': 4748334164499149512,
        'B4': [{'C1': 81,
                'C2': 52180,
                'C3': 20765,
                'C4': [-110, -83, -99, -67, -18, -35, 10, 113]},
               {'C1': -36,
                'C2': 31923,
                'C3': 56475,
                'C4': [-111, 58, 65, -112, 49, -103, 48, 5]}],
        'B5': -1953468800861046743,
        'B6': 2960392265,
        'B7': 29,
        'B8': -0.10394296050071716},
 'A3': 'ljrnep',
 'A4': 65404,
 'A5': -60,
 'A6': {'D1': 4276267404,
        'D2': 0.17821311950683594,
        'D3': 23611,
        'D4': 24,
        'D5': 1239297104220573662,
        'D6': [-49, -45],
        'D7': [0.1659577129344305,
               -0.29897227587646014,
               0.9497674708140422,
               -0.2811023876890588,
               -0.34165476326663735,
               0.99452318240621],
        'D8': 30975},
 'A7': 24764}

Вариант №13

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

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

(b'RRVTr\x80-\xa8\xd3\xd22\xb9?i\x00[\xc2\x81F\x14A\x146\xa8\x93%\xfc\xe8'
 b'?u\x00\xefb\x84E?U\xb0\xc8\x9et\xfbz\xcc?\x81\x00)_\x83Ly\x97\xe5`\x8a'
 b"C\xe2o\xea\xe52\xf9\x05\xb1H'\x8eb\x06\x9eJ\x07p\xa9\x86\xc6 \n\x8b"
 b'\x03~\x0e\x9f?\x1f\xa8\xf8z\x94sn\xb0*?\x04\x00\x8d\x00\x00\x00l\xbaZ'
 b'A\xdc\xe2/\x02l\x0f\x0f\xa7V\x99\xbe\xc4\x81\xed\xe92\xdf\xa7\xba'
 b'\x16\xc7\xb6>rlzr\xac\x9d\xad\xe7n\xc0\x19<7"\x98\x08\xbcn\x01\xa7\xbeX7v'
 b'\xbf\xbc\xa4\x89>')

{'A1': {'B1': 114,
        'B2': [{'C1': 0.0984317557087504,
                'C2': {'D1': [58076, 559],
                       'D2': 108,
                       'D3': 3855,
                       'D4': -0.29948922991752625,
                       'D5': 196},
                'C3': 49755,
                'C4': 1091847809},
               {'C1': 0.7807796367575883,
                'C2': {'D1': [60801, 13033],
                       'D2': 223,
                       'D3': -17753,
                       'D4': 0.3569876551628113,
                       'D5': 114},
                'C3': 25327,
                'C4': 1430209924},
               {'C1': 0.22250312036846287,
                'C2': {'D1': [31340, 44146],
                       'D2': 157,
                       'D3': -6227,
                       'D4': 0.009384257718920708,
                       'D5': 55},
                'C3': 24361,
                'C4': 2541309059}],
        'B3': [-27, 96, -118, 67, -30],
        'B4': [5237974409467521647, 8072502899657313831, 9080254149324867241],
        'B5': -7747606807975059698},
 'A2': {'E1': 115,
        'E2': 0.6667546033859253,
        'E3': [-0.008337052538990974,
               -0.3261827826499939,
               -0.9617819786071777,
               0.2688349485397339]},
 'A3': 1096465004}

(b'RRVT\xe8\xe4\\\xe6x\x82\x1a\xd8?i\x00\x98\x03\x0c\xa1\x01\xa4Lk2\xc2q]\xde'
 b'\xbfu\x00\xcbq\xf6X\x9b\xbfh\x99D\xc9\xb7\xd5\xde?\x81\x00\xd8&\x0fX\xff'
 b'\nxl\xeb\xb2\xd0\xda\x0fh\xa5\xbf\xc0\xae\xe9\xea\x1813.P\xd0\xe2\xe3z'
 b'\x87M\xeb\x91QB*o\xdd\xfc\xaa\x84z\x0b?\xf4\x15I\xbf\x02\x00\x8d\x00\x00'
 b'\x00\xe9\xed\x1bp\xa1Z\xb1\xa6\x06i\xd7\xa8\xd8\xaf\xbdml\x01\xa8\xd3]\x18G'
 b'\x9e\xcft?\xdb7hc\xf6\x88N\xc4\x98\x16l?_\x94\xe74>k\x8f\x1d?')

{'A1': {'B1': -24,
        'B2': [{'C1': 0.37661802107454734,
                'C2': {'D1': [23201, 42673],
                       'D2': 6,
                       'D3': -10391,
                       'D4': -0.08586245775222778,
                       'D5': 109},
                'C3': 920,
                'C4': 2751570188},
               {'C1': -0.4744533916906917,
                'C2': {'D1': [364, 54184],
                       'D2': 93,
                       'D3': 18200,
                       'D4': 0.956292986869812,
                       'D5': 219},
                'C3': 29131,
                'C4': 3214629110},
               {'C1': 0.4817943063266257,
                'C2': {'D1': [26679, 63075],
                       'D2': 136,
                       'D3': -15282,
                       'D4': 0.9222197532653809,
                       'D5': 95},
                'C3': 9944,
                'C4': 184506383}],
        'B3': [120, 108, -21, -78, -48],
        'B4': [-1608136087578341414, -2103092866624448278, 4778761119420873443],
        'B5': 827119351497584426},
 'A2': {'E1': 63,
        'E2': -0.7854912281036377,
        'E3': [0.17666465044021606, 0.6154696345329285]},
 'A3': 1880878569}

Вариант №14

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

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

(b'CTVX\x00\x00\x00=\x00\x00\x00v\x93\xd1\xf5\xb59\x00\x07\x00\x00\x00\x88\x1c'
 b'\x91u:\x13\x1d\x00\x00\x00\x04\x00\x17\\\xc80lp\x80\x03ox\x07\x10\xc6\xbc'
 b'\x13\xe6\xe1\xacS\x88jI\x00\xda\xf2\xd6\x92\x9f\xd0\xf7\xc6\x92\xeb\x19'
 b'z\xa1f\xd62\x16I\x00\x00\x00\x1b\xc2$\x17\xd7\x1blw\x00\x00\x00\x05\x00O'
 b'\'\r\xffl\xd9\xe1$$\xbc\xeb\x02oTH\x9cT\x8a\xdc\x01"*^\xe4\x17W\xcb\x18\x16'
 b'\xa7\xa9\x8d\x98Q\xf3\xeb\x9a[\xb8<\xed\x00\x00\x00T\x18\x91\x94w'
 b'\x93\xfb\x9aD\x82\xf1\xa9m\xf1\xa4\xe3I{#\xba\x91%\xa2\xba\x96\xd1X"G')

{'A1': [{'B1': 11515976679426824570,
         'B2': 41318,
         'B3': -701360567,
         'B4': {'C1': 4893,
                'C2': [28, 145, 117, 58],
                'C3': 23752,
                'C4': 3489287506421053447,
                'C5': 16,
                'C6': -4126401276228643960,
                'C7': [106, 73, 0, -38, -14, -42, -110]}},
        {'B1': 1735759053064786419,
         'B2': 60314,
         'B3': 1538800877,
         'B4': {'C1': 27767,
                'C2': [194, 36, 23, 215, 27],
                'C3': 9997,
                'C4': -41418735555920661,
                'C5': 2,
                'C6': 8022116672524180481,
                'C7': [34, 42, 94, -28, 23, 87, -53]}}],
 'A2': -27695,
 'A3': {'D1': -11,
        'D2': -19143,
        'D3': [412193911,
               -1812227516,
               -2098091667,
               -240852151,
               2065939089,
               631421590,
               -782753209]}}

(b'CTVX\x00\x00\x00;\x00\x00\x00q[6A\x01\x91\x00\x03\x00\x00\x00\x83\xe2'
 b'"\r6\x00\x00\x00\x02\x00\x17S\x0fv6\x81x\xe8Y\x98\xd30\xc4W\x89\xe2'
 b'&\xc1\xd3\xc5ubh=&\xfc\xd0\x01p\x9a\xe2\xf9\x7f\xde\xaeg:54\xb1'
 b'\x15\x00\x00\x00\x19\x98m\xdc\x88\x00\x00\x00\x02\x00MJD\xaec\xcc'
 b'\xe0\x89\xa7x1\xe3\xde\xde:#k\x08X\xfd\xb5p\r\x97\xf4\x9a>\xf5\xfc\xa6'
 b'\xb0YO\xfb^\xd4\xdaz\xd7\xd8f\x00\x00\x00OI\x17p|\x7f6\x9b\x87,3\xff)')

{'A1': [{'B1': 103753091068714670,
         'B2': 26426,
         'B3': 892645653,
         'B4': {'C1': 3382,
                'C2': [226, 34],
                'C3': 21263,
                'C4': 8518138101512116435,
                'C5': 48,
                'C6': -4298815714895998011,
                'C7': [117, 98, 104, 61, 38, -4, -48]}},
        {'B1': 17725225509766298462,
         'B2': 54490,
         'B3': 2060965990,
         'B4': {'C1': 56456,
                'C2': [152, 109],
                'C3': 19012,
                'C4': -5880631423661541327,
                'C5': -29,
                'C6': -2387406828665808643,
                'C7': [-75, 112, 13, -105, -12, -102, 62]}}],
 'A2': 23350,
 'A3': {'D1': 65, 'D2': 401, 'D3': [1226272892, 2134285191, 741605161]}}

Вариант №15

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

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

(b'NMI?E\xf0!cfiaeu*7\xcf\xb7\xdc\xba+Yq\x81\xfbZ\xf7\xba\xe5\xf4\x7fT{'
 b'0\x90t\xdb\xb0R\x9d>\x8f\xb7\x90\x11\xff\x17\x87\x11s\xd8\x07\xe7'
 b'\xa2\xbb\xcc\x8c\xbbrL\x14!\x8a\xb3^$\xfd\xa8\x13\x7ft\xff\x9428\x8fI'
 b"u'\xcb\xc9\xc0\xae0\x8b\x10\x83[\x19\xc9\x1e\xe1>%\xcdv\xbd\xbf7\x8d\xd3"
 b'?\xdd!\\\x90\x1d\x0b\xa0?\xed%\x80K\xdbZ"\x00\x00\x00\x03\x00\x00\x00\xa1'
 b"r\x01U=\xc4\x86P{\xc5\xab\xdb~B\x85^\x95\xd3\xfcA/\xf4&z\xc5q,<\x93UX'DjcMk"
 b'-\xf9\xfc\x1e')

{'A1': 0.7731953263282776,
 'A2': {'B1': 'cfiaeu',
        'B2': 10807,
        'B3': [{'C1': -12361,
                'C2': -2541671376540796070,
                'C3': -595911162402145488,
                'C4': -28556},
               {'C1': -9296,
                'C2': 5952983069434581503,
                'C3': 1695342973971589026,
                'C4': -17460},
               {'C1': -29509,
                'C2': 8235979952847281700,
                'C3': -168863547881712590,
                'C4': 14479},
               {'C1': 18805,
                'C2': 2867607417144773392,
                'C3': -8981556680263123419,
                'C4': -12938}],
        'B4': {'D1': -67,
               'D2': -0.7170078158378601,
               'D3': [0.4551612288816447, 0.9108277780131326],
               'D4': [-7, -4, 30],
               'D5': 1912689981,
               'D6': -997830533},
        'B5': 14243719581817724565,
        'B6': 211,
        'B7': -62836748,
        'B8': [2772745610464105301, 6352121023152614189]}}

(b'NMI\xbfZ\x8f\xfbdhdmmq\x8e\xe2^\x1f\xce.d\x1dz\x9d\xb1\x88P\x143'
 b'\xb4\x1f\xbb\xdd\x0bX\xc0\x15\xfam-^\x99\x1bi\xcd`4\x12\xf0\xad-\xff\xcc'
 b'\xa2_3\x1a@\xd8>\x02$}\x960\x99\xadf\xe1\x83\x90\x956\xbf"\x1e\xb3k\xe8\\k'
 b'\x91\xe6\xb7j\x8d\xe2\x07:\xa2\xd2\x08C^"\x0f\x9a\xbf\x1b\x83\x8a?\xd9=\x85'
 b'E\xe8\xc5\x10\xbf\xd7\xd7\xa7\xba*;<\x00\x00\x00\x02\x00\x00\x00\xa1'
 b'[S\x9b\xfb\xc3c\x9be\xaf\xee\\\xd6\x9f"\x9dP\x84\xd5\x9d*[\xdf8#M[\x843'
 b' \xe9\xbc\x12\xa4m\xd5i\x82\xe0N')

{'A1': -0.8537594676017761,
 'A2': {'B1': 'dhdmmq',
        'B2': 36578,
        'B3': [{'C1': 24095,
                'C2': -3589821775193722488,
                'C3': 5770293871287983371,
                'C4': 22720},
               {'C1': 5626,
                'C2': 7867048135769050464,
                'C3': 3752326066144791714,
                'C4': 24371},
               {'C1': 6720,
                'C2': -2864849957211983719,
                'C3': -5951821902340868417,
                'C4': 8734},
               {'C1': -19605,
                'C2': -1703368284667680115,
                'C3': -2159693025317993634,
                'C4': 8719}],
        'B4': {'D1': -102,
               'D2': -0.6074758768081665,
               'D3': [0.39437991931033967, -0.3725375478760957],
               'D4': [-32, 78],
               'D5': 1532206075,
               'D6': -1016882331},
        'B5': 12677172077957127504,
        'B6': 132,
        'B7': -711120293,
        'B8': [-2362099189400980704, -1604386869824099966]}}

Вариант №16

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

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

(b'RYB\x0f\xdc\xd20\x006\x00<\x00B\x00H\x00tceeuv\xb9\xf4K?v\x00\x00\x00\x08W'
 b'\xbe\x04` \t\xcc\xe0C\x9f2\xf9__\xf7\x0f5\xc24_\xd1\xe2\xa1y\xd5=Q\xd5\x16'
 b'j\x10\xad\xc0hI\xd0\xf1\x9eS\x9a~\xe1\xf3h8\xcd\xcc\x9a\xc9[\xd7;\x1e'
 b'\x9b\xda\x89\xfb0}j\r\xee\x0e\x13O\xd9@\xa6p\x85\xb9\xa5\xdd\xea\x18\x00E'
 b'\xc3?\xe71x\xe2\xc7Qz\xabK\x91\xd8m?\xe5\xdf\xd1\x9c\xb6\x9c\x03\x00\x00'
 b'\x00N\x00\x00\x00\x04\x00f\x00')

{'A1': -11556,
 'A2': [{'B1': -782289726, 'B2': 41442},
        {'B1': 1363006841, 'B2': 5845},
        {'B1': -1062399894, 'B2': 18792},
        {'B1': 1402925520, 'B2': 32410},
        {'B1': 946402273, 'B2': 52429}],
 'A3': 'tceeuv',
 'A4': {'C1': 0.7967029213905334,
        'C2': {'D1': 75,
               'D2': 0.9290857911109924,
               'D3': -8219,
               'D4': -1665753903,
               'D5': [15752217364023462298,
                      1075812112006183817,
                      13368214928274050835],
               'D6': [418045349, 1069761792, 3799527911, 2876920263]}},
 'A5': 8,
 'A6': 87,
 'A7': 4891133534894294206,
 'A8': 3823546597664961183}

(b'RYB\x0f(R0\x006\x00<\x00B\x00H\x00hahkqe\x8e\xeb`\xbd~\x00\x00\x00)~'
 b'\xa3h\x87yR\xc7\xc2\xcf\xdfY)\xbb+\x90U\xdcuE\xc3\xd2\xf6\x85.\x15N\x8c4\x89'
 b'\xd0\xcb:s\xe7\x0b<%)\xcd,\x9c\nB|xra\x1b\xc5\x1c\xc4\xc8]*\x0f\xc9\xbd'
 b'\x80\xbb\x04+\xfe\xd01|\x9e6\x99\x9c\xc4q\xcf\x85\xd8kU\xf9\xa2\x08Q\x0f'
 b'\xe1\xeeO\xe1\xa6wQ\xc9\xca\xca\xad\x0b\xd3\xc9\xb4\xe3g|\xbfj\x13e\x1dw'
 b')\x03\x00\x00\x00N\x00\x00\x00\x06\x00f\x00')

{'A1': 21032,
 'A2': [{'B1': -758954635, 'B2': 34294},
        {'B1': -1941039826, 'B2': 35124},
        {'B1': 1933233104, 'B2': 3047},
        {'B1': -852941508, 'B2': 39980},
        {'B1': 2021409290, 'B2': 24946}],
 'A3': 'hahkqe',
 'A4': {'C1': -0.05491214245557785,
        'C2': {'D1': -76,
               'D2': -0.9859601855278015,
               'D3': 4970,
               'D4': 695672165,
               'D5': [1092788976455828763,
                      15059521503299157449,
                      8197849403581430833],
               'D6': [1809352143,
                      144898389,
                      4007726929,
                      2007425359,
                      3402287441,
                      3386051501]}},
 'A5': 41,
 'A6': 126,
 'A7': 14970747268373112995,
 'A8': -2569989494846957089}

Вариант №17

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

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

(b'UFGO\xc4\xa1\xd1$I\x04\xf6}p\x00@\xd1\x94\x00\x00\x00\x19s(\xbe'
 b'\x7f\xd6\x04\xbf\xd6\xeab?=\xed3?\xe1\xcb\xf7\xbe@\x86s\xbd\xef$<>X\xb4w\x97'
 b"WZ\x19\x0c\xaa\xa7F\x13'\xf7:\xd0\x85\x15\x87\xa5q\xe7\xf7\xb1\xbfG%\x9a"
 b'\xaa\x84\x1f\xeb\xc6\xed\xb1)0\x00\x00\x009\x00\x00\x00B\x00\x00\x00'
 b'K\x00\x00\x008\x89\xad\x85\xc5;\xe5\x1b\x9d\x16\x9e\xcb\x04\x00\x00\x00'
 b"T\x00&\xf4\xd4\xbck\x88\xeb\xfb\x91'\x0c\x1d\xa8\x9a\xf5[x\xc5p\xb9\x88\xc7"
 b'\x03\x00\x00\x00d\x00\x00\x00X>V\xe4\xe7\xbe\x1a\x82\xbd>')

{'A1': 9076446811208655300,
 'A2': {'B1': [{'C1': 88, 'C2': 1469544372, 'C3': [6490, -22004]},
               {'C1': 167, 'C2': 4146533190, 'C3': [-12230, 5509]},
               {'C1': 135, 'C2': 4159140261, 'C3': [-16463, 9543]},
               {'C1': 154, 'C2': 3944711338, 'C3': [-4666, 10673]}],
        'B2': [3168072742, 4226517099, 487335825, 1542822568, 3111175544],
        'B3': -14456,
        'B4': [2242742584, 468007877, 3416135325]},
 'A3': 53568,
 'A4': {'D1': 15960, 'D2': -1092098986, 'D3': 0.3701332211494446},
 'A5': -0.16450156271457672,
 'A6': [-0.5188979506492615,
        0.8863958120346069,
        0.7028387188911438,
        -0.483977347612381,
        -0.05945420265197754,
        0.18373464047908783]}

(b'UFGO\x0b\xb6\n\xcd8\xbf\xd1@g\x00\\\n\x8b\x00\x00\x00\xef\x91&?\x86\xc5U?'
 b'YKQ\xbf\xf12K?\xda\x9e/?\xad\xe0\xa1\xbd\xfb\x99o?hs\xe3\x9b\x89\x1b\xbd\xfb'
 b'&\xf7\xd8W+\xa6\x8ewwX*\x8f\x96\xb8\x9c-\x9b\xfab0\x00\x00\x009\x00\x00\x00B'
 b'\x00\x00\x00Q\xa3f\xc7\xac\x0e$\x87\x8b\x95=5 M8.\x03\x00\x00\x00K'
 b'\x00\xb9o\xa7\xb1QY\xf3\xdc{[fV\xf3vh!o\x05\x0e\xbfJ5\x04\x00\x00\x00W'
 b'\x00\x00\x00\t\xf3\xb0\x94\xd1\xf5\xdb\xc4[\xbf')

{'A1': 4670724539239020043,
 'A2': {'B1': [{'C1': 104, 'C2': 2308694899, 'C3': [-17125, 9979]},
               {'C1': 247, 'C2': 2787858392, 'C3': [30606, 22647]},
               {'C1': 42, 'C2': 2629342863, 'C3': [-25811, 25338]}],
        'B2': [2980540345, 3706935633, 1449548667, 560494323, 3205367151],
        'B3': 13642,
        'B4': [3345392465, 2267287212, 893228427, 775441696]},
 'A3': 2652,
 'A4': {'D1': 62217, 'D2': -170814288, 'D3': -0.8584725260734558},
 'A5': 0.6506642699241638,
 'A6': [0.8350452184677124,
        -0.8175559639930725,
        0.7937460541725159,
        0.686017632484436,
        -0.07904181629419327,
        0.9359433054924011]}

Вариант №18

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

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

(b'WNM\xf4\xbf1|9\x00U>\x86\xe3_\xba\xb5\x81\x1cO=\xd8\xf8a\xa5\xc7\xbe\\\xde'
 b'T\x08\xc1IS\\\x14\x89\x97wb\xeb>\xdb0\x1f(\x1dZ\xa5\x1eD$\x86IV\xcf\x00'
 b'\n\x00\x19\x00(pw\xb0\xb9\xe4\xb1z\x1e.\xe2\\\xcck\x88\x0eNH[;Da2@'
 b'@\x00\x03\x007\x00\x02\x00\x00\x00=\x00\x00\x00\x06\x00\x00\x00? '
 b"\xfb\xaf4\xb3\xccb\x9a\xcd\xe1\xb1\xc9\xbf|\x17\xf4\xcc\xcc#\xaa['Z\xce\xb6"
 b'\xb9\xf8\x87\xb4\xe3\x954\xd6M\x00\x00\x00\x02\x00\x00\x00E')

{'A1': -0.6933017373085022,
 'A2': {'B1': [{'C1': 0.2634534537792206,
                'C2': -17739,
                'C3': 129,
                'C4': 2039917158311503303},
               {'C1': -0.21569186449050903,
                'C2': 2241,
                'C3': 73,
                'C4': 6006698584189657835},
               {'C1': 0.428101509809494,
                'C2': 10269,
                'C3': 90,
                'C4': -6548721884487657777}],
        'B2': 'pw',
        'B3': [176, 185, 228, 177, 122, 30],
        'B4': {'D1': [553365300,
                      -1278451046,
                      -840846903,
                      -1082386444,
                      -859036758,
                      1529305806,
                      -1229326201,
                      -1260153548],
               'D2': 214,
               'D3': 77},
        'B5': [3378364703528455758, 5213826158485979200]}}

(b'WNM\xf4?B\xbe\xf1\x00R\xbf|\xf5f\xa4\x9f\x81\x19l\xdbJO\x91\x15\x07\xbfZ\x9e'
 b'\r\xae]\\\xb4\x03\xaa\x9b\xf0o\xf8l\x00\n\x00\x19jt\x81Z~\x04?\xb4P\x84\xdc^'
 b'\x12\xa66\xa9\x16\xa4\xe8\x15\xc5\xeb6\x04\xc9.N\xbe\xf5kR\xa9\x8dV\xc8{'
 b'\x81\x00\x00\x02\x00(\x00\x02\x00\x00\x00,\x00\x00\x00\x04\x00\x00\x00.'
 b'o\xf3\xe9KD=\x1b\x03\xc8\x025\x91$\xfd\xfe\x9e\xef\xab\xd6\x8d\x83\xdd\xaeC'
 b'\xfa>\xec\x9e\xa9gA\x0e]\xc6\x00\x00\x00\x04\x00\x00\x002')

{'A1': 0.7607260346412659,
 'A2': {'B1': [{'C1': -0.9881194829940796,
                'C2': -23393,
                'C3': 129,
                'C4': 1832080260641920263},
               {'C1': -0.8539741635322571,
                'C2': -20899,
                'C3': 92,
                'C4': -5475345135221868436}],
        'B2': 'jt',
        'B3': [129, 90, 126, 4],
        'B4': {'D1': [1878255947,
                      1144855299,
                      -939379311,
                      620625566,
                      -273951091,
                      -2082623933,
                      -96539490,
                      -1452850930],
               'D2': 93,
               'D3': 198},
        'B5': [4590382451760435878,
               3938704246636398059,
               3892457178681767275,
               5956447386044432640]}}

Вариант №19

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

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

(b'\x8bOCDK\x99\x12\x00\x00\x00\x05\x00\x00\x00B\x13,\x00\x00\x00'
 b'\x05\x00\x00\x00G\x96\x95\xbfL\x9b\xae\xbe.\xe1m>\xa2*\xe9\xbe\xff!\xd9>'
 b'\xe6\xf5Y>h\xa0\x11=7\x86\x1c?S\xaf\xe0\xc0Y\x17\x00\x00\x00Ldfvckcflgt'
 b'\xb1|\x1aP;&\xacdK\xf1k\xc4 \xb6\xcdA\xf6\x05\xfb\xe5\xdd\x8a')

{'A1': [{'B1': 39186, 'B2': 'dfvck'}, {'B1': 4908, 'B2': 'cflgt'}],
 'A2': {'C1': 38549,
        'C2': [-0.7992504835128784,
               -0.17078180611133575,
               0.31673362851142883,
               -0.4983051121234894,
               0.45109060406684875,
               0.2271731048822403,
               0.044805631041526794,
               0.8269023895263672]},
 'A3': 192,
 'A4': 89,
 'A5': 23,
 'A6': {'D1': -79,
        'D2': [2082099259, 648832075, 4050371616, 3066905078],
        'D3': 5,
        'D4': -68821622}}

(b'\x8bOCDK\x14\x93\x00\x00\x00\x04\x00\x00\x00B\xd4\xfb\x00\x00\x00'
 b'\x06\x00\x00\x00FN}\xbe\xc7\x98e\xbe\xbbY\xa8\xbe\x87l!>\x05\xe8\t\xbf'
 b'j4\xbc\xbe\xf8\xf6U?UO\x96?h\xdd\x07\x1akY\x00\x00\x00Lrtcpshvblx'
 b"\x19\xf6\xdb\x9b\xc0&[\xce@;L\x89\x18j\x9a6\x81\x96\x971Z'")

{'A1': [{'B1': 5267, 'B2': 'rtcp'}, {'B1': 54523, 'B2': 'shvblx'}],
 'A2': {'C1': 20093,
        'C2': [-0.38983455300331116,
               -0.3659183979034424,
               -0.2644968330860138,
               0.13076795637607574,
               -0.9148671627044678,
               -0.48625436425209045,
               0.8332456350326538,
               0.9096226096153259]},
 'A3': 26,
 'A4': 107,
 'A5': 89,
 'A6': {'D1': 25,
        'D2': [4141587392, 643550784, 994871576, 1788491393],
        'D3': 150,
        'D4': -1758373337}}

Вариант №20

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

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

(b'ZJZ\xe0\x96&\x1d\x91\x03\x00\x00\x00;\x00\x00\x00S\x00\x00\x00\x93m`\x00'
 b'\x00\x00\xa8\xcc{L\xde)Q>m\xe3\xb1{-\x03JA\x9b.a\x89\x18q\xd3P\xe5\x03'
 b'\x00\x00\x00m\x00\x00\x00p\x96\xd7\xc6ZH\xd9?\xb8 \t+[\xaf\xc7?@\x0fcO\xb7'
 b'w\xe4\xbfY<C@uG\xa4\x96B\x86\xc4G5\xf5\x0c\x07\xad\xfe:v\xed\xa7\xd5he'
 b'\x11\xcc\xca\xf3\x1e\xcb%xC\x0f\x8e;\xe1\x90d$\xa0V\x9b\x86\x0co\x04c\xed')

{'A1': -32,
 'A2': 2434606742,
 'A3': [0.3950411741082922, 0.18503894425726286, -0.6396137762571712],
 'A4': [{'B1': {'C1': 1078148185,
                'C2': 2527348597,
                'C3': -31166,
                'C4': 196,
                'C5': 13639},
         'B2': 28051},
        {'B1': {'C1': 2902920437,
                'C2': 3983948542,
                'C3': -10841,
                'C4': 104,
                'C5': 4453},
         'B2': 52392}],
 'A5': 19579,
 'A6': [10718, 15953],
 'A7': {'D1': -7315,
        'D2': 177,
        'D3': 7002705175324601723,
        'D4': -747562871,
        'D5': 58704,
        'D6': [4861677352074332876,
               11539458718646898191,
               17105520684681304918]}}

(b'ZJZ\xc6\x8f\xdb\xca\x82\x02\x00\x00\x00;\x00\x00\x00K\x00\x00\x00/)X\x00'
 b'\x00\x005j\xe5Re\xe3iWGa\x96G\x93\t\xcb\x83\x0f\x0e\xfe\x1008K \xfd\x02'
 b'\x00\x00\x00e\x00\x00\x00\xc0jb\xdeU\x99\xe6\xbf\xb0/\xa2\xf5x\xf9\xd8?\xb0'
 b'\xa0C\xb7\x95D\xf9\\\xa2\xf8\x181h\xab\xfa|\x03BD\x9a\x11\x11\x82\xa1\xd7'
 b'\xdc\xce\xc7\x92Y\x1e\xc0\xf8\xda\xecn\xb0W\x9c\xf4\x1e\xe4')

{'A1': -58,
 'A2': 2194332559,
 'A3': [-0.7062177031942483, 0.3902265928998032],
 'A4': [{'B1': {'C1': 3074662576,
                'C2': 1559839893,
                'C3': -1886,
                'C4': 24,
                'C5': 26673},
         'B2': 10543},
        {'B1': {'C1': 58522283,
                'C2': 295322690,
                'C3': -32239,
                'C4': 161,
                'C5': 56535},
         'B2': 27189}],
 'A5': 21221,
 'A6': [-7323, 22377],
 'A7': {'D1': 24903,
        'D2': 150,
        'D3': 18306586594029179719,
        'D4': 1261973520,
        'D5': 64800,
        'D6': [15778572531076876238, 16437844642272145132]}}

Вариант №21

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

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

(b'AINA\xd9H\xaf5\x0e\x85\x00\xc4=cz}\x80\x02\x00\x00\x00\x98\x00\xfd'
 b'\xfd\xb6=\x9a-$\xd2G@\xdc\x8e\x05\x1evd\x0c\x97\x16\xb1\xcc\x1d\xef\xbf\xa8'
 b'\x06\n\xd6\x86\x80\xa7o&\x18L\xebR[\xf1\xd4\x82\x96tl\xc3\xb0a\x84>'
 b'\x04\x00\x00\x00\x9a\x00\x00\x00\xe8\x05\x9d\xf4\x99O\xfey6\xe2\xa8\x95'
 b'\xd5\xbf\x10\xeb\xdb0[\x82\x8f<&F\x07?Y\xfc*T\x1d\x96\x0c\x199y'
 b'\x99\x83\xa2\x03\xcd\xb2\xfcDW1\xe3M\xddM\xb6\xe7\x82X\x00g\x00v\x00\xce'
 b'7\xe2\xc1G\xdf\xe2\xbf\xae-1\xa9\tsp\xb6\xdd\xe3\x7f')

{'A1': 238399304,
 'A2': {'B1': [{'C1': 54,
                'C2': 226,
                'C3': -27224,
                'C4': -16427,
                'C5': 4363849892118653712,
                'C6': 38},
               {'C1': 70,
                'C2': 7,
                'C3': 22847,
                'C4': 11004,
                'C5': -7387810933976457900,
                'C6': -125},
               {'C1': -94,
                'C2': 3,
                'C3': -19763,
                'C4': 17660,
                'C5': -1750125792297012905,
                'C6': -126}],
        'B2': -0.5897558962621987,
        'B3': 11694,
        'B4': 49,
        'B5': 2473},
 'A3': 15812,
 'A4': {'D1': -2139260317,
        'D2': 'sp',
        'D3': 0.08935163170099258,
        'D4': 3525586330,
        'D5': 7239006460265119815,
        'D6': {'E1': -0.9723876436953289,
               'E2': [-703986008,
                      1873248390,
                      -347334618,
                      -722379950,
                      1819580034],
               'E3': 195,
               'E4': 0.2585577964782715,
               'E5': [-74, -35, -29, 127],
               'E6': -191035928,
               'E7': 20377,
               'E8': 254}},
 'A5': 121}

(b'AINA\xd9l\xceC<\x85\x00i\xff\x1e\\/(\x02\x00\x00\x00\x98\x00K\xed\xc9\xbeK'
 b'\xd3o\xcdB\xc6j\xbe\xf4\x00\xae?@\xc1R\xdb\xce\xc0\xb9\xbf4L\x92\xa6\xe1'
 b'\xd6\xf7*j/\xf8\xefM\x93p\xf6\xb4"\x94\xc3\x13\xf0\xc3\x81\xbe'
 b'\x06\x00\x00\x00\x9a\x00\x00\x00;\x0f\x92\xe7I\xe6${\x9eR5\xc3F|/p}{\xee\x8b'
 b'\x14Z\xe3\xdc\xb50\xa18\xfb\xf9\xe8^\x95\xedj\xfad\xb1\x10I\xb6\x81\x1fA'
 b'Q\xc5\x83*\x8dH\xf5\x80pX\x00g\x00v\x00({\xeen\x0f\x90\xc5\xbfz_\x07rX'
 b'pc\x90\xd8\xdf\xf3;?')

{'A1': 1011076716,
 'A2': {'B1': [{'C1': -98,
                'C2': 82,
                'C3': -15563,
                'C4': 31814,
                'C5': 6490966819338022959,
                'C6': -29},
               {'C1': -36,
                'C2': 181,
                'C3': -24272,
                'C4': -1224,
                'C5': 7276245716616276217,
                'C6': -79},
               {'C1': 16,
                'C2': 73,
                'C3': -32330,
                'C4': 16671,
                'C5': -9154330896419797679,
                'C6': 112}],
        'B2': -0.16845887104587942,
        'B3': 24442,
        'B4': 7,
        'B5': 22642},
 'A3': -151,
 'A4': {'D1': 674192414,
        'D2': 'pc',
        'D3': -0.3943885266780853,
        'D4': 3446657867,
        'D5': 4588606121503802946,
        'D6': {'E1': -0.10059826712199982,
               'E2': [-1500361676,
                      720885473,
                      -268947606,
                      -160394419,
                      -1013701964],
               'E3': 19,
               'E4': -0.2534480094909668,
               'E5': [-112, -40, -33, -13, 59, 63],
               'E6': -409858245,
               'E7': 58953,
               'E8': 36}},
 'A5': 123}

Вариант №22

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

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

(b'\xbdDILWp >/\xa2G\x00\x00\x00\x04\x00\x00\x00MEx\xfa\xff]\x97D\xcd\xbd'
 b'\x92P\xef\x00\x00\x00\x02\x00\x00\x00\x89\xd7\xbdil>\x9cg\xe4P\xf2u\xc4 '
 b'\x00\x00\x00\x97\xbe\xfe\xc8|\xbfa=1>\xe1\xe4\xaa\xef\x94\x88\xe0@\xa2C\x07'
 b'T\x02\xa1\xad\xe3C\x0baG\xb7\xa3\xfaI\xc4H\xd2\xe2\x19y\xa3\xf1\xff\rL'
 b'z\x1d\x1f\x05R\xf2y\xbf.\xa5?\nX\xb5\x80\xd1\xf4q\xbdJ\x8e\x91\xfd\xf4'
 b'>\xad\x8c\x96\x06\x1e\xb8e\xb2\xfeY\xb0g\x00\x00\x00m\x00\x00\x00{\xcaY\xab'
 b'\xd5\xbb\x19\xbf`SM(I\x036\xce\x87\x13\x86"\xb3\x88\xee\x85\xfb_C\x16'
 b'\x170\x0b\xda\xad\xe8aZ\xdb\x96\xe63\x00\x00\x00\x03\x00\x91')

{'A1': {'B1': {'C1': 28704,
               'C2': 0.171517476439476,
               'C3': {'D1': [189623850920272199,
                             -5214048748832238878,
                             1835678582891695226,
                             2098401805191462702],
                      'D2': 5006026960516105421,
                      'D3': -0.07144343107938766}},
        'B2': [{'E1': -91,
                'E2': 0.5404160618782043,
                'E3': 128,
                'E4': 15128842106057953789},
               {'E1': -12,
                'E2': 0.33896321058273315,
                'E3': 6,
                'E4': 2213631036298473575}],
        'B3': 3619514732,
        'B4': 0.30548012256622314,
        'B5': 1358067140,
        'B6': 32,
        'B7': {'F1': -0.8762710690498352,
               'F2': [675873590,
                      -830008442,
                      582191342,
                      -2047123645,
                      370618379,
                      -626136991,
                      1524340454],
               'F3': 51,
               'F4': [51801, 43989, 47897]},
        'B8': {'G1': [-0.4976233243942261,
                      -0.8798399567604065,
                      0.4411976933479309],
               'G2': 239}},
 'A2': -7743692991058737324}

(b'\xbdDILW\x93o?={\x17\x00\x00\x00\x02\x00\x00\x00MwF\xeeG~\xfe\x03\xa2\xbe'
 b'\xc0\xa1\xb7\x00\x00\x00\x02\x00\x00\x00y\xa3X#@\xbe\xc7\x83m\xb5'
 b'\xfbK\x06\xa8\x00\x00\x00\x87?\x1f\x13\xb5>U\x9f\x1a?ib\xbe]\xfe:\x08'
 b'\xc7\x1d\xf1\x9f\xdd\xad\x90=\x86!\x13\t\xcc\n\x8c\x94\xd8\x14\xd3$'
 b'\x9dY>\xb4\xaab\xb3\x01\xd0\xd8\x19\xd0Y\xc6\x8c\x81\xbf0b\xd4y*\x84n'
 b'\xdd\xd3,y\xc3\x00\x00\x00]\x00\x00\x00k\x15vW\x83\x85s\xbfk\xa4\xe3\xd0'
 b'p{P\xcdc\x8d\xc5\x950;F\xd55c\xec\xeb\x1fr\xc3\xab\xb6\xed\xd6\xbb'
 b'\xe0\xad[\xd4\x00\x00\x00\x03\x00\x81')

{'A1': {'B1': {'C1': -27793,
               'C2': 0.7401594519615173,
               'C3': {'D1': [-5940180262211876404, 760146092901999773],
                      'D2': 8594818929723835298,
                      'D3': -0.3762337863445282}},
        'B2': [{'E1': 89,
                'E2': 0.3528624176979065,
                'E3': 179,
                'E4': 130841994575070860},
               {'E1': -127,
                'E2': -0.6890079975128174,
                'E3': 121,
                'E4': 3063695545528515011}],
        'B3': 2740462400,
        'B4': -0.389674574136734,
        'B5': -1241822458,
        'B6': -88,
        'B7': {'F1': -0.920484721660614,
               'F2': [-797934768,
                      -849113659,
                      -1792001210,
                      -717921300,
                      -350260541,
                      -1414074922,
                      -1142903461],
               'F3': 212,
               'F4': [5494, 22403, 34163]},
        'B8': {'G1': [0.6213944554328918,
                      0.20861473679542542,
                      0.9116629362106323],
               'G2': 93}},
 'A2': -127779988132749347}

Вариант №23

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

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

(b'IPYV\xf8X\x0c~\x00\x00\x00\x87\x00\x03\x00\x99"\xc2)0\xea}\xec\x1b'
 b'\xf99\x1c\xf4b\xc5\xf1\x84\xe6\xa7U\x01\xc4\xebRNbT\x85\xa7\xc6)p\xa7'
 b'[\xa8\x94\xa5\x07\xda\xed\x1a,\xc3\xc2\xc6\xf2\xbb\xa5\x91&\xc4=\xfe rG4'
 b'\x92\x12V\x82\x9a\t\xf9\tC\xd5\x1b\xc8\xa7%Gu\xf6\x9d;\xa7\x7f\xcc [1\xe8WR'
 b'\x03\x83\x13\x0b*+\xa9}\x08oE\xa3\xb3g\x11}\x97\x05]\x13\xd3&\xe1\xac'
 b'\xe5\xd8\x0bs\xdc\xc1\x87\x0e5Z\xf1W\xb4clpmoue\x00\x10\x00/\x00N\x00m'
 b'#\xfd\xd6.\x01\x81\xd6@c\xa3\x0f%\xe5\xf8\xf1\x84$\x85\xca#\xdd\x96+yb')

{'A1': 63576,
 'A2': 3198,
 'A3': {'B1': 22452,
        'B2': 'clpmoue',
        'B3': [{'C1': 2504609632840707099,
                'C2': -7,
                'C3': 14620,
                'C4': 17609855134079559509,
                'C5': 29682514,
                'C6': 5648169815698188656},
               {'C1': -6387326290117534995,
                'C2': 26,
                'C3': 11459,
                'C4': 14035172176497288900,
                'C5': 1040064626,
                'C6': 5130886482940303881},
               {'C1': -501795300901869787,
                'C2': 71,
                'C3': 30198,
                'C4': 11329833454907972401,
                'C5': 3898036739,
                'C6': 9444905119275121928}],
        'B4': {'D1': [1866834867, 1729199511, 89986003],
               'D2': [652324069, -670338084, -1048113611],
               'D3': 23281},
        'B5': 35},
 'A4': [-155886553089556381, -6697092451222322140, -8806186686755407518]}

(b'IPYVX\xb7\x8cf\x00\x00\x00\x87\x00\x02\x00\x99\xd5{\x16\x89\xba\x14V|'
 b'%\x86\xdf\xc9\xd3\xc6\x03h#5\xe2q\xa2\xc6\x82\xeb\xab\x8d\xab\xfdi\x80)\xd6'
 b'\xe5\xb8\xab\x14\x03l\xd8\x15\xe3\x83\xaf<;3N\x98\xf462\xef\x84I\xfd\xc6'
 b'K\xc4\xcb\xf3\xceJ\xd2\xc9\x17\x83\x9eF\x12\x0b\xe7U\x97\x8bP;wm\x19\xee'
 b'\xd1\xbf\xb4O4\xbe\xa3\x91~@\x8b\xea\xe6\xfb"\xc7\xf6\xfb\n\x0f\x9d\x14\x1e '
 b'}C%\xdczX-t\xa4\xb0(\x99\x9e\xcfS\x1a\xe6diwotpg\x00\x10\x00/\x00N\x00m'
 b'w\xda;8L\xc1\\f\x80\xa6d\xcb\xc4\x11I\x83\xaa')

{'A1': 22711,
 'A2': -29594,
 'A3': {'B1': 6886,
        'B2': 'diwotpg',
        'B3': [{'C1': -3063830340707264900,
                'C2': 37,
                'C3': -31009,
                'C4': 14543185339643803106,
                'C5': 1906493058,
                'C6': 16981822589761060905},
               {'C1': -2961758135011545896,
                'C2': 21,
                'C3': -7293,
                'C4': 12627032546788045878,
                'C5': 854557769,
                'C6': 18286386645591903818},
               {'C1': -3258047001362296309,
                'C2': -25,
                'C3': 21911,
                'C4': 10038588953526398673,
                'C5': 3216265012,
                'C6': 13736983259844963046}],
        'B4': {'D1': [-81606666, -83226723, 337518717],
               'D2': [1126554746, 1479373988, -1339516514],
               'D3': -12461},
        'B5': 119},
 'A4': [-2721519647502604672, -6456811922778389590]}

Вариант №24

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

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

(b'YHJD\x02\x00M\x00\x00\x00\x85\x00\x00\x00\x0c2T7J\xb9\xac\xc7P\n'
 b'\xcf\xa3J\xc2\xac\xd8Z\x06I\xeb\xa5\xcb\x9c\x10\xdff\r\xc0\xe0*\xd1}C\x1f'
 b'\xbcO\x89%9\xabd0?\x87\x19\xb3\xbd_#.\xe1\xff\xb0Q\x93\xfb\x8c\x04'
 b'\x00\xa3\x00\x00\x00\r}\xf4\xe8<\ry\xb3\xe0\x00\xd0?\xe6#p\xbf\xfcv\xe6'
 b'%R\xcb\xec?P\xa3\xf5+\x00\xf7\x8e\\OY\xef\xbf\x07\x05o?\xb2\x02\x7f'
 b'\x89\x11\xf8\xee?xhz`\x08<tN\x03\x00}\x00\x00\x00\x0c\xb8\x0bb\xc0'
 b'\x96\xb5\x1b<\xce\xad\x8e\xe3\xff\x1e\x07\x05\x00\x80\x00\x00\x00\x06A\xe2'
 b'\xa5\x1e\x1b')

{'A1': [{'B1': 3908336909,
         'B2': 0.2500535729088431,
         'B3': -0.9380477666854858,
         'B4': 0.8998194446791952},
        {'B1': 737518416,
         'B2': -0.9796521003515579,
         'B3': 0.9336704611778259,
         'B4': 0.9677817998381981}],
 'A2': {'C1': 'xhz',
        'C2': {'D1': 1644935180,
               'D2': 464885440,
               'D3': 513128760383229500,
               'D4': [96, 8, 60, 116, 78],
               'D5': 16646}},
 'A3': 12812,
 'A4': 743313483173082964,
 'A5': 457916548637172687,
 'A6': 7412661777292716873,
 'A7': {'E1': 2252782575936389133,
        'E2': -68,
        'E3': -30385,
        'E4': 14629,
        'E5': [0.6890360713005066, -0.0874510332942009],
        'E6': -7831283663979535521,
        'E7': 36091,
        'E8': [-30, -91, 30, 27]}}

(b'YHJD\x02\x00M\x00\x00\x00\x85\x00\x00\x00\xce:\xa7\x06\xdd\xbd'
 b'\x8e\xef\xb5\xbc\x94\x8d\x85\x89O?\x84\x10\xd7\x8c\x7f4\x18`\xb0\xb1'
 b'I\x84\xa4 (\x95\xf0Na\x9c\x99\x04\x80;\x14\xd6\xbe\x10=\xe0\xbe>\xf9\x9d'
 b'\x0e\xed\xd8xn%3\x05\x00\xa3\x00\x00\x00B\x01\x0b\x97 \xa4x\xe5\x7f\xe6\xd9'
 b'\xbfFw\x08\xbf\x8cF\xe9\xc4\xb9\xee\xd5?d\xcfs\xab\xfe\xcfap4\x93\xeb?\x05M9'
 b'=\xe0\x18\xb9LN\x9f\xb3?vzj\xbf=\xee\xa0\x94\x03\x00}\x00\x00\x00\x7f'
 b'\xe7\xd4\xde3\x97\xa2\xed<h\tx\xc8D\xd2T\x05\x00\x80\x00\x00\x00E\xaa\xaa'
 b'?\x04\x9c\xde')

{'A1': [{'B1': 2534080834,
         'B2': -0.4046935788088053,
         'B3': -0.5330699682235718,
         'B4': 0.34269565801251},
        {'B1': 2876493668,
         'B2': 0.8617193407976627,
         'B3': 0.045239467173814774,
         'B4': 0.07664956448670379}],
 'A2': {'C1': 'vzj',
        'C2': {'D1': 3738494847,
               'D2': 3986855731,
               'D3': 6112023272093214780,
               'D4': [191, 61, 238, 160, 148],
               'D5': 43589}},
 'A3': 15054,
 'A4': -4848706027444697433,
 'A5': 1190145812374850964,
 'A6': -5642904676018975529,
 'A7': {'E1': 5688210328947819593,
        'E2': 97,
        'E3': -26212,
        'E4': -32764,
        'E5': [-0.4181230962276459, -0.43796586990356445],
        'E6': 7960350854041434430,
        'E7': 13093,
        'E8': [-86, 63, 4, -100, -34]}}

Вариант №25

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

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

(b'NRUPc\xf4:\n\xb8\x8du\xcc\xe8?(\xad\xdc\xd6\xfcG\xc8?*\x00hq\x05!#,4\x00'
 b'\x00\x00`\x00i\x00r\x00{\x00\x03F\xa0\x02\x8f9\x88\xa8\xed?$\xe1zM'
 b'\xc2\x04\xe3\xbfDnlxuw\xd9\xaf\xab\xec\xea\xab\xe0So?#\x0c\xe6\xad'
 b'\xbc5\x97\x93\x0e\x1b\x94Y\x15&~\xad\x14j\t\x9bJ\x03\x00]\x00O\x92|'
 b'\x1f\xaf\x04\x00e\x00\x0cZ;\xd3\x0e\x04\x00n\x00\x95H\x91Mn\x04\x00w\x00')

{'A1': 244,
 'A2': 0.7749583976695427,
 'A3': 0.1896968888407653,
 'A4': {'B1': 17923, 'B2': 0.9268227695648257},
 'A5': 29032,
 'A6': 740499717,
 'A7': {'C1': -0.5943309319764336,
        'C2': 68,
        'C3': 'nlxuw',
        'C4': 6044019725412577241,
        'C5': 111,
        'C6': [-435412161, -1758085971],
        'C7': 9089976372374998675,
        'C8': 5293},
 'A8': [{'D1': 74, 'D2': [106, 9, 155]},
        {'D1': -81, 'D2': [79, 146, 124, 31]},
        {'D1': 14, 'D2': [12, 90, 59, 211]},
        {'D1': 110, 'D2': [149, 72, 145, 77]}]}

(b'NRUPc\xdf\xd8,$\xb5\xdd\x1f\xdd?\xa0C$b\x03\x82\xd4\xbf*\x00\xbaJ\xb7_'
 b'0m4\x00\x00\x00_\x00f\x00o\x00v\x00\xa7\xba\x00\xf9\x92\xca\xebU\xc8?'
 b'NE\x8c\x8c\xe2$\xe9\xbf\xbasmfhl<\xd64\xcc\x12\x14\x05\x87\x91\xe1'
 b'\xda\x1b\x90\xf60\x80\x9d\x83\x07\xac]\x9b\x1b\xf5\x98\xf2mLW<\x02\x00]\x00'
 b'\x84\xa6F\x02\x00d\x00\xb2\x8b\xf9^\xbf\x04\x00k\x00I{V\x02\x00t\x00')

{'A1': 223,
 'A2': 0.45506994905072196,
 'A3': -0.32043537696977786,
 'A4': {'B1': -17753, 'B2': 0.19012210265459117},
 'A5': 19130,
 'A6': 1831886775,
 'A7': {'C1': -0.7857525582386786,
        'C2': 186,
        'C3': 'smfhl',
        'C4': -8717539432737745348,
        'C5': -111,
        'C6': [-1877222687, -1652543242],
        'C7': 11021746017164593027,
        'C8': 28146},
 'A8': [{'D1': 60, 'D2': [76, 87]},
        {'D1': 70, 'D2': [132, 166]},
        {'D1': -65, 'D2': [178, 139, 249, 94]},
        {'D1': 86, 'D2': [73, 123]}]}

Вариант №26

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

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

(b'\xfbGKIG\x00\x00\x00G\xbf\tF\xdd?\xd1\xd4\x9e6a3P\x00\x03\x00\x00\x00Y?'
 b'l\xd9\xe4\xbf\xdb\x10\xee\x84\xa4\x95\x8c\x00\x00\x00\x04\x00\x00\x00\\m'
 b'xcG\x8df\xc9\xfdL\xf9\xccC\x7f*v3\x18e\xb4\xfdK\x8c\xabX\x01\xe3\x89Q\x00'
 b'\x00\x00\x02\x00/\xeb\xed \x83\x001\x00<pbq\x1dg\xdc%8\xe09\x05'
 b'\xc9\xf3\xf7\x19!\xba|\xd7\xe2\x88BMp_e^0\xb8k\xe6\xe2\\\xab\xb1')

{'A1': {'B1': 31689041,
        'B2': {'C1': 'mx', 'C2': -5139, 'C3': 8323},
        'B3': [{'D1': 1665633638,
                'D2': 201,
                'D3': 4249680332,
                'D4': 67,
                'D5': 127},
               {'D1': 712389400,
                'D2': 101,
                'D3': 3036498828,
                'D4': 171,
                'D5': 88}]},
 'A2': {'E1': -0.5362375378608704, 'E2': 0.2786021739055302},
 'A3': 'pbq',
 'A4': 0.9251997470855713,
 'A5': -0.42290842965515973,
 'A6': [2118904202127227141,
        14552246508276317399,
        16323369749769577822,
        3510674548919675825]}

(b'\xfbGKIG\x00\x00\x00G\xbf*sp\xbf\xa6e\xa2\x1e\xfe[\xa0\x00\x03\x00'
 b'\x00\x00Y\xbf<\x90\xa0\xbf\xe6\xf8\xc6\xc2\x1d`b\x00\x00\x00\x02\x00'
 b'\x00\x00\\ayJx|\xden\xef\x8e\x86\x89\x0b\xf7\x86\xfb_\x87\x9eX.='
 b'\xcam\xcb\xe8G)\xc6\x00\x00\x00\x02\x00/r$\xa6\x8a\x001\x00<grp{\xa6\xe6\xa5'
 b'k\xaf\x81\x86\x15\x0f\xc3\xa3\xdc\xb15\xa1')

{'A1': {'B1': -397989434,
        'B2': {'C1': 'ay', 'C2': 29220, 'C3': -22902},
        'B3': [{'D1': 1249410270,
                'D2': 110,
                'D3': 4019095177,
                'D4': 11,
                'D5': -9},
               {'D1': -2030346361,
                'D2': 158,
                'D3': 1479425482,
                'D4': 109,
                'D5': -53}]},
 'A2': {'E1': -0.6658239364624023, 'E2': -0.0437441504320113},
 'A3': 'grp',
 'A4': -0.7365818023681641,
 'A5': -0.7178682128242253,
 'A6': [8910062510949761414, 1517646707996833185]}

Вариант №27

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

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

(b'LVLT>\xd0-C\xac?B\x93\xba\x99\xee7C \xef\xfbH\x8b\x02\x00\x82\x00\x00\x00'
 b'~8\xf1\xdau\xbf\x11\xbbM\xbe\xb6\xc5~>\xca\x07\x95>\x89\xbc\x00?\x14P'
 b'\x07?\x84\x02^&\xf1N\xc2\xbe\x0fE\x04\xbe,O\x1d?z\x13\x8c\xbe\x02\x00'
 b"\x00\x00\x86\x00\x00\x00WK\xb1\xedS\xf0F\xd0\x11'\x93\xfb\xe3\xbc)\xcfq\x81"
 b'\xf0V\xafL>`t\x93\xfe\xf0\r:\xdb\x80\xdc\x80>L:\xb5\xf6\xbe4@\xae<#3'
 b'\xc4l`\x00q\x00Uh\x0b\x01\xec\xa2\x07|')

{'A1': 1127075902,
 'A2': -1824374868,
 'A3': 938383802,
 'A4': 4226752579,
 'A5': {'B1': 35656,
        'B2': [{'C1': [41, 207, 113, 129, 240],
                'C2': 0.19988760352134705,
                'C3': 15796953971669824608},
               {'C1': [128, 220, 128, 62, 76],
                'C2': -0.48185139894485474,
                'C3': 7837445477966430260}],
        'B3': {'D1': 126,
               'D2': 56,
               'D3': [-0.9603720307350159,
                      -0.20090891420841217,
                      0.2488010823726654,
                      0.29107505083084106,
                      0.5028768181800842,
                      0.5285656452178955],
               'D4': 643695236},
        'B4': [-0.37950852513313293,
               -0.12916968762874603,
               0.6144893169403076,
               -0.27358609437942505],
        'B5': [17524821, 2080875244]},
 'A6': 19287,
 'A7': 2815260245181590961,
 'A8': -0.02782992087304592}

(b'LVLT\xa7\xe0,Rr[\x1e<\xe0G\x16\xd2\xf7\x05)\xaf\xb9\n\x02\x00'
 b'\x82\x00\x00\x00\xeaGT\x9cr?\xdd\xd0L?\t\xf7d\xbf\xca\x92|?q\xddn?\xfer'
 b'o\xbf\x179>r\x1f\xd6\xb1\xbe\xeb\xf4\x84>~\x12H?\x81\x8d9\xbf\x06\x00'
 b'\x00\x00\x86\x00\x00\x00\xf9\xc4\xa27\xf6zn\xbf\xd5v\xf5W\x93\xbc'
 b'%\xff\x19\xc8jl\x00\xa6>D\x14L#\x81\xe5\xe9h\xae\xfc%\x14\xec\xe8\x891?$\xbe'
 b'\xb5\x01R\x9a-\xcb`\x00q\x00\xea~\xc4/\xf6O\xdd\xb5nt|\xa9\x1aN\xf9>\x86\xbe'
 b'\x9d\xa5\xc4\xfa\xa1\x9e')

{'A1': 1378672807,
 'A2': 1008622450,
 'A3': -770291744,
 'A4': 2938701303,
 'A5': {'B1': 2745,
        'B2': [{'C1': [37, 255, 25, 200, 106],
                'C2': 0.32422196865081787,
                'C3': 7559825792323818564},
               {'C1': [174, 252, 37, 20, 236],
                'C2': 0.6935105323791504,
                'C3': 14640527640658034212}],
        'B3': {'D1': -22,
               'D2': 71,
               'D3': [0.9476978778839111,
                      0.8000620007514954,
                      -0.8943944573402405,
                      0.9866148233413696,
                      0.9330664277076721,
                      -0.935348391532898],
               'D4': 1916680471},
        'B4': [-0.3473367393016815,
               0.2596810758113861,
               0.7815321683883667,
               -0.7248154282569885],
        'B5': [801406698,
               3051180022,
               2843505774,
               1056525850,
               2778578566,
               2661415620]},
 'A6': -15111,
 'A7': 8562960747745130402,
 'A8': -0.017986277118325233}

Вариант №28

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

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

(b'\xe3CRH\x00G\x00Q\x00[\xf0\x8a\x19;\x9e*h\xca\xbe\x04h\xf7\xa2G\x92\xdaQy'
 b'\xc6mV\r\x8am8@\x93I\xaf\x979\x96\x00\x05\x00e\xbe\x8f\xddR>\x07'
 b'\xc9\xef\xbf|\xaf\xa0\xbf\x1b5\xa2?\x1d\x92e?\x16\xfc\x98\xfb?'
 b'\xdb\xd2\x13\xb3`]\xe8DI\xbf\xc4\xc9.\x89\x13w\x00\x9f\xe3?\xd1\xc2\xab\x98'
 b'\xde\xca\xdc,\xfcA\xa1N\xaa\x80y\xec\xad\x1e\x8f')

{'A1': {'B1': [{'C1': 0.43469707982282424, 'C2': 17481},
               {'C1': -0.16238958066144704, 'C2': 40931},
               {'C1': 0.2775067322610718, 'C2': 11516}],
        'B2': {'D1': -1114050213973432118,
               'D2': -0.12930665910243988,
               'D3': 2722599642,
               'D4': 5870941762151615085,
               'D5': [56, 64, 147, 73, 175, 151, 57, 150],
               'D6': [16801, 20138, -32647, -4947, 7823],
               'D7': [-0.28098541498184204,
                      0.13260625302791595,
                      -0.9870548248291016,
                      -0.6062871217727661,
                      0.6155150532722473,
                      0.5897917747497559]}},
 'A2': -5}

(b'\xe3CRH\x00G\x00Q\x00[ORC\xf8\x1bwf\x9f>B\xe5\xbc\x84\xaf\xa9\xde\xb9<'
 b'\x896\x87\xfbW<\x14\xab\xf1\x0ci\xda(h\x00\x03\x00e?[y\xe9>\xef8W\xbf<`S=.'
 b'@\xef>$\xe0x>\x9d\x80\xcf.?\xcf\xa6\xca\xdf\xf9k\xe8.\t\xbf\xe7\xb9'
 b'M\x98[\xa6h\x80\xdb?\xe1\x0f\x0c\xff\x16\xe3\xce\xd8\xd4P!o\x0c\xcd\x92')

{'A1': {'B1': [{'C1': 0.2472776025414014, 'C2': 11785},
               {'C1': -0.741370008062586, 'C2': 32987},
               {'C1': 0.5330872518744572, 'C2': 55508}],
        'B2': {'D1': 5715705609978341023,
               'D2': 0.19032949209213257,
               'D3': 2226104798,
               'D4': -5099049810787608772,
               'D5': [20, 171, 241, 12, 105, 218, 40, 104],
               'D6': [20513, 28428, -12910],
               'D7': [0.8573289513587952,
                      0.46722671389579773,
                      -0.7358447909355164,
                      0.04254239425063133,
                      0.16101253032684326,
                      0.30762335658073425]}},
 'A2': 46}

Вариант №29

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

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

(b"OAHP\x04\x00*\x00$H\xf3'=\x00\x00\x00t\x00\x00\x00\xa8\x18\xe0\x10\xdc|\xd2?"
 b'@E\xc1\xe2T\x84\xa0?\x04\x00\x8d\x00\x00\x00wyhj\xe0I\xbf>\x19\xc6\\\x14kM'
 b';0\xf2\x9dO\x04\x00.\x00\xfc\x03\x002\x00\x06\x02\x005\x00\x94\x03\x007\x00'
 b'\xec\x03\x00:\x00/\xea/\x12t\xa4\xbe\xfc~\xf0\xbdH\xb6\xd0>*\xa3\x0f?x\xf6R?'
 b'Sn\xb9\xbc\n\xa05\xbfr\xd0K\x9c\xe7\x1ag\t\xf3\xcb\x81\xae\x94\xf7\xb2\x84'
 b'F"\x0b\x06\x00\\\x00\x00\x00\xb3<6\xad\xb9\xad\xff\xbf')

{'A1': 'wyhj',
 'A2': 670255140,
 'A3': {'B1': [{'C1': [-32, 73, -65, 62], 'C2': 252},
               {'C1': [25, -58, 92], 'C2': 6},
               {'C1': [20, 107], 'C2': 148},
               {'C1': [77, 59, 48], 'C2': 236},
               {'C1': [-14, -99, 79], 'C2': 47}],
        'B2': 12266,
        'B3': -0.321198046207428},
 'A4': {'D1': -1672753038,
        'D2': -25,
        'D3': -7733100797192739046,
        'D4': -9,
        'D5': 575046834,
        'D6': 11,
        'D7': [-0.1174297034740448,
               0.4076406955718994,
               0.5610834360122681,
               0.824073314666748,
               -0.02263561449944973,
               -0.7094732522964478]},
 'A5': 0.2888708271788212,
 'A6': 0.03225960987095755,
 'A7': [15539, -21194, -21063, -16385]}

(b'OAHP\x03\x00*\x00LWA\x17@\x00\x00\x00{\x00\x00\x00\x087T\\\xa2d\xcf?'
 b'\x00a\xec\\\xbf|\xc3?\x05\x00\x94\x00\x00\x00yzp\t\xd4\xad0\xb3\x04E'
 b'\xd7j8\xf5\xeb\xbf\xdf\x97\xcdI\x12\xb3\x02\x00-\x00\xea\x04\x00/'
 b'\x00H\x02\x003\x00Z\x06\x005\x00\xb2\x05\x00;\x00Nz\xa5+Up\xbfh\xcfZ>E'
 b'\xf51\xbf\xc77&>\xa3\xd8\xf8\xbd9\xa5.\xbfx\x08\xa9=\xac\x1c\\\xbf@'
 b'S\xb0\xf5\x1fw\xb0\xb9\xdf]\x0fM\xb1\xc6"\xd4\xd2?\n\x07\x00_\x00\x00\x00'
 b'\x8a.\x90\x82\x8a\x0c\x02S\xe2Q')

{'A1': 'yzp',
 'A2': 390158156,
 'A3': {'B1': [{'C1': [9, -44], 'C2': 234},
               {'C1': [-83, 48, -77, 4], 'C2': 72},
               {'C1': [69, -41], 'C2': 90},
               {'C1': [106, 56, -11, -21, -65, -33], 'C2': 178},
               {'C1': [-105, -51, 73, 18, -77], 'C2': 78}],
        'B2': -23174,
        'B3': -0.9387995600700378},
 'A4': {'D1': -172993728,
        'D2': 31,
        'D3': -5670859459929722761,
        'D4': -58,
        'D5': 1070781474,
        'D6': 10,
        'D7': [0.21368181705474854,
               -0.695148766040802,
               0.16232214868068695,
               -0.1215069517493248,
               -0.6822085976600647,
               0.08253568410873413,
               -0.8598124980926514]},
 'A5': 0.2452586127114318,
 'A6': 0.15224449193261336,
 'A7': [11914, -32112, 3210, 21250, 20962]}

Вариант №30

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

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

(b'\x84WVRH\x00\x00\x00\x07\x00\x00\x00M\x01<\x00\x00\x00\x03\x00\x9d?_\xd8'
 b'\x90\x00\x00\x00\x02\x00\xa9"E\x1d\x8eJ}*\xf5?c\x1a\xa6\x00\x00\x00\x02\x00'
 b'\x00\x00\xab?:\x8dL\xd8\x12q\xca\xa3\x9a0[\xc5!\xeerQx\xd2\\X'
 b'\x1c\xff\x10\xde\xcd\xd1\x83r\x11\x901\xcaI/\xdeE\xa0\xa2\xacR\xd7\x92k\x06'
 b"\xc7\xd9;\xf7\xbb\xfb\xa7\xda\x94\xddWLB\xb95..\xfa\xbdQ\xee'\xc5L"
 b'X\\\x91\x83o\x93\xe2\x9e\xbd\xc7\x0b\xe4\x8d\x92\xddU\xbd>\xa8!\x0fM\xb1\xca'
 b'W>\xa5}.i\xe8\xcc\xd6?h\xd4\xc6\x00\x00\x00\x85\x00\x00\x00\x8d\x00\x00\x00'
 b'\x95\xe7\xd1\xe0\rI\r')

{'A1': [15097035795635227209,
        3449270920838664919,
        10550534007458363323,
        18133702757534092354,
        13345623850092417518,
        2865780680285061999,
        10656254206237467789],
 'A2': 316,
 'A3': [{'B1': -1830988355, 'B2': 0.32837721705436707},
        {'B1': 1303497303, 'B2': 0.3232206702232361},
        {'B1': 1776864470, 'B2': 0.9094966650009155}],
 'A4': 0.8743982315063477,
 'A5': {'C1': {'D1': [231, 209],
               'D2': 34,
               'D3': [69, 29, -114, 74, 125, 42, -11],
               'D4': 0.8871253728866577},
        'C2': [57357, 18701],
        'C3': 4556109334220796362,
        'C4': 163,
        'C5': 2586860485,
        'C6': 2445017341953727576,
        'C7': 28},
 'A6': -15671603}

(b'\x84WVRH\x00\x00\x00\x04\x00\x00\x00M\x02\x82\x00\x00\x00\x04\x00'
 b'\x8d\xbd\xbd4\x95\x00\x00\x00\x04\x00\x9d\xc0j\xe6\xbf,S\xd44?'
 b'\x03\x95\xc4\x00\x00\x00\x02\x00\x00\x00\xa1\x81anA\x80\xac\x00\x0c\xdd'
 b'\xc8\x17\x10\xd5\x19{\x01\xdc\x96t\xff\x93=\x04\xcc\xe9\xdbT\x8d\xbc'
 b'`\xb3]\x15!\xea\xe9\xa0\xa4-}\x9b\x91\x1b\xa8VRU2?S\xb3P~7^o\xd1'
 b'\xd4!\x92\xa7\xff?S,`\x0cs\xb0\xc5\xbfh1(}p\xba\xb2?i\xda\x0c\xb9R\xfe'
 b'p>w\xa4\x03\x00\x00\x00m\x00\x00\x00u\x00\x00\x00}\x00\x00\x00\x85\x84\x170'
 b's\xe0\xf5\xa2\xc1')

{'A1': [6092732994414253345,
        16927237301447007121,
        1992937746728107859,
        12920966107198640596],
 'A2': 642,
 'A3': [{'B1': 563259391, 'B2': 0.8248958587646484},
        {'B1': 208908485, 'B2': -0.9070000648498535},
        {'B1': 2104539826, 'B2': 0.9134833812713623},
        {'B1': -1185743248, 'B2': 0.24183659255504608}],
 'A4': -0.09238544851541519,
 'A5': {'C1': {'D1': [132, 23, 48, 115],
               'D2': -64,
               'D3': [106, -26, -65, 44, 83, -44, 52],
               'D4': 0.5140039920806885},
        'C2': [57589, 41665],
        'C3': -9123890142465228788,
        'C4': 221,
        'C5': 3356954837,
        'C6': 1836063320012291987,
        'C7': 61},
 'A6': 80538075}

Вариант №31

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

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

(b'DZOGn\r\x8c\xa3\x0b\xd1\x96\x8d\xd4{~\xa4e\xe5\xf2\x16\xbcj\t\x1cr\x83Lz'
 b'ohj\xf5\x98\xfb\tH\xba\x10\xb7V\xb2\x00~[iaohyg\xe6\xdc\x02+`*\xbc\x1c]\xfc'
 b'\xd0\x8f7?\xca\xe1\xce\xc9\xdf\xba\xe9\xe6\x1e\xe6\xf9I\x9dG\no\xd6=\xd1\x84'
 b'\xa6\xb5\xf2w\xfa/\xb5*Kh9;\x07\x1aO\xfb\xf4\x86\xd0\xba\xf37\xb6/'
 b'\xd8\x83?\x04^\x1f!F\xf6C?1\x01;\x08\x95[\xd7\x00n\x00vS\x81\x8e_')

{'A1': {'B1': 3468,
        'B2': -1559506538,
        'B3': -8226814835444816398,
        'B4': 1638300951820534604,
        'B5': 'zohj',
        'B6': -749573320663756617},
 'A2': 22194,
 'A3': {'C1': [{'D1': 0.517061173915863, 'D2': 558298691},
               {'D1': 0.6914250254631042, 'D2': 144006103}],
        'C2': 1400999519},
 'A4': 91,
 'A5': 'iaohyg',
 'A6': 3873178155,
 'A7': [6929557806684885135, 3981123666804596666, -1592551440855229113],
 'A8': [752055223790642869,
        17471708362216983400,
        4123897693380277382,
        15040601326162532483]}

(b'DZOGn\xf5G\x17\x1e\xf1Z#\xe8<\x01\xf6\xee,u<u\xfeFA\x8f\x14\xe9mbgz\x04'
 b'\xc9R\x9e\xf7\x08\xf0\xbe\xdf\xd3\x00~\xc1pvlmea\x1a\xa8\xd1\xe4\xec\xd3'
 b'z\xfa\xb0^\x08\x0e\x07\xbc@\x94[\x89B\xd8\x86\xc8^\xf0\xca\xfe'
 b'\xee\xb8\x05\xf3\x1d\x97\x9d\xa06\xe0U\nt\x9f\x10^T\xc3\xcc\x8c\x16\xad=\xf2'
 b'\xae\xd7\xff\xb4\xac\x9b\x9cJ\x8f\xc6\xbf!\x98q*b?V?\x1c\xf1\x02\xf8"'
 b'\xbc\xe5\x00n\x00v\x95w\x8c\x1e')

{'A1': {'B1': 62791,
        'B2': 387903834,
        'B3': 2587383965059787893,
        'B4': 4356667792251884777,
        'B5': 'mbgz',
        'B6': 344897689173422270},
 'A2': -8237,
 'A3': {'C1': [{'D1': -0.6312323212623596, 'D2': 711081814},
               {'D1': 0.613052487373352, 'D2': -131941147}],
        'C2': 2507639838},
 'A4': 193,
 'A5': 'pvlmea',
 'A6': 447271396,
 'A7': [-1381625443553245170, 557391459822158552, -8734627088994210120],
 'A8': [428718926552119008,
        6127838469514220739,
        14739180613801258711,
        18425541759821582278]}

Вариант №32

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

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

(b'\x0eQCQ\x00\x00\x007\x00\x00\x00?\x00\x00\x00F\x00\x00\x00M\x00\x00\x00T'
 b'\x00\x00\x00[\x00\x00\x00b\x00\x02\x00i=\xc4\x9d\x8aSz\xd8\xe3\x00\x00\x00q'
 b'\x00\x02\x00\x00\x00}\xdd3iqrwlc\xd7Q\xcd\x90P\xee\xf8mgt>\xb2/\xe5'
 b'\xfd\xad\xf6{\x93\x85\xe7\xbc\x0f\xaa\xc5\x84\x987{\x00\xb7\x19\xc7e'
 b'\x93\xdc\xb0v=\x1a\xe3\x84\x1dh\x00A]\xf0\xf3V7\xf00U\x12\xbf\xe2\xe8'
 b'\xce\xf6\xad\x140\xbf\xc4\x16\xd8\x9aHo\x18\xbf\xe0]uV\x13r\x1a')

{'A1': {'B1': {'C1': 51, 'C2': 'iqrwlc', 'C3': -41},
        'B2': [{'D1': 81, 'D2': -846180114, 'D3': 63597},
               {'D1': 103, 'D2': 1950265903, 'D3': 58877},
               {'D1': -83, 'D2': -159673467, 'D3': 59324},
               {'D1': 15, 'D2': -1429896040, 'D3': 14203},
               {'D1': 0, 'D2': -1223047323, 'D3': 37852},
               {'D1': -80, 'D2': 1983716067, 'D3': 33821}],
        'B3': [1744847197, 4042479159],
        'B4': 0.09600360691547394},
 'A2': 1400559843,
 'A3': {'E1': 4029699346, 'E2': -0.590919000424611},
 'A4': [-0.15694720776888782, -0.5114084893389788],
 'A5': 221}

(b'\x0eQCQ\x00\x00\x007\x00\x00\x00?\x00\x00\x00F\x00\x00\x00M\x00\x00\x00T'
 b'\x00\x00\x00[\x00\x00\x00b\x00\x03\x00i>\xb9\xae\xf47\x815f\x00\x00\x00u'
 b'\x00\x02\x00\x00\x00\x81\x8f\xb3uygpiw\xc2-\xe7\xbcE\x1fNAAbe\x05\xe1\x13'
 b'7\xb9\x19\xac\x8c\x1a\xe0\xef9\x8f\xf53t\x0e\xd6d\x1d\x884\x0b\x1a\x02-\xc5'
 b'\xd5\x1aTo"\xda\x88;\x1f{\xaa\x83}u\x00\x8dm\x81g\x90-?\xda\x7f'
 b'\xdf\xa3\x15\xd0\xd8?\xc6\xf1a\xa3"} \xbf\xd0\xa1^\\\x14\xac\x00')

{'A1': {'B1': {'C1': -77, 'C2': 'uygpiw', 'C3': -62},
        'B2': [{'D1': 45, 'D2': -407091937, 'D3': 20033},
               {'D1': 65, 'D2': 1650787809, 'D3': 4919},
               {'D1': -71, 'D2': 430738458, 'D3': 57583},
               {'D1': 57, 'D2': -1879755916, 'D3': 3798},
               {'D1': 100, 'D2': 495465483, 'D3': 6658},
               {'D1': 45, 'D2': -975889836, 'D3': 28450}],
        'B3': [3666361119, 2074772349, 1962970477],
        'B4': 0.3626629114151001},
 'A2': 931214694,
 'A3': {'E1': 2171047981, 'E2': 0.4140547840718347},
 'A4': [0.17924137559473596, -0.25984915725956625],
 'A5': 143}

Вариант №33

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

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

(b'\xc3RYV\x00\x00\x000\x00\x07\x009\x1a9\x00\x06\x00\x00\x00q\x00\xa1o\xcf'
 b'\xb2\xb2\xc5Q|\xbb\xaa\xa7\xcbA\x97\x0b\xae\xbb\x00\x02\x00\x16.\x00'
 b'\x02\x00\x1e\xab4\x8c&m\xf0\x00\x02\x00&\xa8o1\xff6 \xa6\xca\xf5_\r'
 b'm\xbd\x03B\xb8TO\xc6\x02E\x15\r\xb3\x17\x9a\rv\xbf\x814\xfc:\xde\xed'
 b'e\xa4\xdb\x8cH\x9c\x94B\xce\xcd}0m#\xad\xbdq\xc1\xae\x94\xbfG\xb3\x98'
 b'sD\x96\xc4\x1f\xb6\x08\x03G\x8b\xfe\xe1\xda\xae\xf0\xabn\xb6\xea\xee\nuY\x11'
 b'\x11V:\xa6\x98\x87\xe6\xd6z>u\xb3\xd6\xa5\xb9Sl\xe4\xf6\xb2E?\xed\x14'
 b'\xe4\xf1\xd9\x14\x94\xbe\xcdm\x9an\x9c')

{'A1': {'B1': 52,
        'B2': 2351328752,
        'B3': [{'C1': [1875882674, -984515397], 'C2': 46},
               {'C1': [-1431844031, -1760842053], 'C2': 171}]},
 'A2': [-6309769580728244534,
        -765878646655991112,
        6075292135397330355,
        1700686612956001532,
        4242088919842917448,
        -7164027651261386643,
        2570919258576819391],
 'A3': 6713,
 'A4': [5166640818363483167,
        -5330006553166683686,
        -5840980224695931382,
        8455808541523617432,
        -8653993813423574058,
        -6505076459597024699],
 'A5': {'D1': 0.908800575599019, 'D2': -0.40122681856155396, 'D3': 28316}}

(b'\xc3RYV\x00\x00\x000\x00\x02\x009]6\x00\x02\x00\x00\x00I\x00Yu\x00\xb6V\xd4O'
 b'\xebdM\r\xcc\x05\x8c\xbe\xbf\x8b\x00\x02\x00\x16\xe9\x00\x02\x00\x1e\xf4'
 b'\xb7\xa2\xc6U\xd4\x00\x02\x00&\xc4\x0b>\xfb{\xbd\x95\xc6R#E\x08B\xb4\x90'
 b'\x8a2\x98\x8a\x8a=\xbe\xd7R?*\xfd\x0b\xaf\xc5\xbb\xff?\xd4Q\xcf\xe0\xa8\x94'
 b'@\xbfAr\xd4\xe0m')

{'A1': {'B1': -73,
        'B2': 2730907092,
        'B3': [{'C1': [1962980950, -732959900], 'C2': 233},
               {'C1': [1292749829, -1933656181], 'C2': 244}]},
 'A2': [-4320290167698123322, 5918650237076148362],
 'A3': 23862,
 'A4': [3645816224702453586, 4551728600046746623],
 'A5': {'D1': 0.31749340953166794, 'D2': -0.7556583881378174, 'D3': 57453}}

Вариант №34

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

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

(b'SFM\xc3\xfc9\xcc61<\x00\x00\x00\x08\x00\x00\x00t\x00)\x04\x8e\x03\x00'
 b'\x00\x00\x94\x00\x02\x00\x00\x00\x97\x00\x8e\x02\x00\x00\x00\x99'
 b'\x00\x00\x00R\x8a\xaaX\xb7\xb5\x89\x87\xe2?.87\xbfgaoY\x03\x00\x00'
 b'\x009\x00\x10Pq\xf8\x95bR\t\xb6\x15\xf9Lo.!$@}\x9d/\x98\x8br\x1d\x88'
 b'i\xd0\xca\x81.\xaa\x0e\xab\xb8\xa7\xbe\xe6\xc3\xaaMF\xd9\xf4\xfa\xaa'
 b'0\xd0\xde\xe0L\x00\x00\x00Q\x00\x00\x00V\x00\x00\x00[\x00\x00\x00'
 b'`\x00\x00\x00e\x00\x00\x00j\x00\x00\x00o\x00\x00\x00A;"\xa9q\xb1:\x9d@')

{'A1': 252,
 'A2': 825674809,
 'A3': {'B1': 89,
        'B2': 'gao',
        'B3': {'C1': 16, 'C2': 2516087120, 'C3': 3054064226}},
 'A4': {'D1': [{'E1': 1867315477, 'E2': 46},
               {'E1': 2101355553, 'E2': -99},
               {'E1': 1921751087, 'E2': 29},
               {'E1': -892311160, 'E2': -127},
               {'E1': -1425102290, 'E2': -72},
               {'E1': -1008288089, 'E2': -86},
               {'E1': -187087283, 'E2': -6},
               {'E1': -556781398, 'E2': -32}],
        'D2': {'F1': 41,
               'F2': -29180,
               'F3': [65, 59, 34],
               'F4': [169, 113],
               'F5': 142},
        'D3': [15025, 16541]},
 'A5': 35410,
 'A6': 0.5790451573509661,
 'A7': -0.7157009840011597}

(b'SFM\xc3\xf1rx\xe4\xdb;\x00\x00\x00\x06\x00\x00\x00i\x00l\xd6#\x03\x00'
 b'\x00\x00\x81\x00\x04\x00\x00\x00\x84\x00\x85\x02\x00\x00\x00\x88'
 b'\x00\x00\x00\xad\x90\xb8\x8b4a\xd3\x9b\xc8\xbfzh\n\xbfdgi\x02\x00\x00\x00'
 b'9\x00\x10}\xab\xa6O_\xce\xea\x0bO!\x91\xc1\xbc\xc6i\x86\xe2l\xc2\xa5\xa1'
 b'D\xfd\xb3\xb9\x80\xb2k\xbe\xa7\xca+\xfd\xb3\xeaW\xbe4K\x00\x00\x00P\x00\x00'
 b'\x00U\x00\x00\x00Z\x00\x00\x00_\x00\x00\x00d\x00\x00\x00\xf6f\xee'
 b'\x8a\xa8J\x9b\xee\xa7\xa6\x13')

{'A1': 241,
 'A2': 3689183346,
 'A3': {'B1': 105,
        'B2': 'dg',
        'B3': {'C1': 16, 'C2': 1336322941, 'C3': 199937631}},
 'A4': {'D1': [{'E1': -1047453361, 'E2': -68},
               {'E1': -494507578, 'E2': 108},
               {'E1': 1151444418, 'E2': -3},
               {'E1': -1300186701, 'E2': 107},
               {'E1': 734701502, 'E2': -3},
               {'E1': -1101534541, 'E2': 52}],
        'D2': {'F1': 108,
               'F2': 9174,
               'F3': [-10, 102, -18],
               'F4': [138, 168, 74, 155],
               'F5': 133},
        'D3': [42990, 5030]},
 'A5': 37037,
 'A6': -0.1922554230341953,
 'A7': -0.5406566858291626}

Вариант №35

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

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

(b'FRN\x1d\x00\x00\x00\t\x1c\xf5?9)\x02:\xa7(\xac\x00\x00\x00@\xbbm'
 b'z\xa4\x80\xba?\xc1u1\xb4u\n\xcc\x1c\xe3\xe2\xba,X\x02\x00\x00\x00$\x00'
 b"\x00\x00\xbe\x19\x07\xfc'D\xb1:\xb5\xe8m\x80\xef\xab\xfd\xcaA\n;\xc5\x058"
 b'd\xe3s\xa6\xddh(\x00^\x14\\\x7f\x04\xd1\xed?\x03\x00\x00\x00D\x00\x00\x00'
 b'<k\xce-\xd8\xad\x8a/\xbb\x1b\xceO\x04\x00\x00\x00b\x00\x00\x00)]y\x8b'
 b'I\xea\x1eJ\x02\xe2{\xf9\xdf\xd6\xde\xb0\xd7\x9d\xc9a\x9ap\x1d+a\xe89\xed'
 b'j\x00\x1a\x92l\x87W\x0b\xef?\x03\x00\x00\x00\x86\x00\x00\x00g*J\x00\x00\x00'
 b'\x8c\x00\x00\x00@\xd2\xc0\x99[\xb7\xf2_\x02\x00\xa4\x00\x00\x00')

{'A1': {'B1': 3023140289, 'B2': 2677, 'B3': 204},
 'A2': 7177,
 'A3': 2929373863583760373,
 'A4': {'C1': 6913789982016590400,
        'C2': [{'D1': 1759356531,
                'D2': {'E1': 22572,
                       'E2': [58140, 47842],
                       'E3': [-66, 25, 7, -4],
                       'E4': [17447, 15025, 59573, 32877, 44015, 51965, 2625]},
                'D3': 0.9317648398870337,
                'D4': [-15045, 14341, -7324],
                'D5': 27452},
               {'D1': 3979995233,
                'D2': {'E1': 20430,
                       'E2': [11726, 44504, 12170, 7099],
                       'E3': [41, 93, 121, -117],
                       'E4': [59977, 18974, 57858, 63867, 55007, 45278, 40407]},
                'D3': 0.9701345105173147,
                'D4': [25033, 28826, 11037],
                'D5': 10855}]},
 'A5': 0.10352542866688186}

(b'FRN\x1d\x00\x00\x00$\xc2\x7f\xd4\xca\x121\xd4\x8cC\xb4\x00\x00\x000\xe3\xa6'
 b'\x97\x89}\xd6?\x96/\x1e\x94\xd9Z\x85\x80\xb9\xda\xc2\x85\x17!A'
 b'\x03\x00\x00\x00$\x00\x00\x00)m\x9b\x7f\xb2\x13\x8d(\xf8\xe0\xfbd'
 b'\x94\xcd\xc4\x0f\x81t\x80\xb3\xe1l\x15\xf6\xee\xca!%\xdd\xf5a&*\x00\xd8P'
 b'R\xd7\x8f\xac\xd7\xbf\x05\x00\x00\x00F\x00\x00\x009\x8dy.\xe9\x13Qm\x01k'
 b'T\xaeP\x86\x05\x00\x00\x00h\x00\x00\x00\x9c\x07\x03\x07!q\xb4\x00'
 b"'\xbd\x9f\xd6ha\x87\xfcW\xc1L\x1b\xc1D\x83(\xb6\xee\x0b\xd1r\x00\xc8\x06"
 b'\x92\xda\xa5\x8e\xe1\xbf\x03\x00\x00\x00\x8e\x00\x00\x00^\xd3P\x00\x00\x00'
 b"\x94\x00\x00\x00\xd9\xad\x16';.\x95$\x02\x00\xac\x00\x00\x00")

{'A1': {'B1': 2485006230, 'B2': 23257, 'B3': 133},
 'A2': 49700,
 'A3': 4867498604514432127,
 'A4': {'C1': 2636063988489039321,
        'C2': [{'D1': 643954141,
                'D2': {'E1': 16673,
                       'E2': [47488, 49882, 6021],
                       'E3': [41, 109, -101, 127],
                       'E4': [5042, 10381, 57592, 25851, 52628, 4036, 29825]},
                'D3': -0.3699073412656282,
                'D4': [-19584, 27873, -2539, -13586, 9505],
                'D5': 36153},
               {'D1': 3507220150,
                'D2': {'E1': 34384,
                       'E2': [11897, 5097, 27985, 27393, 44628],
                       'E3': [-100, 7, 3, 7],
                       'E4': [28961, 180, 48423, 54943, 24936, 64647, 49495]},
                'D3': -0.5486630696252286,
                'D4': [6988, 17601, 10371],
                'D5': 54110}]},
 'A5': 0.3514121991134287}

Вариант №36

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

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

(b"\x01DCXI\xce\xfb\xc1{\xe0C\xf0\x00\x00\x00'\xda!&\x94E\x1e\xa2'\x15\xd4iP"
 b'Q?\x00\x02\x00\x00\x00\x8c\x05R=`?\xe9Rw\xd5\x19\x04\xee\xea\xedE\xe8'
 b'VV\x9a\xd2^L\xcaO\x00\x03\x00\x00\x00$\x02{A\xe4PY/\\.\x11\xd7\xa2\xb9I'
 b'\xda\xa9\x00\x04\x00\x00\x00F\xfa@\x14x\x0cw\x15O\xc0?\xde\xa0\xfcM%\xbd'
 b'|$I\x07\xf2:9\xe5L\xb6\xfc\xe3\x00\x02\x00\x00\x00j\xa9\x15\x93M\xf5\x80'
 b"8\x0f2?\xee\xcd'[\xbaR\xa4\\\x00J\x00l")

{'A1': 5318465018396689392,
 'A2': {'B1': 96,
        'B2': {'C1': 0.791316906172282,
               'C2': {'D1': [234, 237, 69, 232, 86, 86, 154, 210],
                      'D2': 94,
                      'D3': 76,
                      'D4': -13745,
                      'D5': [5, 82, 61]},
               'C3': 41632228}},
 'A3': 3659605652,
 'A4': 4980596526672013648,
 'A5': 20799,
 'A6': [{'E1': 3319671494242065065,
         'E2': [80, 89, 47, 92],
         'E3': -96463752,
         'E4': [12, 119, 21, 79, -64],
         'E5': 0.4785757783310698,
         'E6': 36},
        {'E1': -992417110884418333,
         'E2': [73, 7],
         'E3': -1458203827,
         'E4': [-11, -128, 56, 15, 50],
         'E5': 0.9625431815680554,
         'E6': 92}]}

(b"\x01DCX\xfe\xff\xce.\x8f6U\xc2\x00\x00\x00'\xb9\x91\xb0\xf51\xe6VfN\xf3oo"
 b'\xbb\xab\x00\x02\x00\x00\x00\x8c\x151nZ\xbf\xcb\xf7\xdah_\x89\xa0'
 b'\xa5\x15\x00U\xa1\xecs(\xfa$\xad\xb6\x00\x03\x00\x00\x00$`\x01\xedF1K'
 b'\x185\x82\xcf\xbfY(\xd9\xd7M\x00\x04\x00\x00\x00F\x13\n\xaf\x16\x06\x15YV'
 b'\xf1?\xc2\xbf\x05\xe5rX\xe8\x8dL|\x82X\x1ccRIj\x7f\x00\x02\x00\x00'
 b'\x00j\xf7\xfb\xf8-8\xd3\x8fRr?\xdf\xe2\xd1\xadg%H\n\x00J\x00l')

{'A1': 18374631704061433282,
 'A2': {'B1': 90,
        'B2': {'C1': -0.21850137802455283,
               'C2': {'D1': [165, 21, 0, 85, 161, 236, 115, 40],
                      'D2': -6,
                      'D3': 36,
                      'D4': -21066,
                      'D5': [21, 49, 110]},
               'C3': 1610739014}},
 'A3': 3113332981,
 'A4': 3595656349913149295,
 'A5': -17493,
 'A6': [{'E1': -9020781138941454515,
         'E2': [49, 75, 24, 53],
         'E3': 319467286,
         'E4': [6, 21, 89, 86, -15],
         'E5': 0.14645456031275406,
         'E6': 141},
        {'E1': -9054455837920499073,
         'E2': [76, 124],
         'E3': -134481875,
         'E4': [56, -45, -113, 82, 114],
         'E5': 0.49821893628957925,
         'E6': 10}]}

Вариант №37

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

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

(b'LWE\x96\x00\xd9\xa7\xeb\xc72p|\x06\xa4\x91A+uaphb\xc7\xe0L\xa9G4'
 b'\x82\xdb~\xb32\xc4\xc4\xf0\x94\x1f\x1a\xf8\xc8`\xe9\xf8\x8f\x1e\xc1?'
 b'\xabk\x06\x90\xc9\xf8\xc9\xc5\x0c\xf8\x82O\x89\xd9\xfd\x86\xe0z\xfb6'
 b'\xba0\xe1\xe8\xbc\xd3\x93\xc4?8\xef?W<\x9c\x17\x98\xcf4g\xd9\xa58\x1d'
 b'\x80\xc1\x84\xe7\x92:x\xa9\xff\xb0)\x03R\x9a\xb7\xcb\xf8H\xe5?m\xd1\xbdw'
 b'\xe5e\xba \xe6\xf9\x1b\x14W\xdd\x0e\x88\xa8\xfe\xba\xccR\xbb\xa5\xce'
 b'4\x99\xcc\xbdi\xac\xd2\xbf\xb9g\xa5\xdd\x88k\xd7\x05\x00\x11\x00\x0035\xbc='
 b'\x010\x11\x0e\xc0\x16\x006\x00V\x00v\x00')

{'A1': {'B1': 215,
        'B2': 'uaphb',
        'B3': -0.01105952262878418,
        'B4': {'C1': 288358717, 'C2': 49166},
        'B5': [{'D1': -57,
                'D2': [1202277600, 2128314932, -993774925, 438277360],
                'D3': 248,
                'D4': 0.13374519018066722,
                'D5': [27563, 36870, 63689]},
               {'D1': -55,
                'D2': [-2097673019, -36075185, -75833210, -516900298],
                'D3': 232,
                'D4': 0.9756163443949997,
                'D5': [15447, 6044, 53144]},
               {'D1': 52,
                'D2': [950393191, -2067693539, 2017104615, 699465641],
                'D3': 3,
                'D4': 0.665157697568086,
                'D5': [53613, 30653, 26085]},
               {'D1': -70,
                'D2': [469362208, 249386772, -1157715832, -1514450228],
                'D3': 206,
                'D4': -0.2917732575900971,
                'D5': [26553, 56741, 27528]}]},
 'A2': 467371824744474585,
 'A3': 725717412}

(b'LWE\x97\x00\xc1OO\x0e9\xec\x15\xb5\x14h?]ztxibm\xa5\x86\xddd\x97'
 b'\xce4\xfd\x03\x81\x00\xd3\x0f\xdc\xe4\x9c\x8e9R\xb2\xf2\xd8\xb0\x9c\xee'
 b'?\x81t\xc0\xa4pY\x96\x14$hiz\x85\xd3%\x92\xd7-g\xc1[P\x8e\x95\xce\x16\x85'
 b"_\xbbO\xe8\xbf\x11\x9a!}'\x07\x9da]\xc2\xa8:R\x9e\xbfD/\xd6\x19)\xd3bl"
 b'\xa2\xc0\xb3n\xe9w\x7f\xad?^TK\xce\xe1\xc9\xf6\xc4\x1fC\xc1!\xe6\x8f\x19'
 b'\xf2\xbe\x7fm\xbbEC\xa4\xdc\x8a\xe6\xaa\x9e \xe0\xe2?\x87VQ\xbc%\x19\xac'
 b'\x06\x00\x11\x00\xed\xf3A\xbf\xb1\x0cf1 8\x17\x007\x00W\x00w\x00')

{'A1': {'B1': 172,
        'B2': 'ztxibm',
        'B3': -0.7576282620429993,
        'B4': {'C1': 828771505, 'C2': 14368},
        'B5': [{'D1': -91,
                'D2': [-1754997370, 66925774, 265486465, -1902320420],
                'D3': 57,
                'D4': 0.9566272961870459,
                'D5': [29825, 42176, 22896]},
               {'D1': -106,
                'D2': [1768432660, 634619258, 1731057554, -1907336255],
                'D3': 149,
                'D4': -0.7597329011557237,
                'D5': [39441, 32033, 1831]},
               {'D1': -99,
                'D2': [-1463657119, -1080143302, 433467204, 1818415913],
                'D3': 162,
                'D4': 0.05761313175694438,
                'D5': [21598, 52811, 51681]},
               {'D1': -10,
                'D2': [-1052565564, 428860961, 1837088498, -1539095109],
                'D3': 220,
                'D4': 0.5898593043304612,
                'D5': [22151, 48209, 6437]}]},
 'A2': -5398148848536301631,
 'A3': 1564436500}

Вариант №38

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

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

(b'CSG\xf6C\x00\x02\x00a\x00\xfd\xd4I\x0c"\xfel\x90\xc5\xc0x\xedC~4\xc1\xbf\xac'
 b'I.\xc3\xc7g\x8e\xc5u\x94\x12\xdc\xb2\xacD\x96\x97\x91\xa9U+\xe8\xae1\xc9'
 b'\x13\xdbp#\x00-\x00W\x14 to\xe1#}\x02\x007\x001W\x00\x04i\xde\xc0\x89\x02'
 b'\x00;\x00\x00\x00nUe?_\x131\xbf\xca<;\x8c\xd9_')

{'A1': {'B1': [{'C1': [117, -108], 'C2': 10491019078682205202},
               {'C1': [-87, 85], 'C2': 8132115306990463019}],
        'B2': 67131185,
        'B3': -1983848855,
        'B4': [1948259415, 2099503471],
        'B5': 0.8958348035812378,
        'B6': -0.6917018294334412,
        'B7': -1942274870},
 'A2': [217, 95],
 'A3': {'D1': -11011,
        'D2': 4263644233,
        'D3': 108,
        'D4': 50576,
        'D5': -0.13441446606424812},
 'A4': 14235429579835460012}

(b'CSG\xf6s\x00\x03\x00\x91\x00\x98\xd7Yr}\x1a\xbe5U 2\xb0#\x85\xed\xba?\xea'
 b'\xa7\x9e\x8d\xd6 \xbdaR\x9f\x80Wo\x1b\x96Kk\xc4U\x98\xc1g\xb4\x94\xbf'
 b'\xb1\xd8H6@\x1bO)\x84\x19\x0c\x94\x8c\x0e\xf2\xb885\x00+\x1dt2\x86`AG\xce'
 b'\x17h\xa8\n\x08!\xda\x9f^\xa4Cu\x9a\xfe*#\x00-\x007\x00A\x00K\x00U\x00\x9b'
 b')\xd8t\xc6\xeb\xcf\xf7\x06\x00_\x00b.l`yw\xf0\xa5\x02\x00k\x00\x00'
 b'\x00\xda\xaby\xbf2E\x18\xbfC\x9f\xb8V z\x16')

{'A1': {'B1': [{'C1': [82, -97], 'C2': 14153489362019374976},
               {'C1': [85, -104], 'C2': 5249140802092033985},
               {'C1': [54, 64], 'C2': 10129734765594103579},
               {'C1': [14, -14], 'C2': 3635562869719120056},
               {'C1': [-122, 96], 'C2': 579460667099989825},
               {'C1': [33, -38], 'C2': 3098083422114176671}],
        'B2': 1617702498,
        'B3': -1510967431,
        'B4': [1960323483, 4157598662],
        'B5': -0.9752784967422485,
        'B6': -0.5948058366775513,
        'B7': 1454939971},
 'A2': [32, 122, 22],
 'A3': {'D1': -10344,
        'D2': 444428889,
        'D3': 190,
        'D4': 21813,
        'D5': 0.1051867687348893},
 'A4': 7042821498148399082}

Вариант №39

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

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

(b'GEG\xc6\x93\xe0@\x00\x9d\xfb\xaa?\xe0l\xa3\xc9\x89\x84\x180\x1d}w\x01'
 b'\xf9\x80[\xa9\xa9\xba\x18<\xa8\xd2\x9b\x96\xc15B\x18A\xf7\n\xe1\x10gk\xbf'
 b'\x9c\xe33\xd0W!?\xd5\xf6P\xd0\x88\xfc\x01\xe1\xbf6\x0c\xa5\x86`\xa2Qp'
 b'\xbfn\xe2\xaf\x00\x00\x00\x02\x00\x00\x007\xe3,\xb3\xa5\xe2[\x87\x8f'
 b'\xea\xe2\x99\xb6q\x97<\xa0\\\t*v&K\xee\xbfx\x8fY\x00\x00\x00\x02\x00'
 b'\x00\x00Z\x91I\x9cc,\xc7\xbdn\xa6%>\xb2\xed\xc3\xbe\xb7<A>\x9eA4?=\xcc'
 b'\x06> \x95j\xbe\x02a\xf6\xbf\r.M-\xf6\xbc\xf4B\x070\x9d\x00?\x00b\xc47\x1f'
 b'\x01nb\xd8ua\x8b\x00\x08\x00}')

{'A1': 3331579968,
 'A2': {'B1': 3312042333243388061,
        'B2': [{'C1': -0.7111304402351379,
                'C2': 2254479953,
                'C3': 112,
                'C4': -0.9331464171409607,
                'C5': [3589689552, 2298216929],
                'C6': [-29, 44, -77, -91, -30, 91]},
               {'C1': 0.01957513578236103,
                'C2': 712386123,
                'C3': 238,
                'C4': -0.9709373116493225,
                'C5': [2274355938, 2578870679],
                'C6': [-111, 73, -100, 99, 44, -57]}],
        'B3': 50231,
        'B4': 2234188260969898379,
        'B5': [-0.05826391652226448,
               0.34947022795677185,
               -0.3578815758228302,
               0.3090912103652954,
               0.7413944005966187,
               0.15681996941566467,
               -0.1273268163204193,
               -0.5514877438545227]},
 'A3': 64426,
 'A4': {'D1': 0.5132616935990226,
        'D2': 3467065238232858715,
        'D3': [43433, 47640, 15528, 53915, 38593, 13634]},
 'A5': 406976266,
 'A6': 16217575970635047731,
 'A7': 53335,
 'A8': 8511}

(b'GEGG\x1b\xbf\x9f\x00\x89=d?\xc1\xab\xbf\xa0\x83mX\xc47\x8a\xfb\x0emv7\x8e'
 b'\xf1\xe4,!I\xaa\xfe\xb1\xef\x9a\xc7\xc6\x8b\x10\x8d\xdf\xe0\x16\xfa\xa0'
 b"dp\xc9%~\xc4x\xe0=\x10\xa9\xcc'\x86\r\xbf\x02\x11J\xac\x1b\xe0sW"
 b"=\xc7\xa3\xda\x00\x00\x00\x02\x00\x00\x007\xe3\xbe\x0b\x1c\xc7\xaf]'"
 b'\xd7K\x90\x8e\xf1n?y\xd0\xfc\x14\x94c\xc3}\xbe{1\x97\x00\x00\x00\x02\x00'
 b'\x00\x00Z=Q\xfa*\xde\xbd>\xe6\xcd\xa0\xbeY\xe8e=,S7\xb3\xe7}o\xe9\x08L'
 b'\xfc\x00?\x00bj\xa5\x8a5f\x8b\xd5\x84\xee\x06\x00\x03\x00}')

{'A1': 1193000863,
 'A2': {'B1': 12963467972013739260,
        'B2': [{'C1': -0.5080763101577759,
                'C2': 2887508083,
                'C3': 87,
                'C4': 0.09748049080371857,
                'C5': [3762098345, 3425142285],
                'C6': [-29, -66, 11, 28, -57, -81]},
               {'C1': 0.9758450984954834,
                'C2': 345269187,
                'C3': 125,
                'C4': -0.2453063577413559,
                'C5': [1562892107, 2425287022],
                'C6': [61, 81, -6, 42, -34, -67]}],
        'B3': 27301,
        'B4': 9958978901768465926,
        'B5': [0.4507875442504883, -0.21280057728290558, 0.042071547359228134]},
 'A3': 15716,
 'A4': {'D1': 0.13805384957854971,
        'D2': -4307821707673110985,
        'D3': [36593, 58412, 8521, 43774, 45551, 39623]},
 'A5': 3331002509,
 'A6': 16131919130929688777,
 'A7': 9598,
 'A8': -15240}

Вариант №40

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

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

(b'OYS\x00\x02\x00\x13=\xc1\x00\x00\x00V\x00d\x00x\x00\x8ccyE\xe4f\x8c\x01\x00Y'
 b'\xb2\x08\xdf\xeeD\x0e\xba\n\xc0\x04J\x92\xac\x8d\x9a\x10\r\xe1\x18\xff'
 b'-\xa0\xa1\x90\x02\xca@v\x16\xea\x18\xecC\x9c\xbb\xbd\x97\xa6d\xdex\xc1\x8d-'
 b'?}\x9db\x00\x15\x00\x00\x00\x05\x00\x00\x00 \x87\x00\x00\x00H\xbf'
 b'\xea\x7f\x872\x0f)R\xfa\xaa\xd4\x06\xef\xc7}?\xa3\xdc\x96\xe6/0\rs\xe7'
 b'\x8c\xb2\xd0\x0b\xaa\x00\xf2\xc2\xf7\xc6\xe8:\xb6\xfb2$\x8b\xc0\xbdr'
 b'D\xff\x1a\xc3+\x0f\xbc\x8b+&\x15\x14\x1d?\x81\xe7\xcb\xb6\xe2\xda'
 b'\xd2l\xc9\xee')

{'A1': 'cy',
 'A2': 15809,
 'A3': {'B1': -121,
        'B2': {'C1': 0.9906827211380005,
               'C2': {'D1': 1172596364, 'D2': 256, 'D3': 1504839903, 'D4': 238},
               'C3': [4904061599586994834,
                      12433763539982817535,
                      3287805367874633846,
                      1651159616410401725,
                      10927532452532555053]},
        'B3': -0.8280673959464286,
        'B4': 250},
 'A4': [{'E1': [-21804, 1775, -14467, 16291, -9066, -6609],
         'E2': 12301,
         'E3': 1944554674,
         'E4': -12277},
        {'E1': [-22016, -3390, -2106, -6086, -18693, 12836],
         'E2': 35776,
         'E3': -1116584705,
         'E4': 6851},
        {'E1': [11023, -17269, 11046, 5396, 7487, -32281],
         'E2': 52150,
         'E3': -488975764,
         'E4': -13842}]}

(b'OYS\x00\x02\x00\x13\x9ei\x00\x00\x00N\x00\\\x00p\x00\x84xf\xeb\xdf_'
 b'\xe8x\xd9H\x9aM\x03\xf3<\xe7\x0f\x19\r\x0cB\xcd\x90`\xfe*\xb2\xcf\xa2\x16'
 b'\xdf\x02U\x1f\xb3\xaa\xc6\x04\xad\x0cU\xb8~\xd4\xefS>\x90\x85\xf2'
 b'\x00\x15\x00\x00\x00\x04\x00\x00\x00 \xe8\x00\x00\x00@\xbf\xc3\xbbr\x8a'
 b'\x0cd\xe8\xe8v\x98\xc2\xdd\xcdq\xf0;P\xdb\xcc\x14\xf2t\x08\xb4\x1eHx<V\xf0yb'
 b'\x85\x84\x1f\xedu\x8a \xf7\xb8[3s#\xaat2iut\xe3\xfd\xedH{\xa3\xa6\x1d\x11'
 b'O\x18\xb0\xdc\xa2\xf9\xc3\xe1')

{'A1': 'xf',
 'A2': 40553,
 'A3': {'B1': -24,
        'B2': {'C1': 0.2822719216346741,
               'C2': {'D1': -337682456,
                      'D2': 30937,
                      'D3': 1218071811,
                      'D4': 243},
               'C3': [4388492962163344077,
                      10403594598567879190,
                      16069500015058011652,
                      12469435719172288339]},
        'B3': -0.1541579412521863,
        'B4': 232},
 'A4': [{'E1': [30360, -15651, -12943, -4037, 20699, -13292],
         'E2': 62068,
         'E3': 146021960,
         'E4': 30780},
        {'E1': [22256, 31074, -31356, 8173, 30090, 8439],
         'E2': 47195,
         'E3': 863183786,
         'E4': 29746},
        {'E1': [26997, 29923, -531, 18555, -23642, 7441],
         'E2': 20248,
         'E3': -1327717639,
         'E4': -15391}]}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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