ИНБО-12-22

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

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

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

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

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

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

(b'SWN\xad\x00\x00\x00\x02\x00\x00\x00#wjlszru\x00\x00\x00Yt\xbe@\x9b]'
 b"P\x00\x03\x00\x00\x00f\x9a\xf4\xe92crxghpq\x9b\x0eN\xfdboxgwxa\xf1?'"
 b'W[\x90\x86\x9f\x1a\xbbI\xb9e\xc5t\x89\xe7\xef\\\xd4|A\x94.\x19zB\x82f\xe05'
 b'b\xbfZc\xbc\x00\x00\x00\x04\x00\x00\x009\x10\xee[\xe8\x8c\xe9\xa3.\x16^\xe0'
 b'\xcb\r')

{'A1': [{'B1': 2599741746, 'B2': 'crxghpq'},
        {'B1': 2601406205, 'B2': 'boxgwxa'}],
 'A2': 'wjlszru',
 'A3': {'C1': -0.8530843257904053,
        'C2': [-1063087730884311393,
               1926214326256235657,
               -1734065263826856914,
               1835852925946049890],
        'C3': 16},
 'A4': {'D1': 116, 'D2': -0.1880926638841629},
 'A5': 80,
 'A6': [-295966580, -375181802, 1591790349]}

(b'SWN\xad\x00\x00\x00\x02\x00\x00\x00#qeatrag\x00\x00\x00Q4\xbf\x1c\x92\x82'
 b'\x00\x00\x02\x00\x00\x00^\xd7\xfa\xd0&powdlzwf\x0fu\xd0igkhgxg\xbb<G'
 b'~\xb7x\xf3\xf0W\xad\xf2\x92\xe3EhK\xbe\xc9\xdfkR\xad\xfcU\xbe\xeb\x13'
 b'\xa9\x00\x00\x00\x03\x00\x00\x009\xf53\xa3\x19\x1d\x08\x8aO\xcc')

{'A1': [{'B1': 3623538726, 'B2': 'powdlzw'},
        {'B1': 1712289232, 'B2': 'igkhgxg'}],
 'A2': 'qeatrag',
 'A3': {'C1': -0.45913437008857727,
        'C2': [-4955006880444779536, 6317972564962797643, -4698979084142773163],
        'C3': -11},
 'A4': {'D1': 52, 'D2': -0.6116105318069458},
 'A5': 0,
 'A6': [866326813, 143282124]}

Вариант №2

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

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

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

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

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

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

(b'\xf2UYN\xb4\xa8\xbd\x97\xea\xd4\xbcb^\x8cY\x0eNu\xe4?\x9b\xa6\x07P[1\x88g'
 b'\x00s\x00~\x00&\x05Yl/\x9d#\xbd(\x89\x8eL\x99\xd8\x04\xa2\x13\xfa\x17'
 b'\xb6W\x98\xcd\x82vj\xd0\xe9\xe5w\x00|\x91\xb8\x9dx\xdd1\xe3!\x03\xe1['
 b'?l\xd6\xa6>\xb6&k?\n\xdc{\xbf\x11I\xa5>\xf3\x17\x14\xbf^\x15\x13'
 b'\xbf=\x02\x02\x00e\x00\x18`\xcex>\xf1\x908\x03\x00p\x00j\xc6\xce\xfb\xbe'
 b'\x88\xbc\x02\x00|\x003\r\xf2>?')

{'A1': 7114795615371765940,
 'A2': 0.6393194465894216,
 'A3': {'B1': 42651,
        'B2': 828067847,
        'B3': -120,
        'B4': [{'C1': {'D1': [61, 2], 'D2': 24}, 'C2': 0.24297475814819336},
               {'C1': {'D1': [-15, -112, 56], 'D2': 106},
                'C2': -0.49181193113327026},
               {'C1': {'D1': [-120, -68], 'D2': 51}, 'C2': 0.7458809018135071}],
        'B5': [1817773350, 3173227823, 1284409640, 2718226585, 3055024659]},
 'A4': 16848083263226222679,
 'A5': [30693, 31744, 47249, 30877, 12765, 8675],
 'A6': [0.8589021563529968,
        0.32585465908050537,
        0.9185594320297241,
        -0.9838262796401978,
        0.32282307744026184,
        -0.5784904360771179,
        -0.5745447874069214]}

(b'\xf2UYN[\x02H\xf5\xcc\x8b\xb6\xf6\x8e\xff\xa4\xf0o\x95\xee?\x06\xcc\xc0T'
 b'\xd7\x94\xaag\x00r\x00~\x007\x18D\xc1x\xf8+\x06\x801d^^s\x8a\xe1J\xb4L'
 b'\x7f\xb7\x01\x976\xd2g\x9a`\x8eU\x94\x97\xaep\xb5?r1\xac\r\x18\xe6\xd3'
 b"\xbeGV\xa3\xbd\xdd~\r\xbf\x08\xfc\x1d>\x80\x8c\xfb\xbe\x1a8e=\xf4'\xbd"
 b'\xbe\xa5\xfe\x02\x00e\x00\x8as*{?k\xeb\x02\x00p\x00\x16>\xacz?\x96'
 b'\x961\x03\x00{\x00\xdb\x86-M?')

{'A1': 17777550291496338011,
 'A2': 0.9557418537224167,
 'A3': {'B1': 52230,
        'B2': 2497139904,
        'B3': -86,
        'B4': [{'C1': {'D1': [-91, -2], 'D2': 138}, 'C2': 0.9811164736747742},
               {'C1': {'D1': [107, -21], 'D2': 22}, 'C2': 0.9791907072067261},
               {'C1': {'D1': [-106, -106, 49], 'D2': 219},
                'C2': 0.8014758825302124}],
        'B5': [3242465335, 103544952, 1583624576, 3783947102, 2135733322]},
 'A4': 6960990326611182007,
 'A5': [21902, 38804, 28846, 16309, 12658, 3500],
 'A6': [-0.4138648509979248,
        -0.07975440472364426,
        -0.5527170300483704,
        0.15428173542022705,
        -0.4913063049316406,
        0.05596170574426651,
        -0.36944544315338135]}

Вариант №3

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

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

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

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

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

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

(b'PFFwrwa"*?\x08\x7f\xb2j?\xd0\xce?\x02\x00\x00\x00w\x00\x00\x00\xdd\x0c'
 b'\x9c\x1d\x0c\xb1k\x984q\r\xbaKCa\xa9\xcc\xae\x05]3\xf9Le\xd5\x9fG\x1e\x8e}'
 b',"\x9b\xd44U#\r)\x89\x8a\x86\\+h\xa0\xc58TL\xcd?\x1c\xbaT9\xb4\xf0'
 b'\xda\xbf\xb8<\xcb\nLv\xea?\xb8\xb6\xd6\xe7-\x10\xdb\xbfc\x7f\x04\xc7\xa3\\'
 b'l\xc9\x02Z\xcc\xfc)\xc0\xd9\xe2\xbf\x8f\x91\xe4\xd5\xd1*\xae\xbf.'
 b'\xf4\xfc\x90 ;\xc75\x17\xc9\xbf\\\x9c\x10\xae\x89\xe1,9\xd9\xe3'
 b'\xa7\xc8\x19\x01\xdd\xa0\xdeSR\xe7e\xaf?\x08\x1e+2')

{'A1': {'B1': 'wrw',
        'B2': {'C1': 0.6645870804786682, 'C2': 0.24073021612002088},
        'B3': [{'D1': [143, 145, 228, 213, 209, 42, 174, 191],
                'D2': 62510,
                'D3': 252,
                'D4': -0.1960208151633691,
                'D5': -1374643108},
               {'D1': [137, 225, 44, 57, 217, 227, 167, 200],
                'D2': 281,
                'D3': 221,
                'D4': 0.06132433776832369,
                'D5': 841686536}]},
 'A2': [496766173,
        -1737772788,
        -1173524172,
        -1453243573,
        1560653516,
        1699543347,
        508010453,
        573341070],
 'A3': 9883445302645806235,
 'A4': 727484042,
 'A5': [0.22889187595433502,
        -0.42094140623786,
        0.8269405566042201,
        -0.42286250725269836],
 'A6': -3932666516112900253,
 'A7': 2,
 'A8': -0.5890808887546755}

(b'PFFvqg\xd3\x103?0\x98\x02\x18\r\xb8\xd7?\x02\x00\x00\x00w\x00'
 b"\x00\x00\xad\x9e{x0\xb6N'3\xc5\x1f|\x9c<\xcd\xc5\x08\xe1(\xdd\x812"
 b"\x9f\xfa\xb7\xa8aT\x8a\xd7\xaeK\xa6'\xc7R6\x07T\x95%\xc8\xd8\x90\xb8V\xfaC4h"
 b'\xc4\xbf\n\xc3\xb1\xa5C\xe5\xe4\xbf\x1eW\xa9\xa2\xbb;\xed\xbf\xa0\xb4'
 b'H\x00\xff\x8c\xd0\xbf\x18\xd4\xa9v\x98M\x95e\x01\xac\xb8db\xe0'
 b'\xba\xdf\xbf\x95gv\x18\xe9\x17\x07^\x91:\xd4\x8c\xd7\xbc{\x02\xd3'
 b'\xe2\xbf\xb8!\x18\x13I\x03\tX\x1ar\x8b\xcc\x12\x9d:\xb8\xe7\x13'
 b'\xa1\xb9\x98\xc8?V\x01\xad\xd4')

{'A1': {'B1': 'vqg',
        'B2': {'C1': 0.6994754672050476, 'C2': 0.3706085905527088},
        'B3': [{'D1': [149, 103, 118, 24, 233, 23, 7, 94],
                'D2': 14993,
                'D3': 212,
                'D4': -0.588258020091176,
                'D5': 320348600},
               {'D1': [73, 3, 9, 88, 26, 114, 139, 204],
                'D2': 40210,
                'D3': 58,
                'D4': 0.1921608006012414,
                'D5': -726859434}]},
 'A2': [2021367469,
        659469872,
        2082456883,
        -976405348,
        -584523512,
        -90230143,
        1415686327,
        1269749642],
 'A3': 10760233339593369510,
 'A4': 2430126117,
 'A5': [-0.15943005866272641,
        -0.6529863582819371,
        -0.913541619966711,
        -0.2586057188771722],
 'A6': 7319842086581818392,
 'A7': 1,
 'A8': -0.4957810364602533}

Вариант №4

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

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

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

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

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

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

(b'TJBR\r\x020\x00\x05\x00[\x00\x00\x00\x92h\x99\xe8\xd9\xd3\x9f\xc6\xbfC'
 b'\xa0\xc1\xf1\xe3\xaeX\xa6?\x0e\x00\x00\x00\x17\x00\x00\x00\xc3\xd8\xa6\xc2'
 b"\xda\xb2\xec\x8bQqzW\x14\x02\x00 \x00\xd0?\x994\xe5Wgx\xee'\x15\x8f7\xaa\xf4"
 b'\x1b\x04z\xd7\xd9=!7\x04\x00(\x00\x00\x00\xeey\xfa\xa9\xbd\x11m\x85h\xc2'
 b'\xee\xde\xf6 X.Z+\xad\x04\xe3\x98\xf1\xf6\x93\xf3\xf4D\n\x00&\x98%Z'
 b'\xba\x9f\xec\x1cL\xe4iJ\xfbcO')

{'A1': 13,
 'A2': 2,
 'A3': {'B1': 81,
        'B2': 341277297,
        'B3': [{'C1': -110, 'C2': -0.17675254955356512},
               {'C1': 67, 'C2': 0.04364534885906157}],
        'B4': 16336,
        'B5': {'D1': 2877369597187929241,
               'D2': 21,
               'D3': [143, 55, 170, 244],
               'D4': 3972524352149783579},
        'B6': [-10045, -15706, -19750, -29716],
        'B7': -18,
        'B8': 3182033529},
 'A4': [17788918096904678673,
        16358390148224669728,
        739985565792268696,
        17050551610588538368,
        5720692248713382940]}

(b'TJBR\xacF0\x00\x05\x00[\x00\x00\x00Y\xb2P\xe9\x89\xb3_\xe8?\x8fh\xa52d'
 b'\x99\x88\xdb?\x0e\x00\x00\x00\x17\x00\x00\x00\xe1\x96H\xf5^;\x1cl'
 b'\xbb\x0b\x92\xec\x9d\x02\x00 \x00S\xc3U\xacjn\xc0\x91\xaf\x0b K\xe8\xd8\x81'
 b'\xacL\xf4NQ\xc5\x92u\x04\x00(\x00\x00\x00\x02\xec\xed\xd2\xa1\x8a\xa7!\xe9^'
 b'_58\x07\x19\xb9\x89\x90L\xf9L\x0cX\x95m\xca\xd8y\x0c\xc9\x92Sf\x972\xb9\xf4}'
 b'Q\x9cCq,\xcf\xc9')

{'A1': 172,
 'A2': 70,
 'A3': {'B1': -69,
        'B2': -1645440501,
        'B3': [{'C1': 89, 'C2': 0.7616822904187954},
               {'C1': -113, 'C2': 0.4302123526091095}],
        'B4': -15533,
        'B5': {'D1': 842051911013805141,
               'D2': 32,
               'D3': [75, 232, 216, 129],
               'D4': 8472050802044980396},
        'B6': [-26911, -2744, 15198, 27676],
        'B7': 2,
        'B8': 2714955244},
 'A4': [4050248301132490634,
        5546548599753087239,
        898987964570621964,
        17634181441784091337,
        14541890586779865469]}

Вариант №5

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

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

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

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

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

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

(b'fSFD\x86B\xbe\x9a\x06;\x83\xb1xX\xf1\xa1\xf9-\xe9\x82/\xdf\xce\x04'
 b'G\xf3\xfe\x86G1,\x96\xdf\x00:s\xf1?:\x8dI\x025\xc1\x01L\xed\xd63[\x16\xf8'
 b'kT\xb2\xb3\x9e\x91\x7f\x96\x0b-y\xeb\xf4t\x00\x00\x00\x03\x00\x81'
 b'\x0e\xe1\x93^\xaa\x0e\x1e\xf5=\x1a\xe9A\xbf\xc7\x8a\xd9\xcf\xbc\xff('
 b'\x00\x00\x00\x06\x00\x8d\x98\x8fX\x17\xbb\x93yn\x01\t\xd1\x02\xc9\x0e'
 b'\x92\x07\x1d\xcew\xa6h]u?\xe1\x8f\x07\x824\xa8\xa0\xa5\x05\xc1QS\x14\xa5'
 b'\xb0\xd7K\x87\xa0\xd7\r&\x96Zu')

{'A1': [{'B1': 134, 'B2': [66, -66, -102, 6, 59, -125, -79, 120]},
        {'B1': 88, 'B2': [-15, -95, -7, 45, -23, -126, 47, -33]},
        {'B1': 206, 'B2': [4, 71, -13, -2, -122, 71, 49, 44]},
        {'B1': 150, 'B2': [-33, 0, 58, 115, -15, 63, 58, -115]},
        {'B1': 73, 'B2': [2, 53, -63, 1, 76, -19, -42, 51]},
        {'B1': 91, 'B2': [22, -8, 107, 84, -78, -77, -98, -111]}],
 'A2': {'C1': 9193547979270386804,
        'C2': [2768617809, 1393862064, 3612051360],
        'C3': {'D1': 1072300221080149749,
               'D2': 0.037820104509592056,
               'D3': -0.183924890932752,
               'D4': [215, 13, 38, 150, 90, 117],
               'D5': -7453641999320385170},
        'C4': 1,
        'C5': 707349679030011677,
        'C6': 3463947880,
        'C7': 23925,
        'C8': 0.5487096350746192}}

(b"fSFD\x8c\xe0\xe2\xb6\x8d\xa8JP\xf8\x1f\xa4]\xc3\x04\x1a7\xc3'\x06\xdb"
 b'\x96\x11w\xdcB\x8c\x93O\x87j"\x87\r\xea\xdd\x1b\xf9iK|\xef0\xf6\xc2'
 b'R\x17U\xe4\x88m\xe7\xda\x97\x82\xd4DqS\xb8\t\xee:\x00\x00\x00\x02\x00\x81'
 b'\xde\x171\x7f\xd3N\x02\xed?"\x97\x0c\xbf\xe0\x8f}g\xf0\x86\xfe'
 b'\x00\x00\x00\x02\x00\x89\xecB1\x12qa\xdad]\xbb\x0en\xe7\xc0J:\x97gW/p\xa8'
 b'\xd4\xbf\xec\xec\x8e\x0f\xad\xae\xa0\xcc\xa2\x02w\x06\x8b6\xd0\xed\xa3')

{'A1': [{'B1': 140, 'B2': [-32, -30, -74, -115, -88, 74, 80, -8]},
        {'B1': 31, 'B2': [-92, 93, -61, 4, 26, 55, -61, 39]},
        {'B1': 6, 'B2': [-37, -106, 17, 119, -36, 66, -116, -109]},
        {'B1': 79, 'B2': [-121, 106, 34, -121, 13, -22, -35, 27]},
        {'B1': 249, 'B2': [105, 75, 124, -17, 48, -10, -62, 82]},
        {'B1': 23, 'B2': [85, -28, -120, 109, -25, -38, -105, -126]}],
 'A2': {'C1': -3151269234868621766,
        'C2': [3433169527, 109786832],
        'C3': {'D1': -2443429847749491987,
               'D2': 0.6351172924041748,
               'D3': -0.5175158529347923,
               'D4': [237, 163],
               'D5': -1422520577014244764},
        'C4': 93,
        'C5': -4967911397300487529,
        'C6': 1733767024,
        'C7': -22316,
        'C8': -0.9038763338298459}}

Вариант №6

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

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

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

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

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

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

