ИНБО-03-22

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

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

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

Поле	Описание
1	uint16
2	uint8
3	int16
4	int32
5	uint32
6	float
7	int64
8	Структура C

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

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

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

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

(b'NON\x10\xed\xac\xd4\x95\xff\xfb\xe9Hnn5\x1a\x07\xdc\x006\xbd]\xb8\x92'
 b'\x8a\x0e@Jf*\xd2\x87\xd5\xb1\x9d1w8\x04K\x9e\xe1%`\xa8\xef\x87\x0f'
 b'\x00\x00\x00\x04\x00\xa9\xaab+e\x9c^0\xbc\xc3\x7f\xbb\x00\x05\xbeXJ$\x86'
 b'\x07W\xecJ\x08\xea\x9e\x91]\x1f>\xf2\x10\xf1\xcd\x97u\xbe\xaa\xe5\x93\xe6!v'
 b'\xc4\x1d\xc8kk=\xbb\xe3\\?e\x8f\x99\xbf\xc5\x84\xd3K\xd2\xa3\xc0\xbf?\x8f'
 b'\xb4\xbfj"\xb58\x00\x02\x00u>m\xbf\xe5\xbe2x:~\x00\x02\x00\x82>\xd9\xd5U\xbf'
 b'7\xd6v\x9d\x00\x02\x00\x8f?A\x8ep?W\xbcS\x98\x00\x02\x00\x9c\x00}\x00'
 b'\x8a\x00\x97\x00\xa4')

{'A1': -1320446850016483000,
 'A2': [28270, 13594, 2012],
 'A3': {'B1': 43618,
        'B2': 43,
        'B3': 26012,
        'B4': 1580252355,
        'B5': 2142961669,
        'B6': -0.21122032403945923,
        'B7': -8788959475424236898,
        'B8': {'C1': {'D1': -111, 'D2': 23839, 'D3': 0.47278550267219543},
               'C2': {'E1': 205,
                      'E2': 38773,
                      'E3': -0.33378276228904724,
                      'E4': -26},
               'C3': [33, 118, -60, 29, -56, 107, 107],
               'C4': 0.09174224734306335,
               'C5': 0.8967223763465881,
               'C6': -0.16811600878034305}},
 'A4': -0.054131098091602325,
 'A5': 9947959315193844359,
 'A6': -3048482636973996981,
 'A7': -6998271248875682033,
 'A8': [{'F1': 56, 'F2': [-0.7482864856719971, -0.9145920872688293]},
        {'F1': 126, 'F2': [0.23217733204364777, -0.17428675293922424]},
        {'F1': -99, 'F2': [0.4254557192325592, -0.7181161642074585]},
        {'F1': -104, 'F2': [0.7560796737670898, 0.8427173495292664]}]}

(b'NON\x10#5\xebA\xd6\xd4AX\x1fD\xff\xa1\xb3\xbc\x006>|\xb0\x88\xc9\xb4\xe3\xa4'
 b"\xaaz\x7frs\xda\xbc\xc0\x17\xca\xaa\x13X\x9fZ'~`\xf9\xa2\x00\x00\x00\x02"
 b'\x00\x8f\xe0\xe9f+\x9dl\x86\x91\xbfcj-\x94?\x0f+\xac\xa9\x1a\x04oiz\x90\x16L'
 b"\xb0\x06\xbf'\xc7r\x19\x1c\x05\xbf4\xae\xa4J\xbc\xbe\x99SNv\x1f?\x1e\x15"
 b'\x06\xbfV\r.\xbf\xe1\xeb$\xe4\xf4\xb1\xc2?(\x887>c\xe2\xccd\x00\x02\x00u>?'
 b'a\x95>\xcc-J\xc8\x00\x02\x00\x82\x00}\x00\x8a')

{'A1': 2537192633102778712,
 'A2': [8004, -95, -19524],
 'A3': {'B1': 57577,
        'B2': 102,
        'B3': 11165,
        'B4': 1820758463,
        'B5': 1667902868,
        'B6': 0.5592601299285889,
        'B7': -6261687455347732458,
        'B8': {'C1': {'D1': 76, 'D2': 45062, 'D3': -0.6553870439529419},
               'C2': {'E1': 25,
                      'E2': 7173,
                      'E3': -0.7057898044586182,
                      'E4': 74},
               'C3': [-68, -66, -103, 83, 78, 118, 31],
               'C4': 0.6175082921981812,
               'C5': -0.8361386060714722,
               'C6': -0.5599541160386752}},
 'A4': 0.24676716327667236,
 'A5': 14534492193805729650,
 'A6': 8348192392503536147,
 'A7': 6385921922305161634,
 'A8': [{'F1': 100, 'F2': [0.6583284735679626, 0.2225448489189148]},
        {'F1': -56, 'F2': [0.1868956834077835, 0.39878302812576294]}]}

Вариант №2

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

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

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

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

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

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

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

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

(b'OLAE>\x00\x00\x00\x07\x00\x8f\x00@g0\xabo=\xeb\xbf\x9d\x00\xb5\x00'
 b'\x00\x00\xfc"\xc3\xdfm\xab}{\x9bb,!\xf9\xa7\x88Z\xda]\x82p\xf8\xab~;\x06\x00'
 b'"\x00\x00\x00&\xa3(\xbf_\xbbiczzmiw.\x00f\xc9aj5\x0e\x85\x0b\xe2-<\x9bm'
 b'\xb2\xf2\xc6\x83,B\xbfh4\x11\xe6\xcf\x9a\xd1=\xdd\x98\xbf.\xe1'
 b'\x89\x9b\xbd\xf8\xe3&[F\x9bB=\x1bO`\xcd\xed\xd5_\xbf\xc8\x0c\xc3\x89\xef'
 b'\xffw>\xee\xbcq\r}\xa5\x8c>\x1a\xf6\x13HW\x00_\x00g\x00o\x00w'
 b'\x00\x7f\x00\x87\x00\x9ei\xe5\x80C\xf8m`\xf5(\xae\n\\z5\x89\xe6\x82\xaa'
 b'\x98n\x83\xb7\x01FE\xf4B\x0c\r\xe9?\xc8\x06\x00\x00\x00\xa9\x00\xd6')

{'A1': {'B1': 'iczzmiw',
        'B2': {'C1': 44024,
               'C2': 15230,
               'C3': [25243, 8492, 43001, 23176, 24026, 28802],
               'C4': -0.658739447593689,
               'C5': -17569},
        'B3': 830085328900573542,
        'B4': -4111027326010249758},
 'A2': [{'D1': -0.7584916949272156, 'D2': -435080088},
        {'D1': 0.10234605520963669, 'D2': 784308445},
        {'D1': -0.07594657689332962, 'D2': 1529275384},
        {'D1': 0.04751136153936386, 'D2': -849326309},
        {'D1': -0.8743579983711243, 'D2': -1983705912},
        {'D1': 0.2421872466802597, 'D2': 225557742},
        {'D1': 0.2747000753879547, 'D2': 1209267738}],
 'A3': -0.8512495368515616,
 'A4': {'E1': [27038, 32997, 63555, 24685], 'E2': 179185909},
 'A5': {'F1': 0.7828427608202808,
        'F2': 200,
        'F3': [31324, -30411, -32026, -26454, -31890, 439],
        'F4': -42},
 'A6': 8898456927147860732}

(b'OLAE:\x00\x00\x00\x04\x00s\x00l\xac\x8cL\xc7F\xd4?{\x00\x91\x00\x00\x00\x8e)'
 b'W\x9cn\xb1\x1e\x80\n\x0e\xc3\xd8r\x12ak\x02\xd0N\x1d\x04\x00"\x00\x00\x00'
 b"\r '\xbf\xa0\x1eeacvlyi*\x0026l|\x1dA0\xfb\n\xc5\xe3\xaec\xec\xf3\x04\xf8"
 b'OD\xbdQ.~\xe1:\xf8\x9d>?\x8b\xf9\x9c\xac\xbc\x97>\x96\xa0h\x06\xba'
 b'\xca\\<\xe7\xb6\x18dS\x00[\x00c\x00k\x00GQ\xc6\x11\xc4\x00{\xd0\x91BS\xdcJ'
 b'W\xfe\x81W\xc4S\xbe-\x80\xe8\x03$n\xe6\x05\xde? \x05\x00\x00\x00\x87\x00'
 b'\x7f')

{'A1': {'B1': 'eacvlyi',
        'B2': {'C1': 53250,
               'C2': 7502,
               'C3': [3594, 55491, 4722, 27489],
               'C4': -0.6528328061103821,
               'C5': 7840},
        'B3': 18100038497299346994,
        'B4': 356888708372481290},
 'A2': [{'D1': -0.04792782664299011, 'D2': -511824303},
        {'D1': 0.3085344433784485, 'D2': -1661367489},
        {'D1': 0.2963613271713257, 'D2': 107520150},
        {'D1': 0.013476068153977394, 'D2': 1679341287}],
 'A3': 0.3168199775270242,
 'A4': {'E1': [20807, 4550, 196, 53371], 'E2': 3696444049},
 'A5': {'F1': 0.4691101146309493,
        'F2': 32,
        'F3': [22346, -32258, -15273, -16813, -32723],
        'F4': 127},
 'A6': 9232011374783572366}

Вариант №3

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

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

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

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

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

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

(b'OVO\r\xc6r\xd5.\x02\x00\x00\x001\x00I{\x04\x003\x00m\xd4\xc9\xc6'
 b'\x94\x0f`\xf4z\x97\x03\x00W\x00\x07\x00Z\x00\x00\x00YR\x8aaw\xae"\xe3\xcaufN'
 b'\xda\xce@t\x03\xd9T5#\xc0\xaf\x98W\x9c.\x83\xecTKR\xb1\x19g\x00H\x9d=\xcf'
 b'\xadURQ\x08\xa3^swp\xa3\x96\x0cq\xdf\xd0|\x95\xf3`\xf8\x8c\xe6v'
 b'\x85\x83\x8c\x97\xa0\xc4\x8a3a\xf7v\x1dfy')

{'A1': 785740486,
 'A2': {'B1': 'uf',
        'B2': 73,
        'B3': 123,
        'B4': [{'C1': 78, 'C2': 3842934990912409306},
               {'C1': 35, 'C2': -1404227409790062656},
               {'C1': 84, 'C2': -7113435168619015605},
               {'C1': 61, 'C2': 6819303406135782863}],
        'B5': {'D1': 54381, 'D2': 50889, 'D3': -195031148},
        'B6': -26758},
 'A3': 'swp',
 'A4': [1896650403,
        2507985119,
        2365087987,
        2206562022,
        3298858892,
        4150342538,
        2036735350],
 'A5': 89,
 'A6': 14619566948097296978}

(b"OVO\r\x89k\x9fx\x03\x00\x00\x001\x00B\x80\x02\x004\x00\x92kb\x17'|\xd8-"
 b'\xb2\x00\x05\x00F\x00\x06\x00K\x00\x00\x00\x02\x19\xe3\xfe#=\xde\x80\x01nhe'
 b'*\xe0\xef\x99\xeed\xc1\xd4g:k,l:\x00wO\xdbfvycw\xa9\xc8\x0b\x02\xe1'
 b"'\x01\x0c\x1a\xc59{\x81\x04C?\x88!\xb5\x9a\x15$\x0cm")

{'A1': 2023713673,
 'A2': {'B1': 'nhe',
        'B2': 66,
        'B3': -128,
        'B4': [{'C1': 42, 'C2': 7481817520213192672},
               {'C1': 58, 'C2': -2643763613379318677}],
        'B5': {'D1': 27538, 'D2': 5986, 'D3': 769162279},
        'B6': 178},
 'A3': 'fvycw',
 'A4': [34326697, 201402337, 2067383578, 1061356673, 2595561864, 1829512213],
 'A5': 2,
 'A6': 108330745235170073}

Вариант №4

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

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

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

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

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

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

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

(b'HUWQW\xa5$Zp\x1c<B\xfe?\xaa\x04\x80\xc9\xae\x8d.]\x00\x00\x00A\x00\x00'
 b'\x00\x03\x00\x00\x00D\xaeu6\x81\x9f\xea\x81\x94K#,\x89\x88W7\x1cwb'
 b'r\x8b\xca\xf8c2\x1b\x00\x00\x00\x03\x00b\x88g \x0e\xab\x97\xfe\xd0\x191\xce'
 b']q)\x17\xb9FYA}F\x99\x97a\x8d\xf2B\xd5\xa3(\x85\x97\x94p\x12\xc8')

{'A1': -23260,
 'A2': 1517296700,
 'A3': 17150,
 'A4': {'B1': 63,
        'B2': 2852421833,
        'B3': {'C1': -20851,
               'C2': 11869,
               'C3': {'D1': 34919, 'D2': 32},
               'C4': [{'E1': [14, -85, -105, -2, -48, 25, 49, -50],
                       'E2': 23921},
                      {'E1': [41, 23, -71, 70, 89, 65, 125, 70], 'E2': 39319},
                      {'E1': [97, -115, -14, 66, -43, -93, 40, -123],
                       'E2': 38804}],
               'C5': 2926917249,
               'C6': 159},
        'B4': [16897950327304391048, 6284523104097176522]},
 'A5': -127716837,
 'A6': [112, 18, 200]}

(b'HUWQW s\x8db\xe2!\x13\xdc:5\xf3\x9b\xd8\xc9\x04+\\\x00\x00\x00A\x00\x00'
 b'\x00\x02\x00\x00\x00D\x7f\x9a\x88N\xc0\xd0q\xe9\xf9\x97\\W\xfb\xe4<C\x0e\x1c'
 b'\xddav\xcaX52\x00\x00\x00\x03\x00X?\xac\xc8\xc6\x94Z\x17&\x176\xfa'
 b'\xd7\xe1)\xb1\x1dK\xd6^}~\x87\xcb\xc0\xe9\xa6')

{'A1': 8307,
 'A2': 2372067873,
 'A3': 5084,
 'A4': {'B1': 58,
        'B2': 905157592,
        'B3': {'C1': -14076,
               'C2': 11100,
               'C3': {'D1': 16300, 'D2': -56},
               'C4': [{'E1': [-58, -108, 90, 23, 38, 23, 54, -6], 'E2': 55265},
                      {'E1': [41, -79, 29, 75, -42, 94, 125, 126],
                       'E2': 34763}],
               'C5': 2140833870,
               'C6': 192},
        'B4': [15020043490452854779, 16446093667143082358]},
 'A5': -900188878,
 'A6': [192, 233, 166]}

Вариант №5

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

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

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

Поле	Описание
1	uint8
2	uint32
3	int8
4	Структура C
5	uint16
6	Структура E

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

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

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

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

(b'WHZ\xbe\xdf_\x06A\x0c\x00\x02\x00E\x00\x00\x00I?@k\xa3:O\x87y\xbf=\xa2'
 b'L\x13b\xbf\x86?J\xc3\xf9\xbe\xfc=p>\xeb\xb7z\xe2\x91\xf7]?n#`\xbe\x12\x00'
 b'\xc8\xbf\x05\xec*\x91\xd0\xe3i\xbd\xa0\xd3\x9bsh\xae\xf0\xa8\x95k'
 b'\xd4\xb3K\x05T\xf9@\x92\\x\xb5\x9c\xe1?\xe8\xb7\xe4R\x9e\xdf\xe8\xeby\x85'
 b'\x04\x14w\xd1\xd0\xc8\xeac6\xf0K_\x00\x00\x00\x02\x00\x00\x00GobM['
 b'\xfd\xa6&\xfe')

{'A1': 48863,
 'A2': 1594245388,
 'A3': 'sh',
 'A4': {'B1': 168,
        'B2': 2506871987,
        'B3': 75,
        'B4': {'C1': 384205923962091701,
               'C2': 40161,
               'C3': 0.7724477399524377,
               'C4': {'D1': -344357628, 'D2': 20, 'D3': 30673},
               'C5': -3402211806634030241,
               'C6': [174, 240]},
        'B5': 28514,
        'B6': {'E1': 19803, 'E2': 4255524606}},
 'A5': [{'F1': [0.7516424059867859, 0.000791661033872515, -0.7407577037811279],
         'F2': 325238662},
        {'F1': [0.7920528054237366, -0.49265623092651367, 0.46038419008255005],
         'F2': 3801216861},
        {'F1': [0.9302272796630859, -0.14258110523223877, -0.5231348276138306],
         'F2': 2446386025}],
 'A6': -0.07852860540151596}

(b'WHZ\xc2S"\\M#\x00\x03\x00E\x00\x00\x00K\xbe\xcfZ.\xbe\xd7\x99v>\x16}\x1eb[T'
 b'\x16>Q\xb4\xe4>\x90r=?bT\x03\x03Z\x10\x91\xbeL"\xaf?\x04M&=`\x9a5xQ\x17'
 b'\xa1\xbfK\xa5\xbbyvx\x9cN\xed\xd9\xe3\x9d]\xc3\xe5/9\xef\xc3\xba\x0b6'
 b'\xcb_\x9f\xbf\xe1\x1e\xact/\x1cd\xaa\x04`A\xce\x8c\xc6XJ\xaa\\y\xaf'
 b'D\xcf\x00\x00\x00\x03\x00\x00\x00Hr\x8b\xac\xa7\x82\xb5\x85\x83')

{'A1': 49747,
 'A2': 576474403,
 'A3': 'yvx',
 'A4': {'B1': 217,
        'B2': 3818741187,
        'B3': -27,
        'B4': {'C1': 3403014617374078667,
               'C2': 24479,
               'C3': -0.5349943417758252,
               'C4': {'D1': -1442553791, 'D2': -50, 'D3': -29498},
               'C5': 6362084737769489615,
               'C6': [156, 78, 237]},
        'B5': 29323,
        'B6': {'E1': -21337, 'E2': 2192934275}},
 'A5': [{'F1': [-0.40498489141464233, -0.421092689037323, 0.14696165919303894],
         'F2': 1650152470},
        {'F1': [0.2047916054725647, 0.28212156891822815, 0.8840944170951843],
         'F2': 56234129},
        {'F1': [-0.19935105741024017, 0.516802191734314, 0.05483456328511238],
         'F2': 2018580385}],
 'A6': -0.7954975962638855}

Вариант №6

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

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

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

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

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

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

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

(b'SNQE\xf7ph%\x95\xde4\x84\xed\x1b\xe6{\x984=\xdc\xcc(\xc3?\x94\xf7\xa4Q'
 b'\xb3\x10@\x00Q\x00\x06\x00\x8f]%n\xf2\xb42U\xf1\xeagoX\xbf\xe8IPL\x8f\xff'
 b'\xe2\xd5t<2l2\xfec?\xed\x17\x1cu9+t?\xe5\x1a[\xd9\x82\xa3\x90]\xe6\xd1'
 b'\xf5+\x93c\xafT\xd0\xf0B=\xaes\xb9\xa3\xb8\x14\x97\xd5X\x92\xb2\xa6G\n'
 b'Y\x91-\r\xc6\x86\xe0\xd0\x0b\x88fr\x1b\x0e\x0f-\xf6\xc3\xb1E{)\x151'
 b'\x97\x80\xb8\x12\n`R\x00\x02\x00A\x81\xfaT$K\xa3')

{'A1': {'B1': 28776,
        'B2': {'C1': 630578740,
               'C2': 9578342659216913469,
               'C3': 3704367299,
               'C4': 0.02047592877058002},
        'B3': {'D1': [{'E1': 1575408117, 'E2': 43, 'E3': -27805},
                      {'E1': -1353395984, 'E2': 66, 'E3': 15790},
                      {'E1': 1941545912, 'E2': 20, 'E3': -26667},
                      {'E1': 1486008998, 'E2': 71, 'E3': 2649},
                      {'E1': -1859318330, 'E2': 134, 'E3': -7984},
                      {'E1': 193488498, 'E2': 27, 'E3': 3599},
                      {'E1': 771146673, 'E2': 69, 'E3': 31529}],
               'D2': 21,
               'D3': 12695,
               'D4': 2159546890,
               'D5': 24658,
               'D6': [0.9090711869733767, 0.6594676254509171]},
        'B4': [-127, -6, 84, 36, 75, -93]},
 'A2': 23845,
 'A3': 28402,
 'A4': 12984535173170687832,
 'A5': -0.7589494223939222,
 'A6': [-43, 116, 60, 50],
 'A7': 1815281251}

(b'SNQE\xf7~A\xaa\n\x80+\x1a0\x195\xb7\xb9P\x0e#\xcd\x03\xfb?\xc1\xc9\xf5`'
 b'\x89\xf5\xf0\x00a\x00\x06\x00\x9f]*\x8e6\xaa\xfd\x80\xda\xb4\xd1\xfc%?\xc9?'
 b'<\xa3\xbc4\xf8\x05ga\x12\xe6\xf9\xfa7?\xe0\xd5<\xca\x16m6?\xda\xc8'
 b"\x0cp\xca\x03@?\xc3\xfb~\x05\x04#x\xbf\xb7['\xaa\x1c\xe7\x00F\t]"
 b'\xb9\xc4^\x913b\xdeQokk\xe1F\xde\x0f^c\xda\xb2\xb92\xe8\xe8\x07'
 b'\x1e\xf0\xcd\xf6\xe5\xb3\x9d\xcd\x04\xff\x98\xb7#D\xcf"S\x00\xa2\xd9'
 b'\xbd2\xa7\xfd\xfa\xd3\xf0\x0e\xd7$\x13\x00\x04\x00AfL;,\xb3\x97')

{'A1': {'B1': 32321,
        'B2': {'C1': -1442152405,
               'C2': 1887035962374574094,
               'C3': 600638459,
               'C4': 0.13897578443349756},
        'B3': {'D1': [{'E1': 1175018937, 'E2': 196, 'E3': 24209},
                      {'E1': 862117457, 'E2': 111, 'E3': 27499},
                      {'E1': -515449329, 'E2': 94, 'E3': 25562},
                      {'E1': -1296485656, 'E2': 232, 'E3': 1822},
                      {'E1': -254937371, 'E2': 179, 'E3': -25139},
                      {'E1': 83859639, 'E2': 35, 'E3': 17615},
                      {'E1': 575864994, 'E2': 217, 'E3': -17102}],
               'D2': -89,
               'D3': -518,
               'D4': 3555725015,
               'D5': 9235,
               'D6': [0.5260299632094874,
                      0.4184599973159955,
                      0.1561124348156928,
                      -0.09123466399332969]},
        'B4': [102, 76, 59, 44, -77, -105]},
 'A2': 23850,
 'A3': -29130,
 'A4': 12321145832380431397,
 'A5': 0.19724233622438425,
 'A6': [5, 103, 97, 18],
 'A7': 3875142199}

Вариант №7

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

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

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

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

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

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

(b'QHDHN\xe7\xd8i.~\x00\x00\x00\x04\x00\x12\x00}pprac\xc8\xce\x7f\x99\x8b'
 b'\xc1[\xd9\xf8\x90\xc3\x19\x1f\t\x00\x03\x00\x00\x00\x16G}\x00\x03\x00'
 b'\x19\xd3\xaf`\xf1\x05> \xb4\x8d\xb7\xd8\xda\x1d]\x00\x02\x00\x00\x00'
 b'1\x10\x14\x00\x03\x003\xe7\x92\xc2\xec\xb5\rG\xee\xdf\x9crn\x00'
 b'\x04\x00\x00\x00K\xebJ\x00\x02\x00O\xdbd\xf4\xa7\x94\xecL\xaa5\xf0\xbd\xd6='
 b'\xf6\x00\x02\x00\x00\x00c.\xbb\x00\x03\x00e\xe0\x1b\xe5>\xe0r\xcak\xbe\x8b;'
 b'y\x00\x00\x00%\x00\x00\x00?\x00\x00\x00W\x00\x00\x00q\xb6\xd1f\xc9<\x9e\xec'
 b'H@(\x84\xd5 K')

{'A1': -25,
 'A2': -40,
 'A3': 26926,
 'A4': 126,
 'A5': 'ppra',
 'A6': {'B1': -8165,
        'B2': {'C1': -27,
               'C2': 0.4383757710456848,
               'C3': 107,
               'C4': -0.27193811535835266},
        'B3': [{'D1': [99, -56, -50],
                'D2': 18301,
                'D3': [2140769217, 1541011600, -1021763831]},
               {'D1': [-45, -81],
                'D2': 4116,
                'D3': [1626408254, 548703671, -656794275]},
               {'D1': [-25, -110, -62, -20],
                'D2': -5302,
                'D3': [-1257420818, -543395218]},
               {'D1': [-37, 100],
                'D2': 11963,
                'D3': [-190343956, 1286223344, -1110032906]}],
        'B4': -18735,
        'B5': 7406517715454148648,
        'B6': -2066407349}}

(b'QHDHN4\xfa\x96\xef+\x00\x00\x00\x05\x00\x12\x00\x7fxitgeK2\x1b\x90\xa6'
 b'\x84\xd3\xf8\xb4"\x00\x02\x00\x00\x00\x17\x90-\x00\x02\x00\x19\xb2\x9f]'
 b'\x9e\x8f\xf4sx\xceb\x8d\x8cj+\x00\x06\x00\x00\x00-d\xa7\x00\x02\x003\x9a'
 b'\x93T\xb8d|[@\x86\xf5\xb3\xfc[\xf2\x00\x02\x00\x00\x00GK\xab\x00\x03\x00'
 b'I\xb0(>VM\xc0\xd4KB\xd2\x864\x89>C\xf4x\xad\x00\x06\x00\x00\x00aLL\x00'
 b'\x03\x00g\x9f\xf09>\x9dH\xcc\x06\xbf=\x8a\xf2\x00\x00\x00!\x00\x00\x00;\x00'
 b'\x00\x00U\x00\x00\x00s\x8a\x14\xbdi\xed\xbc\xf7>D\x1f\x0b\xf4\xd4l')

{'A1': 52,
 'A2': -6,
 'A3': 38639,
 'A4': 43,
 'A5': 'xitge',
 'A6': {'B1': -24592,
        'B2': {'C1': 57,
               'C2': 0.3071960210800171,
               'C3': 6,
               'C4': -0.7404013872146606},
        'B3': [{'D1': [75, 50], 'D2': -28627, 'D3': [462464644, -738675678]},
               {'D1': [-78, -97, 93, -98, -113, -12],
                'D2': 25767,
                'D3': [1937296994, -1920177621]},
               {'D1': [-102, -109],
                'D2': 19371,
                'D3': [1421370492, 1530955509, -1275307022]},
               {'D1': [-80, 40, 62, 86, 77, -64],
                'D2': 19532,
                'D3': [-733265198, -2043377346, 1140095149]}],
        'B4': -30188,
        'B5': -4798042532128865249,
        'B6': 200594540}}

Вариант №8

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

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

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

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

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

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

(b'YGID\x96`\xc5~2\xc4v\x99\x02\x00g\x00\x1bkorlhhmo\xd9\x19\x03>?\x19b9?j\xa2'
 b'\x12?5\xd5??\x00\xd8\x06\xbf\xa7\x91\x02\x00\x00\x00o\x00\x00\x00'
 b'\xe9\xaa;\xbf\\\xc4\x84HG,\xcf"7\x08?l^\xb7\xdbB\xe1\xd7\x0fs\x81\xc1\ro'
 b'=\xab\xa5\xce\xb1\x9f\x81]\xfd\xb4\xfa\x98me\r~\x03@;G\x00\x00\x00W'
 b'\x00\x00\x00\x0c\xb9\x08\xfa')

{'A1': 2126864534,
 'A2': 2574697522,
 'A3': {'B1': [{'C1': 108,
                'C2': 94,
                'C3': [56247, 57666, 4055, 33139, 3521, 15727, 42411]},
               {'C1': -50,
                'C2': -79,
                'C3': [33183, 64861, 64180, 28056, 3429, 894, 15168]}],
        'B2': 27},
 'A4': 'korlhhmo',
 'A5': 217,
 'A6': [0.7422347664833069,
        0.7241531014442444,
        0.5727907419204712,
        0.7493470311164856,
        -0.5267333984375],
 'A7': 37287,
 'A8': {'D1': [-18164, -1528],
        'D2': -0.7330766320228577,
        'D3': 92,
        'D4': 1195934916,
        'D5': -12500,
        'D6': 0.5320912599563599}}

(b'YGIDl\x02d\x98\x88\xe7\x1d!\x02\x00g\x00\xfabhvkpnzp\x97\x00\xb9'
 b'\xf0>\xb2\xf5"\xbe\xae\x01/?\xce\x1b\xf4=\xdbEM\xbf\xf7\x84\x07\x00\x00\x00'
 b'o\x00\x00\x00Df\xf9\xbe\x16\xbeu:o\xe5\x88\xfc\xde\x12\xbf[\xce\x90\x1e\x0c'
 b"\x95RJ\x11r}z\x02\xd8\x8a\xe4\xea,w\x0c\x1f$'E0,uz\x9a\x95\xd8#G"
 b'\x00\x00\x00W\x00\x00\x00\xf2\x1e\x1cq\xa4 \xe4\x0cc\xebp\x8e(M')

{'A1': 2556691052,
 'A2': 555607944,
 'A3': {'B1': [{'C1': 91,
                'C2': -50,
                'C3': [7824, 38156, 19026, 29201, 31357, 55298, 58506]},
               {'C1': -22,
                'C2': 44,
                'C3': [3191, 9247, 17703, 11312, 31349, 38298, 9176]}],
        'B2': 250},
 'A4': 'bhvkpnzp',
 'A5': 151,
 'A6': [0.47016143798828125,
        -0.15914037823677063,
        0.6836193799972534,
        0.1191936582326889,
        -0.8018471598625183],
 'A7': 34039,
 'A8': {'D1': [7922, 28956, 8356, 3300, -5277, -29072, 19752],
        'D2': -0.48710834980010986,
        'D3': 22,
        'D4': 1866102206,
        'D5': -30491,
        'D6': -0.5737149715423584}}

Вариант №9

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

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

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

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

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

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

(b'HDI\xbc\x05\x00\x00\x00X\x00\x00\x00x\xe2\x17\x85\x84\x00!\xe8\xfc\x0ek\x88'
 b"M%\xbc\xba\x8e9\xfc\xbeJ\xe9\x7f\xab\xcf0\x97 lc'\xe5\x19\xbf\x92\xe5W~W\xa2"
 b'3H\x8f\\\x1c)?\xbf\x1dg\x02\xe9\xc9\xc9\xb4\x07QY\xd4\x8d\xdb=\x95\xc8'
 b'B\xde\x1f)\xe3\xee2\xbe\x08\xea\x0e\xbf\x12\x00 \x00.\x00<\x00J\x00\xfei'
 b'\xed_\xb3ryv\xe4\xed\xaf\xf3\x1cQdX\x19V\x1a\x18\x02\x06\xa3%\xde\xb0'
 b'F\xfe\xf1C\xb0\xc4T\xfe\x07\x00b\x00\x00\x00\x03\x00~\x00\xa8\x03'
 b'\x0f>\x1b\xb3\xf8>')

{'A1': 188,
 'A2': [{'B1': 251455521,
         'B2': [107, 136, 77, 37, 188, 186],
         'B3': -0.4926266074180603},
        {'B1': -1417680566,
         'B2': [207, 48, 151, 32, 108, 99],
         'B3': -0.6011528372764587},
        {'B1': 2119689618,
         'B2': [87, 162, 51, 72, 143, 92],
         'B3': -0.7467210292816162},
        {'B1': -385718499,
         'B2': [201, 201, 180, 7, 81, 89],
         'B3': 0.10720410943031311},
        {'B1': -566048619,
         'B2': [31, 41, 227, 238, 50, 190],
         'B3': -0.5582585334777832}],
 'A3': 2232935032,
 'A4': {'C1': {'D1': [1609394686,
                      1987670707,
                      -206574108,
                      1482969372,
                      404379161,
                      631440898,
                      -28921634],
               'D2': [17393, 50352, 65108]},
        'C2': 0.13966238498687744,
        'C3': 0.4857414662837982}}

(b'HDI\xb3\x02\x00\x00\x00.\x00\x00\x00\xeb\xda\x1fMH\x00\xda\xd77\xf8\x95A'
 b'\xe4\x9ay\xd6k-\xdd>\xa9\xe8\xcfi\x7f\xe5\x91\xa4$)0C\xea=\x12\x00 \x00\x94c'
 b'~\x83X\xaa\x01;\xe1V\xd9\x9a%\xca#\x96.\xc83?\xb7\x82\x04\x002\x00'
 b'\x00\x00\x03\x00B\x00\x81\x9e\x08\xbf\xa5\x0bp\xbe')

{'A1': 179,
 'A2': [{'B1': -130557990,
         'B2': [149, 65, 228, 154, 121, 214],
         'B3': 0.43198713660240173},
        {'B1': 1775233193,
         'B2': [127, 229, 145, 164, 36, 41],
         'B3': 0.11438596248626709}],
 'A3': 1293933291,
 'A4': {'C1': {'D1': [-2088868972, 989964888, -1697032479, -1776039387],
               'D2': [51246, 16179, 33463]},
        'C2': -0.533668577671051,
        'C3': -0.23441942036151886}}

Вариант №10

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

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

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

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

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

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

(b':JTH\xbfgu\xf2\x00\x00\x00\x04\x00\x8dI\xbd\x19\x0ex\x8a\xb3E\x98\xa3'
 b'\xbe\xcbl\xbd\xbf?a\x9b?}\xb5-\xbb\xfa\x13\x85\xbfu($\xbf\x0ck\x1a?y\xab\xad'
 b'\xbfZ!\xdc?.\xb6\xc8?\xef+$w\xa6\x89"\x9f\x11\xbe\x9c!&p\xaa\x03o8<'
 b'\xf8\x8dw{\n\x14\x03\x9eA:x~32S\xbf\xe6\xa6\x0e:\xbe\x80\x0e\xee\xf5\xc4{\\'
 b'\xe7\x148\x83\xe7\xbfL\xf9p\x00\x00\x00\x03\x00\x00\x00\x95q\xbd\x04'
 b'I\x0ep\xcf47\xda@\x1b\xeb6\xec\x00\x00}\x00\x81\x00\x85\x00\x89T\xbd;'
 b'\xf7)\x19')

{'A1': {'B1': -0.9041434526443481,
        'B2': [{'C1': 29117, 'C2': 1097},
               {'C1': 3696, 'C2': 53044},
               {'C1': 14298, 'C2': 16411},
               {'C1': 60214, 'C2': 60416}],
        'B3': [73, 189, 25, 14, 120, 138, 179, 69],
        'B4': {'D1': -26461,
               'D2': [-0.3973139822483063,
                      -0.7475830912590027,
                      0.9910457730293274,
                      -0.007631721440702677,
                      -0.9576437473297119,
                      -0.5485092401504517,
                      0.9752758145332336,
                      -0.8520791530609131],
               'D3': 0.6824765205383301,
               'D4': 0.9740164124416746,
               'D5': -24815,
               'D6': -0.304940402507782,
               'D7': 28842,
               'D8': [3, 111, 56, 60, -8, -115]},
        'B5': 30587,
        'B6': 169083806,
        'B7': 16698,
        'B8': 2021536562},
 'A2': 83,
 'A3': -0.707770457014705,
 'A4': 17218884784439628856,
 'A5': -31769,
 'A6': -0.8006811141967773,
 'A7': [21693, 15351, 10521]}

(b':JTH\xbe\x95+\x02\x00\x00\x00\x04\x00\x8d\x84 *\x05\xd9\x83^8\x1d0'
 b'\xbfF\xed\x16>\x94<7\xbeT\x14\x0e>\xd1?\xa4?*O|?U\xa5\xf0>E;\x87?F\n\t'
 b'\xbe\x1e\xe4\xe0\xbf\xe7Q\xf6\xf8|\x89\xe44D>\xd5\x0c\xbe\xb9\xc3'
 b'\x08\x8f\x9c\xefR!\xf4TP\xc7\x16!\xa1\xd2R4\x83}\x1b?\xe6\xb2\x05\x9e'
 b'\xf6\xbc4\x1e\xcaW\x00\x05<q\xfa\xa9/\xbd9\x18\x08\x00\x00\x00'
 b'\x04\x00\x00\x00\x95\xa1<\xf0\xdbW\xc0\xa5\xb8\xcb\x9eC\xcf\xb8\x91\xee'
 b'\xb2\x00}\x00\x81\x00\x85\x00\x89\x0f\x85v\xa1\x9f\x8cZ\x9a')

{'A1': {'B1': -0.2913437485694885,
        'B2': [{'C1': 41276, 'C2': 61659},
               {'C1': 22464, 'C2': 42424},
               {'C1': 52126, 'C2': 17359},
               {'C1': 47249, 'C2': 61106}],
        'B3': [132, 32, 42, 5, 217, 131, 94, 56],
        'B4': {'D1': 7472,
               'D2': [-0.7770551443099976,
                      0.2895219027996063,
                      -0.2071077525615692,
                      0.40868866443634033,
                      0.6652753353118896,
                      0.8345632553100586,
                      0.19260989129543304,
                      0.773590624332428],
               'D3': -0.15516996383666992,
               'D4': -0.7287554600955528,
               'D5': 13380,
               'D6': 0.41611284017562866,
               'D7': 47555,
               'D8': [8, -113, -100, -17, 82, 33]},
        'B5': 62548,
        'B6': 1355224609,
        'B7': 41426,
        'B8': 1379173245},
 'A2': 27,
 'A3': 0.7092311959039592,
 'A4': 2218681424032854522,
 'A5': -22225,
 'A6': -0.04518893361091614,
 'A7': [3973, 30369, 40844, 23194]}

Вариант №11

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

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

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

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

(b'SKGW\\\x04\x00\x00\x00X\x00\x00\x00o~\xb4\xd0w\xc2\xa3\xf5\xda\xf5d'
 b"9\xd0\x1e\xdf\x12\xfb\xfe{\x1et>'y\x06\x00h\x00\x00\x00\xdf\xc2^\x9e\xeb"
 b'\xce\x80\xde\x10\x1e\xb1\x11\xb95\xf3\x16\xd0k\xf1Z\xc0!\xaa!sM\xd9\xa1S'
 b'wZ\xb9Qr\x82d\x17\xac\x05\xc2\xc4\xcdN\xe3\xbf<>\xc0\xbdg\xe6\x00?'
 b'\xd1\\\xab>\x87\xe2\xcb\xbd\xccwb\xba\xa0#\xe4?\x1c2\xdfq\xb2\xcf\xe2\xbf'
 b'\xd8@\xb6i\xc0}\xe4\xbfL\xe7C:c\x82\xe0\xbf`\x194\xfe\xf6\xce\xde\xbf'
 b'B\xc2N\r\xaf\xde\xe2?')

{'A1': [-0.09386870265007019,
        0.5035156607627869,
        0.33469250798225403,
        -0.09955316036939621],
 'A2': 111,
 'A3': {'B1': 126,
        'B2': [{'C1': -76, 'C2': 30672, 'C3': 194},
               {'C1': -93, 'C2': 56053, 'C3': 245},
               {'C1': 100, 'C2': 53305, 'C3': 30},
               {'C1': -33, 'C2': 64274, 'C3': 254}],
        'B3': 0.2383975237607956,
        'B4': 31015,
        'B5': {'D1': [0.6293491020512589,
                      -0.5878536438045248,
                      -0.6403505387006829,
                      -0.5159164560311438,
                      -0.48138212990342844,
                      0.5896830806651183],
               'D2': -33,
               'D3': [-341942590,
                      283017422,
                      -1190022882,
                      -803802315,
                      -1067781781,
                      1931586081],
               'D4': 77},
        'B6': 217},
 'A4': 9399665228804215713,
 'A5': 100,
 'A6': 23,
 'A7': -0.6033696024825779}