(b'\xb6QIO>\x00\x00\x00\xa5\xdbs\xbd\xd7M8\xec\x06\x00z\x00\x00\x006z'
 b'\xd8\xc6\xbd\x16\x00?\xe2\x9e\xd8\xbb\x1c\x1e\x00w\x11\xc7\x1a\xc0\xfe&'
 b'\x00\xf3pa\xcd\x7f;.\x00\xa5Q\x87\xb4\xac(6\x00\x9d\xa5\xe0kq\x94\xf7'
 b'_\xe8\xcehbcSdT\xe2\x1b\x00\x00\x00#\x00\x00\x00+\x00\x00\x003\x00'
 b'\x00\x00;\x00\x00\x00\xd4{\x02\xb06\x99$\xdexxlh}\xf4\x15\x93u\xf5!w&\xa1'
 b'\xcef\x90[L\x0cM\x1a\xd0\xbf\xb2\xf5\xf9\xb3\x187\xea\xbfhf?\x1e\xa3"'
 b'\xea\xbfB\xd6\x1e\x1f\xc8\x7f\xe2\xbf\xdc\xae\xc3\x82\x8cj\xd7\xbf \x99'
 b'\xcd\x96\x80\xe2\xad\xbf')

{'A1': {'B1': 16744374156516909221,
        'B2': -2137973613781686066,
        'B3': [{'C1': {'D1': 31286, 'D2': -14632, 'D3': 189}, 'C2': 63},
               {'C1': {'D1': -24862, 'D2': -17448, 'D3': 28}, 'C2': 119},
               {'C1': {'D1': -14575, 'D2': -16358, 'D3': 254}, 'C2': 243},
               {'C1': {'D1': 24944, 'D2': 32717, 'D3': 59}, 'C2': 165},
               {'C1': {'D1': -30895, 'D2': -21324, 'D3': 40}, 'C2': 157}],
        'B4': -2439656637967729708,
        'B5': 'xxlh',
        'B6': [125, -12, 21, -109, 117, -11],
        'B7': 2703652641,
        'B8': 26318},
 'A2': -0.059535641223192215,
 'A3': 19927,
 'A4': 60472,
 'A5': [-0.2516052837467493,
        -0.8192256465114751,
        -0.8167281714224375,
        -0.5780983550855086,
        -0.3658782269473997,
        -0.05836870041712161]}

(b'\xb6QIO>\x00\x00\x008\x18s\xbf\xa8\x06\xd0%\x05\x00z\x00\x00\x00\x9b\xc0'
 b'6\xc0\xe8\x16\x00\xd7\x1d\x00\xcf\x1cs\x1e\x00I\xef\x07\x01n\xd3&'
 b'\x00\x9a\xac\x96\xd1QP.\x00$\x8f\xab,\xbd\x026\x00\xa2\xd1\xec\xc5\x89\xa8#'
 b'\x98im9u?X\x97Z\xcd\x1b\x00\x00\x00#\x00\x00\x00+\x00\x00\x003\x00'
 b'\x00\x00;\x00\x00\x00Ay\xbe\xf4D\x97\xeb^ttzc6\x83\xd2\xda9\xbb^\xe4\xc1F'
 b'\x9aG8K!{\x1e;\xc6\xbfp\x89cx[\x02\xe6\xbf\xb8GL\xa7X~\xcc?\x14n'
 b'\x1e\xc2\x837\xd6?\x80\xc8\xf3\xd8\xc7\xcd\xcc\xbf')

{'A1': {'B1': 7608870777215380689,
        'B2': -3649438142752802451,
        'B3': [{'C1': {'D1': -16229, 'D2': -16330, 'D3': 232}, 'C2': 215},
               {'C1': {'D1': 29, 'D2': 7375, 'D3': 115}, 'C2': 73},
               {'C1': {'D1': 2031, 'D2': 28161, 'D3': 211}, 'C2': 154},
               {'C1': {'D1': -26964, 'D2': 20945, 'D3': 80}, 'C2': 36},
               {'C1': {'D1': -21617, 'D2': -17108, 'D3': 2}, 'C2': 162}],
        'B4': 6839726781511924033,
        'B5': 'ttzc',
        'B6': [54, -125, -46, -38, 57, -69],
        'B7': 1187112030,
        'B8': 18330},
 'A2': -0.9495882987976074,
 'A3': 1704,
 'A4': 9680,
 'A5': [-0.17367917072496097,
        -0.6877877570480404,
        0.22260578316541824,
        0.34713834721489545,
        -0.22502992719052273]}

Вариант №7

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

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

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

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

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

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

(b'XRGT\x02\x00\x00\x00\x1d\x00\xc2-\xdc\xbe\x02\x00$\x00\x00\x00#\x00\x924'
 b'X\x00\x00\x00\x7feo\xa3\xca\xcb*\x0c\x17\x0e\xcdi*\xa2\x80\x9b\n\x8c\x843'
 b'!L\x1d\xba\x03\\\x03\x00\x00\x00\x1f\x00\x00\x00\x1e\xb4\t\xb2E\x07'
 b'\xaa~\x9e\xab\x17\xa9\x19\xd8\xb3\x1c\xa3.\x02\x00\x00\x00"\x00\x00\x00'
 b'r\xe2\xb2E\xca\x7f\xc0\x0e\x95\xe7\xfb\xb5\x1a\xdb\xc8\xbb`\xd1r\x03'
 b'\xcd<\x1c\\')

{'A1': 'eo',
 'A2': -0.43003660440444946,
 'A3': [{'B1': 3607,
         'B2': {'C1': 27085,
                'C2': 41514,
                'C3': 5485722465492179840,
                'C4': 47645,
                'C5': 23555},
         'B3': [-93, -54, -53]},
        {'B1': 46110,
         'B2': {'C1': -19959,
                'C2': 1861,
                'C3': 15571663105738833578,
                'C4': 7347,
                'C5': 11939},
         'B3': [42, 12]}],
 'A4': 881983523,
 'A5': {'D1': 57970,
        'D2': [-78, 69, -54, 127, -64],
        'D3': 14,
        'D4': -1241782379,
        'D5': -0.006129634566605091,
        'D6': [96, 209, 114, 3, 205, 60],
        'D7': 28,
        'D8': 92},
 'A6': 127}

(b'XRGT\x02\x00\x00\x00\x1d\x00%\xba;\xbe\x02\x00$\x00\x00\x00\xce\xa9\xfdn'
 b'X\x00\x00\x00\x08duAF\x12\xbb:A\xcb\xf5\xder\xa7w-\x19\xb3\xb2\x19Z\x13m_'
 b'\x9d\x99\x03\x00\x00\x00\x1f\x00\x00\x00\xefuV\xe3\xa9\xb7\xa2\xc8\x95\x19'
 b'\xd8\xd3p\xd0\x13k^\xdc\x02\x00\x00\x00"\x00\x00\x00M\xc3\xc9!r\x9b\x13]'
 b'\x9c\x03\x94\xffg\x1dC?\x85\x8f\x19\xaeN\xcc<\x8a')

{'A1': 'du',
 'A2': -0.18332727253437042,
 'A3': [{'B1': 52033,
         'B2': {'C1': -8459,
                'C2': 42866,
                'C3': 1394455289924234615,
                'C4': 24429,
                'C5': 39325},
         'B3': [65, 70, 18]},
        {'B1': 30191,
         'B2': {'C1': -7338,
                'C2': 47017,
                'C3': 15019737682376247458,
                'C4': 27411,
                'C5': 56414},
         'B3': [-69, 58]}],
 'A4': 1862117838,
 'A5': {'D1': 49997,
        'D2': [-55, 33, 114, -101, 19],
        'D3': 93,
        'D4': -7076964,
        'D5': 0.7621673941612244,
        'D6': [133, 143, 25, 174, 78, 204],
        'D7': 60,
        'D8': -118},
 'A6': 8}

Вариант №8

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

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

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

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

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

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

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

(b"JWL\xbf\xbeIb=BHpFzT\xba\x00\x00\x00\x02\x00\x96\xc6\x9f'\x8c\xdf\xd1E"
 b'\x12\x18\xb4\xee\xca\x7f\x8bG\xa7\xf0\xdd\xc6\x90 j\xdcgx\xf6\x00'
 b'\x02\x00\x00\x00\x9e\xbc\x00\x02\x00\x00\x00\xa0\xbe9\xa7\xe5\xbf!\xe2\x9f'
 b'\xe2\xfa\xa0\x8c&,\xf8m\x00\x03\x00\xa2\x9f\x0eZ3\x83\xdf6\x08'
 b'\xf4\xd1\xb9\x05cGxl\xda\x99\xadc\xadR\xad\xab\n?\xeb\xc9}\x03m\xa0'
 b'H\xc3/\xdcb\xbb\xf6\xb4\xd0\\\xf0w\x87\x97\x829\xd9\xe4\xb7\xe1\xc9\xc4\xe7$'
 b'x\x0c\x05\xca\xbf\xea-\xdd\xdf0\xdd\xa0\x8e^\x00\x00\x00P\x00\x00\x00sO\x0c'
 b'\xdb3\x08\x0c\xcdM\xa0y')

{'A1': -0.11830724711970375,
 'A2': 70,
 'A3': 31316,
 'A4': 186,
 'A5': {'B1': {'C1': [{'D1': -6985546794702785016,
                       'D2': 244,
                       'D3': [-776403613, 1199074522, -1716690003, 1387113226],
                       'D4': 0.8683457438428457,
                       'D5': 49967},
                      {'D1': -2566282169377858320,
                       'D2': 119,
                       'D3': [-2020113863, -639322143, -909842652, 2014053834],
                       'D4': -0.8180989607998761,
                       'D5': 36446}],
               'C2': -962648180,
               'C3': -539933422,
               'C4': 6324,
               'C5': 17206705562501771485},
        'B2': 14307971659492456694,
        'B3': [79, 12],
        'B4': {'E1': -68,
               'E2': [-37, 51],
               'E3': -0.18130452930927277,
               'E4': -0.6323642134666443},
        'B5': 16355561520545724525},
 'A6': [2060, 52557, 41081]}

(b'JWL\xbf\xd1\x92\xa8 oZ\x14\xd2\xfd\x97\x12\x00\x00\x00\x02\x00\x96e\xa6\x9f'
 b"\x168\xad$\xc9\x10\xefR\xef/'\xfd\xf8\x9a\xb9k\xaf\xec-\xd5,\xa8\x05\x00"
 b'\x02\x00\x00\x00\x9e)\x00\x02\x00\x00\x00\xa0\xbd\xa5\x17\x11=\xba\x01\xe9'
 b'|\x03\x08C\xc2\x84\x81M\x00\x05\x00\xa24\xd5d<\xae\x08&\xed\xd8\x95\xd9\x1b'
 b'\x01X\xcd\xf3\xa6\x8eT\xac\xf3\xfa\xdb<\x87?\xc9\x9e\xe6S\xe2o\xb8\xdd\xaeW'
 b"y\xdb-'\xe3/\x01,\xebOD\x826\xa4\xe6\xb39\x17\x13\x10+\xd6{K\xbf\xef\xd5p"
 b'\x8c\xd1\xe1\xd4%\x93\x00\x00\x00P\x00\x00\x00s\\\x13L\xf7\xf7)\xb4UY\xb6'
 b'\xe5\x8e\xe9\xd4')

{'A1': -0.2745762173412072,
 'A2': 210,
 'A3': -617,
 'A4': 18,
 'A5': {'B1': {'C1': [{'D1': 3807059271792207597,
                       'D2': 216,
                       'D3': [-1780933887, 1489892262, -1907053325, -86295417],
                       'D4': 0.20016173454211894,
                       'D5': 56750},
                      {'D1': 6303310140470931201,
                       'D2': 44,
                       'D3': [-347126654, 916776627, 957813520, 735476555],
                       'D4': -0.9948046446216332,
                       'D5': 9619}],
               'C2': 1705418518,
               'C3': 950871241,
               'C4': 4335,
               'C5': 5976047079355095737},
        'B2': 7759680364576811013,
        'B3': [92, 19],
        'B4': {'E1': 41,
               'E2': [76, -9],
               'E3': -0.08061040192842484,
               'E4': 0.0908239558339119},
        'B5': 8935995172752490829},
 'A6': [63273, 46165, 22966, 58766, 59860]}

Вариант №9

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

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

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

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

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

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

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

(b'UFSC\x96\x8c=Y\xf5\xe9\xfe\x04@\x14\x13\xbe\x01v\xa3\xbf\xe4\x02\x00\x00'
 b'\x00<\x00\x00\x00\x03\x00\x00\x00>\x00\x00\x00c |\xafQ\x1d(\x9b\xdc\x03\x00'
 b'D\x00G\x00\x00\x00W\x00\x00\x00\x18%wlt@\xb5>\\{hoh\xa3\xf9\xca\xe8\xbd'
 b'?\xe1}\xb0\xe3[0=\x0b\xbf\xbf\x00\\\xeb4\x7fpB^n\xcb\x16\xf2\x0e'
 b'\x82\x97n\x05\xa5\xbb\x82-\xee\xa2\xb1y4\xcf]\x8b]}:B\xefdxl\xb0W\xfee'
 b'\xd76\xd2:\xc5\xe1W\xdf\xa60k\x83 \x8e=\xea\xda+')

{'A1': {'B1': 359982260209683606,
        'B2': -0.038009695484597206,
        'B3': -28,
        'B4': 'wl',
        'B5': [{'C1': 116, 'C2': 64},
               {'C1': 181, 'C2': 62},
               {'C1': 92, 'C2': 123}]},
 'A2': 99,
 'A3': 1370455072,
 'A4': -593811427,
 'A5': 'hoh',
 'A6': {'D1': 9070601209387874723, 'D2': -0.12126524382246262},
 'A7': {'E1': [6792114879679126528,
               7968981066358115182,
               12800054970174645509,
               4214627679444350073,
               18327311188530360130],
        'E2': -768157851,
        'E3': [58, 197, 225, 87, 223, 166],
        'E4': 545483568,
        'E5': 142,
        'E6': 735767101},
 'A8': 9496}

(b'UFSC\x83\xa83;\xfeV\xb0^p\xa3\x9cfP\xd5\xec?\xcd\x02\x00\x00\x00<\x00\x00'
 b'\x00\x02\x00\x00\x00>\x00\x00\x00\xea|f\xe58\xe7\x9e\xd1D\x06\x00B\x00H\x00'
 b'\x00\x00X\x00\x00\x00\x1f\xdekq\xa5\xfa(\x8dzfiwaeSC\x83{\xa4\xaa\xea\x1f'
 b"\xf8<[\xc95\x89\xd7\xbfdCOg\x9d\xfd?L\xea=>\x0elEK\x88\xd8'\xa5\xb2"
 b'\xef"\xef\xcc\x83c\x1d\x0b\xf2\xb3zFh]\xedK\xaf\x85\xb4w\xd2G\x93\x06'
 b'fq\x1c\xbb\x98\xd7"*\xcf\xb5\'^U\xa7B')

{'A1': {'B1': 6823049085381224579,
        'B2': 0.901039314664656,
        'B3': -51,
        'B4': 'kq',
        'B5': [{'C1': 165, 'C2': 250}, {'C1': 40, 'C2': 141}]},
 'A2': -22,
 'A3': 954558076,
 'A4': 1154588391,
 'A5': 'zfiwae',
 'A6': {'D1': 2299838183149618003, 'D2': -0.36774964011870237},
 'A7': {'E1': [5494388922900235108,
               9821019742809243114,
               14767060116060841944,
               5078569381963588483,
               8625666174260960616],
        'E2': 110315474,
        'E3': [102, 113, 28, 187, 152, 215],
        'E4': 3050252834,
        'E5': 39,
        'E6': 1118262622},
 'A8': -8673}

Вариант №10

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

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

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

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

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

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

(b"CISX\xa7\x10fuirchk\x1f{]a\x084N\x025>f\xb2on\xf2w\x00'\x004\x00A\x00N\x00c#"
 b'\xbf\xe0\x95\xfc\xb9\x1d\xd6\xea\xbe\x10y\x111?\xe2\xb5\xe8\xb5\x98k'
 b'P>\xc7\xd2~\x17\xbf\xe0r\xa9\xc4\xf6(\xd6>z\xc7\x9d\x94\xbf\xd9\xbd\xa3a'
 b'|\x04P?,u\xb5\xbf@\x98\xfd>\xc0\xf6\xbe\x00\x00\x00\x02\x00\x00\x00[\xd8'
 b'\x95\xe7T\xc7\x89Y\x9dZ<\xad\xc8\xda\x88\x0c\xd6\xf8a\xab\xc4\x89'
 b'\xa5\xdc\x14\xddP\x8f\x7f\xfaB\xb1')

{'A1': 16,
 'A2': 'fuirchk',
 'A3': {'B1': 528178529, 'B2': 591183222482560690, 'B3': 'on', 'B4': -3465},
 'A4': [{'C1': 35, 'C2': -0.5183089843328308, 'C3': -0.14108683168888092},
        {'C1': 49, 'C2': 0.5847056910309707, 'C3': 0.39027780294418335},
        {'C1': 23, 'C2': -0.5139969679742318, 'C3': 0.2449020892381668},
        {'C1': 148, 'C2': -0.40219959754910395, 'C3': 0.6736710667610168}],
 'A5': {'D1': [-0.7523344159126282, 0.37688249349594116],
        'D2': -40,
        'D3': [2514965703, 2304351578, 1018022106, 2282542840],
        'D4': 97,
        'D5': 171,
        'D6': 14162032867904671887,
        'D7': 32762,
        'D8': 17073}}

(b"CISX\xa7\xe2utchiah2\xda5\x1d\x11N\xc2[\xaa\xc8\xaborr9\x97\x00'\x00"
 b'4\x00A\x00N\x00c\x8b\xbf\xe1\x9e\xe1X^c\xc4?Z\x10\x1f\xed\xbf\xc8\xe1'
 b'\xbe\x91y\\\xb8\xbe\x94}\xe0D\xbf\xebh\x9f;\xb8\x7f\xce\xbf{K[\xfc?'
 b'\xe2\xa0\x0cHpX\xfc\xbe}\x81\x93\xbe\xa0\xf4W?\x0f\xbf\xcb\x00'
 b'\x00\x00\x02\x00\x00\x00[\np\xa4T\xcdq\x9d\x06M\xab2+$\xb3\xeb\x9b\xc0'
 b'\xb1~\x0fc\xac;:5m\x90\x99\xd7\xe1\xbc')

{'A1': 226,
 'A2': 'utchiah',
 'A3': {'B1': 853161245, 'B2': 1247147845791296367, 'B3': 'rr', 'B4': 14743},
 'A4': [{'C1': 139, 'C2': -0.5506445623351444, 'C3': 0.851808488368988},
        {'C1': 237, 'C2': -0.19438917258478283, 'C3': -0.2900228500366211},
        {'C1': 68, 'C2': -0.8565212408466267, 'C3': -0.9816185832023621},
        {'C1': 252, 'C2': 0.5820371069737855, 'C3': -0.24756459891796112}],
 'A5': {'D1': [-0.31436416506767273, 0.5615202784538269],
        'D2': 10,
        'D3': [1889817805, 1906116173, 2872191780, 3018562496],
        'D4': -79,
        'D5': 126,
        'D6': 1108919303642901904,
        'D7': 39383,
        'D8': 57788}}

Вариант №11

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

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

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

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

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

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

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

(b'fWLL\xb0{\x00*\x00\x00\x00J\x00\x06\x00z\x06\xc6\xe5H!\xd5\x80\tM-C\x0c'
 b'S\xe5v\niI\x18h\xec\x91\x0f\x13v\xf9\xd9\x05\xa2\x99\x0fWB<\x8d\xcc'
 b'3(\x1b\xa7\xcc\xdc\x14R\x94\xe3~\x18\xcd\xba\x1a\x88\xba0\xf1\x90'
 b'X\xd8\x94\xb1\xdf\xca\x00\x02\x00C`\xb6\x00\x03\x00E\xf7k\x00\x02\x00H\xca*'
 b'x\xae\x90-M#?\xea\x19\xc3\xf4hs\x14:>~\xe1fx\x95#\x0e=\x8b\x97>cE\xed\xbe^'
 b'\x13\xe6\xbe\xc5\xf2\x00>\x9d\x8b\xfb\xbf-\xc7/\xbeC\xda\xab')

{'A1': 45179,
 'A2': {'B1': -39,
        'B2': 94542095,
        'B3': {'C1': 1463958669, 'C2': -3732595566915560428},
        'B4': 5950631138384787994},
 'A3': {'D1': 38065,
        'D2': [{'E1': 57290, 'E2': [136, 186]},
               {'E1': 24758, 'E2': [48, 241, 144]},
               {'E1': 63339, 'E2': [88, 216]}],
        'D3': 14567588635821821219,
        'D4': 0.8156451963037363,
        'D5': 58,
        'D6': [62, 126, 225],
        'D7': 7383815566869236631},
 'A4': [0.22194643318653107,
        -0.21687278151512146,
        -0.3866119384765625,
        0.30770859122276306,
        -0.6788205504417419,
        -0.1912638396024704],
 'A5': [488329707584323593, 5561174835098646026],
 'A6': 7586621886206906131,
 'A7': 30457}

(b'fWLL\x9a\xfb\x00*\x00\x00\x00K\x00\x05\x00{s\x87\x06\x01\xcb\x00\x05\xeb'
 b'UBL\xb1\xa8:m\x98g\xc8\xd1\xaa\x8f\x0f\xa8\x84\xad\xd9\xcb\xc5=\n\xf7\x1c'
 b'\xbb\xec\xdfJE\xb4\xce\xcd\x9c\x11\xfe\x06\xa1U\n\x02\xd5EQ\xdeC{\x97\x95'
 b'\xd9M\x7fXUj\x8a\x00\x03\x00C\x07\xac\x00\x03\x00F\x17$\x00\x02\x00I\xb3'
 b'\xdd*H\xca\xdd\x7f\xf3?\xd6R\xed\x9cv|\xcc\xad\x8aJO\xf8\xae\x19\x85\xbf'
 b'\xca\x02\x92\xbf\x16w\x11\xbf \x90\xb6>\x00\xc4\xe5\xbf{\xd8D\xbfM\xad<')

{'A1': 39675,
 'A2': {'B1': -53,
        'B2': -985855241,
        'B3': {'C1': 482077919, 'C2': 5351882532505522686},
        'B4': 477756536963548497},
 'A3': {'D1': 22613,
        'D2': [{'E1': 27274, 'E2': [222, 67, 123]},
               {'E1': 1964, 'E2': [151, 149, 217]},
               {'E1': 5924, 'E2': [77, 127]}],
        'D3': 12960561794771681267,
        'D4': 0.3488115337331237,
        'D5': 173,
        'D6': [138, 74, 79],
        'D7': -527456044116737390},
 'A4': [-0.5877543091773987,
        -0.6272081136703491,
        0.1257510930299759,
        -0.9837687015533447,
        -0.803424596786499],
 'A5': [8324629040988161515, 6143557167602101656],
 'A6': 7478457711723522180,
 'A7': -21031}

Вариант №12

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

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

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

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

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

(b'VMF\xfff\xf7\xe1Mxb\x008\x80\x046\xe6o\xca?16+wqbvetnfr\xf2\xe8\xd3\x0b\x02'
 b'\x00\x00\x00r\x00\x00\x00\x03\x00v\x00+\x0f\x01xyn\xa9\xd9\x02\x00\x00\x00y'
 b'\x00\x00\x00\x02\x00}\x00\xa5>o\xfd\xb3@\xa8t\x03\x00\x00\x00\x7f'
 b'\x00\x00\x00\x02\x00\x85\x00\xd8\x03\xdb\x18\xf0\xaf\xdc\xad\xcb\xdd?\x93w'
 b'\x16o\xc6\x823\xceojsk\xf7V:\x9e\x0c\xc7\xf9\x05M\xb2\xfb)K\t'
 b'\x1e\x8c\xae\xd8\xd4HG:\x11)\xdf')

{'A1': 26367,
 'A2': {'B1': 2018370039,
        'B2': {'C1': 14858363384404277139, 'C2': 'ojsk', 'C3': 2654623479},
        'B3': 0.2065398944623682,
        'B4': 49,
        'B5': 11062},
 'A3': 'wqbvetnf',
 'A4': [{'D1': -739708302,
         'D2': 11,
         'D3': [50956, 1529],
         'D4': [77, -78, -5],
         'D5': 43,
         'D6': 271},
        {'D1': -1452377736,
         'D2': -39,
         'D3': [19241, 7689],
         'D4': [-116, -82],
         'D5': -91,
         'D6': 28478},
        {'D1': -1472154627,
         'D2': 116,
         'D3': [54488, 18248, 4410],
         'D4': [41, -33],
         'D5': -40,
         'D6': 56067}],
 'A5': 0.4655565886639592}

(b'VMF\xf5\x1d\xe4r8\xd8b\x00\x96\xe8_\x13\x05\xa7\xe9?v4>ijuaqhnx\xa7\x8d'
 b'\xc3.\xd4\x02\x00\x00\x00r\x00\x00\x00\x02\x00v\x00\xa3\xf5\xb1\xc3\xd4'
 b'g\x9bQ\x02\x00\x00\x00x\x00\x00\x00\x02\x00|\x00.R\x0cY\x99\xccgn\x02'
 b'\x00\x00\x00~\x00\x00\x00\x03\x00\x82\x007\xa0\x06\x96\x172Q\x893'
 b'\xe1\xbf\xfd\xd0\x80\x02(\xe6\xce\xfbqgzi#\xa9\xaas\xe4/\x95=\x1a,W|\xee\xbb'
 b'\x0f\xbf\r\xf7\xcb\t\x077\x8a')

{'A1': 7669,
 'A2': {'B1': -667389212,
        'B2': {'C1': 18144693008237383933, 'C2': 'qgzi', 'C3': 1940564259},
        'B3': 0.8016381624613753,
        'B4': 118,
        'B5': 15924},
 'A3': 'ijuaqhnx',
 'A4': [{'D1': 784567719,
         'D2': -44,
         'D3': [12260, 15765],
         'D4': [26, 44],
         'D5': -93,
         'D6': 45557},
        {'D1': -1687694141,
         'D2': 81,
         'D3': [31831, 48110],
         'D4': [15, -65],
         'D5': 46,
         'D6': 3154},
        {'D1': 1741461849,
         'D2': 110,
         'D3': [63245, 2507],
         'D4': [7, 55, -118],
         'D5': 55,
         'D6': 1696}],
 'A5': -0.5375410638668991}

Вариант №13

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

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

(b'\x06PWBTS\x00mfexetsh\xeb\xed|_`\xc3\xc6\x90\x11\xa6\xcd\xd8\xce\xd6/O\x81'
 b'\xe2m\x00\x00\x00;\xad\x1b<\xcb\xba\x80\xed2\xb1\x9e\x82$\x99\x8d'
 b'\xae\x02:\x90\xe2^\x03\x00%\x00\xb8\xc5\xb90\x01X\x9c\x13d\xba'
 b'\xa1\xa7\xbf\x03\x00+\x003W\x8d\xf62M\xa0.+\xd2\xf5\x00\xa9\xbf\x02\x00\x00'
 b'\x001\x00\x00\x00\xec\x87f\xbf\xea\xd6\xdb\xbe\xb3\x8b\xd4=\x86\xd2\xd5'
 b'e\x02\x00e\x00o')

{'A1': {'B1': 19762,
        'B2': -0.04883545103583953,
        'B3': [{'C1': 16325612432410908964,
                'C2': 94,
                'C3': [44347, 15387, 47819],
                'C4': 817481144},
               {'C1': 12079140614572890113,
                'C2': 191,
                'C3': [60800, 45362, 33438],
                'C4': -158509261}]},
 'A2': 'mfexet',
 'A3': 3991627891,
 'A4': 24444,
 'A5': -1866022048,
 'A6': -23023,
 'A7': -2125330482256226099,
 'A8': {'D1': 1037339571,
        'D2': 1708511878,
        'D3': [-0.9005115032196045, -0.4293740391731262],
        'D4': 111}}

(b'\x06PWBTS\x00csmuhw\x81\xc1\xf0.\x84L>i\x08\xb8{\xfd8\xf9\x80q\xfc*8'
 b'1m\x00\x00\x00\x00G\x0fj\x19\x0e1\x87\xdcz\x9b#\xb9\xd0s~\xfc\xf7\xef'
 b'\xdb\xac\x03\x00%\x00\xda\x83\x9a\xcb\xfd\xe1\x7fN\xef`\xfe\xf3E\x03'
 b'\x00+\x00\xa4sN\xb0$\xbb\xdc\xff\x9d\x96\x1ec\xd3?\x02\x00\x00\x001\x00\x00'
 b'\x00\x99\xe3\x01?\xc8\xc8\x1e>\xc2T\xd9\xce}<8\x9d\x02\x00e\x00\xc8')

{'A1': {'B1': -17628,
        'B2': 0.3029247732993079,
        'B3': [{'C1': 15848158277565403321,
                'C2': 172,
                'C3': [18176, 27151, 3609],
                'C4': -879066150},
               {'C1': 17581596576231449085,
                'C2': 69,
                'C3': [34609, 31452, 9115],
                'C4': -1337035868}]},
 'A2': 'csmuhw',
 'A3': 787530113,
 'A4': 19588,
 'A5': -1207408322,
 'A6': -645,
 'A7': 3546631970278668600,
 'A8': {'D1': 3470349506,
        'D2': 2637708413,
        'D3': [0.5073791146278381, 0.15506279468536377],
        'D4': -56}}

Вариант №14

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

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

(b'\xc4JSX\x00\x02\x00\x00\x005\x00\xbb\xbf\xefY\x86\x8fka\xb8\x00\x00\x00\x03'
 b'\x00\x00\x00\xc2\xb9\x02\x00\x04\x00\x00\x00\xc8\xd6@\xd3d\xee?\xe3\x06'
 b'\xac\x91\xb1\n\xec\x1fR\xe2<io?\xe5\xa2G\x1aN\x1f \xbf\xecrB\xd7W:\x9a\xd5'
 b'\xe2b\xef\xbb!\x9f\x86\x93\x00\x00\x00\x02\x007\xbf\xe0\xa57,Mu\xcc?\xdd'
 b'q\xc5Xru\x88\xa6\xe0\xb2N?Z\x87\xc7\xdb\x00\x00\x00\x02\x00V?\xec\xa1'
 b"<\x02\xaa\r \xbf\xe9p\t%\xbb\xe5\xd6'\xd1\xfd\x02\xbf\x1d-\xb6,\x00\x00"
 b'\x00\x02\x00u\xbf\xe4\xa5\x10\x94\x9fF\xba?\xe5\xfc\x9d\x16Rm\xa2'
 b'\x9f\xf4\x1fn?w\xe3t\xc3\x00\x00\x00\x02\x00\x94\x00G\x00f\x00'
 b'\x85\x00\xa4\x85\xab\x00\x04\x00\xb3\x1eP\xb9x\x9a>\x86\xe3\x8aA\xf7')

{'A1': 'io',
 'A2': {'B1': -31317,
        'B2': [{'C1': -706583825,
                'C2': -0.0024661733768880367,
                'C3': -109,
                'C4': [0.6760592950604156, -0.8889478879808224]},
               {'C1': -1495223730,
                'C2': 0.8536342978477478,
                'C3': -37,
                'C4': [-0.5201679101261845, 0.4600690234891194]},
               {'C1': 668073218,
                'C2': -0.6139787435531616,
                'C3': 44,
                'C4': [0.8946819355045683, -0.7949262368194308]},
               {'C1': -1611391122,
                'C2': 0.9683144092559814,
                'C3': -61,
                'C4': [-0.6451495077874008, 0.6870866237617757]}],
        'B3': 30},
 'A3': -0.9796784211312604,
 'A4': {'D1': [20665, 30874, 16006],
        'D2': 47362,
        'D3': [-29, -118, 65, -9],
        'D4': 214,
        'D5': 1087595758,
        'D6': 0.5945647092379125,
        'D7': 525525564}}

(b'\xc4JSX\x00\x02\x00\x00\x005\x00\x9a\xbf\xea:d\x8c\xa6ip\x00\x00\x00\x03'
 b'\x00\x00\x00\xa1\xcci\x00\x02\x00\x00\x00\xa7t\xd2\xbc\xc4.?\xe2\xd7'
 b'(\x96<\xfcp\xe1\xd7\x9c\x83by\xbf\xe6b\x9c\xaek\x97*?\xde\xe7\x1f\xb2'
 b'\x19\xf5\xbc\xc6y\xb6\xb6\xbe\x85a\x0f\xd7\x00\x00\x00\x02\x007?\xec'
 b'\r\xa8g\x85\x06\xd8?\xdby\x13m\xa1\xa2$\xf4l\x10~\xbe\x94\x8c\xa7\x1d\x00'
 b'\x00\x00\x02\x00V\xbf\xd3\xb6\xb2\xd6I\xbd\xc4?\xb2\xff6\xd2j\xb8`\xa8"F'
 b'\xea>f\x9c\xcd\xe0\x00\x00\x00\x02\x00u\x00G\x00f\x00\x85P\xd9'
 b'\x00\x03\x00\x94\x8d\x80l\x9dL=\xe61\x82')

{'A1': 'by',
 'A2': {'B1': 20697,
        'B2': [{'C1': -965101898,
                'C2': -0.26050612330436707,
                'C3': -41,
                'C4': [-0.6995376021047595, 0.482856677939562]},
               {'C1': -194244482,
                'C2': -0.29013559222221375,
                'C3': 29,
                'C4': [0.8766672155254254, 0.4292648859614323]},
               {'C1': -1474148630,
                'C2': 0.22520752251148224,
                'C3': -32,
                'C4': [-0.30802603651588023, 0.07420675885325201]}],
        'B3': -115},
 'A3': -0.8196280238219469,
 'A4': {'D1': [32876, 40268, 15846],
        'D2': 52329,
        'D3': [49, -126],
        'D4': 116,
        'D5': -759380946,
        'D6': 0.5887644705143327,
        'D7': 3789003907}}

Вариант №15

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

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

(b'\xe1ICSS\x00\x04\x00\x00\x00\x0fw\xe7\x00O\xa7\x99\xb3\xe0\xb5\xc5\xe82\x98'
 b'_\x8b\xfd)\x9e\xa0\xa7Q<\xec\x1fN\x0e\x17\x0ek@\xb7\x8c?\xe7}\xbc\xe6'
 b'!\x93X\x16~XR)\r\xd5z\xea\xb1Y\xa3"|{\x19\x07>\xcd\x8f;5\x1c\xbf\xb0'
 b'a\xc6\xfb*\x02G\xdf\xdd\xc3r^\xe2%6It?\xc3+\xe3\xea\n\xdb\x00'
 b"\x00\x00\x02\x00\x00\x00#\xd9\xb4\x00'\x00\x00\x00\x04\x00;\x00\x02\x00"
 b'\x00\x00?\xbf\xe4\x9e\xea\x13\x82\x95\xa2\xb1?\xe0\x84\xd2\xaeM\xdff'
 b'<\x81\xaepM9')

{'A1': [{'B1': -89, 'B2': -26189, 'B3': 57525},
        {'B1': -59, 'B2': -6094, 'B3': 39007},
        {'B1': -117, 'B2': -727, 'B3': 40608},
        {'B1': -89, 'B2': 20796, 'B3': 60447}],
 'A2': 30695,
 'A3': {'C1': 704792543,
        'C2': 15979741654687233609,
        'C3': 8376628425207188187,
        'C4': {'D1': [19982, 5902],
               'D2': -9804,
               'D3': {'E1': 27456,
                      'E2': 46988,
                      'E3': 0.7340988631009209,
                      'E4': [5758, 22610, 10509, -10886]},
               'D4': [-22, -79, 89, -93],
               'D5': [2484996441827626383, 4266347831626942203],
               'D6': -0.6443987256104047,
               'D7': 177,
               'D8': 0.5162137417200767},
        'C5': 1015131760,
        'C6': 19769}}

(b'\xe1ICSS\x00\x03\x00\x00\x00\x0f\xb9\xa5\x00H\xa2H\x05\x90\x98\x02\x1c!-'
 b'\xb6GM\xbfC\xc0Q\x9b\xc8\xb0\x84\xa1\xaau\xbf\xc1\x837\x93$\xbe\xe0tG'
 b'\x1e\x9b\xdd\xef\xff\xbb\xfd\x14\xe1{^\xf3\xd1\xec\x86\x82\xe1$\xc0\xfc'
 b"qY\xd5\xa3\x81\x99\xfb\x90\xf5\xdb'\xe5\x8b\xb8\xc9L\xb2\xbaG\xdd| \xdd&"
 b'\x00\x00\x00\x02\x00\x00\x00\x1e\xe0$\x00"\x00\x00\x00\x02\x006\x00\x02'
 b'\x00\x00\x008\xbf\xeaZ2\x9fj\xef\xbc4\xbf\xe5\xf7\xf0\xdcU\xe8V0\x1d\xc6'
 b'\xcd\xdb\xe3')