(b'SKGW\\\x05\x00\x00\x00X\x00\x00\x009\xf7|hS\t\xc9\xf1\xeb\xee4|7\xb5\x99'
 b'\xe5:\xe7\x11\xd3l>\xb1P\x05\x00l\x00\x00\x00\x9e"\xbcUY\xd2\xb1\xa0\xde'
 b'\x19\xaa\xd6-\x93~\xe2\xe4\x9fpzq@\x83\x83\x92\xe8E\xf6xE?\xdf\x92t[\xf1p'
 b'\xc0\x1au\x96aD\xe6?L\xb0\x0b?\x94\xf9\x8b;\xccM\xf2>7\xa88\xbf\xcc\xd7I\xbf'
 b'>\xc6)\x19S\xdb\xef?z\x92\x90\xf2`w\xe3\xbf@\x16\xc7?Y\xd8\xc9\xbfJS)\xca'
 b'\xca$\xe6?\xd4o\xa1\\J@\xd8?')

{'A1': [0.5456588268280029,
        0.004271695390343666,
        0.47324979305267334,
        -0.7213167548179626,
        -0.7884490489959717],
 'A2': 57,
 'A3': {'B1': 247,
        'B2': [{'C1': 124, 'C2': 21352, 'C3': 9},
               {'C1': -55, 'C2': 60401, 'C3': 238},
               {'C1': 52, 'C2': 14204, 'C3': 181},
               {'C1': -103, 'C2': 15077, 'C3': 231}],
        'B3': 0.23127390444278717,
        'B4': 20657,
        'B5': {'D1': [0.9955230227917082,
                      -0.6083225953667146,
                      -0.2019149362005681,
                      0.6919912289109587,
                      0.37892397924383414],
               'D2': -98,
               'D3': [1498790946,
                      -559894062,
                      769042969,
                      -454918509,
                      1903849631,
                      -1836874944],
               'D4': -24},
        'B6': 69},
 'A4': 6590053642286758134,
 'A5': 241,
 'A6': 112,
 'A7': 0.6958473147031654}

Вариант №12

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

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

(b'oTVR?\xc6\xbcLA\x11~\xf0\x00\x00\x00S\xbf\xea\xbf\x11\x16\xd8\x19\xac'
 b'\r\xd5\x12\xf8EjA7\x9c\x0f\xc7VU9M\xb50&\xe6#k\x1b\x08\xd7\x00\x18\x00$izp6'
 b",)\r\xd4/.e]?\xbc\xaaX\xb9\xe1h\xef\xa1\xbcx\x1f'\xb0DM\xe5\x0e\x19\x00"
 b'\x02\x000\xbf\xe2\xb8\x0c\xb8/j\xd0\x00\x00\x00\x03\x004\xaf%\x11'
 b'\xc4\x00\x00\x00\x07\x007\xbf\x86a$j\xd7\x9e\xa3\xa8\xd98\r\xf10\x8b\x1b\xfe'
 b'\x83\xce\xcf\xa1r\x92\x9a[\xb5\x9f')

{'A1': 0.1776213948933143,
 'A2': {'B1': [{'C1': 232067832, 'C2': 1164591415, 'C3': 2618279766},
               {'C1': 1429818805, 'C2': 807855651, 'C3': 1796933847}],
        'B2': -0.5849670026176117,
        'B3': 'izp',
        'B4': {'D1': 44837,
               'D2': 4548,
               'D3': [908863757,
                      -735105435,
                      1564458154,
                      1488576872,
                      -274613128,
                      522694724,
                      1306856985],
               'D4': 49030},
        'B5': 97,
        'B6': [610981790, -1549215432],
        'B7': 1004637565908583374,
        'B8': 14961365411081991583},
 'A3': -0.8358235784697192}

(b'oTVR\xbf\xeeZ\xe6\x05IH\xf2\x00\x00\x00W\xbf\xb3E4\xc5\xa0\xe9\x90i\xb5m1'
 b'\xa8\x17\x80\xba\x86\xa9\x93\x05wtT\xd09,\xc0J\xddE\x9b\x89\x00\x18\x00$akq,'
 b'cR\\\x8dr\x82+\x92\x01\xf7&\x16\xf4\xe0\xe5@\x16\xdf\xdbIkD8\x0b\xbf&P\x94'
 b'\x15\xbb\xf3\x00\x02\x000\xbf\xea\xd6$\xfe\x07\xc7\xd8\x00\x00\x00\x03\x00'
 b'4[\xaf\x9a&\x00\x00\x00\x08\x007\x19n\x0c\xf4\x0b\x95\xebM\x99\xd1k\x97\xeb'
 b'\xe04\x8c\x17\x1e\xden\xa6)\xcc0\xca\xec\xac')

{'A1': -0.9485960105178306,
 'A2': {'B1': [{'C1': 1773497649, 'C2': -1474854726, 'C3': 2259260165},
               {'C1': 2004112592, 'C2': 959234122, 'C3': 3712326537}],
        'B2': -0.8386406861811748,
        'B3': 'akq',
        'B4': {'D1': 23471,
               'D2': -26074,
               'D3': [744706652,
                      -1921875413,
                      -1845364954,
                      385147109,
                      1075240923,
                      1231766584,
                      197076560,
                      -1810514957],
               'D4': 6510},
        'B5': 12,
        'B6': [-200567317, 1301926251],
        'B7': -7499654238162182434,
        'B8': 7973106147274714284},
 'A3': -0.07527475190082655}

Вариант №13

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

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

(b'TUGU\x00\x00\x00|[v\xeeB\xba\xed\xbf\xe4@\x1fb/p\xa2\x00\x06\x00\x00\x00\x8b'
 b'\xd5\xf2(S\x04c\x1d\xa1f\xffR)\xb9\xffK-d\xa8\x87\x85\xa3\xe4U\xdc'
 b'\x04\xbb\xfe-Y\x86\xc2\xbcS\xb9\n5\xde\xefj%R3\x9d5:\x86\x9e\xa5'
 b'\xda\xca\x97\xc9\xaa\xba\x98\x0c\x92\xb3:64-\xcf\xb7\xde\xbc\xb1\x97'
 b'B\xe5\xa74m\xa3\r\xfe4\xb4\xb4\xba\xbe\xc1\xedB\xbf\x01\xb9\x1d?K\xbe\x9d'
 b'>\xb8\xfa\xbc\xf5\x00\x00\x00\x02\x00\x00\x00V\x00\x00\x00\x04\x00l\xb1'
 b'&v\xb8\xadF')

{'A1': {'B1': 245,
        'B2': [{'C1': [14902, 13357, -12361, -8516, -20073], 'C2': 66},
               {'C1': [-6745, 13421, -23795, -460, -19276], 'C2': -70}],
        'B3': [-0.37876325845718384,
               -0.506730854511261,
               0.7958772778511047,
               0.3612879514694214]},
 'A2': 1534520898,
 'A3': 47853,
 'A4': -0.6328274648363001,
 'A5': {'D1': [-79, 38, 118, -72, -83, 70],
        'D2': [-3030315262245921375,
               7421741050097519405,
               7253196207930234332,
               341145667525591740,
               6032864402329266725,
               5923250786863062693]},
 'A6': 56010,
 'A7': -7509283185271991629}

(b'TUGU\x00\x00\x00\xa2\xf2-\r1\xe8\xa7?\xd1j6\x15\xd9\xfe\x1c\x00\x03'
 b'\x00\x00\x00\xb1\xb5\xc8^\xb6\x10\xfb/W\xf6\x97\xe4)k\x95\t\xcb'
 b"\xe8\xa5\xe2\xda~\xa8'|$D\x01\x14,oJfT\xdc\xfd\xd3V\x81\xb9 \xddy\x07\xae"
 b'Y>R!\x9f.;\xfc\xc6\xd1\x19O\x0c\xe3Mr\x054\xf9E\xf9\x98\xc1\xcbZZ\x9e\xac'
 b's\xb7\x8ay\\\x01\xc3\xba.\xae\xd6\xbeH\x8d\x02\xd3&%\x12\xd1t\xce\xea>'
 b"QM\xb0U;\x1e?w\x86l?'\x96\xdb\xbe\xab\xfd\xe9\xbf;\xa9\xe5?U\xb3\xcc?@"
 b'\x96n\xbfAE\xcb>\x8d..\xe1\x00\x00\x00\x04\x00\x00\x00V\x00\x00\x00\x08\x00'
 b'\x82 \x91]')

{'A1': {'B1': 225,
        'B2': [{'C1': [19826, 1332, -1723, -1640, -15925], 'C2': 90},
               {'C1': [23198, -21389, -18550, 31068, 451], 'C2': -70},
               {'C1': [11950, -10562, 18573, 723, 9765], 'C2': 18},
               {'C1': [-11916, -12566, 15953, 19888, 21819], 'C2': 30}],
        'B3': [0.9668948650360107,
               0.6546456217765808,
               -0.3359215557575226,
               -0.7330611348152161,
               0.8347747325897217,
               0.7522953748703003,
               -0.7549712061882019,
               0.27574294805526733]},
 'A2': 4063038769,
 'A3': 59559,
 'A4': 0.27210762151659806,
 'A5': {'D1': [32, -111, 93],
        'D2': [-5347920421440508073,
               -677822352346248757,
               -1682689457697314948,
               2613214869938195046,
               6115041478193559840,
               -2487948873742527967]},
 'A6': 40750,
 'A7': 4322548343743909091}

Вариант №14

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

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

(b'ANB\xcb@P"-3\xba\xd8\xf2\x11\x0fNdJ\xfbB\x02\x00\x00\x00#\x00\x00\x00A'
 b'\x00K\xafj T\x00am\xa9uI\x03\x00\x00\x00%\x00\x00\x00!\x8f\x11\x91'
 b'\x03\x00\x00\x001\x00\x00\x00-(\x004\x00\x02\x00=\x00\x00\x00\xc0\x81\xb7\r.'
 b'&\xea?\xc8\xf0\x9f\x87\x10\x98\x92\xf9\x16\xd6\x1a\xe4\xbf\xb8\xb6\xca\x02'
 b'\xc2\xb5\xf6\x96\x11\rF\xa5\x86\xbe\x8f\x0e\xee\xbex\xcbi\xd3\xafB')

{'A1': 15616850926802845899,
 'A2': 4826533220324413938,
 'A3': 'am',
 'A4': {'B1': [{'C1': [169, 117, 73], 'C2': 33},
               {'C1': [143, 17, 145], 'C2': 45}],
        'B2': 0.8171606319338522,
        'B3': 2275406024,
        'B4': 16},
 'A5': 543862603,
 'A6': {'D1': -0.6282759140709286,
        'D2': 10878081794835134136,
        'D3': 3345,
        'D4': [-0.2629796862602234, -0.46495482325553894],
        'D5': -13448,
        'D6': 1118819177}}

(b'ANB\xb1)o.\x8a4V\x99\xe2\x050\xc6\x00\x03\xc1\xb9\x02\x00\x00\x00#'
 b'\x00\x00\x00Z\x00\x83\x9c\xaa\x84m\x00ub6:\x02\x00\x00\x00%\x00\x00\x00\xa9'
 b'\n*\x02\x00\x00\x000\x00\x00\x00\x0e\x84!\x02\x00\x00\x00;\x00\x00\x00Pz\xfe'
 b"`\x03\x00\x00\x00F\x00\x00\x00&'\x002\x00=\x00I\x00\x04\x00R\x00\x00\x00"
 b'\xb2LR\x1e\xef\x03\xec\xbf\x98c\x05Y\xaaf\x1d\x87\x9e1\xf9\xee?\x08n\x08'
 b'\xe9S\x9d\xef{<\x99P\xf5I?\xfb\x08\xaa>\xcbg\xbb\x92\xfe\xab')

{'A1': 11049076503889258929,
 'A2': 13384982869381744098,
 'A3': 'ub',
 'A4': {'B1': [{'C1': [54, 58], 'C2': 169},
               {'C1': [10, 42], 'C2': 14},
               {'C1': [132, 33], 'C2': 80},
               {'C1': [122, 254, 96], 'C2': 38}],
        'B2': -0.8754802314964734,
        'B3': 1493525400,
        'B4': 170},
 'A5': 2225773699,
 'A6': {'D1': 0.9679191681142754,
        'D2': 8930529569816473096,
        'D3': 39228,
        'D4': [0.7888994216918945, 0.3320997655391693],
        'D5': 26571,
        'D6': 2885587643}}

Вариант №15

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

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

(b'RZIE\xf7\x9c\xab\x81)\x077\x00\x00\x00\xbf,Pi\x81\xa1\xfe*J\x84'
 b'\x96\xcb\x1f\x94/h\x12\x00\x18\x00bchkef\xb8\x8e\x97y\x8a\xe8\\\xa5'
 b'\xdb\xcf\xeb\x7f.\xc1\xdf\x02\x00\x1e\x00\x00\x00\xb0\xc2\x04'
 b'\x18\xec\xe3\xc3?\x05\x00\x00\x00"\x00\x00\x00\x02\x00\'\x00\x00\x00\xc3'
 b'v\xa7@\xf5\xdd\x80\x00\xcd\xc0\x80\xd0eR\xd84\xdby\xf3\xc3\xcd\xb0\xfdX&'
 b'\x0f\x120\xc7\xc2V\'y\xc9nQ!\xf5"\xe8E\xab7\xbc\xc9\xf1')

{'A1': -100,
 'A2': 120160683,
 'A3': {'B1': [{'C1': 721330561, 'C2': -31670},
               {'C1': -1809855594, 'C2': 26671}],
        'B2': 0.15539313481123918,
        'B3': 'bchke',
        'B4': [6694753100924631142, 16123219267915078565],
        'B5': 36272842440406723,
        'B6': {'D1': 3807884082185027789,
               'D2': 31195,
               'D3': 1091657806300169203,
               'D4': [3267833874, 3380160342, 4112601454, 2873485346],
               'D5': [55, 188],
               'D6': -3639}},
 'A4': 1766862015}

(b'RZIE\xf7\xec\x91t\x97\xa88\x00\x00\x00o\xa4\xcb\xf7\x16\xe8lsi=A\xc8\x94\r'
 b'\xfbZ\x12\x00\x18\x00dosjty\x0ezn\x90\x1eK\xf8\x1d\xc5\x07G\x0e\xc6v\x04\x9f'
 b'\x02\x00\x1e\x00\x00\x00\xf6`\xec>;\xf5\xe9\xbf\x06\x00\x00\x00"\x00'
 b'\x00\x00\x02\x00(\x00\x00\x00{\xc6#z\xcaQ.\x0br\xd2\xc1\x00!\xa0\x13\xec'
 b'\x82w=le\xee\x87\xb0BiF |?\xe0]\xaa\xb6\x99\xeb\xea\x10p\xb0]E\xa3~\x1b\xe9')

{'A1': -20,
 'A2': 2828498065,
 'A3': {'B1': [{'C1': 1936517142, 'C2': 15721}, {'C1': 227854401, 'C2': 23291}],
        'B2': -0.811185477158715,
        'B3': 'dosjty',
        'B4': [2159558615968414222, 11458413944952522693],
        'B5': 805671313420306043,
        'B6': {'D1': 17011116281115562610,
               'D2': 30594,
               'D3': 7584818820312034365,
               'D4': [1065099334, 3064618464, 283831193, 1163767920],
               'D5': [163, 126],
               'D6': -5861}},
 'A4': -137649041}

Вариант №16

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

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

(b'KSIO\xfb\x151\xf6b\x92\x05\x14\xd1\x04\x00F\x00\xd0,\xab\xcd!q!{\x96\xdc\xca'
 b'>urevgvq\xb2\x83!\xdf k&\x16\xcd\x05\x04\x00V\x00\xb0\x82\x0fvp\x00'
 b'\x00\x00r\x04{.\nBQ\t\x86\xae\xfa\x91:\x00\x00\x00=\x00\x00\x00@\x00'
 b'\x00\x00C\x00\x00\x00\xf4t\xb6\t\xc3(NL\xa7\xe9\xf3<+\xf5\xf4\xbef.'
 b'"?\xa0\xc3\x9a\x06\x10K\xea\x00X.\xb5\tVL\xbf\x18[#{\xa3\xe2\xec?\xd0)\xcc'
 b'>\x03\x00^\x00\xe9\x99\xfc\x1e\x06\x00\x00\x00j\x00\x00\x00F')

{'A1': -5,
 'A2': -3381071293964734187,
 'A3': {'B1': [{'C1': 1138, 'C2': 123},
               {'C1': 2606, 'C2': 66},
               {'C1': 2385, 'C2': -122},
               {'C1': -1362, 'C2': -111}],
        'B2': 8872497130894994640,
        'B3': 0.39621418714523315,
        'B4': 'urevgvq',
        'B5': {'D1': 1596080906876060594, 'D2': 1485},
        'B6': [29940, 2486, 10435, 19534],
        'B7': 1980727984,
        'B8': {'E1': 234,
               'E2': -0.0008647487069193271,
               'E3': 0.902665844444388,
               'E4': 0.3987565040588379,
               'E5': [0.02977450005710125,
                      -0.4784329831600189,
                      0.6335204839706421],
               'E6': 519870953,
               'E7': [-96, -61, -102, 6, 16, 75],
               'E8': 70}}}

(b'KSIO|\x04]\x1d\xba\x8f\xc3\xb8\x11\x02\x00@\x00\x86\x12\xd7\xdd\xd3\xe0\x1b'
 b'p\\\x1a\x17?qpozpqz@\xc9(;\x15\x11\r:r1\x05\x00H\x00\x93\xfcN(a\x00'
 b'\x00\x00[W\x06xUb:\x00\x00\x00=\x00\x00\x00v;L\xb4\x8b\x9bl\xb0'
 b'\xac\xa0\x8b\xbf\x98\xbeK\x04\'\xbf\x9f\xb2\xb8\xbe\x808%{$\xb7\xd8"\x87v'
 b'\xd2?\xb4\xbd\xda\x85\xb7\xba\xe0\xbfe\x94\x8b\xbe\x03\x00R\x00X-'
 b'\xa0:\x03\x00\x00\x00^\x00\x00\x00\xed')

{'A1': 124,
 'A2': 1276985516429761796,
 'A3': {'B1': [{'C1': 22363, 'C2': 6}, {'C1': 21880, 'C2': 98}],
        'B2': 8078297557183697542,
        'B3': 0.5902459621429443,
        'B4': 'qpozpqz',
        'B5': {'D1': 4183018411781572928, 'D2': 12658},
        'B6': [15222, 46156, 39819, 45164, 41132],
        'B7': 676265107,
        'B8': {'E1': 123,
               'E2': 0.28848436739905226,
               'E3': -0.5227925886483065,
               'E4': -0.27261653542518616,
               'E5': [-0.29833635687828064,
                      -0.6524092555046082,
                      -0.36073777079582214],
               'E6': 983575896,
               'E7': [-128, 56, 37],
               'E8': 237}}}

Вариант №17

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

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

(b'KRG!\x03\x00 \x00\x90\x06\x00&\x00:\\p?U\x00o\x00\x00\x00\xc28\xf1\xfe\x08'
 b'\xcc\x12\x9f\x82\x17\x00\x1a\x00\x1d\x00vkepiq\xffb.w\x83\xc3\xbc\xcc'
 b'\xf35^\xa1\x82\x81?\x12?\xc6mp@\xd9\x00H\x02[p\xac\x03\xad\xde\xbf'
 b'\xe3\x05\x00\x00\x00=\x00\x00\x00:\xa5\xf9\xec \xa4\xeby\x9e\xed\xbf'
 b',\x00G\x00\xe0\xc9r\xbeCL\xcd\xb4Q\xbfT\x02\x00\x00\x00d\x00\x00\x00\x03'
 b'\x00l\x00\x00\x000vB&\x83\xc5')