{'A1': [{'B1': -94, 'B2': 18437, 'B3': 37016},
        {'B1': 2, 'B2': 7201, 'B3': 11702},
        {'B1': 71, 'B2': 19903, 'B3': 17344}],
 'A2': 47525,
 'A3': {'C1': -2120615024,
        'C2': 17715797426037115212,
        'C3': -5568058972694323930,
        'C4': {'D1': [20891, -14160],
               'D2': -8156,
               'D3': {'E1': 33953,
                      'E2': 43637,
                      'E3': -0.1368169277643494,
                      'E4': [29767, 7835, -8721, -69]},
               'D4': [-3, 20],
               'D5': [16247684481961199234, 16223303948161373603],
               'D6': -0.823510466921554,
               'D7': 52,
               'D8': -0.6865162185124614},
        'C5': 807257805,
        'C6': -9245}}

Вариант №16

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

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

(b'JTLMC\xfe\xf6of\x00\x00\x00\x02\x00\x00\x00\x9c=\x14\x07\xeb\xb5\x81\xd6'
 b'\x05\t\x7f\x97\x00\x03\x00\x00\x00\x159<\x9c\xbcP\x00\x02\x00\x00\x00'
 b'\x18\xfazX\xa5%q\xa6f?\xc5\xfe\xd0k\x8f\x18\x00\x198\x93\xda\xd8 g\xc7?,['
 b'WW\xba\xb0\x12P\x06\xc9C\xc3\x95\xa7rjhL\x7f>\xfeY\x87\xcc\x16\x00'
 b'\x02\x00\x00\x00Y\xb8\xbf\x1b\xb2\xe8\x00\x02\x00\x00\x00[\x99\x8d\xe1\xf5'
 b'\x1em\xaa\xd4?\xd2\n1\x91\x93m\x8c\xfc\xcfx\xfa\x01\xd3\xff\xe8>\x8c\x85L'
 b' \x00\x03=\x93@\xd9\xd8\x84)\xfdnR]O\x9b\x00\x00\x00\x1a\x00\x00\x00]')

{'A1': {'B1': 65270, 'B2': 'of'},
 'A2': [{'C1': {'D1': 127,
                'D2': -105,
                'D3': [181, 129, 214],
                'D4': 57,
                'D5': 0.019132763147354126,
                'D6': [5, 9],
                'D7': 18048835922961737318},
         'C2': 0.17183881046202032,
         'C3': 1817365017782151111,
         'C4': 0.673268735408783,
         'C5': {'E1': 1471852562, 'E2': 20486, 'E3': -14013},
         'C6': 3281364850,
         'C7': 1785220223},
        {'C1': {'D1': -52,
                'D2': 22,
                'D3': [62, 254],
                'D4': 184,
                'D5': -0.6081986427307129,
                'D6': [89, 135],
                'D7': 11064748302412917460},
         'C2': 0.28187216965098894,
         'C3': -229832040804778008,
         'C4': 0.2744544744491577,
         'C5': {'E1': 536871741, 'E2': 37696, 'E3': -9768},
         'C6': 2217344366,
         'C7': 1381846939}],
 'A3': 0.03614036366343498}

(b'JTLMC\xf3\xb4no\x00\x00\x00\x02\x00\x00\x00\xa1\xbe\xc3\xa1r\xef\x9c\x14'
 b'\xc9\xb8\x1b\xff\xef@\x00\x03\x00\x00\x00\x15\xd3>\n\x07O\x00\x04\x00'
 b'\x00\x00\x18\xa1g\xea\xdc\xe4g\xdf\x16\xbf\xdaa\xc6\x9fh!\x88S\xcd:\xdfJ'
 b'e\x1d\x98>A\x19i*\xe2B\x1do\xa0\xbf>\x04\xf6\xae\xbd\xf3u!\x12I"67c'
 b'r\xf71\xcd\x00\x03\x00\x00\x00[ \xbf\\\xe0\x86\x00\x04\x00\x00\x00'
 b'^\x97\xb5\x06\xbfd2>\xf9?\xe1\x1e\xf5\xff\xb9\xef\xdc\x1a@<8-\xfcw'
 b'\x8e>\xca\x8d!+ \xffd\x80;7\x84\x0f\xee\xed\xae\xbcsk(\x00\x00\x00'
 b'\x1c\x00\x00\x00b')

{'A1': {'B1': 62388, 'B2': 'no'},
 'A2': [{'C1': {'D1': -17,
                'D2': 64,
                'D3': [239, 156, 20],
                'D4': 211,
                'D5': 0.1347935050725937,
                'D6': [201, 184, 27, 255],
                'D7': 11630522797153312534},
         'C2': -0.4122177654940278,
         'C3': 6038547406073961880,
         'C4': 0.18857349455356598,
         'C5': {'E1': 719471133, 'E2': 28576, 'E3': -16578},
         'C6': 83275453,
         'C7': 4084539666},
        {'C1': {'D1': 49,
                'D2': -51,
                'D3': [73, 34, 54],
                'D4': 32,
                'D5': -0.8628009557723999,
                'D6': [55, 99, 114, 247],
                'D7': 10931651089601281785},
         'C2': 0.5350294108061422,
         'C3': 1891578055482963854,
         'C4': 0.39560797810554504,
         'C5': {'E1': 723582820, 'E2': 32827, 'E3': 14212},
         'C6': 267316654,
         'C7': 3161680680}],
 'A3': -0.38209110498428345}

Вариант №17

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

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

(b'YNM\xe7Do\x91\x82\xf7/\xf2\x00\x08\xce;\x15`\\\xbf\x03\x00R\x00\x82'
 b'\xcf\xb5\xb2\x97\xc9\xbf\\\x95\x1b\xc4w\xf8JH\xb6\xf9\xceXC?\x02\x00\x00\x00'
 b'U\x00\x00\x00\x02\x00a\x00\x00\x00\x95!\x898\xd7ZI\x97m\x00\x00\x00\xca\xc3'
 b'\xa6\x96\x1b\xd6]\x00\xc6\x88I\xd3shthv3\x1c\x989\x8aX\xa9(\xf0\x86\x03\x00W'
 b'\x00\xf0n\x02\x00]\x00}\x8c\x137')

{'A1': {'B1': -995304852467792665,
        'B2': -0.0017318923339364467,
        'B3': 'sht',
        'B4': 6683282025416609666,
        'B5': -107,
        'B6': 17993648848038773787,
        'B7': 0.7630738019943237},
 'A2': 'hv',
 'A3': [{'C1': [7219, 14744, 22666], 'C2': 28400},
        {'C1': [10409, 34544], 'C2': 35965}],
 'A4': -7545399820269575787,
 'A5': {'D1': 19, 'D2': 55},
 'A6': -15414,
 'A7': -702835034,
 'A8': [93, 0, -58, -120, 73, -45]}

(b'YNMS\x91p\xb0=;%D|`\xd5D\xe5?\xdb\xbf\x02\x00R\x00\x9fv\x8e02\xc6<Ec'
 b'\xeb\xfcD\xb6/\xaf\xd9fr$\x11?\x04\x00\x00\x00T\x00\x00\x00\x02\x00b\x00'
 b'\x00\x00\xcf\xab\xad!\xc3H3\xe3n\x00\x00\x00H\x86\xb0\x16&\x1d5\xa3\xbb=}&hd'
 b'eomp\xe4\xa0]\xb0\x9c\xd8?\xc4\x1c\xc0\x03\x00X\x00\x8c\xc0\x02\x00^\x00'
 b"\xa9\xf3'\xa5")

{'A1': {'B1': 4910396104856605011,
        'B2': -0.42577487680455994,
        'B3': 'hd',
        'B4': 4989080406084974239,
        'B5': 99,
        'B6': 7411147281271160043,
        'B7': 0.5669623613357544},
 'A2': 'eomp',
 'A3': [{'C1': [41188, 45149, 55452], 'C2': 49292},
        {'C1': [50239, 49180], 'C2': 62377}],
 'A4': -2075235000366814257,
 'A5': {'D1': 39, 'D2': 165},
 'A6': -31160,
 'A7': 489035440,
 'A8': [53, -93, -69, 61, 125, 38]}

Вариант №18

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

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

(b'FPOS<s54\xe6^\x00\x03\x00\x00\x00H?\xc8\xb6K\xac\xff\xd2\xb8X\x15>h'
 b'\x1f\x8c\xdb\xfde\xe6\x00u\x00\x04\x00\x8eVO9\xbb\x81\x15%v`v(\x84'
 b'\xec\x81\x1aa\xfd=\x92\xdc\xde\xe5K\xea"\x0c\xf3\x00Xo`m\xa0\xbf-G'
 b'\x03\x00\x00\x00\x02\x006\x83\xbd\xf4\xe9\x87\x00\x00\x00\x04\x00:$<'
 b'\xac,\xd6\x00\x00\x00\x03\x00B\x05us\x8bp+\xbbf\x8a\xe9\xbe\xd9\x00\x00\x00'
 b'\x06\x00\x00\x00i\x10%\xa6Jx\\Xi?\xca"\x93\x16\xf0\x9f`;\xbb\xfd\xde\x93')

{'A1': {'B1': 1014183220,
        'B2': 58974,
        'B3': [{'C1': 160, 'C2': -0.6768648028373718, 'C3': [6753, -707]},
               {'C1': 131,
                'C2': -0.1195860430598259,
                'C3': [-27940, -8475, 19434, 8716]},
               {'C1': 36,
                'C2': 0.021017473191022873,
                'C3': [-3328, 22639, 24685]}],
        'B4': 0.19306322047454727,
        'B5': 1477787240},
 'A2': 529325053,
 'A3': 26086,
 'A4': {'D1': [1397, 29579, 28715, -17562, -29975, -16679],
        'D2': 1163518917522249833,
        'D3': 0.20418013210405217,
        'D4': 59},
 'A5': [-69, -3, -34, -109],
 'A6': [22095, 14779, 33045, 9590, 24694],
 'A7': 679799937}

(b'FPOS\xfd\xa3Q\xc6\x959\x00\x04\x00\x00\x00X?\xe0\x02\xad_d\x02.\x88\x99x\xd6'
 b'\xa9\x93\x10e\x91X\x00\x8a\x00\x06\x00\xa3\x13L\x7f\xe1 O\xa40;1)\xa4'
 b'\x05Z\xa4t\x13\xb5X\x807!#SF>\xad[\x07\xbd:"a\xe5\xc7\x8e\x03\x02\x85\xa0'
 b'\x01\xbb\xf1\xec\xe7C\xa5\xa6+?%\xd4}\x00\x00\x00\x05\x006\xcc'
 b'\xbf\x15\x80\xc2\x00\x00\x00\x05\x00@\xb6\xbfb\x96\xfb\x00\x00\x00\x04\x00'
 b'J\xe7?%\x05E\x00\x00\x00\x03\x00R\xb9\x94\xd7\x01\r\xe4\x00\x00'
 b'\x00\x03\x00\x00\x00\x84\xff\xe0\xbf(\x06g^\xff?\xec\xc2\xb8\xadZgt/W\xe2n}{'
 b'\xcd')

{'A1': {'B1': 4255338950,
        'B2': 38201,
        'B3': [{'C1': 43,
                'C2': 0.6477735638618469,
                'C3': [-23436, 5045, 22656, 14113, 9043]},
               {'C1': 204,
                'C2': -0.5839959383010864,
                'C3': [17982, -21157, 1981, 14882, 25061]},
               {'C1': 182,
                'C2': -0.8851162791252136,
                'C3': [-14450, 770, -31328, 443]},
               {'C1': 231,
                'C2': 0.644611656665802,
                'C3': [-3604, -6333, -23130]}],
        'B4': 0.500326811132316,
        'B5': 2291759318},
 'A2': 2844987493,
 'A3': -28328,
 'A4': {'D1': [-18028, -10495, 3556],
        'D2': -8797020627706113,
        'D3': 0.8987697015574967,
        'D4': 47},
 'A5': [87, -30, 110, 125, 123, -51],
 'A6': [4940, 32737, 8271, 42032, 15153],
 'A7': 698615130}

Вариант №19

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

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

(b'gBQCR\x19#\x94\xbc\x03i\xab\x08A\x1c\x00\x00\x00\x03\x005\x00\x00\x00'
 b'\x02\x00\xa6b\xa9l\x92x\x8c\x1cx\x16\xd3R\xd8\xa8C\xb4\x94\xe6\x97\x0f6\x8a'
 b'D6;\xcd\xb2lfac\x8a\xbb6\xc2\xb7\x9c\x81\xbf\xe1\xb6\x01\xcdN\xcd\xc2'
 b'\xbf\xcf\xf8R\xeftn\xd0?\xe1\x98ChH\xcc\x82\xbf\xe0\xfd\x87\x0b\xdb\xf3:'
 b'B\xfe(\x86\x00\x00\x00\x08\x008f\x00\x00\x00\x04\x00@\xae=\xb2\x97-U/%}\xd1?'
 b'\xec\xf2[\xb5\xc8\x7f$\xbf\xd0vN\xd4\xb9\x1a\x00?\xd9A&\x95\xab\xc6xM'
 b'\xeb\xea%\x00\x00\x00\x08\x00s\xdb\x00\x00\x00\x03\x00{\xc1{\x00`\x00\x93')

{'A1': 421762236,
 'A2': 873,
 'A3': -1425522404,
 'A4': 'lfa',
 'A5': [{'B1': 1123952774,
         'B2': {'C1': [99, -118, -69, 54, -62, -73, -100, -127],
                'C2': 102,
                'C3': [-0.5534676561277865,
                       -0.24976574604158097,
                       0.5498368298343765,
                       -0.5309481841683017]},
         'B3': 44605},
        {'B1': 1307306533,
         'B2': {'C1': [-78, -105, 45, 85, 47, 37, 125, -47],
                'C2': 219,
                'C3': [0.9045847464039736,
                       -0.2572209432004513,
                       0.39460148445423426]},
         'B3': 49531}],
 'A6': 7109332863124511864,
 'A7': 22,
 'A8': {'D1': -3219272566414469914, 'D2': -7561765281853981747, 'D3': 178}}

(b'gBQCR{\xc2\x01S\xb7\xa9\xd3\\\xbe\xb0\x00\x00\x00\x05\x005\x00\x00\x00'
 b'\x02\x00\x9c\x8f\x8f\x89\xaa@[\xd6H\x16\xcd\xdbQ$\xfd\xfb\x130\xcd0\xf2,'
 b'\x816:hAxzhnq\xfe\xa9\xbf\xe5\x8bP\xd7{\r\xf4?\xc9\xb7\x15N\x12\xbf\xa8'
 b'\xe1.>}\x00\x00\x00\x02\x00:\x9a\x00\x00\x00\x02\x00<\xd0\x0b\x06'
 b'\xad\xbf\xe4\xe5\xbd\x83\xd8O\xac\xbf\xb9om?i|0\xbf\xea\xc7\x96\x89-\xfe'
 b'\xf6?\xba5F\xf7\xed\xc3\x10\xbf\xde\xec\xf6y\xc8\x07\xe4\xc5\xe9\xac'
 b'\xb9\x00\x00\x00\x02\x00_\x9b\x00\x00\x00\x05\x00a7\xa3\x00L\x00\x89')

{'A1': 2076311891,
 'A2': -18519,
 'A3': -748896592,
 'A4': 'xzhnq',
 'A5': [{'B1': -517063043,
         'B2': {'C1': [-2, -87],
                'C2': 154,
                'C3': [-0.6732563217742027, 0.20089975654763959]},
         'B3': 53259},
        {'B1': -974541639,
         'B2': {'C1': [6, -83],
                'C2': 155,
                'C3': [-0.6530444693657862,
                       -0.09935648725648671,
                       -0.8368637732782804,
                       0.102375445870859,
                       -0.4832130612631984]},
         'B3': 14243}],
 'A6': 10344638233410524744,
 'A7': 22,
 'A8': {'D1': -3613205056712928464, 'D2': -3661160224091915672, 'D3': 65}}

Вариант №20

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

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

(b'\x9aOZSD\x0f}tg{\x9a*\xe1\x00\x06\x00\x00\x005\x00\x00\x00;<\xbe6Untuo\xa6'
 b';\x9d\xb0l\xa9(\xfe\xbe\xe2\x00\x00\x00\x02\x00M\x00\x00\x00\x02\x00\x9drwn'
 b'zzm\xc2}&\xc4\xfcPJ\xffZ\x85\xe8]\x8b\xcd\xb0\xc0\x80\x82\xbf\xefwpC\\f'
 b'\x9e\xbf\xe6\xb0ey\x80\xf2\xfc?\xe5\xc0\xaa,L\xaf\xc8?\xd9S\x0e\x9f\x01g'
 b'\\\xbf\xd6\xf6\x1d/-5\xa0\xbf\xd9F\xb1^\x96\xdc8?\xe9\x8f\x8b\xb85\x9b'
 b'\xb8?\xee\x9f\x17\x04\xad<\xf6?\xea\xe3\xae\xee\xf0^"\xbf\xe6\x99'
 b'\x91\xff\x0e\xb8lv\xbc')

{'A1': {'B1': 1116176270461905633,
        'B2': 'rwnzzm',
        'B3': {'C1': -4432343830774134017,
               'C2': 1518725213,
               'C3': -1949454144,
               'C4': 32898},
        'B4': 0.023219266906380653},
 'A2': 'ntuo',
 'A3': 42555,
 'A4': -7084042740060733726,
 'A5': [{'D1': -0.9833298984187484,
         'D2': [-0.7090327618712702,
                0.6797686448312499,
                0.3956944039142536,
                -0.35877160651292606]},
        {'D1': -0.3949397491191493,
         'D2': [0.7987726781692492,
                0.9569201556531926,
                0.8402933756614781,
                -0.7062463742820575]}],
 'A6': [118, 188]}