{'A1': [{'B1': -62, 'B2': 61752},
        {'B1': -2, 'B2': 52232},
        {'B1': 18, 'B2': 33439}],
 'A2': -112,
 'A3': {'C1': 'vkepiq', 'C2': 0.938907265663147},
 'A4': {'D1': 58,
        'D2': -1627,
        'D3': -0.9255952455869454,
        'D4': {'E1': 14752881448766563071,
               'E2': -1587661325,
               'E3': 130,
               'E4': 0.5712814927101135},
        'D5': {'F1': -559086676,
               'F2': 58303,
               'F3': [28102, 16496, 217, 584, 28763]}},
 'A5': {'G1': [-1099773472, -1261614013],
        'G2': [81, 191, 84],
        'G3': 30256,
        'G4': 3313706562}}

(b'KRG!\x02\x00\x1d\x00\x96\x05\x00!\x00\x01\xd9\x0e?I\x00p\x00\x00\x00\xf6'
 b'`\x83\\CU\x17\x00\x1a\x00mndpg\x15\xe3e_\xb1\x8ax\xc7\x02%J\x9dH\x8f'
 b'a\x0f\xbf\x8b \xaf\x0e46\t\x82^\xc9\x02\x00\x00\x007\x00\x00\x00\xa3\x14\xc2'
 b'z\xd0\x08\x1cC\xd7\xe5?&\x00;\x00\xc54\x04\xa3\x8d)jqu\x98\xdb\xa0'
 b'\xad\xcb\xd3P{\x9b\xa8\xf4q)\x1bV\x05\x00\x00\x00X\x00\x00\x00\x04\x00l\x00'
 b'\x00\x00\xc6^7\xee\xae?')

{'A1': [{'B1': -10, 'B2': 33632}, {'B1': 92, 'B2': 21827}],
 'A2': -106,
 'A3': {'C1': 'mndpg', 'C2': 0.5579987168312073},
 'A4': {'D1': -93,
        'D2': -15852,
        'D3': 0.6825271174952967,
        'D4': {'E1': 14373390705167295253,
               'E2': -1656085246,
               'E3': 72,
               'E4': -0.5600823760032654},
        'D5': {'F1': -2113325516, 'F2': 51550, 'F3': [8331, 3759]}},
 'A5': {'G1': [-1560005435, 1902782861, -1596221323, 1356057517, -190276741],
        'G2': [113, 41, 27, 86],
        'G3': 24262,
        'G4': 1068428855}}

Вариант №18

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

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

(b'SPW\xa8\x04\x00\x00\x00\x9c\x00\x00\x00\xfe\x1b\x03\xfae\xc2\xe5\xbf'
 b"\x8b\x8f\xf6\xf0TbBs}e\xa9ot\xdcq\xd2\x15D0\xe7\xbf|\xd1`\xa1'\xd5z"
 b'\xc7>\x81\x90|\x85\xa8L\xbf\xda\x94\xb0`\x034\x1b\xb7\xdb\xbf1\x9cx\xb4\x13'
 b'bI\xb1\xeaPrZ\x10\x00$pG\xc4\xc5\xec?%a\xe7\x10\x82\r+\xd6I\x9b\xc42'
 b'.\xb6f\xb7tk\xc3\x88\xd4!CK\xa9=M+\xfa>\xa2\r\xfe\xff\x92E\xfaz,\xb2'
 b'\x87\xa0K\xfe2\x1cNRL\x02[\xcba \xeb\x8cJP\xc9#\xda\xed\x04\x00'
 b'\x00\x00\xa0\x00pjap.\xa3\x11\xbd')

{'A1': 'pjap',
 'A2': [{'B1': -0.6799802668618893,
         'B2': -252276853,
         'B3': 84,
         'B4': 8390110884176020066,
         'B5': {'C1': -0.7246418405734931, 'C2': -11908},
         'B6': [-9133643663884705440, -7720648275207553904]},
        {'B1': -0.43305091933644757,
         'B2': -1267164111,
         'B3': 19,
         'B4': 1178379944371243362,
         'B5': {'C1': 0.8991414447092438, 'C2': 24869},
         'B6': [-7257033844132278041, 7743015311127753412]}],
 'A3': 567576771,
 'A4': {'D1': 0.08266308158636093,
        'D2': 0.4886116087436676,
        'D3': -127582,
        'D4': 2063222162,
        'D5': [2031965982666764844, 2333369673695646286, 17139050679454305515],
        'D6': [46, 163, 17, 189]}}

(b'SPW\xa8\x02\x00\x00\x00\x9c\x00\x00\x00v\x91\x9d\x04\xdb\xe9\xe2\xbf'
 b'\xdfKY\xa3\xdc\x89\x85\x8a\xfdI\xcd\xaf\xf4\x80P\xbd3+\x88\xd5'
 b'\xbf\xe8\xa8\x1f$\xc6:X\r\x04d\xc0\x8b\x0c\x82\x1aA>i\x88@K\x15\x81'
 b'\xb6\xe5\xbfr\xd4\xa4\x19\xbe\x07Rg\x11S\xab|\xb9T\xac\xd5#\xd2:\xe2?'
 b"\xa1\xb6~\x03'\x15g\xcc<5E\x8f\xb5\xfa\xf6\xe4\xf6\x06\xcd&%\xd0\xa3\r"
 b'"\xbe\'CB>Y\x03\xa7\xae\xf7\x1e\x9fb\xb9\x8c\xe5:>B\\v\x84\x89\xc40,V'
 b'n\x95\x0b\x11o\xcekn\xee\xe3\x07\x00\x00\x00\x9e\x00pt?\x87(\x9e+\xc7(')

{'A1': 'pt',
 'A2': [{'B1': -0.5910468187471867,
         'B2': -1554428961,
         'B3': -36,
         'B4': -815207289860749943,
         'B5': {'C1': -0.33643608143507464, 'C2': -22296},
         'B6': [7206899976293983263, 7583570404645309376]},
        {'B1': -0.6785283485314872,
         'B2': 430232690,
         'B3': -66,
         'B4': -5080997906318142969,
         'B5': {'C1': 0.5696802806754797, 'C2': -18783},
         'B6': [3836165725721396094, 501840157917679429]}],
 'A3': -802871603,
 'A4': {'D1': -0.15825514495372772,
        'D2': 0.18970929086208344,
        'D3': -1364786343,
        'D4': 1654595319,
        'D5': [8528764629376404665, 10767638506886171012, 16424186300370718987],
        'D6': [63, 135, 40, 158, 43, 199, 40]}}

Вариант №19

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

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

(b'\xdeHKOJ\xbd\xcfV\x00\x00\x00\xc4\x9c\xd0\xd0tqwkz\xa5\xa7\xb4@\xe5\xedT@'
 b'HN\x91\xe8\x01\xb55\xbe\x02\x00\x80\x00\x00\x00\x8b\xdb\x9d\xbd\xafa'
 b'\x0c\xac\xf8n\xe5^\xb2\xe7?>\\\x81\xb5\xbe\xf16&?\xfb\x8b$?\xad~\x0c\xbfU<'
 b"\x9e\xbe\x90\x04\x1a>'\xb6\xf5\xf12\x00A\x02\xe9w\xd5\xfd\xf0QA^Q\xc1"
 b'\x85wP\xc2\x96\x18T\xab3\xf8\xb6\xf0%\xea\xca\xbb2\x8c\\\xd1f\xf8\xea\xe5'
 b'\x12\x9er8\x81\xf6\x9d\xbcxs/\xbf')

{'A1': -12355,
 'A2': {'B1': {'C1': 28408,
               'C2': 24293,
               'C3': [0.18740728497505188,
                      -0.3545025587081909,
                      0.6492758393287659,
                      0.6427609324455261,
                      -0.5488079190254211,
                      -0.30905404686927795,
                      0.15040802955627441],
               'C4': -235555289},
        'B2': 65,
        'B3': 59650,
        'B4': 119,
        'B5': [{'D1': 64981,
                'D2': 8612502417633792496,
                'D3': 412533328,
                'D4': 4164135764},
               {'D1': 61622,
                'D2': -3360657072398341595,
                'D3': 3857381478,
                'D4': 947035666}]},
 'A3': -791634748,
 'A4': 'tqwkz',
 'A5': 4635591485359957925,
 'A6': {'E1': 20040,
        'E2': 59537,
        'E3': -0.17744828760623932,
        'E4': [-0.01928258128464222, -0.6853556632995605],
        'E5': -0.07707890123128891},
 'A7': -1408474705}

(b'\xdeHKOJ\x1ecV\x00\x00\x00l\x17\x1a\xa8bbbgp\xce\xef\xd6\xe3B!\xe0\xee'
 b'\x89\x80\x9e\x85+\xd8\xb1>\x03\x00\x80\x00\x00\x004\x04}?\xc9$\xa9:\xc1]'
 b'\x19\xfe\xc1p@\xbe*:M\xbe\x00\xa3{\xbe\xb1\xfb\xac\xbe\x14_E?\xc9\xff'
 b'\xa0>6\x0e<??\x97\xfd\xc52\x00\xca6\xfcc\xd8\xc7\x08R.\xf4j!\xd5%\xf0\x9a'
 b"\x07\xc7\x9f\x98\xfbm\x14\x9f^w'|o\xe5\x1f\x88X<\x0b\xbc\xb5\xba>1\xd3\xc99?"
 b'P?\x1a?\xe8~\x18\xbf')

{'A1': 25374,
 'A2': {'B1': {'C1': 24001,
               'C2': 65049,
               'C3': [-0.1879301220178604,
                      -0.2004171907901764,
                      -0.24573898315429688,
                      -0.33785775303840637,
                      0.770982027053833,
                      0.3144514858722687,
                      0.7345918416976929],
               'C4': -973236417},
        'B2': -54,
        'B3': 64566,
        'B4': 99,
        'B5': [{'D1': 51160,
                'D2': 2726121892689629704,
                'D3': 3339164400,
                'D4': 1845205151},
               {'D1': 40724,
                'D2': -8637933293286230178,
                'D3': 3154852952,
                'D4': 826194613}]},
 'A3': -1474685076,
 'A4': 'bbbgp',
 'A5': -1233949726725443634,
 'A6': {'E1': -32631,
        'E2': 34206,
        'E3': 0.34735235571861267,
        'E4': [0.7257358431816101, 0.6025285720825195, -0.5956864356994629],
        'E5': 0.9883453845977783},
 'A7': 984163529}

Вариант №20

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

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

(b'MBAI\xca\x02\x00\x00\x00\xa0\x00\xd0n\xf1Fl(lO\xa8\x00\x8a\x1d\xcb>\xcaN\xd2'
 b'\xc4\xbd\xb5\xa6:\x7f\xbc\xb5-\x04\x00\x00\x00!\x00\x00\x00\x10{\xca'
 b'\xe6\x8a\xd8\xe5\xbfk\xb9w\x9f5\xf2\xb9o\xde1Y\x9e\xf7\xd1\xfcVe\xbf%'
 b"\x00\xb9'\xdd\xce^\xd3\x01\x96\x03\x00\x00\x006\x00\x00\x00\xe1\x1cY"
 b'\xefm\x04\x8fK\xe7\xed\xb2\x03\x00\x00\x00a\x00\x00\x00xz\xd5+\xf0)\xdc?'
 b"\xf8'\xc8`\x13\x85\x95\x0e\xac\xe0\x7f\xb0\xe5S#i\x82\xbed\x00$\x14vd"
 b'\x96M\x93\r\x03\x00\x00\x00u\x00\x00\x00F\xd6\xc0\xb4b\xc8-\xefB\x00\x81\x00'
 b'\x15]\xb9\x8a=\xd8~\xf4\xd3\x8eAE\xe4\x04\x00\x00\x00\xa4\x00\x00\x00')

{'A1': 202,
 'A2': [{'B1': 209,
         'B2': -0.8958585262298584,
         'B3': {'C1': [127, 188, 181, 45],
                'C2': -0.6826834209094574,
                'C3': 107},
         'B4': 10169,
         'B5': {'D1': -12579,
                'D2': -1778265250,
                'D3': [899643321, 3731864050, 4154349873]},
         'B6': 5444575344727760097},
        {'B1': 83,
         'B2': -0.2547083795070648,
         'B3': {'C1': [231, 237, 178], 'C2': 0.44005970268873495, 'C3': 248},
         'B4': 5156,
         'B5': {'D1': 25718,
                'D2': 227757462,
                'D3': [325109799, 2886636933, 3853549536]},
         'B6': -1212092398427908538}],
 'A3': 5722993671992864464,
 'A4': {'E1': 4101953597,
        'E2': 36563,
        'E3': 17729,
        'E4': -28,
        'E5': [21, 93, -71, -118]},
 'A5': 0.39670974016189575,
 'A6': 4226265126989352650}

(b'MBAI\xb5\x02\x00\x00\x00\x9e\x00\xa0`\x0f\xb1\xa1\x04\xd9f\xa4'
 b'\x00\x0c\x1a\x9a\xbe\xa3}p\t/\x1de\x00\x8f\xf39\x03\x00\x00\x00!\x00\x00\x00'
 b'\x1c\xc3\xf8\xaa0\xb9\xd5\xbfHf{\x86\x83*\xf2$\xe1d(\xb1\x14?$\x00}sM\x9a'
 b'\xa3\xb4\x8e\xf7\x02\x00\x00\x005\x00\x00\x00\xd7\x12\x96\xab\xafW\xc9\xd9'
 b'\x95_\xaa\x04\x1e\r\x06\x00\x00\x00\\\x00\x00\x00\\\xeb\xe2z\xb0\xa4'
 b'\xe3?6\xcf\x0bd\xef\x9c\x14\x06\x9aB\x06\x07/\xf0F\xf1y?b\x00\x1b\t'
 b'\xee\x12\\\x9d\x89M\x03\x00\x00\x00s\x00\x00\x00&R%O1\xfd\x17\x9b=\x00'
 b'\x7f\x009\xdf\xc2\xb6\x19B\x03\x7f\xab\x08M\x02\x00\x00\x00\xa2\x00\x00\x00')

{'A1': 181,
 'A2': [{'B1': 100,
         'B2': 0.5808281898498535,
         'B3': {'C1': [143, 243, 57], 'C2': -0.339428107227876, 'C3': 72},
         'B4': 29565,
         'B5': {'D1': -26035, 'D2': -141642589, 'D3': [2206628710, 3777294890]},
         'B6': -2753573285150715177},
        {'B1': 240,
         'B2': 0.9763377904891968,
         'B3': {'C1': [149, 95, 170, 4, 30, 13],
                'C2': 0.6138536834836077,
                'C3': 54},
         'B4': 2331,
         'B5': {'D1': 4846,
                'D2': 1300864348,
                'D3': [4016311247, 2584089756, 788989506]},
         'B6': -7271064685143305690}],
 'A3': 7410959754321682592,
 'A4': {'E1': 1108981442, 'E2': 32515, 'E3': 2219, 'E4': 77, 'E5': [57, -33]},
 'A5': -0.30097997188568115,
 'A6': 28461060506811811}

Вариант №21

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

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

(b'FELI?R\x03\x06?\xec^\x9cZ5\xed8\x96\x83\xb3\xcb\xa5\xfb\xc4d\x1f\xa2NM'
 b'\xbe\x94J\x9e\xd7\x0b\xba&\x12\xc7-\xb3k\xc0\xbc/>\x12/\x9a])\x00D\xc2w\x9a)'
 b'r\xa3\xe6Q\xa3\xd7\xcc\xf3?{m\x99\x8cvx\xa9\x7fWieieql\xbf\xd8"#'
 b'C\xc8\x9b\xfc\xbf\xdb\x1b7\xbeH\xa88?\xd6*\xc2\xea\xb3j\x84?\xeaJM'
 b'\x02\xf8v\x94\xbf\xd1m\xef\xf9\x16D\xac\xbf\xb41\xc1Q2\xbd\x90?\xe3\x04\x93'
 b'\x964\xcb\x9e\xe1\xa9\xed@\xff\x006?r\xd0p?\xe2\xfe\x87\xc4>\xc8\xa6G')

{'A1': 0.8203586339950562,
 'A2': 0.886549164002111,
 'A3': [{'B1': 10845710014882759780,
         'B2': 530730573,
         'B3': -0.28963178396224976},
        {'B1': 15495683615584890291,
         'B2': 1807793199,
         'B3': 0.14275971055030823}],
 'A4': 23849,
 'A5': {'C1': 35958,
        'C2': 2024374103,
        'C3': 'ieieql',
        'C4': [-0.3770836030911935,
               -0.42353623945621477,
               0.34635994834904005,
               0.8215699251192796,
               -0.2723350460519878,
               -0.07888420326593448,
               0.5943086560931652],
        'C5': [225, 169, 237],
        'C6': 16639,
        'C7': {'D1': -1708559709,
               'D2': -430857257,
               'D3': 52467,
               'D4': 0.9821410775184631},
        'C8': {'E1': 0.9484930038452148, 'E2': 0.5935705979266188, 'E3': 71}},
 'A6': [-62, 119]}

(b'FELI\xbf+\x87\xb8?\xd26\xba\xf5-5\xdc\x95\x97\x9e\x1f\x90\x99\xc9UK4[$'
 b'?s\xf5\x82\xc4\xa4\\\xeb\x8a\xf41\xf11\x17\xe5\xd0>\xf5\xfe_\xf7k\x00D'
 b'r\xc7_\x80\xed"\xf7]\x06j\x91A\xbd\xe2\x96H\xfa\xda\x85\x8e9hcfoiga'
 b'\xbf\xc7\x18\x0e\xafWG\xf0?\xe6d,\xe4\xade\x02?\xa4l\xf3\xa5QK`'
 b'\xbf\xcd\x9a\xb2e[\x83@\xbf\xdc\xc5\xee-z*\xd8\xbf\xef\xdd\xa0"\x84\xd6\xce'
 b'?\xb6\xc4\x9ab\x0bL\xc0\xc3\xc2\xfb\xe8V\x006\xbe,\xd3\xcc?\xd69\xf9\xe6'
 b'\xed2@\x8f')

{'A1': -0.6700396537780762,
 'A2': 0.2845904726317181,
 'A3': [{'B1': 10779258091541743957,
         'B2': 1261722404,
         'B3': 0.9529649019241333},
        {'B1': 14169552494332752369,
         'B2': 823649744,
         'B3': 0.48045632243156433}],
 'A4': 63339,
 'A5': {'C1': 64218,
        'C2': 2240690536,
        'C3': 'cfoiga',
        'C4': [-0.18042167245454221,
               0.6997284380296664,
               0.03989373581921174,
               -0.23128347348304068,
               -0.4495807117570343,
               -0.9958038973042791,
               0.0889374245992256],
        'C5': [195, 194, 251],
        'C6': 59478,
        'C7': {'D1': 1602284834,
               'D2': -144898454,
               'D3': 37185,
               'D4': -0.11063820123672485},
        'C8': {'E1': -0.16877669095993042,
               'E2': 0.3472885851995535,
               'E3': 143}},
 'A6': [114, -57]}

Вариант №22

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

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

(b'SNIvxjc@\x94\xba\\\x00\x00\x00H\x00\x00\x00V\x00\x00\x00b\x00\x00\x00p\x00'
 b'\x00\x00~\x00\x00\x00\x8b\x00\x00\x00\x98\x00\x00\x00\xa4\xcdGO\xda\xc6'
 b'\x7f#o\xbf\xe8}\xf0H\x98Wf\xba\xf4(\x86-\xd7\xa1\xb6\xb1~"\xc4\xf8\x04IG\xda'
 b'\x00\x03\x00\x00\x00Ew;\xb1K\xa4\x8f\x0br\x00\x04\x00\x00\x00R\xabhX8'
 b'\xb0:\x00\x02\x00\x00\x00`\x15\x1c(\x9f;\xe8\x97\x87\x00\x04\x00\x00'
 b'\x00lF\xf5`\xf0\xe7\x10\x1a\n\x00\x04\x00\x00\x00z\xf1\xec\x15\x1e'
 b'\xb9L\x17\x00\x03\x00\x00\x00\x88\xde\xf7\x1d\x9cM\xff\xd4\x00\x03\x00\x00'
 b'\x00\x95\xbdc\xf4#\x7f\xd8\x00\x02\x00\x00\x00\xa2')

{'A1': 'vxjc',
 'A2': {'B1': 1083488860,
        'B2': [{'C1': [4, 73, 71, 218], 'C2': [34, -60, -8]},
               {'C1': [164, 143, 11, 114], 'C2': [119, 59, -79, 75]},
               {'C1': [88, 56, 176, 58], 'C2': [-85, 104]},
               {'C1': [59, 232, 151, 135], 'C2': [21, 28, 40, -97]},
               {'C1': [231, 16, 26, 10], 'C2': [70, -11, 96, -16]},
               {'C1': [30, 185, 76, 23], 'C2': [-15, -20, 21]},
               {'C1': [156, 77, 255, 212], 'C2': [-34, -9, 29]},
               {'C1': [244, 35, 127, 216], 'C2': [-67, 99]}],
        'B3': 14791879302173369199,
        'B4': {'D1': -0.7653733651993491, 'D2': 3136563334},
        'B5': 11735},
 'A3': 2713104766}

(b'SNInbvmZ&@\x0f\x00\x00\x00G\x00\x00\x00U\x00\x00\x00a\x00\x00\x00m\x00'
 b'\x00\x00z\x00\x00\x00\x86\x00\x00\x00\x92\x00\x00\x00\x9e\x8b'
 b'\xab\x91\xa1\xca[\x1c_?\xcc\xde\x05\xa6\xec\x8ex\xfb\xdfT\x01\x91\xba\xc00A'
 b'\xd4[\xfe\xf3{\xeb\x9c\x00\x02\x00\x00\x00E\xe4\x12\xd5\x04\xc7\xc4\xd4'
 b'\xaa\x00\x04\x00\x00\x00Q\xda\x89\xbdh\x02)\x00\x02\x00\x00\x00_\x91'
 b'm\x85\xb6\x02\xc6\x00\x02\x00\x00\x00k\x18W)\x9b]\x1a\xa0\x00\x03'
 b'\x00\x00\x00w3g*\x7f\xad\xa8\x00\x02\x00\x00\x00\x84\n`\xee\xdf\x12=\x00\x02'
 b'\x00\x00\x00\x90aF\x0c@\t\x8a\x00\x02\x00\x00\x00\x9c')

{'A1': 'nbvm',
 'A2': {'B1': 1512456207,
        'B2': [{'C1': [243, 123, 235, 156], 'C2': [91, -2]},
               {'C1': [199, 196, 212, 170], 'C2': [-28, 18, -43, 4]},
               {'C1': [189, 104, 2, 41], 'C2': [-38, -119]},
               {'C1': [133, 182, 2, 198], 'C2': [-111, 109]},
               {'C1': [155, 93, 26, 160], 'C2': [24, 87, 41]},
               {'C1': [42, 127, 173, 168], 'C2': [51, 103]},
               {'C1': [238, 223, 18, 61], 'C2': [10, 96]},
               {'C1': [12, 64, 9, 138], 'C2': [97, 70]}],
        'B3': 10064297916360236127,
        'B4': {'D1': 0.22552557612026525, 'D2': 4225717249},
        'B5': -28230},
 'A3': 3224388052}

Вариант №23

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

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

(b'YWD\x91\x00\x00\x00\x16n\xe6\xd1\x83\x0c>\xe6\xa1l>v(\xc6\x81\x96\r'
 b'\xd0\xf9\x02\x00\n\x00(\xbb\x1e\xbf*\x19X\xbd\xaf&\xf72\xf0\xcd'
 b'\xed\x95\x02\x00\x1e\x00\x94\x16*?\x16v\x92=\xc8\xa1\xa3\xb0\xa2Q'
 b'\x1c\xae\x02\x002\x00p\xd3\x18>2 H?\xb3\x8a\xb8\xfd\xbb\x96\xab\xa1\x02\x00'
 b'F\x00\xef\xfcz>J\xbd\x8a\xbc\x81\x02\x91F\x9d>Q)\x02\x00Z\x00\x12\x00'
 b'\x00\x00&\x00\x00\x00:\x00\x00\x00N\x00\x00\x00b\x00\x00\x00\xf2\xb3'
 b'P\xeb\xfdu9\xef\xc25\xab\xad\x0f@\xed{\x958\x16?\x13\xb6\x1c\x05\x00\x00'
 b'\x00n\x00\x00\x00\x07\x00\x00\x00\x82\x00\x04\x00\x00\x00\x89'
 b"\x00\x00\x00\x05\x9e\xdf\xbd\xce\xef\x7f\xbf\x9a\xb56'\xa5")

{'A1': {'B1': 123,
        'B2': 0.5868008732795715,
        'B3': 46611,
        'B4': {'C1': 28,
               'C2': [{'D1': 18000902650673375350,
                       'D2': [0.1372215896844864, 0.2310863435268402]},
                      {'D1': 10803517512662591151,
                       'D2': [-0.6200432777404785, -0.05275837332010269]},
                      {'D1': 12545992421137424840,
                       'D2': [0.6644070148468018, 0.07151429355144501]},
                      {'D1': 11649570595283700403,
                       'D2': [0.14924407005310059, 0.7817412614822388]},
                      {'D1': 2977229673883304577,
                       'D2': [0.24510549008846283, -0.016935963183641434]}],
               'C3': [242, 179, 80, 235, 253, 117, 57],
               'C4': [-15633, -21707, 4013, -4800],
               'C5': -0.10918811708688736},
        'B5': -50,
        'B6': 11900540693963046895},
 'A2': 28182,
 'A3': 230}

(b'YWD\x8e\x00\x00\x00\xad\xfd\xb2\xef\xf2\xcd>r\x8aH?R\xff\xe2"A\xaf'
 b'0\xe3\x02\x00\n\x00\xb8\xfa\xfd>V\x89z\xbf\xc3\x06\xd6:$\x1a\xe4\x10\x02\x00'
 b'\x1e\x00a\x9d\x01?\x9f\xfc\x16?\x82\xa0\xc0\x01\xa57\xa9f\x02\x002\x00cu'
 b'1?\x98\xf6\xe2=\xa9\nnI}\xfe\xa4t\x02\x00F\x00B\xa3u?\xeb\xd4\x16?\xd1\x8a'
 b'\xde2\xa6\xfd\x99\x16\x02\x00Z\x00\x12\x00\x00\x00&\x00\x00\x00:\x00'
 b"\x00\x00N\x00\x00\x00b\x00\x00\x00.q[F\xc4b\xf5<\x0f\xe9\x87\xd8'h\xadQ\xbfw"
 b'\xdc\xd2\x05\x00\x00\x00n\x00\x00\x00\x02\x00\x00\x00\x82\x00'
 b'\x05\x00\x00\x00\x84\x00\x00\x00\x18\x02\x89>\xfe\xfe{\x96v\xce\xa0\xe4F')

{'A1': {'B1': 39,
        'B2': -0.8190522193908691,
        'B3': 56439,
        'B4': {'C1': 210,
               'C2': [{'D1': 16370777339784789842,
                       'D2': [0.40224406123161316, 0.7833625078201294]},
                      {'D1': 1217126542205126339,
                       'D2': [0.49605345726013184, -0.9786580801010132]},
                      {'D1': 7397505044771283074,
                       'D2': [0.5063076615333557, 0.5897921919822693]},
                      {'D1': 8405122618636503721,
                       'D2': [0.6931974291801453, 0.11082190275192261]},
                      {'D1': 1628611630530988753,
                       'D2': [0.9595223665237427, 0.5891863703727722]}],
               'C3': [46, 113],
               'C4': [18011, 25284, 15605, -5873, -10105],
               'C5': 0.2675940990447998},
        'B5': -2,
        'B6': 5108384685958265854},
 'A2': 64941,
 'A3': 178}

Вариант №24

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

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

(b'WJK\x00\x00\x00\x02\x00\x1a\x07\xca\xe4[\\\x00n\xcd`\x00\x04\x00\x8d\xb8N'
 b'\xde~\x16\x9dB\xde\x9a\x14\xa8\x05\xc3o?\xe2\x0e\xf0\x80J\x88d\x01\xd8\xcc.'
 b'\xa1Yr\xfe{\x0e\xbf\xed_\xaaXp\xc8\xea\x19x!$\xb7+z\xda?\xea2\xb2fE'
 b'\xe5@\x82\xc8\x15\xc9N\x99:\xc5J\xdd=\xfeO\x01\x87d\xc3\xd8\xbf\xe8O\x99'
 b'\xe3Q_\xb0z4\xc8%uh{\xa8\xab\x07\x1c\x9d\xb2\x95?\xd4T\x80N(W\x04l\xcc'
 b"\x9c\x00\x00\x00>\xbe%\xd1\x94\xf1\xa1'\xdf$H\t\x89T#+\xe3")

{'A1': [{'B1': 379405022,
         'B2': {'C1': -1709922299, 'C2': -15505, 'C3': 0.5643236642538452}},
        {'B1': 30985262,
         'B2': {'C1': -1587973378, 'C2': 31502, 'C3': -0.9179279067377852}}],
 'A2': 7,
 'A3': -891004068,
 'A4': {'D1': 8910559909785744021,
        'D2': 0.31765754349304154,
        'D3': 27852,
        'D4': -100,
        'D5': {'E1': 1835253289729096410,
               'E2': 0.8186885831375221,
               'E3': [33480, 5577, 20121, 15045],
               'E4': 19165,
               'E5': [1040076545, 2271527896],
               'E6': -0.7597169341852261,
               'E7': [31284, 51237, 30056]},
        'D6': -0.16193228960037231,
        'D7': 61857,
        'D8': 10207},
 'A5': -12960,
 'A6': [9288, 2441, 21539, 11235],
 'A7': -1202790786}

(b'WJK\x00\x00\x00\x02\x00\x1a\x1c\xb6\x1a5`\x00n\x82\xe6\x00\x03\x00\x8dLB'
 b'\x89\x8dDqf\x00\xd4\xc8\xe7\x8a\xd23?\xba\xe5k\xd2w\xb7\xc0\xf2\x14vx'
 b'\x909\xa9V\x88|\xbf\xac_~.V\xb0\xa0V\xbb\xed{\xfb\xda\xddL\xbf\xeb?V\x1a\x00'
 b'\xdcz\x02\x0c\xa4pVTq\xd9\x91\xaa\xed\xa5B%\xaa\x18\xfc\x1c?\xebL\xc6'
 b'9\xbc\x14\xe4\xe3\xa5X\x1d\x96e\xc7K\xebN\x19\xc7\xaf\x9e?\xc3[N5\xcd'
 b'\xb1\x80W5\xf2\x00\x00\x00>>\xbeK10\xe1\xce= \xed\xf4\xe1\xa36')

{'A1': [{'B1': 1148282368,
         'B2': {'C1': -725031030, 'C2': -11725, 'C3': 0.10506318939562131}},
        {'B1': 4061427320,
         'B2': {'C1': -1875269290, 'C2': -30596, 'C3': -0.055416052967616425}}],
 'A2': 28,
 'A3': -1239796384,
 'A4': {'D1': 14360830557473451934,
        'D2': 0.15122392298816223,
        'D3': 22325,
        'D4': -14,
        'D5': {'E1': 6249850024668880204,
               'E2': -0.8514814861181457,
               'E3': [524, 42096, 22100, 29145],
               'E4': -28246,
               'E5': [3987030565, 2853764124],
               'E6': 0.8531218650465715,
               'E7': [58277, 22557, 38501]},
        'D6': 0.37166741490364075,
        'D7': 12513,
        'D8': 52797},
 'A5': -32026,
 'A6': [8429, 62689, 41782],
 'A7': 1279429005}

Вариант №25

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

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

(b'NLNY\x7ft\x00\x02\x00\x00\x00)E\t\x81lY\xe7mvKq\x10\xe0@DG\xf1q~2\xf8'
 b'\x97\x00[gszren\x00\x03\x00#\x1e-~j\xce\xbeV\xff)H\xf1\x9cCc\xcfJq8\x00'
 b'\x03\x00&\xbe4\xc5\xfal|\xfd~\xea\x82\x94!\xa8\xa2$9\xb48\xfd\n\xc7'
 b'\xa5j\xb8>\x15\x93p\xc4\xc50\xc5\x90C9CY\x18\xd6N\x00\x00\x00\x03\x00'
 b'U\x88/\x05{\xb2\xe0\x13B')

{'A1': 32628,
 'A2': [{'B1': 'gsz',
         'B2': 2174533192290031359,
         'B3': 41,
         'B4': [72, 241, 156, 67, 99, 207, 74, 113],
         'B5': 56},
        {'B1': 'ren',
         'B2': -4740946828361663106,
         'B3': -22,
         'B4': [130, 148, 33, 168, 162, 36, 57, 180],
         'B5': 56}],
 'A3': 69,
 'A4': {'C1': 9,
        'C2': 129,
        'C3': 7807525886345572624,
        'C4': -2287753534920098254,
        'C5': -8,
        'C6': -105},
 'A5': {'D1': 0.14607024192810059,
        'D2': [-15163, 12485, -28605, 14659, 22808, -10674],
        'D3': [-758, -14427, 27320],
        'D4': 9813068141903745858}}

(b'NLNY\xce7\x00\x02\x00\x00\x00/(\xfcF\xfd4\x93\x05\xcd\x16y\xc1\x13'
 b"O\x96\x00\x01\xc2\x82s\xdf)\x00agludiwsjgdvq\x00\x07\x00#\xde\xc4\x00'V"
 b'Q\x10\xaf^\x1cn\xc2J\xa1\x8dc\xad\xd7\x00\x05\x00*\xe7\xeao\xa0\x1a\xf0J'
 b'`\t]\x9d\x0b\xc6\xb5H _\x87\xf0\xfa\x03\xcc\xc9\x85?\x06M\xd8\x90\x03\x15'
 b'\xa0\xa4\xaeK,0\xc8`\xc4\x00\x00\x00\x03\x00[EB\xc8\xaf>N1\xa4')

{'A1': -12745,
 'A2': [{'B1': 'gludiws',
         'B2': -2394788932902383441,
         'B3': 94,
         'B4': [28, 110, 194, 74, 161, 141, 99, 173],
         'B5': -41},
        {'B1': 'jgdvq',
         'B2': -1735451972960499104,
         'B3': 9,
         'B4': [93, 157, 11, 198, 181, 72, 32, 95],
         'B5': -121}],
 'A3': 40,
 'A4': {'C1': 252,
        'C2': 70,
        'C3': -201374430199907903,
        'C4': 1391495736654463603,
        'C5': -33,
        'C6': 41},
 'A5': {'D1': 0.524625301361084,
        'D2': [-28669, 5536, -23378, 19244, 12488, 24772],
        'D3': [-3846, 972, -13947],
        'D4': 4990771992070074788}}

Вариант №26

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

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

(b'GIERJ\xcb\xbd\x1b\x05\x00\x00\x00j\xd5E9\x81\x92>\x08\xb5|x@\x8a\xd7\r\xf1'
 b'\xa4[\xc9\xf1\xe0b\x1cC\x04G%OA\xa8#\x08\x05\xb2\x131g\x05b\xbc\xe6^\xbe\xf9'
 b'q!#{\x9f\x0f\xbf\xe1\xc5\xcaNr.\xb6\x00\x00\x00\x02\x00\x00\x00.M\xba'
 b'\xb9\xb1>\xd1esC\xd6>\xb7\x9a~\xcf\x13\xe1\xa9\xad3\xf3\xca\xe8\xef\x8cH'
 b'\x0b\xaf\xa6\xfe\x00\x03\x00\x16{%}\xc7;\x12\xa7\x96\x006#\x00\x03\x00O\x00'
 b'\x03\x00\x00\x00g>\xa4}\xd9')

{'A1': -876799227,
 'A2': {'B1': -22786,
        'B2': [{'C1': [120, 64, -118, -41, 13, -15], 'C2': -23461},
               {'C1': [-55, -15, -32, 98, 28, 67], 'C2': 1095},
               {'C1': [37, 79, 65, -88, 35, 8], 'C2': 1458}],
        'B3': 8873636935446472598,
        'B4': {'D1': 13761154523550424847,
               'D2': -0.5553943187855654,
               'D3': [322004741, 1656546910],
               'D4': 77},
        'B5': 35,
        'B6': [-4991763828604308669,
               -3008765626856565791,
               -6220258388154454132],
        'B7': [72, 11, -81],
        'B8': 0.3212726414203644},
 'A3': -716883583,
 'A4': 146,
 'A5': 0.13350480794906616}

(b'GIERJ\xfa\\\x89\xfe\x00\x00\x00\x85\x90\x13\xe7\xe6\x93\xbf\x11v\\\xc8\xae'
 b'\xd0BM\xb5\x9b\xa4~\x95\xfe/-\xddq\xf5\xe1\x1a\xcb)\x1b\x1e~\x19>\xfb'
 b'\xc7b@\xf8\x9a\x8c\xa6\x04\x04\x17?\xc2\xa5\xa6\x1d\x16\xf80\x00\x00'
 b'\x00\x03\x00\x00\x00&\x08\xde\xff:e\xf1]\xda\x03\xdb\x97Z\x11N\x8aI3\xcb'
 b'\xa3\x003\x9d\xf5C\x02\xea\xfd\x15/\x91o\xbb\x17\x85\xee\x9cRe\x04\x8d\xebt'
 b'+\xc9\xd4OKk\xa8\xd6\x1c\xaa9\x1eI\xb7!!\xc3\xe1\xd4\x00\x02\x00\x16\xda'
 b'\x13\xe2\x9a8)<\x02\x0028\x00\x07\x00K\x00\x02\x00\x00\x00\x83>\x95~\x92')

{'A1': -94598658,
 'A2': {'B1': -7724,
        'B2': [{'C1': [-56, -82, -48, 66, 77, -75], 'C2': -25692},
               {'C1': [126, -107, -2, 47, 45, -35], 'C2': 29173}],
        'B3': -2732591396888691710,
        'B4': {'D1': 4681661741523010583,
               'D2': 0.145680202678649,
               'D3': [-518337751, 454983193, 1056687970],
               'D4': 8},
        'B5': 56,
        'B6': [-2378117868712764925,
               -2623529227541395149,
               -3773171841112915198,
               -1514030605678953705,
               -8795921144511951381,
               8371006246098791336,
               -3018350487947069663],
        'B7': [33, -61],
        'B8': 0.2919812798500061},
 'A3': -1877743642,
 'A4': 147,
 'A5': -0.5682122707366943}

Вариант №27

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

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