(b'\x9aOZSDj>\xf64\xd8\x1f\x84\xba\x00\x03\x00\x00\x005\x00\x00\x008?x\xf2hi'
 b'xuv7\x11\x0c>N\xad\xff\xdf\xfc\x91\x00\x00\x00\x02\x00J\x00\x00\x00\x02\x00'
 b'\x9amyiwT$\xfbqQ\xcb\xd1|\xe7=u\xac\x94\xea\x1d\xff\xd4?\xe9\xf4\xfe\x0fb'
 b'\xd2\x12?\xdb\xae\xe8~\xb9VD\xbf\xd7\xec\x8e\xc0\x0f\xb4d\xbf\xe1\x84\xf5DG'
 b'\xb3\xe6?\xc8\xcf\xe8\x02\x13_\x10?\xb3jR\x80p\x94\xe0?\xd5\xc6\xde\x07\xe6'
 b'X\xb4?\xedc\x95 \xe3\xfb@?\xc3\xd7b\xc5\xed\xaf@?\xc6\x8c(\xcc\xf6S\xd0\x17a')

{'A1': {'B1': 7655827123401098426,
        'B2': 'myi',
        'B3': {'C1': 8598538250913696721,
               'C2': 2095529333,
               'C3': -1399526883,
               'C4': 65492},
        'B4': 0.9724488258361816},
 'A2': 'ixuv',
 'A3': 14097,
 'A4': 882229086240373905,
 'A5': [{'D1': 0.8111563015468752,
         'D2': [0.43255054831874795,
                -0.37381333118429994,
                -0.5474802335353359,
                0.19384479619360961]},
        {'D1': 0.07584109912621129,
         'D2': [0.34026289721931424,
                0.9184060709375004,
                0.1550105539748703,
                0.17615232475205156]}],
 'A6': [23, 97]}

Вариант №21

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

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

(b'EVJF\xa3\x80\xef\x8b\xbf\xe7%\xc1G\xe0\xa3f\x00\x03\x00\x00\x00!\x00feesm'
 b'rczjr\xad\x00\x03\x00\x18N\x89i\x898&\x96t\x8b\xfcdM\xd5w\x01M\x99\x00'
 b'\x03\x00\x1b\x1e\xcf\x9b\x17\x8e@\xa9\x9c#\xb1G\x8e\xb0\xb7\xe7\x9fH'
 b'\x00\x03\x00\x1e\x8e\x0c;\x08\x9d\x8bR\x87\xeb\x0cS\xa7e\xf3\xa1F'
 b'\xf6\xbc;\xfb\xa5\x1a\xb2\xf0\xfb\xc9\xbc}\x03\xe0\x00`]L\xe4\xc3'
 b'\xc4h\xd8\x83\x079mx\xc7e\x12\x00')

{'A1': -1551831157,
 'A2': -0.7233587650162974,
 'A3': [{'B1': -83,
         'B2': 'ees',
         'B3': 1317628297,
         'B4': 4046086742547915853,
         'B5': -713621171},
        {'B1': -103,
         'B2': 'mrc',
         'B3': 516922135,
         'B4': 10250379239974061966,
         'B5': -1330124897},
        {'B1': 72,
         'B2': 'zjr',
         'B3': 2383166216,
         'B4': 11352258029434983335,
         'B5': 1710465350}],
 'A4': {'C1': -5552661496678513696,
        'C2': {'D1': [-10, -68, 59], 'D2': -1115, 'D3': 26},
        'C3': [6722999873222269059, 520567597446795776]}}

(b'EVJF\xd9\xa4\xfc,?\xd1\xc9\x0b\xd6S\xfb\x1c\x00\x05\x00\x00\x00$\x00\x93ebbh'
 b'ircmzpfa\x0e\x00\x03\x00\x18%~\x90>\x8d\x9d\xdf\x9d\xa2\x11\x9fCs|\xd7'
 b'-G\x00\x02\x00\x1bDMh\xa8\xe1\x000"\xea\x90\xac\xfe!\x16h\xe0\xdd\x00'
 b'\x02\x00\x1d\xa7\xb4\xe70@\xf90L_\xd3\x9c\x14\xf3O\xca-\x1f\x00\x03\x00\x1f'
 b';(\xa9\x8f\xe9\x99c{\x1e\xfa;\xf51\xad\x02D\xf4\x00\x02\x00"\xcb\x04L'
 b'\xcf}\x16\x07\x14\xc3\xb66\xb7\x87\xa8\xe0O\xa5\xcd\xa92\x1f\x8c\x90'
 b'#\xb8\xfb+\xf8\x9a\xad\x00\x8dW5)\xe8\x11\xfa\xd81\x8d2\xb1\x94\xc9\xce\x9f'
 b'\xa7')

{'A1': -643498964,
 'A2': 0.2778958886191718,
 'A3': [{'B1': 14,
         'B2': 'ebb',
         'B3': 629051454,
         'B4': 10204558198813335363,
         'B5': 1937561389},
        {'B1': 71,
         'B2': 'hi',
         'B3': 1145923752,
         'B4': 16213011585056156926,
         'B5': 555116768},
        {'B1': -35,
         'B2': 'rc',
         'B3': 2813650736,
         'B4': 4681826392211692564,
         'B5': -212874707},
        {'B1': 31,
         'B2': 'mzp',
         'B3': 992520591,
         'B4': 16832594462725782517,
         'B5': 833421892},
        {'B1': -12,
         'B2': 'fa',
         'B3': 3406056655,
         'B4': 9013399489992865463,
         'B5': -2018975665}],
 'A4': {'C1': -8060395519149040979,
        'C2': {'D1': [-91, -51, -87], 'D2': 12831, 'D3': 140},
        'C3': [6283974931776198705, 10174389760782409639]}}

Вариант №22

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

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

(b'VRHN\xdcd\x03k}\x04\x15\x13ufB\xbfV\xaa\x90\xbe\x03\x00s\x00g.4\x87'
 b'\xec\xd8a^\xe7q\xd5\xf3\x83\x00\xa9#>\xdc\xa7[\x12\x8a\xe46zxdb&\x00\x00\x00'
 b'\x04\x00\x00\x000\x00\x00\x00\x85\xcf\xbeu\x1b\xf3\xf8B\xdc\xc9vupt@\x00'
 b'\x00\x00\x04\x00\x00\x00J\x00\x00\x00\xc8\x97\xc5Ow?\xf7\x0b\xe1\xe8zseZ'
 b'\x00\x00\x00\x03\x00\x00\x00d\x00\x00\x004\x00\x00\x00N\x00\x00\x00g'
 b'\x00\x00\x00\xfb\xb9Ba\xf24\xcb\x86\x7f@GRWbX\xd2\x18\xf8\xa5o\x92'
 b'\x9d\x17\xbfi\x00o\xb5>\x83!\x02\x00\x7f\x00')

{'A1': 1375010197944362204,
 'A2': -0.7593758702278137,
 'A3': -0.28254956007003784,
 'A4': [{'B1': {'C1': -87, 'C2': 35, 'C3': 1537727550, 'C4': 920947218},
         'B2': 'zxdb'},
        {'B1': {'C1': -123, 'C2': -49, 'C3': -216304194, 'C4': 3386655480},
         'B2': 'vupt'},
        {'B1': {'C1': -56, 'C2': -105, 'C3': 1064783813, 'C4': 3907062775},
         'B2': 'zse'}],
 'A5': -2026623385,
 'A6': 17570074759790713068,
 'A7': {'D1': -14,
        'D2': 6292169971733023540,
        'D3': {'E1': 98,
               'E2': [88, -46, 24, -8, -91, 111, -110, -99],
               'E3': 6930199,
               'E4': 2201924975,
               'E5': 33,
               'E6': [-17925, 24898]}}}

(b'VRHN\x99T\xc3\xb75\xdd\xb3\xf9ai\x97=D\x97w?\x03\x00p\x00s\xf5\x91 '
 b'\x01\xf3\x07\x93L\x14a$\x80\x00\x1f\x1c\x10\n\xdb\xc9uv\xa3.ftg&'
 b'\x00\x00\x00\x03\x00\x00\x000\x00\x00\x00\x86\xe8\xd8\xff\x90\x9dsx\xa9'
 b'\xb6ew?\x00\x00\x00\x02\x00\x00\x00I\x00\x00\x00\xe8~\xa7\xd0\xd46-\xba\xd2'
 b'\x89fnmW\x00\x00\x00\x03\x00\x00\x00a\x00\x00\x003\x00\x00\x00K\x00\x00\x00'
 b'd\x00\x00\x00[vF\x9a\xde\x07\x88\xc8\n\xa2eH["S\x9c\xe3\x96G\xbc'
 b'\x90\x8eF\xa1\x83\xe6|d\x0e\xd01\x02\x00|\x00')

{'A1': 17992968159061300377,
 'A2': 0.07393146306276321,
 'A3': 0.9671518802642822,
 'A4': [{'B1': {'C1': 31, 'C2': 28, 'C3': -908391920, 'C4': 782464629},
         'B2': 'ftg'},
        {'B1': {'C1': -122, 'C2': -24, 'C3': -1651441704, 'C4': 3064559731},
         'B2': 'ew'},
        {'B1': {'C1': -24, 'C2': 126, 'C3': 919916711, 'C4': 2312288813},
         'B2': 'fnm'}],
 'A5': 546436467,
 'A6': 2621398777223181057,
 'A7': {'D1': -34,
        'D2': 6577619002414630919,
        'D3': {'E1': 34,
               'E2': [83, -100, -29, -106, 71, -68, -112, -114],
               'E3': -427581114,
               'E4': 3490604156,
               'E5': 49,
               'E6': [30299, -26042]}}}

Вариант №23

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

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

(b'EQD\x91\x92\xd3\xaf\x01\x00\x00\x00\x02\x00B\t\xea[\xde\x17\x8c\x84\x1fot'
 b'\xeb\x9c\x87!\x1b*\xadL\xc8[\xec\xc9\xad\xba\xa7\xe0\xfd\xe2J\xa9'
 b'\xa0\xdc\xad\x05\x90\x10\x00\x04\x00\x88\x00\x00\x00\x8cH\x190=\x0b\xa3'
 b'V\xb9\xff\x81\xb4\x04MB4\\\xbe\xca\xc2O\x82\x95\xd4\x98\x01\xa0'
 b'\xac\xbc\xbf\xde[\x80\xddS\xad\x88~\xf7/\xfb3\xdf\xe7{:\x06\xba\xc6\xefw'
 b'\xd1<Y\xb6o\x92\xf2YJ\xccv\x15\t?\xc5\xf0.\x9e*\xc7\xc0\xd2_\x9cqa\xff\xd8'
 b'~}<\xad\x0c~\xb1\x8cq\xbf{X\xb3\x076s\xb8\xd3\\\xd0')

{'A1': {'B1': -1831620863,
        'B2': [{'C1': 18411194682236351580,
                'C2': [-1094008241, -2104109928, 27307196],
                'C3': -0.47433492292358226,
                'C4': 126,
                'C5': -2257,
                'C6': -80486425},
               {'C1': 8879417014585620433,
                'C2': [1012512367, -1829611190, -864676599],
                'C3': 0.1713922760296196,
                'C4': 210,
                'C5': 24476,
                'C6': 1902247896}]},
 'A2': 166353886,
 'A3': [1696876430160620444,
        -8709650334247761829,
        -1384384393247654430,
        5380008099526840336],
 'A4': [126, 125, 60, 173],
 'A5': {'D1': 3198, 'D2': [45452, 29119, 31576, 45831, 13939, 47315, 23760]},
 'A6': 5195236683894970041}

(b'EQD\x91\xcf\x07\x83\x10\x00\x00\x00\x02\x00B\xc4\xa1\xff\xd9\xd5\xd8'
 b'\x9d\xd3\xe7\x10\x01\xbe\x7f\xf2\xf8\n\x1fq\xd4\xa8xv=\xab\xfa}\xa1=tT'
 b'!f\x90<\xe9\xb4\x00\x04\x00\x88\x00\x00\x00\x8c\x8e?\x0cJ)\x89\xfb\\\x00G'
 b'\x90D\x15Z*i\xd6`\xfdo=\x16i8e1\x88\x9c\xbf\xe5\xd8P\xefNg\x02\x16K'
 b'J\x94\xa8\xf8g\xd4\xcd[\x11\xd35\xc97C\xd6k\xeaV")\x0b\t\x19\xee'
 b'\x92\xbf\xeet<^\xe00\xec/\xf3r\xcbil\xec\r\x9f\x85%7\xb8 !\x9dq\\D\xfb8k\n'
 b';X[\xd0')

{'A1': {'B1': -821591280,
        'B2': [{'C1': 20143345436863081,
                'C2': [-698286737, 1024878904, 1697745052],
                'C3': -0.6826557802152993,
                'C4': 22,
                'C5': 19274,
                'C6': -1800865689},
               {'C1': 15334012438382496055,
                'C2': [1138125802, 1445079307, 152694418],
                'C3': -0.9516889431993412,
                'C4': 47,
                'C5': -3214,
                'C6': -882283284}]},
 'A2': 3298951129,
 'A3': [-3037504415221153346,
        9219704109541741736,
        8680193140654448957,
        8382361530833627572],
 'A4': [13, 159, 133, 37],
 'A5': {'D1': 14264, 'D2': [8225, 40305, 23620, 64312, 27402, 15192, 23504]},
 'A6': -8196819284126991524}

Вариант №24

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

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

(b'ZZJO&\x9f0\xec\xfe\xbezyqfpfeh\x03\x00v\x00\x11\xcbI\xbe\x90\xf3\x85\nn\xdd'
 b'\xd9v\xf1\xee\xa9/\xf2\x92\xd7\x03\x00\x00\x00\x82\x00\xf5~\n\xb1\xc7'
 b'\x1e\x14\x9f\x12\xc1\x11&\xc1\x0c\x7f\x1d\xc7\xdb+[=r\x04\x00\x00'
 b'\x007\x00\x00\x00I\xba\xde\x81V\xab^(\xf6\x83\xf1\x99\x02\x00\x00'
 b'\x00M\x00\x00\x00RN\x97\x81l\xfe_?\x06\xa7y4\x01\x03\x00\x00\x00a\x00'
 b'\x00\x00;\x00\x00\x00O\x00\x00\x00d\x00\x00\x00\xb9\xab\xcb#-1')

{'A1': {'B1': -24794,
        'B2': -0.4978957176208496,
        'B3': 'zyqfpfeh',
        'B4': [{'C1': 193,
                'C2': 4421175682132705036,
                'C3': 114,
                'C4': [18, -63, 17, 38]},
               {'C1': 222,
                'C2': -1043720035372411263,
                'C3': 153,
                'C4': [73, -70]},
               {'C1': 129,
                'C2': 3781237007429140076,
                'C3': 1,
                'C4': [82, 78, -105]}],
        'B5': -0.19706369936466217,
        'B6': 8564119631114400656},
 'A2': 61169,
 'A3': {'D1': 12201,
        'D2': -14,
        'D3': 55186,
        'D4': [43961, 9163, 12589],
        'D5': 32501},
 'A4': -20214,
 'A5': 2668895943}

(b'ZZJO\xd44\xdfk,?whgjgqkx\x03\x00v\x000\x08\xf6\xbe\xc0)\x00\xc1\xc7\xd7'
 b'S\xf3\xa7|\xb8\xf8\xd5\x0bb\x02\x00\x00\x00\x82\x00\xe3\x07Q5\x86/\xaa\x89$'
 b'O\xb3\x89\xbe\xe0Ms\x97\xfc\xe2\xe6\x02\x00\x00\x007\x00\x00\x00lM\xa1\x1cp'
 b'\xed\xb8\x13W\n\xa3\xa1&\x03\x00\x00\x00K\x00\x00\x00\xbe.\xaa\xeb\xa4>G3'
 b'\x93At\x01\xbf\xcb\x04\x00\x00\x00`\x00\x00\x009\x00\x00\x00N\x00'
 b'\x00\x00d\x00\x00\x00\t\xb9!G')

{'A1': {'B1': 13524,
        'B2': 0.6735209822654724,
        'B3': 'whgjgqkx',
        'B4': [{'C1': 179,
                'C2': -2090629605523145079,
                'C3': 230,
                'C4': [36, 79]},
               {'C1': 28,
                'C2': -6799579643289997968,
                'C3': 38,
                'C4': [108, 77, -95]},
               {'C1': 164,
                'C2': -4683334312497297602,
                'C3': 203,
                'C4': [-66, 46, -86, -21]}],
        'B5': -0.4805312156677246,
        'B6': 17533595027219950016},
 'A2': 31911,
 'A3': {'D1': 63672, 'D2': -43, 'D3': 25099, 'D4': [47369, 18209], 'D5': 2019},
 'A4': 13649,
 'A5': 2309631878}

Вариант №25

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

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

(b"CYFF\x9b\xc2g\x04\x00\x00\x00\x04\x00B}\xf3A1h\x02\xb4'\x00\x00\x00P\x00\x00"
 b'\x00l\x00\x00\x00\x88Y?\xb1J\xf3\xbb\xff\xfb\x9c\xf0\xd84\xd2\x8b'
 b'\x97\xdc\x00\x00\x00\x04\x00\x9a\x07\x8bC\x82H\x06}\xea\xd9~mymx\xd8\x02'
 b'\xc5WD6f\x95\xfc\x8c\x00\x00\x00F\xa3\x04i2\xdc\x99?\xc7\x95\xdcZ^'
 b"*\xe8\xa5\x9e\xfbo\x05\x101\x8a\xd0\xc5\x00\x00\x00bQ\xf2'\x01CF?\xed"
 b'\xf5\x0c\x81(-\xe0u\xd2\x9d\x89\xb4v\x84\xf1\x05z\x00\x00\x00~\xb3u\x87B'
 b'\x87]\xbf\xeco\xff\x86;=\xc0"\x93&Y\\\x1c\xd52')

{'A1': -1681758460,
 'A2': 'mymx',
 'A3': 9075669354535892007,
 'A4': [{'B1': {'C1': -40, 'C2': 199661708969940476, 'C3': -116},
         'B2': 41732,
         'B3': 1764940953,
         'B4': 0.1842608872651319},
        {'B1': {'C1': -91, 'C2': 11455872144684190416, 'C3': -59},
         'B2': 20978,
         'B3': 654394182,
         'B4': 0.9361631891819648},
        {'B1': {'C1': 117, 'C2': 15176437727483982085, 'C3': 122},
         'B2': 45941,
         'B3': 2269284189,
         'B4': -0.8886716481883283}],
 'A5': [1497346378, 4089184251, 2633029684],
 'A6': {'D1': 53899,
        'D2': [151, 220],
        'D3': [8851, 9817, 23580, 54578],
        'D4': 1931},
 'A7': 1132611590,
 'A8': 2112543102}

(b'CYFFN\xbe\xc7\xe6\x00\x00\x00\x02\x00B\x94\x8c\xc5\xe6\xa5\xf5\xc1f\x00\x00'
 b'\x00N\x00\x00\x00j\x00\x00\x00\x86\x8b\xd1j\x1at5\xb7\x04\x96\xbd'
 b'\xbe;\xd8\xa8\xb9)\x00\x00\x00\x02\x00\x98\x91\xfbP\xe3A\x90\x16\xe9'
 b'\x9e\x8bqk7 \x90g\x0b~e\x1cT\xce\x00\x00\x00D&9\xfa\x93\xf3\x1d\xbf\xe5b5'
 b'\x8a\xf2\xcb\xccF\xc6FG\x90\x07>\xbe`\xaf\x00\x00\x00`\xe0\xc1'
 b'\xd3\xf2\x17\xda?\xe5!V\x8cq\x91\xe67\xd0\x11\xce\xe4:\xdb\xfe'
 b'\x12\x80\x00\x00\x00|N\x1f?\x9c2\x11\xbf\xe8\x0b\xe6\xe9\x80\x93\x1aM\xb8*B')

{'A1': 1321125862,
 'A2': 'qk',
 'A3': -7742596064939228826,
 'A4': [{'B1': {'C1': 55, 'C2': 2346488704922885204, 'C3': -50},
         'B2': 9785,
         'B3': 4204000029,
         'B4': -0.6682384218059894},
        {'B1': {'C1': 70, 'C2': 14287185551801892448, 'C3': -81},
         'B2': 57537,
         'B3': 3555858394,
         'B4': 0.6603195899047563},
        {'B1': {'C1': 55, 'C2': 14992992114128453138, 'C3': -128},
         'B2': 19999,
         'B3': 1067201041,
         'B4': -0.7514528809157099}],
 'A5': [2345757210, 1949677316, 2529017403],
 'A6': {'D1': 55464, 'D2': [185, 41], 'D3': [19896, 10818], 'D4': 37371},
 'A7': 1357070736,
 'A8': 384409227}

Вариант №26

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

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

(b'PEEH\x8b\x00\x00\x00\x03\x00\x00\x00\x1c\x002j\xaeM\x03\xe0\xed\x84\xb9:'
 b'\x96Q\xd3%\x00\x00\x00\x13\x00\x00\x00\x16\x00\x00\x00\x19edyz\x88\xce5\x0b'
 b'\xd5\xc6I\x87n\xbc\x82\x03\x1c1\x00\x00\x00\x04\x00(\x08\\k@\x00\x06\x00\x00'
 b'\x00,\xa8Du\xa9}C\x0fm\xe6tR\xf7\xbf\xe7\x1d\xf3\xbe:\x81|\x9b')

{'A1': [{'B1': 224, 'B2': -4732},
        {'B1': 185, 'B2': 14998},
        {'B1': 81, 'B2': -11483}],
 'A2': {'C1': 1233612476,
        'C2': -2113725391,
        'C3': 'edyz',
        'C4': 140274496,
        'C5': [-120, -50, 53, 11, -43, -58],
        'C6': {'D1': [2823058857, 2101546861, 3866383095],
               'D2': -0.7224062648202074},
        'C7': 155},
 'A3': 1789807875}

(b'PEEH\x8b\x00\x00\x00\x03\x00\x00\x00\x1c\x00/\xda\xfc\xc8Z\x80"\xf7C\''
 b'\x88e\x0b\x12\x00\x00\x00\x13\x00\x00\x00\x16\x00\x00\x00\x19efc\xc5'
 b'\xf4\x93\x1cT\xd2=\xcd\xc3\xab\x05\xdb\x00\x00\x00\x03\x00(\xc3\xafx'
 b'q\x00\x04\x00\x00\x00+][\x08\xaeb\xf5\x99l\x94\xdcp]?\xedp<\x7f\x17H\x12a')

{'A1': [{'B1': 128, 'B2': 8951},
        {'B1': 67, 'B2': 10120},
        {'B1': 101, 'B2': 2834}],
 'A2': {'C1': 1423064525,
        'C2': -1012202021,
        'C3': 'efc',
        'C4': 3283056753,
        'C5': [-59, -12, -109, 28],
        'C6': {'D1': [1566247086, 1660262764, 2497474653],
               'D2': 0.9199507219548215},
        'C7': 97},
 'A3': 3673999450}

Вариант №27

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

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

(b'VXVE\x02\x00\x1d\x00\x00\x00\xdc\xa2\xbdaclb\x80c\x00\x8c\x7f\x10{'
 b'\xca\x81\x84\xc3M\xb4\x1a&\x1a>\x1a\x1a\xf3@\xb34@\x9b\xe0\xaaq\x89\xc9\xd5'
 b'+\x0b\x17`\x111:\xaf\xe5\xab\xf7\xd2\xacr\xad\xc8\x02[\xa9\xa6\xddAF`'
 b'\x82\xf4\x88,\xea\xde\x91\xc7w\xb2k\x02\x00K\x00r\xa5^\xb4\x81E\x84\xbf)'
 b'\x08\xea>\xd8i\xf6\xe7\xe7\xcf\xf6D\xa0\xaeD?\x80\x05\x03\x003\x00S\x00\x12'
 b'\xf9\xde>')

{'A1': [{'B1': -76, 'B2': 9754, 'B3': 3797450323662618138},
        {'B1': 64, 'B2': 57499, 'B3': 1660469084825416106}],
 'A2': 1639817948,
 'A3': 'clb',
 'A4': -128,
 'A5': {'C1': 4969387833786001880,
        'C2': 0.7682895660400391,
        'C3': -128,
        'C4': 5,
        'C5': [-600133584565497504, -6243393397492372270, -8578088040226759258],
        'C6': {'D1': [-1847662036, 1806858183],
               'D2': [114, 165, 94, 180, 129, 69, 132, 191],
               'D3': 0.4570935070514679},
        'C7': 0.43549400568008423},
 'A6': -116,
 'A7': 5603468054361739391}

(b"VXVE\x02\x00\x1d\x00\x00\x00i\xe6'\x95mkg\xb2[\x00.\x10\xaf\xabx\x14\xee "
 b':c\xb04\xcc\x18\xfaG\x9eS\xa6\xda|N\xec@\xf9\x1b=\xd9\x08\xcf\x84q'
 b'\x10\x80\x08\x12\x92\xa5\xc94>\xbf\x0e\x88{m/A\xae\n#+\x1d\xf9K\x02'
 b"\x00C\x00I0V\n'\x08!\xe3\x7fR(?\xd4\x9b\xc2E\x14\x1f\xe2\xf8;z\x10?\xdc"
 b'\x03\x02\x003\x00K\x00O\xba<\xbd')

{'A1': [{'B1': 99, 'B2': 13488, 'B3': -2691371788029781812},
        {'B1': 124, 'B2': 60494, 'B3': -8876866611397789376}],
 'A2': -1792547223,
 'A3': 'mkg',
 'A4': -78,
 'A5': {'C1': 17933930838072925140,
        'C2': 0.5643650889396667,
        'C3': -36,
        'C4': 3,
        'C5': [-3916563694779101071, 3417523516537257524],
        'C6': {'D1': [587902529, 1274617131],
               'D2': [73, 48, 86, 10, 39, 8, 33, 227],
               'D3': 0.6575087904930115},
        'C7': -0.04607611522078514},
 'A6': 46,
 'A7': 4188609425145835280}

Вариант №28

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

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

(b'EEXF\x15\x85\xf1v>\x06\x00!\x00!\x97U\xe5\xc4e\xff\xbd\xb3f\xf2'
 b'\x93\x00\x00\x00~\xad{\x8d\xa5}\x850\x91\x9b0C\xab\xe0?\x18\x19\xff\xa8;'
 b',\xd7\xcf\xaco\n\xb1)\x8e\x84\x9b\xef?Y/S\xd46\xd6\x93&\xe5\xec:'
 b'\xd2\x89\xca\xee\xc3\xee\xbf\x9cFlP\x19\x84\x15\x14\xcf\xd3`\xc8h'
 b'\xee\x8d\xe0\xd3?\xca\xa8\xc4\xf8\xf0\x18bI\x84\xc7\xd8\x86\xfa\xf8\xe3'
 b'\xc1\xcd?m\xfd\x87\x9c\x96_-\xf3\xae0\x88 &1x\x87\xe2\xbf\x1f\t\x7f'
 b'\xf5\x00\xec\xc7\xd4\xdd\xbcdJ\xbaf\xc3\x9c\x06\x00\x00\x00\x8d\x00\x00'
 b'\x00\x92\xb6A1\xfeO\xee?')

{'A1': 0.2411556988954544,
 'A2': {'B1': {'C1': [{'D1': -31363,
                       'D2': 0.5209060620659667,
                       'D3': -3470256353115694824},
                      {'D1': 28588,
                       'D2': 0.98773410574134,
                       'D3': 2779800925996527449},
                      {'D1': -4891,
                       'D2': -0.9614175754382537,
                       'D3': 1447208099527804572},
                      {'D1': -11313,
                       'D2': 0.3105807140556234,
                       'D3': 5287816335731239114},
                      {'D1': -14460,
                       'D2': 0.23247956902655775,
                       'D3': -923977248065192595},
                      {'D1': 12462,
                       'D2': -0.5790368041935077,
                       'D3': -3114261128440510177}],
               'C2': [-26847, -6827],
               'C3': [196, 101]},
        'B2': -1,
        'B3': -228150339,
        'B4': {'E1': 40131,
               'E2': [221, 188, 100, 74, 186, 102],
               'E3': 0.9472647630734221}},
 'A3': 126,
 'A4': 31661,
 'A5': -115,
 'A6': 165}

(b'EEXF\x15Ub\x00?\x03\x00!\x00\xb0-h\xe2\xfc*\x0b\xc9B\xab\xe0\\\x00\x00\x00'
 b'kQpJ\xc5X\x85\xe0\x89w\x87"\xd7\xe4\xbf\xde\xa0\xae?\x9e\xfe\xbb\xaa$\x88P,d'
 b'\x1e\xae\x95\xb5?JT\x8f\xfeb\xa49\x15\xb4hhzhc\xcd\xce\xcf?\xbaC\xdb}\n'
 b'J\x9b\x9a6l:\x99\x83Lf\x05\x00\x00\x00W\x00\x00\x00\x1a\xd3\x0e\x0f\xb9X'
 b'\xe0?')

{'A1': 0.5015004277229309,
 'A2': {'B1': {'C1': [{'D1': -31400,
                       'D2': -0.6512615819777317,
                       'D3': -6144037310990212898},
                      {'D1': -30684,
                       'D2': 0.08431518785452963,
                       'D3': 1529434293553550410},
                      {'D1': 26804,
                       'D2': 0.24849860528862,
                       'D3': -7306164561556847686}],
               'C2': [11696, -7576],
               'C3': [252, 42]},
        'B2': 11,
        'B3': -525647159,
        'B4': {'E1': 26188,
               'E2': [54, 108, 58, 153, 131],
               'E3': 0.5108304304218081}},
 'A3': 107,
 'A4': 28753,
 'A5': 74,
 'A6': 197}

Вариант №29

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

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

(b'\xb7KJSH~\x83!\xc2\x11\xd2\xbf(\x00=\x00R\x00\x03\x00\x00\x00e\x00\x1a\xd4S?'
 b'9\x06\x00\x00\x00h\x00ljZ\xe4\xde\x05\x00\x00\x00#\x00\xb5\xe0\x8b4*a'
 b'\x06\x98\x1c\xeb\xa9p\xce\xda\xbd\x02\x00\x00\x00;\x00e\x87\xf4\xacn'
 b'\xdfj\x1d\xbe)\x1c\xe3\xd2\xa8F\x02\x00\x00\x00P\x00\\@\xf2=\xcc\xfbKL'
 b'\xdf\xfdo\x0b\x94/\xf3+\x18}\xe8\x1e\xee\x18\x03?i\xed\x80\xc5v\xcf\xfa\x04'
 b'\xb0LR{AR\x8f\xe6')

{'A1': -0.28233388207261045,
 'A2': {'B1': [{'C1': [108, 106, 90, 228, 222],
                'C2': {'D1': 57525, 'D2': -117, 'D3': -6202832622505088460},
                'C3': -12688},
               {'C1': [218, 189],
                'C2': {'D1': 34661, 'D2': -12, 'D3': 2029362140663475884},
                'C3': -11549},
               {'C1': [168, 70],
                'C2': {'D1': 16476, 'D2': -14, 'D3': 8069851626103098429},
                'C3': -27637}],
        'B2': [47, -13, 43]},
 'A3': 0.8274551630020142,
 'A4': 57,
 'A5': [518552856, 1057167598, -981406359, 83545974, 2068991152, -426814911]}

(b'\xb7KJSD\xb3k\xa8\x14\xa5\xd2?*\x00C\x00]\x00\x02\x00\x00\x00p\x00g9S?'
 b',\x05\x00\x00\x00r\x00\xd8\xa2a\xde>\x1dv\x07\x00\x00\x00#\x00P\xe0\xc2\xa0'
 b'.\xf2\x93\xaa\x9a\x0f\x93=n\x90\xf5D=W\x07\x06\x00\x00\x00=\x00\x17W\xf4'
 b'u\xa2\xfb\xfa\x18\xc3+KX\x12%\xe2;P\xee\x8d\x12\x07\x00\x00\x00V\x00p'
 b'\x965\xb3R\xcafR]\xf8\x822.&T\xf7\xf0\x1d\x022Oy/o\x0c\x83Mfv\xaa\xc3My'
 b'\xf6D')

{'A1': 0.2913257260068358,
 'A2': {'B1': [{'C1': [216, 162, 97, 222, 62, 29, 118],
                'C2': {'D1': 57424, 'D2': -62, 'D3': -7849885568066244960},
                'C3': 28221},
               {'C1': [144, 245, 68, 61, 87, 7],
                'C2': {'D1': 22295, 'D2': -12, 'D3': 5416637488900579957},
                'C3': 4696},
               {'C1': [37, 226, 59, 80, 238, 141, 18],
                'C2': {'D1': 38512, 'D2': 53, 'D3': -9009348446061440333},
                'C3': 11826}],
        'B2': [38, 84]},
 'A3': 0.8250946402549744,
 'A4': 44,
 'A5': [35516663, 796479282, 1300434031, -1012238746, 1157003597]}

Вариант №30

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

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

(b'KMUz\\23"k\xbf\x03\x00\x00\x00O\x00\xdf_\xe5W\x90F?\\\tY\x81e\x02\x00y\x00'
 b'l\xc7\x90\xbd\xd9K{tQ1\xf9\xfb\xc4/ \xd1B\xe4\xa1\xaf\xce\xbf2\t'
 b'\x1b\xfcO\xa0\xea\xe7\n.\x8b\xbeUU\x9c-\xb0\xfe>awrsaqD\x9f\xe2\xc6{'
 b'\xcdK\xd7\x02\x00I\x00\x00\x00\x83G\xa7\xe7-t\x8a\x03\x02\x00K'
 b'\x00\x00\x00\x9d\xf7\xaa\xaeE\x00F\x17\x02\x00M\x00\x00\x00?g6\xf7\xa9\xbdT'
 b'S')

{'A1': 12892,
 'A2': -0.9184905886650085,
 'A3': [{'B1': -2933024800800334012, 'B2': 'aw'},
        {'B1': 255144069408704387, 'B2': 'rs'},
        {'B1': 1677028210525271965, 'B2': 'aq'}],
 'A4': {'C1': {'D1': 223,
               'D2': 95,
               'D3': 229,
               'D4': -9126252878086369193,
               'D5': 101,
               'D6': [4147537727, 1398062505],
               'D7': -0.07069286704063416},
        'C2': -290146475072336935,
        'C3': 12228,
        'C4': -0.2397348751598054,
        'C5': 4229630258},
 'A5': 41039,
 'A6': 59370,
 'A7': -0.2718356251716614,
 'A8': {'E1': [85, 85, 156], 'E2': 0.49743786454200745}}

(b'KMUz\xd1\xd6\xcc\xaf\x08\xbf\x02\x00\x00\x00M\x00\xfc1\xcfi\x04\xd2\x0c\xbc'
 b'4\xfe\xb7,\x02\x00i\x00\xe1y\x94=m\xbe\x95Y\xa8\xdc\xf1Q\xe9M\xac\xaf'
 b'\xdf\xcb\x93J\xee\xbfJ\xe2\xb7y\x83\xe4>z_\xfc-\xbf\x88G\t}\xb7\xde\xbefit'
 b'c\xba\xda\xc6D\xefvk\xb3\x02\x00I\x00\x00\x00\xf2\x15=p6P\xdeE\x02'
 b'\x00K\x00\x00\x00\xdf`\xb3\x99\xa33\x13\x94')

{'A1': -10543,
 'A2': -0.5339324474334717,
 'A3': [{'B1': -5518186148389266758, 'B2': 'fi'},
        {'B1': 5034549628188300786, 'B2': 'tc'}],
 'A4': {'C1': {'D1': 252,
               'D2': 49,
               'D3': 207,
               'D4': -5188651738410646423,
               'D5': 44,
               'D6': [2578669791, 2484286371],
               'D7': 0.07249809056520462},
        'C2': 5904743202075033197,
        'C3': 19945,
        'C4': -0.9466036779317526,
        'C5': 2042094154},
 'A5': 58499,
 'A6': 31294,
 'A7': -0.6796321272850037,
 'A8': {'E1': [136, 71, 9], 'E2': -0.4349936544895172}}

Вариант №31

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

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

(b'HSZ\x02;\x88\x00\x00\x00$\x00\x00\x00(n\x0c\x05\xe0C*h\x0c\xca\x1a\x00,\x8cy'
 b'\xef\x9a\xd9\x0c?\x1f\x9d\x97yt\x9a\x1cnl\xc1\xfc\xeca8C?h\xe2V\xc7\xa3H\xf6'
 b'\xf0\xcb\x85V~\x16\x18\x98')