(b'1AQLR\x00P\x00\x9c\x00\xe8\x014<\xd6g\xd3c\x12#FO\x01J\xe8\xc7\x00\x02'
 b'\x00\x18R\xe4\t\x00\x02\x00\x1f\x06\x7f\xbf\x00\x02\x00&\x85\x9e\x9b\x00'
 b'\x02\x00-\x1d.\xf3\x00\x02\x004B\xca\xd4\x00\x02\x00;#\x95\xfd\x00\x02\x00B'
 b'\x1a\xd8\xf1\x00\x02\x00I.\x00\x1a\x00!\x00(\x00/\x006\x00=\x00D\x00K'
 b'=\x1a\r\xdcf \x00\x02\x00d\xd0\xeb\xcf\x00\x02\x00k\x9e"\xd7\x00\x02\x00r'
 b'\xa9\x83E\x00\x02\x00y\x03O\xc8\x00\x02\x00\x80\xd2\x90w\x00\x02\x00'
 b'\x87\x10R\x16\x00\x02\x00\x8e\xc8\xebP\x00\x02\x00\x95>\x00f\x00m\x00t\x00{'
 b"\x00\x82\x00\x89\x00\x90\x00\x97{\xe7\x82\xc6\xc5I\x00\x02\x00\xb0'\xc9"
 b'\xac\x00\x02\x00\xb7\xc6\xbf"\x00\x02\x00\xbe\x97Q\xa4\x00\x02\x00\xc5\x9c'
 b'\r\x9c\x00\x02\x00\xcc\x1d\x13\xbd\x00\x02\x00\xd3#FS\x00\x02\x00\xda'
 b'\x86\xb7\xe2\x00\x02\x00\xe1`\x00\xb2\x00\xb9\x00\xc0\x00\xc7'
 b'\x00\xce\x00\xd5\x00\xdc\x00\xe3OeQS\xd3\xdf\x00\x02\x00\xfc\xbf\x90'
 b'\x08\x00\x02\x01\x03\x9cP\n\x00\x02\x01\n?\xe5\xdd\x00\x02\x01\x11\xc9'
 b'<}\x00\x02\x01\x18J\x1b\xb3\x00\x02\x01\x1f\xb2\x86f\x00\x02\x01&'
 b'\xb5\xe2\n\x00\x02\x01-N\x00\xfe\x01\x05\x01\x0c\x01\x13\x01\x1a\x01!'
 b'\x01(\x01/\xdd\x12FYV:1:\x00\x00\x00\x02\x00\x00\x01H')

{'A1': [{'B1': [{'C1': [-24, -57], 'C2': 82},
                {'C1': [-28, 9], 'C2': 6},
                {'C1': [127, -65], 'C2': 133},
                {'C1': [-98, -101], 'C2': 29},
                {'C1': [46, -13], 'C2': 66},
                {'C1': [-54, -44], 'C2': 35},
                {'C1': [-107, -3], 'C2': 26},
                {'C1': [-40, -15], 'C2': 46}],
         'B2': 1025117660},
        {'B1': [{'C1': [102, 32], 'C2': 208},
                {'C1': [-21, -49], 'C2': 158},
                {'C1': [34, -41], 'C2': 169},
                {'C1': [-125, 69], 'C2': 3},
                {'C1': [79, -56], 'C2': 210},
                {'C1': [-112, 119], 'C2': 16},
                {'C1': [82, 22], 'C2': 200},
                {'C1': [-21, 80], 'C2': 62}],
         'B2': 2078769862},
        {'B1': [{'C1': [-59, 73], 'C2': 39},
                {'C1': [-55, -84], 'C2': 198},
                {'C1': [-65, 34], 'C2': 151},
                {'C1': [81, -92], 'C2': 156},
                {'C1': [13, -100], 'C2': 29},
                {'C1': [19, -67], 'C2': 35},
                {'C1': [70, 83], 'C2': 134},
                {'C1': [-73, -30], 'C2': 96}],
         'B2': 1332040019},
        {'B1': [{'C1': [-45, -33], 'C2': 191},
                {'C1': [-112, 8], 'C2': 156},
                {'C1': [80, 10], 'C2': 63},
                {'C1': [-27, -35], 'C2': 201},
                {'C1': [60, 125], 'C2': 74},
                {'C1': [27, -77], 'C2': 178},
                {'C1': [-122, 102], 'C2': 181},
                {'C1': [-30, 10], 'C2': 78}],
         'B2': -586004903}],
 'A2': 60,
 'A3': 15449549469177300559,
 'A4': {'D1': 12602, 'D2': [86, 58]}}

(b'1AQLR\x00P\x00\x9c\x00\xe8\x014\xbb\xde\x95\xfa\xa1_}\xd2\xc1\x01J'
 b'\xccD\x00\x02\x00\x18\x9ds\xa8\x00\x02\x00\x1f g\xcc\x00\x02\x00&'
 b'\xa7\xef|\x00\x02\x00-G\x87$\x00\x02\x004\xc7i\xc0\x00\x02\x00;\xdd\xb9-'
 b'\x00\x02\x00By\x87\xb5\x00\x02\x00Is\x00\x1a\x00!\x00(\x00/\x006\x00='
 b'\x00D\x00K\x86\xf0\xbc!0\xe5\x00\x02\x00d%\xa4\xb5\x00\x02\x00k\x01\x9d\x8f'
 b'\x00\x02\x00r\x9f\x01a\x00\x02\x00y\x93H\xd6\x00\x02\x00\x80P\x0e'
 b'\x1b\x00\x02\x00\x87H\x87\x02\x00\x02\x00\x8e\xf3\xf6\xa4\x00'
 b'\x02\x00\x95\xdb\x00f\x00m\x00t\x00{\x00\x82\x00\x89\x00\x90\x00\x97'
 b'h\xba\xc4g\xcd\xd6\x00\x02\x00\xb0\x9bW\x0e\x00\x02\x00\xb7\x14A8'
 b'\x00\x02\x00\xbe\xba\xbe\xe0\x00\x02\x00\xc5\x0b(\x08\x00\x02\x00\xccF>'
 b'\xc0\x00\x02\x00\xd3\xa3\xd8k\x00\x02\x00\xda+\n4\x00\x02\x00\xe1K'
 b'\x00\xb2\x00\xb9\x00\xc0\x00\xc7\x00\xce\x00\xd5\x00\xdc\x00\xe3XFv^'
 b'\x8e\xf0\x00\x02\x00\xfc:\xfe\x82\x00\x02\x01\x03g\x92\xa6\x00\x02\x01\n'
 b'\x19PQ\x00\x02\x01\x11G\xae3\x00\x02\x01\x18J\x8aw\x00\x02\x01\x1fQ\xe6d'
 b'\x00\x02\x01&/\xd2)\x00\x02\x01-\xfa\x00\xfe\x01\x05\x01\x0c\x01\x13'
 b'\x01\x1a\x01!\x01(\x01/\x1d\\dVg\xf9\x17\xd7\x00\x00\x00\x02\x00\x00\x01H')

{'A1': [{'B1': [{'C1': [-52, 68], 'C2': 157},
                {'C1': [115, -88], 'C2': 32},
                {'C1': [103, -52], 'C2': 167},
                {'C1': [-17, 124], 'C2': 71},
                {'C1': [-121, 36], 'C2': 199},
                {'C1': [105, -64], 'C2': 221},
                {'C1': [-71, 45], 'C2': 121},
                {'C1': [-121, -75], 'C2': 115}],
         'B2': -2031043551},
        {'B1': [{'C1': [48, -27], 'C2': 37},
                {'C1': [-92, -75], 'C2': 1},
                {'C1': [-99, -113], 'C2': 159},
                {'C1': [1, 97], 'C2': 147},
                {'C1': [72, -42], 'C2': 80},
                {'C1': [14, 27], 'C2': 72},
                {'C1': [-121, 2], 'C2': 243},
                {'C1': [-10, -92], 'C2': 219}],
         'B2': 1757070439},
        {'B1': [{'C1': [-51, -42], 'C2': 155},
                {'C1': [87, 14], 'C2': 20},
                {'C1': [65, 56], 'C2': 186},
                {'C1': [-66, -32], 'C2': 11},
                {'C1': [40, 8], 'C2': 70},
                {'C1': [62, -64], 'C2': 163},
                {'C1': [-40, 107], 'C2': 43},
                {'C1': [10, 52], 'C2': 75}],
         'B2': 1481012830},
        {'B1': [{'C1': [-114, -16], 'C2': 58},
                {'C1': [-2, -126], 'C2': 103},
                {'C1': [-110, -90], 'C2': 25},
                {'C1': [80, 81], 'C2': 71},
                {'C1': [-82, 51], 'C2': 74},
                {'C1': [-118, 119], 'C2': 81},
                {'C1': [-26, 100], 'C2': 47},
                {'C1': [-46, 41], 'C2': 250}],
         'B2': 492594262}],
 'A2': -69,
 'A3': 16039001218948649665,
 'A4': {'D1': 6103, 'D2': [103, -7]}}

Вариант №28

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

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

(b'VXRLv?{\x86?\x00\x06\x00\x00\x00Xcsnwsefi\xbf\xe7.\xe4W\x0c\xb5\xc6\x00'
 b'\x00\x00\x99\x08!e(\xa0\x1f\x10C\xedp\xf1\xf2\x18\x86\nc\xbc\xeaU\t|'
 b'\xe3J&\xdb.D\x19\xcfx|H\xe4\xb9\xde\t\xd5\xe6\xde\x99\x9f\xb8\xa2\xaa\xfc'
 b"\x84\xda\xfbj\xe2z\x7fC\x00(\x000\x008\x00@\x00H\x00P\x19'\xe0\xb5i\x8d\x9b9"
 b'\xa5W\xf1Q\xd1C\xc1\x86j\xbf\xe5\xf6\xec\x1e\x02\xf7\\\xbf\xde\xa3'
 b'\nm\x92\xdd\x00?b\xd2\xc5\x8e\xf4\xddv)y7t\x00\x03\x00d\xa5\xf9\xd5c\xe0+('
 b'\x00p\x00\x00\x00\x02\x00\x95\x8f\x94\xf5VD\x1a\xf0\xc8\x1f\x85\xef\x1e')

{'A1': 0.9825171828269958,
 'A2': [{'B1': 521159661, 'B2': 1894904344},
        {'B1': 2248827836, 'B2': -363525764},
        {'B1': 3813287643, 'B2': 776214991},
        {'B1': 2021411044, 'B2': -1176630827},
        {'B1': 3873347999, 'B2': -1197298948},
        {'B1': 2228943722, 'B2': -495288509}],
 'A3': 'csnwsefi',
 'A4': -0.7244741153896761,
 'A5': {'C1': -8149,
        'C2': 40,
        'C3': {'D1': -784088698,
               'D2': 106,
               'D3': -0.6863918863452727,
               'D4': -0.47870121670298715,
               'D5': 0.8860285878181458,
               'D6': 2398412150,
               'D7': 695809908,
               'D8': [422043829, 1770887993, 2774004049]},
        'C4': [42489, 54627],
        'C5': [2408904022, 1142616264, 528871198]},
 'A6': 136406312,
 'A7': -96}

(b'VXRLv?:G\x8a\x00\x06\x00\x00\x00Xcnoquiur?]\x83\x18Q\xcc\x04\x00\x00'
 b'\x00\x00\x95\n\t\x9e\x11\xb7\xec\x95>\xbc\x00\xbd\xaa\x90\x06[M\x91.f$\xef'
 b'\x83\x89\xa0\xb6X\r\xc1\x89\x80i^\x8dn\xb4`\xbf\xa8\xd0=c\xc8\xf4\xe3\x1b'
 b'\xf0\xa4\xb1\x86C\xd2\rj\x00(\x000\x008\x00@\x00H\x00P\xc70\xc4\xf8'
 b'\x0f\xb5+\xd3\xd8|\xd7\x8a\x04?\xb6\xc6p\xba\x8c\x03\x90\xbf\xe9\xb5'
 b'\x7f_\xbfp\x02\xbf2N\xb6\xa2\x02\xa3\xdf\xf3\xa2?\xd8\x00\x02\x00d@gS}Nu\xad'
 b'\x00l\x00\x00\x00\x02\x00\x91T\xe7%>D\xcf\xe0\xe5\xb8Vv\x11')

{'A1': 0.7276540994644165,
 'A2': [{'B1': 3969203900, 'B2': 12429968},
        {'B1': 106646929, 'B2': 778446063},
        {'B1': 2206834870, 'B2': 1477296521},
        {'B1': 2154389133, 'B2': 1857315007},
        {'B1': 2832219491, 'B2': -923475173},
        {'B1': 4037325190, 'B2': 1137839466}],
 'A3': 'cnoquiur',
 'A4': 0.0018012750144296152,
 'A5': {'C1': 20085,
        'C2': -83,
        'C3': {'D1': -662906998,
               'D2': 4,
               'D3': 0.08896545938843148,
               'D4': -0.8034054632257723,
               'D5': -0.6965135335922241,
               'D6': 2718082015,
               'D7': 4087496664,
               'D8': [3341862136, 263531475]},
        'C4': [16487, 21373],
        'C5': [1424434494, 1154474213, 3092674065]},
 'A6': 168402449,
 'A7': -73}

Вариант №29

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

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

(b'WLIR\xc8\x17t\x8f\xb3\xf9\xbd\xaa\xe1zwgof\x02\x00\x89\x00\x00\x00'
 b'\x0c\xca*\xa4\xe3T\xe2\xc1p\x13\x93\xc1}\x05\xab\x87;\xd0s\xce-\x04\x00!'
 b'\x00\x00\x00\x02\x00)\x00\x00\x00\xc2\x95\x0c\x85\x19\xfd\xef\xbf\xe8\xdb<'
 b'\x9a>$K\xb4U4\x13?:\x15\xd0h\x9d\xac-\x00\x00\x00\x85a\xd3A\x94\xa3)\xee\x02'
 b'\x00W\x00\x00\x00\x02\x00[\x00\x00\x00D\x07H\xc8\x9c\x10\xd7\xbf\x9d\x91cMX'
 b'Gv\xcc\xc6\xb3=\x8b\xf8\xae?\xda\x16\x94_\x00\x00\x00K\x00}\x00')

{'A1': 12303264306647275464,
 'A2': {'B1': 225, 'B2': 'zwgof'},
 'A3': [{'C1': -6008531084923748589,
         'C2': {'D1': [37651, 32193, 43781, 15239],
                'D2': [29648, 11726],
                'D3': -0.9996459578148278,
                'D4': [56296, 39484, 9278],
                'D5': 46155,
                'D6': 85,
                'D7': 52}},
        {'C1': -7775787739555263683,
         'C2': {'D1': [24965, 16851],
                'D2': [41876, 60969],
                'D3': -0.3603889423248925,
                'D4': [37277, 19811, 18264],
                'D5': 52342,
                'D6': 198,
                'D7': 179}}],
 'A4': 12,
 'A5': 8125024056977402570}

(b'WLIRdFm\xb9\x19dKp\xadafqkq\x03\x00\xbb\x00\x00\x00\xa7mnBH\x8cX\xf2'
 b'\xe3l\t\xf7\x93\x11Kr\xfe\x02\x00!\x00\x00\x00\x02\x00%\x00\x00\x00\x8e\x7f7'
 b'\xbepS\xe4?Ke\xd2\x7f\xc8bYN\x90\xc3\xa9\x93\x80_6\xff\xfb[)\x00\x00\x00\xed'
 b'\xcds\x9d\xaaI\xbb\x9b\x02\x00S\x00\x00\x00\x02\x00W\x00\x00\x00\xc8'
 b'\xe0\xe1\x81VE\xe0?\x81\x12\xa4\xaf\xe5U;\x9dE\xb1\xc2\x08!-\xe9\xee\x8a'
 b'\n[\x00\x00\x00\x13\xf35\x85\x12p\xa0\xd7\x94\xfc\xd6g\x04\x00\x85'
 b'\x00\x00\x00\x02\x00\x8d\x00\x00\x00\xb2\x06w\xe8\xd0\xac\xeb'
 b'\xbf\x85\x16\xab<C?\xaf\xd0M\xbc\x10ne\xf9\x10\xd0(\xd5\x91\x00\x00\x00G'
 b'\x00y\x00\xaf\x00')

{'A1': 8091671217149134436,
 'A2': {'B1': 173, 'B2': 'afqkq'},
 'A3': [{'C1': 6628171885601395625,
         'C2': {'D1': [2412, 37879],
                'D2': [19217, 65138],
                'D3': 0.6351855960056001,
                'D4': [25931, 32722, 25288],
                'D5': 20057,
                'D6': 144,
                'D7': 195}},
        {'C1': 759682172417280194,
         'C2': {'D1': [52717, 40307],
                'D2': [18858, 39867],
                'D3': 0.5084641014828089,
                'D4': [4737, 44964, 21989],
                'D5': 40251,
                'D6': 69,
                'D7': 177}},
        {'C1': -3086988773240246768,
         'C2': {'D1': [62227, 34101, 28690, 55200],
                'D2': [64660, 26582],
                'D3': -0.8648457088786101,
                'D4': [5765, 15531, 16195],
                'D5': 53423,
                'D6': 77,
                'D7': 188}}],
 'A4': 167,
 'A5': -2021455923204952467}

Вариант №30

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

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

(b'RMEK~\x00\xe1\xae\xc5\x1b\x9e<\xd5Pa\x0f\x89,\xc2\xed\xb9W\x03\x06'
 b"\xee.\xcc\xd8\xae\xa7\xd4>\xdd'\x92B$n\xaa\xa1%\xd9;u\xbf\xcak\xb9\xe3S\rw"
 b'\x13\x00\x93\xc8hR\xf6\xb9l(\x1f\xc1C\xf2|\xf9\x1b\x01\x9b\xcf'
 b'\x0e\xa6\x01\xc4&\x08\xfd\x82\xc8P0\x9d\xb9\xe3\xb7?\xbb\xbf.\x18'
 b'v\x1c\xf6\x89\x07\x08@\xe6\x18\xa9R\xc6/$\x06G\xbb?\x00.\x8d\x9e\x1a\xd7'
 b'\xbc_\x00@u\x05\xf8\xed\xbd\xbf\xc1+\xe6a.\x00\x97A\x1a\xb5\x88>i\x02'
 b'\x00\x00\x006\x00\xd2\xb1\xf6\xfc?\xf2\xab\x91\xeb\xc3\x90\x87t>\x08'
 b'\x14\xc0\xfc\xd7Om\x13q\xbfi')

{'A1': {'B1': {'C1': 1642474433,
               'C2': {'D1': -18069,
                      'D2': 1997362147,
                      'D3': {'E1': 47597,
                             'E2': 855,
                             'E3': 60934,
                             'E4': 46,
                             'E5': 2872521220399487180,
                             'E6': -2799653839976512878,
                             'E7': -893422277}},
               'C3': 16791,
               'C4': 0.26700669527053833},
        'B2': 105,
        'B3': [{'F1': [2912907526597560467,
                       79931733444903199,
                       587372312778428315],
                'F2': 1355318013,
                'F3': -0.10644101438230247},
               {'F1': [578582767272859694,
                       2607520767597405760,
                       11424838408312932102],
                'F2': 1606211354,
                'F3': -0.11691236623050827}],
        'B4': [-50941486, -1851002305, -2020555797, 336084596, 1339555008],
        'B5': -0.941702663898468,
        'B6': 105},
 'A2': 5824628342842044129,
 'A3': [97, 15, -119],
 'A4': -15828}

(b'RMEK~\x00\x1bm\xd0\x9c\xe4]{\x11X\xb2\xeeM\xb68^y\xc2km\xcb\xf8\x14'
 b'\x83\xd6f\xd5\x19w\xd7\x07q\xa8r\xd3\xe2oR3\x81Gm\x13r\xc8:u\x13\x00\x1ai'
 b'\t_91oqM\x94\xcf\xef\x88\x1c\xf3q\x96\xfb\xcb.\xa4\x12|\xda\xad\x9cdC \xbe'
 b'M\xa202\xc6?\xe4\x9dZ\xeb\xf3_k\x04\xac@\xc2\x94R\x95\xf6\x9e6\xd7'
 b'\xa7\x00\x14U\xb1\xd9\x8b\t\xc0\xf8\x14\xf6JD\xd6\xa7\xd6\xbf\xb1\n'
 b'\x81\xb8.\x00\x92\xc8\xe5e\xbc\xbd \x02\x00\x00\x006\x00C\xebK5\xe4\xfd\xd0'
 b'(\x00\xa6(\xbd\xa34[\x87+-Y)\x17\x14Q\xbe\x06')