{'A1': 2,
 'A2': 15240,
 'A3': [{'B1': 'yt', 'B2': -26084}, {'B1': 'nl', 'B2': -15876}],
 'A4': 7929719504650266636,
 'A5': -54,
 'A6': {'C1': 26,
        'C2': {'D1': -329172925,
               'D2': 0.9097036123275757,
               'D3': [-14429, 18678, -3893, -31402],
               'D4': [32278, 6296]},
        'C3': -1938165862,
        'C4': -9972,
        'C5': 0.6234983801841736}}

(b'HSZ{\x95\xfb\x00\x00\x00$\x00\x00\x00(\xb1\x9b\x7fZS\x1d\x16]E\x97'
 b'\x00,\x80\r\xb0\x14\x84}\xbfA\xb4\x92py\xee\xddcepR\x9d\x1d\x98\xfb'
 b'>\x95#\x08\x8d\x92\xec9\x05}l\xb2\xbe\x0b5v')

{'A1': 123,
 'A2': -27141,
 'A3': [{'B1': 'py', 'B2': -4387}, {'B1': 'ce', 'B2': 28754}],
 'A4': 12797962792021595741,
 'A5': 69,
 'A6': {'C1': 151,
        'C2': {'D1': -1659004677,
               'D2': 0.29128289222717285,
               'D3': [-29294, -5063, 1405, 27826],
               'D4': [-16885, 13686]},
        'C3': -2146586604,
        'C4': -31619,
        'C5': -0.7566615343093872}}

Вариант №32

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

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

(b'VTTTK\xea\xf3\xbe\xf0\xd34\xa5\xcb\xac\xde?\x03\x00\x00\x00T\x00Z\x00'
 b'\x00\x00\x8e\x1c/\x1d\xfa\xc2u\xf6\xce\x97\xe3\xbf\x02\x00\x00\x00c\x00'
 b'g\x00\x00\x00\xcf\xd9+>\xfc.\x97q\x94\xa4\xd9\xbf\x03\x00\x00\x00p\x00v\x00'
 b'\x00\x00\r\x00\x15T\x02\x00\x7f\x00\x01\xd8l\xfd\x8dC\xe4C\xd8N\xf5\xe8\x91l'
 b'\x17\xd2x,j\x9f \xa4K\xc6\\\x99<.zi\xbb\xa3"\x14\xee\xa9\xe9C5\xb2\xaa\xa1'
 b")C\xccf\xc24D'\x9b\x17\xad$\x13\x81;")

{'A1': {'B1': -0.4763968884944916,
        'B2': [{'C1': 0.47929659970696914,
                'C2': [17380, 20184, -5899],
                'C3': {'D1': 27793, 'D2': -11753, 'D3': 2674535544, 'D4': 32},
                'C4': 489626766},
               {'C1': -0.6122813047096252,
                'C2': [19364, 23750],
                'C3': {'D1': 15513, 'D2': 31278, 'D3': 581155689, 'D4': 20},
                'C4': 1043061199},
               {'C1': -0.40067015736416045,
                'C2': [-22034, 17385, -19915],
                'C3': {'D1': 41386, 'D2': 17193, 'D3': 885155532, 'D4': 68},
                'C4': 1410662413}],
        'B3': [2904005415, 998314788]},
 'A2': [1, 216],
 'A3': 1133378924}

(b'VTTT\x07\xd6n?r\x83\xb9\x00\x9ca\xe8\xbf\x02\x00\x00\x00T\x00X\x00'
 b'\x00\x00\x16\x1d\x19,\x94YJd\xb6\xc3\xd6?\x03\x00\x00\x00a\x00g\x00\x00\x00'
 b'd\xf9\xd9\x99 l\xe0\x8fM[\xc6\xbf\x02\x00\x00\x00p\x00t\x00\x00\x00\xb0{'
 b'q\xa0\x03\x00}\x00\xf2s\xf7\x03\xf0b\x8e\x0b3\x82\x91.\x13P_Q\x0bT\x9a?\xb5Z'
 b'e\xe2?\xb5\xbf\xdfd\xaf1\xd8\x8a1d\x11\t\xfbA!\xe7\xea\xcf\xcab+'
 b'\xef\xf5\x9c\xb7\xf1v\x08\xeb}F\xeaL\xc9')

{'A1': {'B1': 0.9329532980918884,
        'B2': [{'C1': -0.7619152082589677,
                'C2': [2958, -32205],
                'C3': {'D1': 11921, 'D2': 20499, 'D3': 1410027871, 'D4': -102},
                'C4': 739843350},
               {'C1': 0.35569534105288736,
                'C2': [-19137, 25946, 16354],
                'C3': {'D1': 49077, 'D2': 25823, 'D3': 2329424303, 'D4': 49},
                'C4': 2581199204},
               {'C1': -0.1746613457224564,
                'C2': [4452, -1271],
                'C3': {'D1': 8513, 'D2': -5401, 'D3': 727894735, 'D4': -17},
                'C4': 2691791792}],
        'B3': [4055342325, 2112555126, 3377261126]},
 'A2': [242, 115],
 'A3': 1659896823}

Вариант №33

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

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

(b'\xc2ATSG\x02\x00<\x00\x00\x00d\xce>\x00\x00\x00A\x00\x00\x00D\x00\x00'
 b'\x00G\x00\x00\x00\xc6\xc3\xc0\x06\xe1\x86\xaa\xdaJ\x00[\xda\x02\x00Z'
 b'\x00\xc3`\xb0g|\xf5\x9a/\xd3\xbfJ::\xcb\xd3pf5\x16g_s\xc7\x19\x81\x177'
 b'r\xeaG\x17\xa0*\xbe\xb3u!v\xb6\xa1\xa3\xd6\xa20\xeer\xeb\x12H\xc3\x9e'
 b'\xe5\xbf\x08\xbc)\x14p\x94\xd8?')

{'A1': {'B1': 'pf',
        'B2': -12700,
        'B3': [{'C1': 53, 'C2': 26390},
               {'C1': 95, 'C2': -14477},
               {'C1': 25, 'C2': 6017},
               {'C1': 55, 'C2': -5518}],
        'B4': 113296326,
        'B5': -626358559,
        'B6': {'D1': [71, 23, 160, 42, 190, 179, 117],
               'D2': 33,
               'D3': 17163397222660945526},
        'B7': 55899,
        'B8': [-0.6756302268689593, 0.3840599247841401]},
 'A2': 24771,
 'A3': -0.2997805974315453,
 'A4': 3409590858,
 'A5': -45}

(b'\xc2ATSG\x02\x00<\x00\x00\x00\x83\xa4>\x00\x00\x00A\x00\x00\x00D\x00\x00'
 b'\x00G\x00\x00\x00\xa9\x89\xd1\xcf{\x12\x0c,J\x00\x8fS\x02\x00Z\x00C\xf42'
 b'\x0c$j\xe4\xed\xed\xbf\xa8\r\x16\xd2\xcabv\xeco\xf6|-vk\xb1\xef='
 b'\xa6$\x04\x03U~A]\xe5\x00h\x8f\x04\xb2\x03o\xafA`\x0beA\x15E\xba\xbf\x94\x91'
 b'\xb4:\x1a\xab\xd4?')

{'A1': {'B1': 'bv',
        'B2': -23421,
        'B3': [{'C1': -20, 'C2': -2449},
               {'C1': 124, 'C2': 30253},
               {'C1': 107, 'C2': -4175},
               {'C1': 61, 'C2': 9382}],
        'B4': -808351319,
        'B5': 738988667,
        'B6': {'D1': [4, 3, 85, 126, 65, 93, 229],
               'D2': 0,
               'D3': 4733123795051908968},
        'B7': 21391,
        'B8': [-0.102616623368744, 0.32294326527542094]},
 'A2': 62531,
 'A3': -0.9352895806372372,
 'A4': 3524660648,
 'A5': -54}

Вариант №34

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

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

(b"XUOWJ\x00\x00\x00\x06\x00'\x1c\x82\x00\x05\x00-\x00\x02\x00ig\xf6\xb3"
 b'\xd4\x06!\x0fj\x00x\xc9\xfa\xa9R\xdf\x16\xde\xefofkjrj\xbf\x03\xfcB\xf2\xf6 '
 b'\xe7\x1c\xc1\x8b\x06=&\xb2\x03j*\x87\xa7\xa4\x1fo\x1c?}\x05\x8d\x15\xfd\xe3'
 b"r\\2;Q?l\xa6\xc7T'\x0bv|\xb6\xace\xbf_\xe8\xdb_\xe5Zql\xdb\xe3\x8f\xbeg\xed"
 b'\xc4\xbfB\x86p|n?\xf1\x02}z\x00\x03\x00\x00\x00q\xe0\xdc\x13s\x00\x00'
 b'\x00\x02\x00\x00\x00tq\xa9\xd7\xb2')

{'A1': {'B1': 'ofkjrj',
        'B2': 7298,
        'B3': [{'C1': -0.5155678987503052, 'C2': -939527295268189434},
               {'C1': 0.04069710895419121, 'C2': 7650076071125020444},
               {'C1': 0.9883659482002258, 'C2': 1584672724216855377},
               {'C1': 0.9244198203086853, 'C2': 6063828026804055141},
               {'C1': -0.8746468424797058, 'C2': 6910028646474048399}],
        'B4': [-0.22649294137954712, -0.7598638534545898],
        'B5': 7491372753394667370,
        'B6': {'D1': [124, 110, 63],
               'D2': -522448013,
               'D3': [-3838, 32122],
               'D4': 113,
               'D5': 169,
               'D6': -10318}},
 'A2': -3892612754513142033}

(b"XUOWJ\x00\x00\x00\x06\x00'9\xe8\x00\x07\x00-\x00\x02\x00\x81\xa8\xd87"
 b'\x17\xd6?\xab\x82\x00\x93L\xbb|\xcbE=\x92kwlsbzy\xbf\x0f\x10\xf0\xf7)e'
 b'k\xa47u\t\xbe\x9a\xfe\xf2T#\x15\x816\xf7?\x03?}\xb5\xbd\xec\x97Vc^~='
 b'\x98\xbfr\xed\xcb\xa7\x186q\x02\x0c\xd9v\xbfZ_}\xa9\xa7\x9a\xb0\xe6E\xa7'
 b'A>\xb1~\\\x9c\xdd\xae=0P,\x9f?\x1a\x80\xc8\xbf\xea,\xca\x9bQ\xfc\xd4\xbf |'
 b'\x99=\xc9\x94;\xc0\xd4I\x93\x98^UY\x12:\x00\x06\x00\x00\x00\x89\xce*\xc0'
 b'y\x00\x00\x00\x02\x00\x00\x00\x8f\xc9I\x17\x91')

{'A1': {'B1': 'wlsbzy',
        'B2': 14824,
        'B3': [{'C1': -0.5588521957397461, 'C2': -636866359305210615},
               {'C1': -0.3027263283729553, 'C2': 6062713168087957251},
               {'C1': 0.991054356098175, 'C2': -1398554174488167016},
               {'C1': -0.9489409327507019, 'C2': -6406310610940929674},
               {'C1': -0.8530195355415344, 'C2': -6221834275620804799},
               {'C1': 0.34666717052459717, 'C2': -7143361856112939873},
               {'C1': 0.6035275459289551, 'C2': -4617829219214164780}],
        'B4': [-0.6269012093544006, 0.09842725843191147],
        'B5': 12166534968859667330,
        'B6': {'D1': [192, 212, 73, 147, 152, 94],
               'D2': -836059015,
               'D3': [21849, 4666],
               'D4': -55,
               'D5': 73,
               'D6': 6033}},
 'A2': 5529150180009284203}

Вариант №35

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

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

(b'VRRRm\x81|\x00\x00\x00v\x00\x00\x00\x89\x00\x00\x00\x9c\x00\x00\x00\x02\x00'
 b'\x00\x00\xa6\x00\x00\x00\x05\x00\xac8\xbdA\x7f\x00\x00\x00\x03\x00\x00\x00'
 b'\xb1\x01\x84\xf1\xb4\x97\xaa\x8b\xaek\x9c\x80[\xc30\x94\x82_[\x9c\xe3\xe27\t'
 b'\xc0%\xe7\xe1\xe6l\xc69+\x06\n\x1a\xfa\x98\r\xb5\xad`;jI3\xe8H'
 b'\xa9\xe7\x9a\x98\x9dt\x82\xdc\xd9\xd40\x18]\x13\\\xeb\x00\xbf%JH\xffs{'
 b'k(\x8c]\xf9\x16\x00\x00\x00m\xf2@\xbfr\xdeF\x8b\xbcrCz\xa3M\x8e'
 b'\xe4\x00\x00\x00\x80D\xa6?\x02\x90\x98t\xb4\x87Z\xbb\xacKT\xdf'
 b'\x00\x00\x00\x93\xd4\x93\xc7*\x8c\xc3\x83\x1ddfqcv\xdb\xddu')

{'A1': -32388,
 'A2': [{'B1': -1939998442,
         'B2': {'C1': -0.6456646919250488, 'C2': 4285758315, 'C3': 40},
         'B3': 62016},
        {'B1': -1555198236,
         'B2': {'C1': -0.9487041234970093, 'C2': 2344383043, 'C3': 122},
         'B3': 17574},
        {'B1': -1404349217,
         'B2': {'C1': 0.5100188255310059, 'C2': 1957988186, 'C3': -69},
         'B3': 54419}],
 'A3': [{'D1': -14550, 'D2': -116}, {'D1': -15485, 'D2': 29}],
 'A4': 'dfqcv',
 'A5': 951927167,
 'A6': [219, 221, 117],
 'A7': [109478048904678318,
        7754213790030271618,
        6871258159050590656,
        2731400078807152939,
        435189977589855661,
        6934252913903028393,
        -1757924902502736679,
        -3156996550750835968]}

(b'VRRRm\x16U\x00\x00\x00v\x00\x00\x00\x89\x00\x00\x00\x9c\x00\x00\x00\x05\x00'
 b'\x00\x00\xa6\x00\x00\x00\x04\x00\xb5\xb5^$\xbd\x00\x00\x00\x02\x00\x00\x00'
 b'\xb9\xad3\x8bA\xfd\t?\x1a\xc1n\xcc\xebC/\xa5\xe3M\xeb\xe8&:\x15l'
 b'\x13\x87f\xdf\x9e\xcdcG\xb2Q\xf4\x04\xd35\xb6\xeev\xa1^\xfe\x05\xb4f\x92'
 b'\xb6>)\xf7\x004[\xb9\x05\xfbl\xdbj\xea9\x97\xc8>n\x9a\xc0j\xb2>\xf5\x11I\xe1'
 b'bb\x00\x00\x00mj\x8d\xbe\x99h\xab:\x1e%\x8eV\xbb\xf5\x88\xfa\x00\x00\x00'
 b'\x80h\xaa?X\xd0.\xb2Z\xc3\xd7)$\xc1\xd80\x00\x00\x00\x93\xaf\xd8\x9e\xd0'
 b'\xec\x9b\xf9\x9c|\xf9\x19\xb5`|\xda.\x10pvpzx\xbb')

{'A1': 5717,
 'A2': [{'B1': 1239507554,
         'B2': {'C1': 0.23301219940185547, 'C2': 1790066421, 'C3': 17},
         'B3': 27277},
        {'B1': -1141536518,
         'B2': {'C1': -0.2996266782283783, 'C2': 975054222, 'C3': 86},
         'B3': 26794},
        {'B1': 616683568,
         'B2': {'C1': 0.8469265699386597, 'C2': 2992292823, 'C3': 41},
         'B3': 45016}],
 'A3': [{'D1': -24880, 'D2': -20},
        {'D1': -25607, 'D2': -100},
        {'D1': 31993, 'D2': 25},
        {'D1': -19104, 'D2': 124},
        {'D1': -9682, 'D2': 16}],
 'A4': 'pvpz',
 'A5': -1252121411,
 'A6': [120, 187],
 'A7': [-5966271965801398502,
        -4508440866134710813,
        5614836611328338963,
        -8690012557821130830,
        5905350316575354486,
        -6818733485337439562,
        4479382884647155973,
        -329647420462229560]}

Вариант №36

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

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

(b'XPRE\xa3\x15\xb7\xbd{\xc8\x89=_\x07mfv\x81\x00\xe5!\x97\xd1\x8c\x92L\x99<'
 b'\x8a\xfa\xf3\x84i\x85\xb8\x06E\xca\xcbp\xdd<o@\xe8p\x7f\xd6\x06\xf3+!'
 b'\xa2\xd8n\xa0]\x11\xd9h\\\xbb\xee\xb9\xf3\xdaT:?\x04\x00\x00\x00\xa6\x00\x82'
 b'\r\xa0_\r&\x82\xea>rKYT\x83>&\xb1\x9a\x17\xf2\xe9\x95\x95\x00\x9d'
 b'\xc1\xfdF\xb0(a\xbd\x7f\tBi<%N\xffJ=\x02\x00\x00\x00\xaa\x00\xd2'
 b'\xd7\xe1\x18\t\xc1\x0e\xc0(\x85`\xe2=\x8f\xd4\x1f?\x8dU?\xbf\xe8\x0e\x96\xbe'
 b'\xdf\xb9\x0f\xbd\xaf\xe6\x14^!\x99X>\xc7\xc1)\xea\xbb\xd2\xc0\x04'
 b'\xb8\xf4\xdce')

{'A1': -0.08939673751592636,
 'A2': 51323,
 'A3': 123682185,
 'A4': {'B1': 109,
        'B2': 'fv',
        'B3': {'C1': -16370,
               'C2': 40,
               'C3': [0.11053565889596939,
                      0.6243371367454529,
                      -0.7473991513252258,
                      -0.29308247566223145,
                      -0.03508936986327171],
               'C4': 1578428079,
               'C5': 0.21152164041996002,
               'C6': -15929,
               'C7': 3535530537},
        'B4': 11046365119542403557},
 'A5': [{'D1': -201684420,
         'D2': -3762118643546756732,
         'D3': 9183095003650252144,
         'D4': [1750, 11251, -24031, 28376, 23968],
         'D5': 17562330710384630033,
         'D6': 0.727857232093811,
         'D7': [-64, 4, -72, -12]},
        {'D1': 1604324738,
         'D2': 6434362107176822285,
         'D3': -1002162306425126060,
         'D4': [-27159, 149, -15971, 18173, 10416],
         'D5': 2683135210354097505,
         'D6': 0.049559883773326874,
         'D7': [-36, 101]}],
 'A6': 417454034,
 'A7': 49417}

(b'XPRE\x1d\x08\x07>;Z\xc4\xc0\x89\x16\x9dle\x81\x00\x84?\x0c\xed{h\xa0f^'
 b'\n\xaa2 Y.G\xb06\xfc\x10+\xf23\xbe\xad7\xb9j\xaf;\xba\nL\xfe1U\xa8'
 b'\x1cL\xc4\xec\x86\xaf\xe3d\x1e\x957@\xbf\x03\x00\x00\x00\xa6\x00#n^~\xe3'
 b'\x9ed\x96\xdb\x08U\x8dP\x03N\xdb\xf5\xc6\x85\xae2\xaf\xb8\xb7nq^cE'
 b'\xeb\x98\x94\xd9<R\x9f\x97\xa7\xfe\xe6\x84\xbe\x03\x00\x00\x00\xa9\x008'
 b'M\x00\xd9\x855\xfa\xe1\xbd0|t\xbd\xbf\x9e\x12\xbf\xf5\xa29?\xbc\xcf\x18\xbf'
 b'\xac\xfaP\xbf\xa6bF\xca7r\xea>\x07k\xbcG\xc5\x02P\xf3\xb1\xe3\xff\xfb')

{'A1': 0.13186688721179962,
 'A2': 23099,
 'A3': 378126532,
 'A4': {'B1': 157,
        'B2': 'le',
        'B3': {'C1': -7686,
               'C2': 189,
               'C3': [-0.0596887469291687,
                      -0.5727347731590271,
                      0.725142776966095,
                      -0.5969197750091553,
                      -0.8163249492645264],
               'C4': -901356890,
               'C5': 0.4579026401042938,
               'C6': 27399,
               'C7': 46483388},
        'B4': 7395025469609623428},
 'A5': [{'D1': 850004574,
         'D2': 1223913329474296096,
         'D3': 7690239058071777835,
         'D4': [15279, 2746, -436, 21809, 7336],
         'D5': 2190125661831349324,
         'D6': -0.750848114490509,
         'D7': [80, -13, -79]},
        {'D1': 2120117795,
         'D2': -8262688202127270173,
         'D3': -5871067779958963376,
         'D4': [-20686, -18504, 29038, 25438, -5307],
         'D5': 12076296101374301336,
         'D6': -0.259574830532074,
         'D7': [-29, -1, -5]}],
 'A6': 3640675640,
 'A7': 13701}

Вариант №37

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

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

(b'VKOZ\xba\xc4?\xe4\x95\xd1\x13\xb92\xf2\x16\xc0eC\x008\x00X\x00\x02'
 b'\x00x\x00\x03\x00\x00\x00z\\_\xbe\x86\x7f\xd2\xe6\t\x8e\x05\xdeZ'
 b'\xb6\xb9\x12\xfb\xf3Q\x84\xb2\x0f\xb0\xcb\xda\xb9p\xe7i\x969\xd1\x81'
 b'\xb0\xc2\xc7\x81\xaf\xbfHL\x98\x03\xcb\x06K\xaa0(\xeb\x06Z\x1e'
 b'\xbe\x9b\xb6\xce\xcbXT\x01jLV\x95<3\x81H\xc4jZ\xb7\xf1\xcb\x84Z]Q\xb2\xfb'
 b')\xd2\xcby\xbfv\x8e\x16+$\xa4\x08\xd0rf\x15\xc2\xff\xd3j\xae\xcf')

{'A1': -60,
 'A2': 0.6432881722663224,
 'A3': 381707587,
 'A4': {'B1': [{'C1': [-1183783063,
                       -1774595711,
                       -1329412223,
                       -1346418612,
                       -1744581882,
                       1269444648,
                       -351905250],
                'C2': -0.30412906408309937},
               {'C1': [-883403775,
                       1783387797,
                       1010008392,
                       -999662921,
                       -238320550,
                       1565635323,
                       701680505],
                'C2': -0.9631055593490601}],
        'B2': {'D1': [43, 36],
               'D2': [-1542926222, 1712702207, -747983153],
               'D3': 23647,
               'D4': -0.26269394159317017,
               'D5': -1870808014339262791,
               'D6': [18, -5, -13, 81, -124, -78]}},
 'A5': 263244762}

(b'VKOZ\xba\xf0\xbf\xeeT\xc3!\xa6\xa8\xe4\xe4\xe4B\x97\x008\x00X\x00\x02'
 b'\x00x\x00\x03\x00\x00\x00z\x9c\xec\xbe\x91\x1f\x0fh[{^\xfeV\xcc\xe1\xc4u'
 b'\x83\xf4\xd5CC\xeds\x15\x97\x82\x82,\x88\x01\xf8\x8a\xdfj\x9b\x05'
 b'\xf8\xf4\xc5&\xa2\xa7\xcb\xbaV2\xf4\xf6\xd5\xc8\xf0\xaf\xbf[\x1f\x9f'
 b'\x92\xb2\xd8D?\x0eU\xf6>\xceI \xdd\xb0\x14r"\x04\x7f\xc2\xbd5@\xda'
 b'\x1d:\x8b\xa7\xbf\x11-\xa7\x84rU\xcb\x80\x8dS\xb1\x07*c\xdf\xf7v')

{'A1': -16,
 'A2': -0.9478469521757487,
 'A3': -454802793,
 'A4': {'B1': [{'C1': [-1753054676,
                       -2013136758,
                       -546661627,
                       -118176474,
                       -1566061638,
                       1446180086,
                       -708251473],
                'C2': -0.8559512495994568},
               {'C1': [-1833772988,
                       1057904118,
                       1053706528,
                       -575662990,
                       570720194,
                       -1120583462,
                       490376103],
                'C2': -0.56710284948349}],
        'B2': {'D1': [-124, 114],
               'D2': [1439400077, 1404110634, 1675622262],
               'D3': 40172,
               'D4': -0.28344008326530457,
               'D5': 7519739650749418721,
               'D6': [-60, 117, -125, -12, -43, 67]}},
 'A5': 1139634965}

Вариант №38

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

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

(b'\xbdPIKZ\x00\x06\x00\x00\x00\x1d{\xb2-\x8fS\xde\xbf\xa4\x00\x03\x00#\x00'
 b'P\x00\x02\x00\x91zssdyr~\x99\xd9\xfas\xd9/p\xbb\xf6\x11\xa5\xcd\xc54\xa2\xf1'
 b']\x06*\xce\x0b5\xd5\xfc\xeen\x1cH\xb4\xa9%\xfaWw\x9f^\xe38 \xdd9%r:'
 b't\x15t\x89\x83\x98U$\xf5\x9c\x15\x91\xba\x18\xd8a\x13G$\xce]{\x14\xbc'
 b'\xc3\rx\x1d)\xcbs;}9\xc5\xd7\\\x95%\x8b\x86\x17\x98(-\x07#92O\xd3\x17'
 b'\x10\xe54\xe93\xb8\x86\xff\x89k|v\xf0\x03\x88W\x8a')

{'A1': 'zssdyr',
 'A2': 8913236706130313124,
 'A3': [{'B1': 2124012026,
         'B2': 29657,
         'B3': 795917302,
         'B4': 4517,
         'B5': 52677,
         'B6': 52},
        {'B1': 2733726982,
         'B2': 10958,
         'B3': 188077564,
         'B4': -4498,
         'B5': 7240,
         'B6': 180},
        {'B1': 2837838423,
         'B2': 30623,
         'B3': 1591949344,
         'B4': -8903,
         'B5': 9586,
         'B6': 58}],
 'A4': {'C1': {'D1': 116,
               'D2': 1546011770384360693,
               'D3': [2618659258,
                      416833811,
                      1193594461,
                      2064956611,
                      225975593,
                      3413326717,
                      969267036,
                      2502265734],
               'D4': 1700153033190750514,
               'D5': 5751966510414620979},
        'C2': 13296595915536889584},
 'A5': [904, 22410]}

(b'\xbdPIKZ\x00\x04\x00\x00\x00\x1dEIu\xefB.&\x85\x00\x03\x00!\x00N\x00\x04\x00'
 b'\x8fqbryJ\xf0\xfb\x81o\xc8\xf1\x13\xe74\xea\xfa\x08\xbe-\x16\x96\xd9\xdd'
 b'h\x12\xf6\xdb\xf7)\xac\xef\xfe\x08\x11\x08\x81\x7fm\x80f>\xde)/1LV'
 b'\xe7u\xdf\xae\x82\x11\x04\x1b\xfc\xc8HV,\x15;\x9f\xa0iFL\xc9\xe1\x1e$'
 b'\xee\x0fgS\xa5\xa8\xde\xfb\x0c\x9c\xf0\x1f7\x18\x7f}\xe8E^@m\x0f\x9f\xa3'
 b':s\xaf\xd4\xa9O\x00F\xa4K\x1c\xccDP\xde@M|\x15\x15|hb\xc5A\x05\xb6')

{'A1': 'qbry',
 'A2': 4992651332384859781,
 'A3': [{'B1': 1257307009,
         'B2': 28616,
         'B3': 4044613428,
         'B4': -5382,
         'B5': 2238,
         'B6': 45},
        {'B1': 378984925,
         'B2': 26642,
         'B3': 4141610793,
         'B4': -21265,
         'B5': 65032,
         'B6': 17},
        {'B1': 142704493,
         'B2': -32666,
         'B3': 1054746927,
         'B4': 12620,
         'B5': 22247,
         'B6': 117}],
 'A4': {'C1': {'D1': -33,
               'D2': -5872112254790612920,
               'D3': [1445729595,
                      2678090054,
                      1288298782,
                      619581287,
                      1403365598,
                      4211907824,
                      523704447,
                      2112374110],
               'D4': 4642383969201583023,
               'D5': 15323866069708589852},
        'C2': 14718978397645405205},
 'A5': [5500, 26722, -15039, 1462]}

Вариант №39

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

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

(b'XWJS\xf1\x00Y\xd4\x07Q\xf8\x00\x03\x00\x00\x00\x92?\xe4\x88?\x81\x88\xcf'
 b'4;6\x00\xa5>\xcd\xc2\xd9\xbcC\x95;\x05\x9b\x17&+C\xbf\xb8J{\xb4\x9eX\xe0?'
 b'\x08\x13\xa4\xe8\x1a\xf9\x1c:\x81_\xb9G\x16?\xe2r\xaf\xad7\xaax\x00\x1d\x00'
 b'3\xcbD\x1b\x0e=\xf5\xb0\xef\xbe\xf1zY\x9b\xb9\x00\x02\x00II\xbf\xca\xcd\n'
 b'\x1b\xf6dx\xbf\xe4\x97l`\x10G2?\xd7C\xdc\xc9\xa3\x84\x00?\xedf\x92'
 b'M\xd7\x0b\xce\xbf\xebv\xeb\x91\xa7\xd0x\x00\x00\x00\x02\x00M\x00\x00'
 b'\x00Q)\xbeH\x83\xd4Zx\xf3?\x8e\xbe\x93w\xbf\xc3\xdd@\x98\xd4\x7fcO'
 b'_\x00\x07\x00\x00\x00\x9e')

{'A1': {'B1': -25671,
        'B2': [{'C1': 0.40187719464302063,
                'C2': 13565850583299725094,
                'C3': 11075,
                'C4': -0.09488652381546414},
               {'C1': 0.5315496921539307,
                'C2': 16724954065829715897,
                'C3': 18198,
                'C4': 0.576499784770319}],
        'B3': 73,
        'B4': [-0.20938230862956053,
               -0.6434842945329591,
               0.3635169953468562,
               0.9187709350884405,
               -0.8582666249117343],
        'B5': [52036, 6926],
        'B6': {'D1': 0.11996638029813766, 'D2': -0.471636563539505}},
 'A2': -737717768,
 'A3': [700336259, -732268301, 1066319507],
 'A4': 0.6416318445176104,
 'A5': 15158,
 'A6': {'E1': 2137214815, 'E2': [119, -65, -61, -35, 64, -104, -44]}}

(b'XWJS\xf1\x00Y\xf47(\xc0\x00\x04\x00\x00\x00\x92?\xd6/z\x8f\x80\x88'
 b'\x1c\xc7\x19\x00\xa7\xbeh=\xac\x03j\xe6\t%\x9b\x97IF\x8c\xbf\xef\xd78U'
 b'5\xa7\xcc>zT\x16\x07\xfd5\x98\\\x1bP\x99\x1fB?\xe1J\x8d\xa6%\x9d'
 b'.\x00\x1d\x003\t\xe9\x00\xe4\xbd\x0e\xcf\xc4>\xf6\xbd\xd2\r]\x00'
 b'\x02\x00I\xe6\xbf\xe9WZ\xb8\xfa\x03P?\xcd\xc2\x88k\xdf\xa0\xd0'
 b'\xbf\xb7\xc9\xd5_|\xd5\xa0\xbf\xd1\xec8\x96\x1fK\x00?\xc4u-\xdd\x83\xdb('
 b'\x00\x00\x00\x02\x00M\x00\x00\x00Q\x93W\xb1\x13\x9d=\x8d\xe8rW'
 b'\xc2\xf0\xe6\xe1\xb59\xb3\x80\x9cD\x9a\xee"\xf3W\x00\x05\x00\x00\x00\xa2')

{'A1': {'B1': 3421,
        'B2': [{'C1': -0.22679775953292847,
                'C2': 246262056605161289,
                'C3': 18060,
                'C4': -0.9950219787835919},
               {'C1': 0.24446138739585876,
                'C2': 575675255869886617,
                'C3': 8002,
                'C4': 0.5403507466370792}],
        'B3': -26,
        'B4': [-0.7919133770775293,
               0.23249917285216393,
               -0.0929234846233471,
               -0.28004278812765904,
               0.1598260242096441],
        'B5': [2537, 228],
        'B6': {'D1': -0.03486610949039459, 'D2': 0.48191696405410767}},
 'A2': -197711680,
 'A3': [-1822969581, -1656910360, 1918354160, -421415623],
 'A4': 0.3466478730571241,
 'A5': 50969,
 'A6': {'E1': -299699369, 'E2': [-77, -128, -100, 68, -102]}}

Вариант №40

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

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

(b'\x02FBKYUU\xc5p\x00?\xb7\xe8P\x8bB\x00u\xf2)\xaa\x11\x02\xe0\x03\xf3\x93\xc5'
 b'h\xc2\x06N&F\xdc\xdaWB\xea\x81\xbb\xfer\xc8\x1f3Z1\xf6H\x1a\x00'
 b'\x00\x00\x15\x00\x00\x00$hmq\x8e\x00\x00\x00\x02\x00\x00\x003u\xf5J\x8b\x1e'
 b'6\xcb\x03\x00\x02\x00\x00\x00;\x00\x00\x00\x02\x00\x00\x00=nK=\x1f\xb30\xee'
 b'i\xe9\xbf\xd6h\xa5\xb82I0\x05\xfd\xc9\xca\t \x12L\xb5zi\x9e;?H\xb9\xe2\xc9'
 b'\xde8\x0f*^\xd3\xae\x00\x02\x00\x00\x00sq')

{'A1': 21845,
 'A2': 50544,
 'A3': {'B1': {'C1': [{'D1': 1225788356174267752,
                       'D2': 194,
                       'D3': 1614,
                       'D4': 9798,
                       'D5': 56538},
                      {'D1': 6287845872688329416,
                       'D2': 31,
                       'D3': 13146,
                       'D4': 12790,
                       'D5': 18458}],
               'C2': 117},
        'B2': 62794,
        'B3': -1960954165,
        'B4': 3,
        'B5': 'hm',
        'B6': {'E1': [113, 142],
               'E2': 7947513173784981097,
               'E3': -23,
               'E4': -0.3501371668618445,
               'E5': 100518346},
        'B7': 9},
 'A4': 183,
 'A5': -397374654,
 'A6': {'F1': 76,
        'F2': -1250268770,
        'F3': 59,
        'F4': 0.7840863466262817,
        'F5': 14546125484239803310,
        'F6': [32, 18],
        'F7': 113},
 'A7': [242, 41, 170]}

(b'\x02FBKYn\xa4\xfcL\x00Ux\xa8$\x14h\x00\x8b\x95s\xcf\x0b\x04\x8b\xefoe?'
 b'4\x1c#\xc5\x8c\xae\x83\x16\xde\x0bdL\xdf\xcb&\xf5\n\x9c2\x8f\x15\xdd\xdc~'
 b'\x99R\x05+\x91\xa0\x8d \xba\xc6\xce\xeb\x05\xe6\x00\x00\x00\x15\x00\x00'
 b'\x00$\x00\x00\x003fabw\x8d  \x00\x00\x00\x03\x00\x00\x00B\x07\x92\xb0^T:x'
 b'\xa0\x00\x04\x00\x00\x00N\x00\x00\x00\x03\x00\x00\x00R\xdf\xd7$d\np{h\xe3'
 b'?\xbeU\xed\x90\xb1\xdf\xb0\xa6\xb6IM\x19\xf9h\xcfr=\xccq\xd5\xbe\xd3e'
 b'\xf6\x07Af\x05\xf1\xc0\xc4\x1b\x00\x02\x00\x00\x00\x89H')

{'A1': 28324,
 'A2': 64588,
 'A3': {'B1': {'C1': [{'D1': 793913294806400820,
                       'D2': 28,
                       'D3': 9157,
                       'D4': -29522,
                       'D5': 33558},
                      {'D1': 15999992382498744053,
                       'D2': 10,
                       'D3': 39986,
                       'D4': -28907,
                       'D5': 56796},
                      {'D1': 9122412702374928525,
                       'D2': 32,
                       'D3': 47814,
                       'D4': -12565,
                       'D5': 1510}],
               'C2': 7},
        'B2': 37552,
        'B3': 1582578296,
        'B4': 160,
        'B5': 'fabw',
        'B6': {'E1': [141, 32, 32],
               'E2': -2317343471168357528,
               'E3': -29,
               'E4': 0.11849865706051221,
               'E5': -1498003123},
        'B7': 25},
 'A4': 120,
 'A5': -1474030488,
 'A6': {'F1': 207,
        'F2': 1916652657,
        'F3': -43,
        'F4': -0.4128872752189636,
        'F5': 522811207468499995,
        'F6': [-7, 104],
        'F7': 72},
 'A7': [149, 115, 207]}

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

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

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

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

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

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

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

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

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

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

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