{'A1': {'B1': {'C1': -1199502671,
               'C2': {'D1': 4973,
                      'D2': 1966786674,
                      'D3': {'E1': 24120,
                             'E2': -15751,
                             'E3': 28011,
                             'E4': -53,
                             'E5': 8582125202593486072,
                             'E6': 8062238772352321495,
                             'E7': 1199649618}},
               'C3': -14190,
               'C4': -0.09199122339487076},
        'B2': 32,
        'B3': [{'F1': [8173805971178088730,
                       8210937920091034701,
                       15743478893749468054],
                'F2': 1130667181,
                'F3': 0.17340667653069008},
               {'F1': [318453699890028004,
                       11454506884179050668,
                       15686412521506854710],
                'F2': -121632373,
                'F3': -0.3539939562723202}],
        'B4': [894167875, 684785124, -1121409536, -2024065885, 693710123],
        'B5': -0.20417819917201996,
        'B6': 6},
 'A2': 1259703757245017371,
 'A3': [88, -78, -18],
 'A4': -18867}

Вариант №31

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

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

(b'VTNH\x9e<\x00\x00\x00\x84\x96\xb3:z%>\xbe\xbe\x0f?:\xdc\x12\xae'
 b'\xa7\xbc\xda\x00\xb3\xa9\xef\x92\xb9X1\xf8\xf1&\xb1U\x1cv_\xb6\\\xe5\xa2\xf3'
 b'\x89\xe7=\xcc\xd7\x00\xc2a(g\xa1\xee\xef\xbd\xfeze\x8e@.;*\xfc+J\x1e\x17\x84'
 b"Q\xc9\x8c\t\xc6\x1a$\xb4\x07@\t\x01R2z\xcd\x0cyK\xf9H\x96p\x00\x00\x00'\x00"
 b'\x00\x00E\x1a{\xf9[?\xe2F\x9ahP\xe2\xf6\x00\x02\x00\x00\x00k\xd9\xa0+'
 b'\x93Xr\xab\x00\x02\x00c\x00\x00\x00o\xbf\xef\x96\xe2\xe75  \xa9]\xcab'
 b'\x94U,\x8e?\xec\xbb\xb7\x043\x8c\x9e\x00\x00\x00\x02\x00\x82/\xf2'
 b'\xd8\x8a\xbfm\xf2\xb3\xff|\xd6?\x8aS\x07@\xb6\xf0\x10')

{'A1': {'B1': 60,
        'B2': {'C1': [{'D1': 6132906946025285026,
                       'D2': [62345, 59197, 52439, 194, 24872, 26529],
                       'D3': -1229555272576037312,
                       'D4': 46,
                       'D5': 59},
                      {'D1': 3097398241056490577,
                       'D2': [51596, 2502, 6692, 46087, 16393, 338],
                       'D3': 3637445102513420616,
                       'D4': 150,
                       'D5': 112}],
               'C2': {'E1': 0.571118549100986,
                      'E2': [6779, 63835],
                      'E3': 217,
                      'E4': 2687210328},
               'C3': -0.9871687427303222,
               'C4': 43357,
               'C5': -899509163,
               'C6': 11406,
               'C7': 0.8979144174631022,
               'C8': {'F1': [114, -85],
                      'F2': 804444298,
                      'F3': -0.9294845461845398,
                      'F4': -1}},
        'B3': 2528328314,
        'B4': 9534,
        'B5': -0.3712100684642792,
        'B6': 15068},
 'A2': 18,
 'A3': 2930228442,
 'A4': {'G1': 2094415754, 'G2': 21255, 'G3': 1085730832},
 'A5': 12245167236589943025,
 'A6': 9905}

(b'VTNH\x9e\x1a\x00\x00\x00\x85\x14\xb9L\xdc\xaa{?24\x9a\xd9\xa8\xf3x'
 b'\xfa7\xdc\x00\xb43\x97\x01\xa0\xd0\xe5D\xf1\x04\xd5\xe4\xb3\xbd\x8a\x95'
 b'\xd0\x9b\x95\x9d\x0c\xb6 "D4\x98\x8f\xc4\x1d\x98lSr)\x02\xe4D\x15\xca'
 b'\x85\xd0Vfg|c\xd0\xbb{\x7f\x0fW\xf1Z\x98\x1f\xee\x1d\xf4\xbeXM\xc5%mou'
 b'Y"\x7f\x00\x00\x00\'\x00\x00\x00EJ\xe5\xe8\x18\xbf\xee((\x82\x0e\x91\xd6\x00'
 b'\x02\x00\x00\x00k\x98F^\x96\x06\x13u\xc3\x00\x02\x00c\x00\x00\x00o?\xd7U'
 b'\xbf\xf64#\x00v\xcf\xcd\x15d\xeb\xca0?\xe4:\xe1\xcb\xb9]\x90\x00\x00\x00'
 b'\x03\x00\x82\xc0Iw\xbb\xbcr/\x94.\xabq\xcb{\xb6\xda\xe3\x8a\xe9I')

{'A1': {'B1': 26,
        'B2': {'C1': [{'D1': -1967020209314161771,
                       'D2': [40204, 46624, 8772, 13464, 36804, 7576],
                       'D3': 7805708099630941205,
                       'D4': 202,
                       'D5': -123},
                      {'D1': -3434445071168843589,
                       'D2': [31615, 3927, 61786, 38943, 60957, 62654],
                       'D3': 6362958613084861785,
                       'D4': 34,
                       'D5': 127}],
               'C2': {'E1': -0.9424021282362058,
                      'E2': [19173, 59416],
                      'E3': 152,
                      'E4': 1180603910},
               'C3': 0.36460875552488403,
               'C4': 30415,
               'C5': -854235925,
               'C6': 51760,
               'C7': 0.6321877459512724,
               'C8': {'F1': [19, 117, -61],
                      'F2': 3226040251,
                      'F3': -0.014781851321458817,
                      'F4': 46}},
        'B3': 347688156,
        'B4': 43643,
        'B5': 0.6961151361465454,
        'B6': -9816},
 'A2': -13,
 'A3': 2029664220,
 'A4': {'G1': 2876361595, 'G2': 46810, 'G3': -477435575},
 'A5': 3717441807628715249,
 'A6': 1237}

Вариант №32

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

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

(b"JTNQ\x0cQ\x00u\xbc#\xbd,6t\xea'\x82q\xbf\x02\x00\x00\x00l\x00\x16\x03\x00"
 b"\x00\x00p\x00'\x04\x00\x00\x00v\x00U\x05\x00\x00\x00~\x00\xfd\x06"
 b'\x00\x00\x00\x88\x00\xce\x04\x00\x00\x00\x94\x007\x07\x00\x00\x00\x9c\x002'
 b'\x06\x00\x00\x00\xaa\x00$|}fSla\x02\x00\x00\x00O\x00\x00\x00\xa8\xc6+'
 b'\x98g\xe0\xcd?0\xd6\x17\x1f\xe1b\xec\xbfxxwE\xac\x1a\x91\xe8^\xc2\x0c'
 b'T\xcf\xa4^\xf7y\xfc\x85\x14\x98\xb3\xd5?.\xd5b\xb3\xe7\r\xf3\x8b\x90>\x12'
 b'x\xe0\x1f\x15@\x0e\\\xd2\xad\xb4%t\x91\xa3:\x1c\xe7\x11\xfbH\x05\x10\x87)'
 b':X\x02e~\x8d\x0f\xa0B\xf0I\xd6\xb2\x9dk\xad\xcc\x13')

{'A1': {'B1': 'la',
        'B2': 0.23341078691696748,
        'B3': -0.8870702369010299,
        'B4': 'xxw'},
 'A2': {'C1': 3173235829, 'C2': -361482708},
 'A3': -0.9433922171592712,
 'A4': [{'D1': [44101, 37146], 'D2': 22},
        {'D1': [24296, 3266, 53076], 'D2': 39},
        {'D1': [24228, 31223, 34300, 38932], 'D2': 85},
        {'D1': [54707, 11839, 25301, 59315, 62221], 'D2': -3},
        {'D1': [37003, 4670, 57464, 5407, 3648, 53852], 'D2': -50},
        {'D1': [46253, 29733, 41873, 7226], 'D2': 55},
        {'D1': [4583, 18683, 4101, 10631, 22586, 25858, 36222], 'D2': 50},
        {'D1': [40975, 61506, 54857, 40370, 44395, 5068], 'D2': 36}],
 'A5': 1399225724}

(b'JTNQ\x0cQ\x00X0\x1f\x98\x9d\x83\xcbN{\x16\x03\xbd\x06\x00\x00\x00l'
 b'\x00\xcd\x04\x00\x00\x00x\x00\xe4\x07\x00\x00\x00\x80\x00&\x06\x00\x00\x00'
 b'\x8e\x00\x93\x06\x00\x00\x00\x9a\x00n\x03\x00\x00\x00\xa6\x00'
 b'\xa3\x07\x00\x00\x00\xac\x00{\x05\x00\x00\x00\xba\x00\xbf\xd9aB\xa8t'
 b'f\x02\x00\x00\x00O\x00\x00\x00H\x9e=\x91.(\xc8\xbf\x14\xe35\xab\xda\xe9\xe4'
 b'?yoi%\xc6\xb7E\x0c\xad&S[\x8e\x02LK\xc7\xa9\x8e\x86\x7fb\xd5\xa9\x8a\xdb\xd6'
 b'jU\x13\x9c\xc6\x15\xac\xfe\xe5V\xfd\xd2F\xd2\xe3\xa9/7\x9b\x10_\xfe\xf5b'
 b'C\xfa\x1c\xda\xcf\xc0I\x8f\x10\xa1OB\x97)\xf4\x8e\xd7\xee]l\xfd\xd0\x16\xe8'
 b'\x18\x9c!\xf2i\xaf\xe7;\x95\x1b\x15*\x05\xc4bz')

{'A1': {'B1': 'tf',
        'B2': -0.188726254385289,
        'B3': 0.6535466522173885,
        'B4': 'yoi'},
 'A2': {'C1': 2552180824, 'C2': 1321960349},
 'A3': -0.03200386092066765,
 'A4': [{'D1': [50725, 17847, 44300, 21286, 36443, 19458], 'D2': -51},
        {'D1': [51019, 36521, 32646, 54626], 'D2': -28},
        {'D1': [35497, 55003, 21866, 39955, 5574, 65196, 22245], 'D2': 38},
        {'D1': [54013, 53830, 43491, 14127, 4251, 65119], 'D2': -109},
        {'D1': [25333, 64067, 55836, 49359, 36681, 41232], 'D2': 110},
        {'D1': [16975, 10647, 36596], 'D2': -93},
        {'D1': [61143, 27741, 53501, 59414, 39960, 61985, 44905], 'D2': 123},
        {'D1': [15335, 7061, 10773, 50181, 31330], 'D2': -65}],
 'A5': 2822922713}

Вариант №33

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

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

(b'JABL$\x00\x03\x00[\x00a\x00\x8a^^%\x92?\x11\x96\xec;\x1b5\xbb\xce\xde?'
 b'x\xe8\xb0\xfeD\xc8\xb2\x9dnSI\xbes\x9d\xc68\x1a9\xf1\xa1\x9a\xcc\x14\xad'
 b'\x05)y\x04nO\x9f#\xb7z\xc5\xd3vv\x02\x00@\x00_za\x02\x00G\x00\x19kpitso'
 b'ks\x08\x00N\x00AB\x00I\x00V\x00\xabP\rS\xbfP\r`Z\x84\x07}\x87\x05M:\xf49\xd1')

{'A1': {'B1': -0.1966073215007782,
        'B2': 11669170894278139251,
        'B3': 322333952689097882,
        'B4': -3187006234299510930},
 'A2': [{'C1': 'vv', 'C2': 95},
        {'C1': 'za', 'C2': 25},
        {'C1': 'kpitsoks', 'C2': 65}],
 'A3': {'D1': -85,
        'D2': -0.8244218826293945,
        'D3': [3408, 23136, 1924, -30851, 19717, -3014, -11975]},
 'A4': -7633249996491563382,
 'A5': 0.4813678759209654,
 'A6': [120, -24, -80, -2, 68, -56, -78, -99]}

(b'JABL$\x00\x02\x00P\x00T\x00\x88\x1e\x04\x8fzbG\xa9\x80\x13Q\xe7'
 b'\r\xfa\xda\xbf\xb2\x83(;\xa4\x88\x1b\xe6\xaa~\xc3=-gP( \x1bT\xc2-\xd8Y\xf7'
 b'g\x0e\xd4\x8b\xdfTi\x83JWW\x85kawo\x04\x00@\x00\xc4ic\x02\x00I\x00\xaf'
 b'D\x00K\x00N|\xd17\xbe\x8exw\xe0\xbe\x98X\x8b\x93\xe9\xacK&\x12')

{'A1': {'B1': 0.09545643627643585,
        'B2': 14002846966330976045,
        'B3': -8371049967680628691,
        'B4': -8838499766147394337},
 'A2': [{'C1': 'kawo', 'C2': -60}, {'C1': 'ic', 'C2': -81}],
 'A3': {'D1': 78,
        'D2': -0.17951005697250366,
        'D3': [30862, -8073, -26434, -29864, -5741, 19372, 4646]},
 'A4': -6248917679428329848,
 'A5': -0.42151210393449645,
 'A6': [-78, -125, 40, 59, -92, -120, 27, -26]}

Вариант №34

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

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

(b'WGDFUk*\x19\x84|\x0e)?\xd2t,?\x8f\xad\xd4\xbf\x07-\x9fN}\xceO\x0e\x8c!C'
 b'\x00\x00\x00\x02\x00\x8b\xd7%5\x92f\x08\x85\xa8\x00\x00\x00\x97\xbf\xe4'
 b'\xfapR\xcd\x1e^\r\xdb=\x9f\xb9\xad>\xc8\xaa\xad?c\x12#>\xcb\x8c\xe3?#\xd8V'
 b'\x1c5l\xcd\xe2\x00\x05\x00<\xbf&\x90\xe3\x96\x00\x05\x00\x00\x00P'
 b'\xbe\x9e%\xab>\xbd\x85\x97>\xc3\x9c\xba\xbe\x81\x18\x82\xbfm\x8f^'
 b'h\x07\x98\xe3\x00\x05\x00d>}Z\xacb\x00\x04\x00\x00\x00x\x00\x00\x00U\x00'
 b'\x00\x00|\xf0\xea&\x1fc\x83\x00\x00\x00\x02\x00\x00\x00\x93a')

{'A1': 1433086489,
 'A2': -2072244695,
 'A3': 0.2883406277385039,
 'A4': {'B1': -0.5280398726463318,
        'B2': 5655903545989013827,
        'B3': [{'C1': [0.07799086719751358,
                       0.39192715287208557,
                       0.8869954943656921,
                       0.397559255361557,
                       0.6400197744369507],
                'C2': -0.650648295879364,
                'C3': 150,
                'C4': [28, 53, 108, -51, -30]},
               {'C1': [-0.30888113379478455,
                       0.3701598346233368,
                       0.3820551037788391,
                       -0.2521401047706604,
                       -0.9279688596725464],
                'C2': 0.2474161982536316,
                'C3': 98,
                'C4': [104, 7, -104, -29]}],
        'B4': -2943887878523419224,
        'B5': {'D1': 25475, 'D2': [61674, 9759], 'D3': 97}},
 'A5': -0.6555711381160554,
 'A6': 3547}

(b'WGDFm>\x1cZ\x8e\xd6\xd3)?\xc9\x15\xf3\x9d/\xc5\xb0?:\xd6\xa1\x8a)X\xe5'
 b"\xa6#\xd8\xdf\x00\x00\x00\x02\x00uO\xe2\x9d'\x14\x8dUA\x00\x00\x00\x85?\xa5"
 b'78\xd1\x86h@\xb7\xff\xbf"\xa4\x8f?\x11]\xc1\xed\xb4\xb6A\xbas\x00\x02'
 b'\x00<\xbe\xa2\r\tu\x00\x06\x00\x00\x00D?\x03E\xdb?{\xe4\x9dz5B5?\x00\x02'
 b'\x00Y\xbe]a\xc7\xd8\x00\x05\x00\x00\x00a\x00\x00\x00J\x00\x00\x00f75\xe1'
 b'\x1eO\xa5\xe0\xben\x19\x00\x00\x00\x04\x00\x00\x00}\x93')

{'A1': 1832787034,
 'A2': -1898523863,
 'A3': 0.1959824101937051,
 'A4': {'B1': 0.7298374772071838,
        'B2': 9955586194637314271,
        'B3': [{'C1': [-0.6353234648704529, 0.5678368210792542],
                'C2': -0.31650570034980774,
                'C3': 117,
                'C4': [-19, -76, -74, 65, -70, 115]},
               {'C1': [0.5127846598625183, 0.9839571118354797],
                'C2': -0.2161933034658432,
                'C3': 216,
                'C4': [122, 53, 66, 53, 63]}],
        'B4': 5756336064907007297,
        'B5': {'D1': 28185, 'D2': [14133, 57630, 20389, 57534], 'D3': -109}},
 'A5': 0.04143693502119605,
 'A6': 47103}

Вариант №35

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

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

(b'\xd3FSYK\x00\x00\x00f\x00\x02\x00\x86\xde\xbf\xeb\xc7\x08a\xcc\xb5\xf04c'
 b'\xaf\xf2\xdd\r\x01w\x88I\x8b2\xeaj\xba4\x9a\xfbB\x0b\xb9\x1e>\x87"e'
 b'\x07\xed?(\x8e\xd5\x00\x00\x00\x02\x00\x00\x00$\xb2\x0e\x15\t\xfboz`\x99\x19'
 b'\xb4W\xd4\xbf(3Eb\xf0?R\xe7I\x00\x00\x00\x02\x00\x00\x00C>\xa5\xe6\xdeD\x00,'
 b'\x00KKN\x95\x1d\xf6d\x1a\xcd\xa2^\x00\x02\x00\x00\x00b=\x98b\x05\xbd\xaf'
 b'&\x98\xbf\xea\xf4\xde\xb9\x9c\x99\x9a\xe4\xb0\xc4\xeb')

{'A1': {'B1': 5426438556948372173,
        'B2': 41566,
        'B3': [{'C1': {'D1': 0.26393428444862366, 'D2': 2029},
                'C2': 0.6584294438362122,
                'C3': [3124009723, 1108064542],
                'C4': [-78, 14, 21, 9, -5]},
               {'C1': {'D1': -0.657032310962677, 'D2': 25328},
                'C2': 0.8238416314125061,
                'C3': [1870291097, 431249364],
                'C4': [62, -91, -26, -34, 68]}],
        'B4': 0.07440570741891861,
        'B5': -0.08552283048629761,
        'B6': -0.8423913598278887},
 'A2': [-6992, -15125],
 'A3': 222,
 'A4': -0.8680459890508114,
 'A5': 3775054370292171127,
 'A6': {'E1': -30647, 'E2': 35634, 'E3': -5526}}

(b'\xd3FSYK\x00\x00\x00f\x00\x02\x00\x86\xf8\xbf\xd7\xf9j\xbc+Jd: \x88\xf1;\xec'
 b'c(\xaa\x13^\xaf\x9cL\x1d\xf5\xb9\rR\xd4\xb8F?~\xb7\x90zz\xbf\x01'
 b'(\xa5\x00\x00\x00\x02\x00\x00\x00$\xf6\xc0\x84\xcc\x8a\xb5\xae\xdaa\xf9'
 b'\xacJ\xf7\xbfT\xd1\xcdx\xd2\xbe\xfc\xe1\x13\x00\x00\x00\x02\x00\x00\x00'
 b'C#\xb4l_3\x00,\x00K!\xe4-\xcbO\xe8\x80p\xaez\x00\x02\x00\x00\x00b\xbe\xd7'
 b'5\x0c?S\x8d\x0c\xbf\xe7\x82\xe3\xcfx}\xca2\xeeJ\xbc')

{'A1': {'B1': 2442127249183899760,
        'B2': 44666,
        'B3': [{'C1': {'D1': 0.9949884414672852, 'D2': 31354},
                'C2': -0.5045264363288879,
                'C3': [502642957, 1389672518],
                'C4': [-10, -64, -124, -52, -118]},
               {'C1': {'D1': -0.8313263058662415, 'D2': 30930},
                'C2': -0.4939046800136566,
                'C3': [3048135265, 4188818167],
                'C4': [35, -76, 108, 95, 51]}],
        'B4': -0.4203265905380249,
        'B5': 0.8263709545135498,
        'B6': -0.734727769104148},
 'A2': [13038, 19132],
 'A3': 248,
 'A4': -0.37459820152176904,
 'A5': 4188498223128404776,
 'A6': {'E1': -21997, 'E2': 24239, 'E3': -25524}}

Вариант №36

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

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

(b'YAD8bku\x08\x00\x00\x00\x02\x004Y]\x0fL\xc1\xe2in6\xc9\xbf\xc2\xbf\xba'
 b'#\xac\xf2\xe9\x8f\xb0\x00\x00\x00H>0\x0f\xf1\x80\x98\x89\xbf\x01\xc1'
 b'\xc39\xc7\x94\x00&\x00-8\x1533\xf94Ihi\xd4>\x99X\xf9\x93s\xa2S\xae\x03'
 b'\x0e[n@\xdcq\xeb_/\x12q\xffy|\xfa\xd1]\x94\xd5D\x00\x02\x008\xbfFbL')

{'A1': {'B1': 'bk',
        'B2': 29960,
        'B3': [{'C1': 0.1719358116388321, 'C2': [-128, -104, -119]},
               {'C1': -0.5068628191947937, 'C2': [57, -57, -108]}],
        'B4': 1499270988},
 'A2': 13970844916143210434,
 'A3': -0.10210686617352738,
 'A4': {'D1': [-1571574269, 240873024, -596513953, 789737983, 2038233809],
        'D2': 1570035012,
        'D3': [4041192538952190312, 7625788897388761971],
        'D4': -0.7749373912811279}}

(b'YAD8zj\xe3\x0c\x00\x00\x00\x05\x00I\xfc;\xf6\x00W\xa5\xa3\x9f\xc6\x99'
 b'\x15Q\xbf\xdc8r<]\xce<\x00\x00\x00k?>\x88\x0bm\x19\xae>\xfdr\xce}n\x87'
 b'>k[\xe1\xf2K&>\xcbN\x1c\x91\xfb&\xbd\xbe\x06\xa73\x90\x10\x00&\x00-\x004\x00'
 b';\x00B\x94\xe3\x1cP\xa94>\xac\x1c\x1ak\x04\xea\x0b\xb5&@.\xbds\xbc'
 b']\xf9\xc3\xbe\xfdU"6\xeb\xfe`\x9e4\x8e\x04AL\x8a\xcf\x90\x14\xc8.\xe3'
 b'8\xd7\x97\x00\x03\x00S?\tFB')

{'A1': {'B1': 'zj',
        'B2': 58124,
        'B3': [{'C1': 0.7442633509635925, 'C2': [109, 25, -82]},
               {'C1': 0.49501651525497437, 'C2': [125, 110, -121]},
               {'C1': 0.2298426777124405, 'C2': [-14, 75, 38]},
               {'C1': 0.39708030223846436, 'C2': [-111, -5, 38]},
               {'C1': -0.09278612583875656, 'C2': [51, -112, 16]}],
        'B4': -63179264},
 'A2': 6315633959084037457,
 'A3': -0.44094520468863485,
 'A4': {'D1': [-1090693854, 921435744, -1640722940, 1095535311, -1877686226],
        'D2': 3812153239,
        'D3': [-7718294203621163348, 2025048651307136294, 4624842172135242179],
        'D4': 0.5362282991409302}}

Вариант №37

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

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

(b"YEX!?\xbc\xda\xf2}\xfc\xd6pd)L\x13\x1bQ\x0c'\x9f\x05?\x19\xda'\x94h"
 b'<\xae\xca\xe1u\xf6\xbf\x00\x8d\x14\xb9\xf4=4\x93\x96fS\xbf\x7f'
 b'\xa1\xce\xe7\xd8\xbf>\xfc\xb4\xa0-\xbf|f+\xee\xec\xbf\x03k|\x00~k\xc0'
 b'>\xec\x1cA\xb8e\xc2J\xeeB|w[\xdc\x92\x9b\xbf,~\xd2\xbe\x97\xaad?c]\x9d'
 b'\xbd\x8co\x02>\xdeI\xd3\xbf J\x8e?\n\x91\xc8?Z\xb5\xc7sbmklo\x00\x06'
 b'\x00x\xa5')

{'A1': 0.1127158696734456,
 'A2': 7217383522784316455,
 'A3': [{'B1': 40709, 'B2': 0.6009849905967712},
        {'B1': 37992, 'B2': 0.021336974576115608},
        {'B1': 30198, 'B2': -0.502152681350708},
        {'B1': 47604, 'B2': 0.04408606141805649},
        {'B1': 26195, 'B2': -0.9985626935958862},
        {'B1': 59352, 'B2': -0.7460434436798096},
        {'B1': 41005, 'B2': -0.9859339594841003},
        {'B1': 61164, 'B2': -0.5133588314056396}],
 'A4': {'C1': 'sbmklo', 'C2': -91},
 'A5': {'D1': 27584,
        'D2': 0.4611530601978302,
        'D3': [-1201290678, -297632649],
        'D4': 1541182107,
        'D5': [-0.6738101243972778,
               -0.29622185230255127,
               0.8881471753120422,
               -0.06857110559940338,
               0.43415698409080505,
               -0.6261376142501831,
               0.5412869453430176,
               0.8543362021446228]}}

(b'YEX!?\xd5Wa\xdc\x85,d\xb2\xe8\xc2dj\x907N?b>s\xda14\x99\xbfR\x1c6'
 b'\x17%\xbf\x03\xe6\x16\xb5\xed?Y\xd4\x83\xb8\xa2\xbfp\x11\xe3`\x01'
 b'\xbe\x81W\xcb\xa4\x03?\x1b:\xec\xe1\x08\xbeW\xb9:\x00ziw?%\xd6/\xe51\xa2N'
 b'\xd97\xbf\xd8w2n ?Q \xa7\xbfk\xd4\x96\xbe\xa5;\xc3\xbf\x19j\x98=\xf8\xff\xa3'
 b'\xbe\x95\xd5%\xbfcWd\xbe(\xf6\x01jl\x00\x02\x00x\\')

{'A1': 0.3334583905713713,
 'A2': -5554976403821152434,
 'A3': [{'B1': 16226, 'B2': 0.23813702166080475},
        {'B1': 13465, 'B2': -0.8207429647445679},
        {'B1': 5925, 'B2': -0.5152295827865601},
        {'B1': 46573, 'B2': 0.8508989214897156},
        {'B1': 47266, 'B2': -0.9377729296684265},
        {'B1': 24577, 'B2': -0.25262293219566345},
        {'B1': 41987, 'B2': 0.606367826461792},
        {'B1': 57608, 'B2': -0.21066752076148987}],
 'A4': {'C1': 'jl', 'C2': 92},
 'A5': {'D1': 26999,
        'D2': 0.6477994322776794,
        'D3': [-449732018, -650657832],
        'D4': 1999793696,
        'D5': [0.8169044852256775,
               -0.9212125539779663,
               -0.32272157073020935,
               -0.5992827415466309,
               0.12158133834600449,
               -0.2926417887210846,
               -0.888052225112915,
               -0.16500093042850494]}}

Вариант №38

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

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

(b'SBFL\x01\xfa|j\xa9\xdfOx\x9a8:\x02\x0c\x7f\xfb\x1dxchmeyed\x8c\x00\x00\x00'
 b"\x02\x00\x00\x00Oc'u\xcd\xb3\x15\xb6:\xd9\xa0\x10\x82\x12O\x81\x0c\xc1;\x81"
 b'\x0c\xaa\x15\xce\xe5\xf7\xe7\x04\x04O\x82\x0c\xe6\xbf\xbe\xdb\xde\xa9i\xf5'
 b'\xc0\xeaZ\xb9\xe0\xcauR7`\xdeV\xe0\xd9\x8c\xa3\x8cf\xb8R\x97\xc5\xb7\xee'
 b'\xad\xa4\x9f)QM\xde\xc0\xfdo7\x86\xbc]X\xe6\xfamf\x03\xbe\xff\xb1\xb2'
 b'\xf5\xa3\xbc\xce\x9c\xc7>\xac"\xfc_)hA\xd2-,\x05\xa2\x89\xf1\xd4\xeat'
 b'\xda\x0c\xb7\x94\xd1$r\xf3\x9f')

{'A1': 142563135773953912,
 'A2': 11112695861010758429,
 'A3': 'xchmeye',
 'A4': {'B1': 100,
        'B2': 140,
        'B3': [{'C1': 47584,
                'C2': -3858087107971098912,
                'C3': -39,
                'C4': 2359528550,
                'C5': [-5164898947190313564,
                       -6977956752742351505,
                       4001092428074777197]},
               {'C1': 26115,
                'C2': -4683829705258582834,
                'C3': -100,
                'C4': 3342773282,
                'C5': [-261444725606568660,
                       406038588169024730,
                       916364675173774239]}],
        'B4': 1663530445},
 'A5': {'D1': 12904420671175528578,
        'D2': 18,
        'D3': [20353, 3265, 15233, 3242, 5582, -6665, -6396, 1103],
        'D4': 130},
 'A6': 3302,
 'A7': -0.12054244648057644,
 'A8': -5542}

(b'SBFL\xafP\x9a;2\xf8\x86\xf8g0\\\x83Q\xbe\xfd\x97werovuiT2\x00\x00\x00'
 b'\x02\x00\x00\x00O\xc3\xd7\xbaN\xd0\x89\xeca\xc5\xf1\x81\xc9\xa7\xb9P'
 b' j\xa9\xe2\x83\x1d\xbc8\xf9X\x9ctK\xc82sP?\xe3\xc4p*\xc5\xdd\x82\xdb\xfd\xa8'
 b'\xf8\t\xa4\x8bJ\x0b\x9c\x02u\t\xfa/\x07_\xfeS\xef+/\x91Vq^x\xad8\xc6\x00'
 b'!\xb7\xe8L\x14\x9d\xe8\xa4s\x96-GJ\xfci\xdf\x11B\xc9U\x97\x0e\xae\xd7'
 b'\x1dC\xb6\xb2\x89\x1e\x91c\xa3\xa8\x14t\x9a>(#\xfd4\xb4[7\x91a\x96>')

{'A1': -5813977539886414088,
 'A2': 7435544703870631319,
 'A3': 'werovui',
 'A4': {'B1': 84,
        'B2': 50,
        'B3': [{'C1': 43256,
                'C2': 694833392660513397,
                'C3': 9,
                'C4': 4197386079,
                'C5': [-120489796248185231,
                       6807381296122175927,
                       -1707967490234748010]},
               {'C1': 11591,
                'C2': 5403310059725965653,
                'C3': -105,
                'C4': 246339357,
                'C5': [4879283548295619491,
                       -6335310569986841603,
                       3797760680000591422]}],
        'B4': 3285695054},
 'A5': {'D1': 15026801536375292361,
        'D2': -89,
        'D3': [-18096, 8298, -22046, -31971, -17352, -1704, -25484, 19400],
        'D4': 50},
 'A6': 29520,
 'A7': 0.6177292666824743,
 'A8': -9219}

Вариант №39

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

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

(b"\xa1HMBM4T\xa0{4\xe5\x19r\xff\xe2\xf5\x0b\xbd'\xc9\xb0\xb0\xad\xe0"
 b'\xef\xb6\xb2u\x89\xd6\x11V\x8c3\x14\\\xba\xb02{\xe6\xc5V@9j?\xca.\xfcA<'
 b'\x87X\x00\x02\x00\x00\x00dh\xb1\x01\x8d\x7f\xe5\xbe6Q\xe6?1\xc3`?\x0f'
 b'\xa9\x8e?i\xdd7>\x1a\xc4g\xbe|\xd2\x83\x00\x00\x00\x02\x00f\xf7\xdf\xd4b'
 b"\xd7c~\xf4\xf6\xcf9\xe28\x90G\xeb'\xcfd\xc5\x1c\x14")

{'A1': {'B1': [{'C1': 1295275168, 'C2': 2067064089},
               {'C1': 1929372405, 'C2': 196945865},
               {'C1': 2964368864, 'C2': 4021727861},
               {'C1': 2312507734, 'C2': 2352157788}],
        'B2': 47792,
        'B3': 846980805,
        'B4': 1447049578,
        'B5': 0.2045588797128015,
        'B6': {'D1': [215, 99],
               'D2': 104,
               'D3': 177,
               'D4': {'E1': 26050533,
                      'E2': [-0.1780467927455902,
                             0.6943874359130859,
                             0.5611809492111206,
                             0.9135317206382751,
                             0.15113984048366547,
                             -0.24689678847789764]}},
        'B7': [9148208112986110096, 5182279567922240532]},
 'A2': -136326046}

(b"\xa1HMBj3!\xb7\xdf\xa5\xc4A\xde\xeaL\x17'O\x14Y\x15\xbbq1\xbe\x07\xe3\x1e"
 b'\xb7\xea\x10T+n\x9e\x1d\x12p\x95\x81\x1fr\xad\x9c\xef\xee\xbf\xe4'
 b'\xf2\x12\x9d\x88\x8d\xa8\x00\x03\x00\x00\x00d\x8b`\x07f\x10c\xbe\xad'
 b'\x0b\xc6\xbff\x05J<\x86\x03\xfa\xbf?oB\xbf>%\xaf\xbf*U\x82\x00\x00'
 b'\x00\x02\x00gz\x18\x07\xcd\xdb\x11\xc0\xb7h\xa8\xac\x19K\xea\xbe\xf9'
 b'\xf9}\xa5\xfc\xdd\xb6\xcb')

{'A1': {'B1': [{'C1': 1781735863, 'C2': 3752182849},
               {'C1': 3739896855, 'C2': 659493977},
               {'C1': 364605745, 'C2': 3188187934},
               {'C1': 3085570132, 'C2': 728669725}],
        'B2': 4720,
        'B3': -1786699918,
        'B4': 2912743406,
        'B5': -0.6545498921226924,
        'B6': {'D1': [219, 17, 192],
               'D2': 139,
               'D3': 96,
               'D4': {'E1': 124129379,
                      'E2': [-0.3379804491996765,
                             -0.8985182046890259,
                             0.016359318047761917,
                             -0.7477914094924927,
                             -0.7427625060081482,
                             -0.6653672456741333]}},
        'B7': [13215998563630967486, 18012566336510473931]},
 'A2': 2048395213}

Вариант №40

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

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

(b'LZAv\xd6\xa0\\\xa3\x8f\xee\xf5UP\x8b\xf1%\x0be\x05~.\xbc\xa9\x02'
 b'\x00u\x00\x00\x00\xc0U\xea\xd3F\x84M\xb9N\xca\xf9\xf6}\xadZ\x02\x00w\x00'
 b'\x00\x00\xef\xcd\x0co\xae\xe3v9\xba\xc4\x1di\x94N\xf2\x02\x00y\x00\x00\x00d'
 b'\x96@\xbb\x1a\xca\x92\x83\xd88\xb9O\xc9\xca\x03\x02\x00{\x00\x00\x00'
 b'\xc1\xe9_\xa2\xc5\xbbK\xce\x83\xd0<\x80ZEv\x02\x00}\x00\x00\x00\x91\x00\x00'
 b'\x00rowwmdwkgr\xc6\x90\xc1W"\xaf\xeb?\xb6\x91U\xb5\xde\xe1\xfdr\x04'
 b'\xd2Pg\x85\xd9\xe0\xd2\xd7\xa5\xe7\x95\x01n\xa4G\x8f\xa7S)Ju?\x05\x10'
 b'\xee\xc3]\xdaF\x95\xe2\x9f>\x7f\x00\x00\x00')

{'A1': -1554210602,
 'A2': [{'B1': -113,
         'B2': 238,
         'B3': 245,
         'B4': 388729200431550549,
         'B5': -1447285122,
         'B6': 'ro'},
        {'B1': -64,
         'B2': 85,
         'B3': 234,
         'B4': 17999285418516039379,
         'B5': 1521319414,
         'B6': 'ww'},
        {'B1': -17,
         'B2': 205,
         'B3': 12,
         'B4': 2145044078505733743,
         'B5': -229731223,
         'B6': 'md'},
        {'B1': 100,
         'B2': 150,
         'B3': 64,
         'B4': 13346655555327498939,
         'B5': 63621455,
         'B6': 'wk'},
        {'B1': -63,
         'B2': 233,
         'B3': 95,
         'B4': 4382147359488591266,
         'B5': 1984256640,
         'B6': 'gr'}],
 'A3': {'C1': 80,
        'C2': -1754759179075484313,
        'C3': {'D1': 405,
               'D2': -1891130258,
               'D3': 21415,
               'D4': 0.9581628441810608,
               'D5': [5, 16, 238]},
        'C4': [-61, 93, -38, 70],
        'C5': 0.31227555871009827,
        'C6': {'E1': 0.8651286806093814,
               'E2': [37302, 46421, 57822, 29437, 53764]}}}

(b'LZAv\xe4,XH\xe6\x0f\x1c\x0fA\xce\x9d7\x80[\xcc\xe6U\xf3?\x02\x00u\x00\x00'
 b'\x00\x8e\xed\x0ey\x13\xb8\r\xe8 \xef7\xa0\x1eR\xcc\x02\x00w\x00'
 b'\x00\x00\x92\x8c(\xfe\x9a\xf8\x1c\xc9\xa3\x11\xa2\xd1v\xd1s\x02\x00y'
 b'\x00\x00\x00@3(\x9a\xee9\x83\xd9\x82NEKT\x9b\xfb\x02\x00{\x00\x00\x00'
 b'g\x9f\xeb\x93H~,p\xfd\x95\x0e\x01\xd0\xaf\xb8\x02\x00}\x00\x00'
 b'\x00\x91\x00\x00\x00yfaijsevpb\xd8\xd8\x90\xa8\xf4\x85\xcd\xbfjr\xa2\x89\x8e'
 b"\x8e\x83\x05\x0b\xccE[\xd3\xec\xf0P\xa3\xa1\xa7\xed'\xa4'\x8b\xb3"
 b'\x0bp\x11\x86:\xbf\x18\xf8\xae\x93\xf8\x9b\x00\xaa\x97\x15?\x7f\x00\x00\x00')

{'A1': 1213738212,
 'A2': [{'B1': -26,
         'B2': 15,
         'B3': 28,
         'B4': 14725504382977065231,
         'B5': 1072911846,
         'B6': 'yf'},
        {'B1': -114,
         'B2': 237,
         'B3': 14,
         'B4': 4030476372554552185,
         'B5': -867033440,
         'B6': 'ai'},
        {'B1': -110,
         'B2': 140,
         'B3': 40,
         'B4': 11678295392918215422,
         'B5': 1943107281,
         'B6': 'js'},
        {'B1': 64,
         'B2': 51,
         'B3': 40,
         'B4': 4994072907521584794,
         'B5': -73706421,
         'B6': 'ev'},
        {'B1': 103,
         'B2': 159,
         'B3': 235,
         'B4': 1051024746285516947,
         'B5': -1196437503,
         'B6': 'pb'}],
 'A3': {'C1': 69,
        'C2': -6367628830090407077,
        'C3': {'D1': 10221,
               'D2': -1282725980,
               'D3': 28683,
               'D4': -0.7286081910133362,
               'D5': [24, 248, 174]},
        'C4': [-109, -8, -101, 0],
        'C5': 0.5843454599380493,
        'C6': {'E1': -0.2306505034518469,
               'E2': [29290, 35234, 36494, 1411, 52235]}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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