ИКБО-07-22

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

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

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

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

Поле	Описание
1	double
2	int32
3	Структура D
4	uint8
5	uint32

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

(b'WHZT$\xd0\xf6q\xc7@\xf8\xa0-\xb1he\xf7\xd4\xa5*\x1d\x99\xaa\xa6\x15te\xea'
 b"\x16\xb4\x8b\xae\xf6j\xbf'\x00\x1c5\x10\xdbC\xed\xacl\xe4?\x7f\x990\x07\xdf"
 b'\xa7\x8b\xef\xa92\xfc\xb7l\x86\xe3\x12\xdd\x00}9:\x8f&\x9a\xb6\xf88\xf57')

{'A1': [{'B1': 3287900685088192208, 'B2': 177, 'B3': 'he'},
        {'B1': 12009579706885461239, 'B2': 21, 'B3': 'te'}],
 'A2': 2343835370,
 'A3': -0.9178265333175659,
 'A4': {'C1': 0.6382660516818266,
        'C2': 120625535,
        'C3': {'D1': [-22561, -4213, 12969, -18436, -31124],
               'D2': [227, 18, 221, 0, 125, 57],
               'D3': -1708748998},
        'C4': 182,
        'C5': 938817784},
 'A5': 13596}

(b'WHZT$\x89\x8d\t\xf4\xefOM1\xfajj\xc1\x8a\x80\x9bA\xd1\xb7=\x08xg|96\xb6c'
 b"\x17??'\x00\xcf\x04\xf0\xa4\x10\xbax\x1a\xe1?\xe0\xa4\xd8/74lM\x96"
 b'.\xa2\xc0\xc8\x8dy\\\x91a\xc0\x8e;\xed=\x1e\x15E>{r')

{'A1': [{'B1': 3552583573075234185, 'B2': 250, 'B3': 'jj'},
        {'B1': 4447253236763626177, 'B2': 8, 'B3': 'xg'}],
 'A2': 3057006972,
 'A3': 0.7464506030082703,
 'A4': {'C1': 0.5344813951570853,
        'C2': 802727136,
        'C3': {'D1': [13367, 19820, 11926, -16222, -29240],
               'D2': [121, 92, 145, 97, 192, 142],
               'D3': 507374907},
        'C4': 21,
        'C5': 1920679493},
 'A5': 1231}

Вариант №2

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

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

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

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

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

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

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

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

(b'ZXNKa\x00y\x8c\x00\x00\x00\xf8\xfa,\xdel\xdb\xfb\xce?i\t\xc3o[Az\xb0'
 b"\x1a\xa7\xfan\x13@'] \x99\x12\x14\xe4\xd7\xb1\xa0&\x8a\x9fX\xac\xd5\xe6\xf3"
 b'\x92\xb9\x12\xd6\xbd\xeb\xa9=\xa7\xdc\x04\xd259\x06\xdb\x8c\xbf\xe4rc\xf3q*'
 b'a\x1f\xa7\xfd\xceS34xX\xf7\x1a\xbe~\xe0>\xb2\x97\xc4\xb5H\x0b\x00\x00'
 b'\x00\x05\x00\x00\x00\\\x00\x00\x00\x10\x8c~\xe8\x11\xcf\x91\x01K\xc6?'
 b'\xc2w\xb8\xa1\xa0\x1d\x15\x1dtp\xc5?kc\xf1_\xaa\xa6\xe4\xe6\x04\x00\x84\x00'
 b'\x00\x00\xf4-d-DKo \xed\x13\xc1\x7f\xea\xe81\xfbo\xbc\xf7\x07\x04\x00'
 b'\x88\x00\x00\x00')

{'A1': {'B1': {'C1': -1288,
               'C2': [{'D1': 56876,
                       'D2': -9364,
                       'D3': 1765789435,
                       'D4': 1534051081},
                      {'D1': 31297,
                       'D2': 6832,
                       'D3': 326040231,
                       'D4': 542975808},
                      {'D1': 4761,
                       'D2': -7148,
                       'D3': 648065495,
                       'D4': -1403478134},
                      {'D1': 59093,
                       'D2': -27917,
                       'D3': -1110043975,
                       'D4': -1489131029},
                      {'D1': 1244,
                       'D2': 13778,
                       'D3': -1931803079,
                       'D4': 1668474047},
                      {'D1': 29171,
                       'D2': 24874,
                       'D3': -822237409,
                       'D4': 2016686931}],
               'C3': -2216,
               'C4': 26,
               'C5': 0.43846696615219116},
        'B2': {'E1': [-78, -105, -60, -75, 72], 'E2': 16},
        'B3': 32396,
        'B4': 0.17416400546620925,
        'B5': 2713221058,
        'B6': 0.1674943105701745},
 'A2': 121,
 'A3': {'F1': [107, 99, -15, 95],
        'F2': 761540084,
        'F3': 68,
        'F4': [75, 111, 32, 237, 19, 193, 127],
        'F5': 574134666654771434,
        'F6': [170, 166, 228, 230]}}

(b'ZXNKc\x00z\x8c\x00\x00\x008\x16\x8c\x8b%\xcd\x12\xa6\x1aP\xd7`Y'
 b'\x92\x13\x04\x10\xaa\xf1\x1e\xd9(\xb2\xc8\xf16y\x0e`\x1f\xb8\x88S'
 b'\x96\x94\x85~^\xac\x1d0\x94+\n\x9f-\x17"\x13\x96\x93,Bw\xd4M4 \xb7:l'
 b'\xa5\xfe\xb7~\x8bP\xdf9":\x95\xd9Q\xbcPL\x9f\x10\x15=\x08\xd6\xcc\x00'
 b'\x88\xd4\xf3\x0b\x00\x00\x00\x07\x00\x00\x00\\\x00\x00\x00\x13'
 b'\x07\xd1\xf0\xdd\xef\x9e:\x90\xce?\x83z-\xcbP\xa4)-\x99\xfc\xb0\xbf\xa9`'
 b'h9\x1e\xdd\x03\x00\x86\x00\x00\x00)\xb9\xd2\xe52Y\xf1\xbbo\x9eX|\x07\xfe'
 b'\x86V\x96\xdb\xb3\n\x03\x00\x89\x00\x00\x00')

{'A1': {'B1': {'C1': 5688,
               'C2': [{'D1': 35724,
                       'D2': -13019,
                       'D3': 1343923730,
                       'D4': -1839636265},
                      {'D1': 1043,
                       'D2': -22000,
                       'D3': 685317873,
                       'D4': 921815218},
                      {'D1': 3705,
                       'D2': 8032,
                       'D3': -1772910408,
                       'D4': 1585350036},
                      {'D1': 7596,
                       'D2': -27600,
                       'D3': 765397547,
                       'D4': -1777130985},
                      {'D1': 11411,
                       'D2': 30530,
                       'D3': 540298708,
                       'D4': -1519633737},
                      {'D1': 47102,
                       'D2': -29826,
                       'D3': 574218064,
                       'D4': 1373214010}],
               'C3': 20668,
               'C4': 76,
               'C5': 0.036392804235219955},
        'B2': {'E1': [8, -42, -52, 0, -120, -44, -13], 'E2': 19},
        'B3': 53511,
        'B4': 0.23877651939959277,
        'B5': 3408755331,
        'B6': -0.06635434486965264},
 'A2': 122,
 'A3': {'F1': [-87, 96, 104],
        'F2': -439174871,
        'F3': 50,
        'F4': [89, 241, 187, 111, 158, 88, 124],
        'F5': 771201399953751559,
        'F6': [57, 30, 221]}}

Вариант №3

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

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

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

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

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

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

(b'MMRR\x02\x00\x11\x00\x00\x00\x08\x1f\x00\x00\x00\x8c\xa2\xafor\xbakcs'
 b'\xf1:C\x16qjg{\xa0\xcd\xbe6\x1d+1>\xac5?\xb5\xad\x14>\xfaN\xef\xbe\xf7'
 b'3%?\xaa\xb0\x85\xbe\xa8\x83o?\xbc\xe2\x9f\xda\xf2\x91s\xda\xba_\x90\xe0"'
 b'\x7f\xde\xac\x88lI\x8b(\xd8H\x99]j\xca\xc4O\xfd\xd6e\xedVn\xaad\x93C\x8b\x02'
 b'\x873\x08\xaarN\xe79\xc5\xbb|')

{'A1': [{'B1': -1166905425, 'B2': 'kcs'}, {'B1': 373504753, 'B2': 'qjg'}],
 'A2': {'C1': 8,
        'C2': {'D1': -0.4016149938106537,
               'D2': 824909110,
               'D3': [0.7096594572067261,
                      0.1451938897371292,
                      -0.4673994183540344,
                      0.645324170589447,
                      -0.2611134648323059,
                      0.9356026649475098],
               'D4': 58044,
               'D5': 6898065969176042143,
               'D6': 57488,
               'D7': [10036672578843475746,
                      14180263326965618728,
                      12280848811501747535,
                      590964421111812964],
               'D8': 8987994333832442538},
        'C3': -23924}}

(b'MMRR\x02\x00\x11\x00\x00\x00;\x1f\x00\x00\x00n\x11\xafD\x12Mutj\x1e\x7fs|'
 b'bbq\xb4\t{?i:\x8c0\xac/\x18?m\xee\xda>\x9b\x9d\x85\xbejv\x17\xbc_\xe5\xf0<e'
 b'\xfc\x0f?\x99\x99\x15-\xd4/\x8a\x03\xf0`\xa3AN\xf3\xa2No\x17\xd2k\xe7'
 b"_b\xe1\x87\xb2\xcd{]Y\xe3\xda\xf9\xaa4\xe4\x85_|>\x9f\x8a'\xc7\xd8>s\xa1\xa4"
 b'\xf4\x16\xb5')

{'A1': [{'B1': 1293042863, 'B2': 'utj'}, {'B1': 2087943966, 'B2': 'bbq'}],
 'A2': {'C1': 59,
        'C2': {'D1': 0.9806168079376221,
               'D2': 814496361,
               'D3': [0.5944774150848389,
                      0.42760029435157776,
                      -0.26096805930137634,
                      -0.009244540706276894,
                      0.029406247660517693,
                      0.5624449849128723],
               'D4': 39321,
               'D5': 6985086914094443797,
               'D6': 16803,
               'D7': [7769298073995637582,
                      8920982733562470375,
                      16443956129532434781,
                      14350591154192146309],
               'D8': 13048885958273089240},
        'C3': 4462}}

Вариант №4

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

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

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

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

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

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

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

(b'LRW*-\x02\x007\x00\x00\x00\xb7q=4%J\xc7\xf8W\x00\x00\x00\xc2[\tpS'
 b'\xa5\xcc+\xbeSEA\x1b\x00ZE\xbf\xd4\xa3c(\xc9\xbd%\xdb\xb9)\x00\xfd`\xf3f#'
 b'\x00\x00\x001\x00\x00\x00\x1c5\xaa\x03\x81\x7f\xe0\x06H\xc6~V\x8b\xb0UJ6'
 b'8\x06P\xd2\xb9p5\x02\x00?\x00\x00\x00\xc2\xfc\x99\xbe\x02\x00C'
 b'\x00\xbf\x19\xef\x96\x89\xdd,\x01\x02\x00\x00\x00S\x00\x00\x00')

{'A1': 45,
 'A2': [{'B1': {'C1': {'D1': 83, 'D2': -0.16777284443378448, 'D3': 17747},
                'C2': 65},
         'B2': -725662374},
        {'B1': {'C1': {'D1': -93, 'D2': -0.0982215628027916, 'D3': -9435},
                'C2': 185},
         'B2': 1727226109}],
 'A3': -520365708287315529,
 'A4': {'E1': [13596, 938],
        'E2': -830,
        'E3': 48793,
        'E4': [6232636946982666113, 5766358178721017995],
        'E5': -1762715201,
        'E6': 19717513,
        'E7': [47570, 13680]},
 'A5': 1879661506}

(b'LRW*e\x02\x007\x00\x00\x00\xf0#6\xcb\x96\xc7\xe2\x9ca\x00\x00\x006xb\xd2\xed'
 b'\xd8\nc\xbe\xcf{\x11\x1b\x00\x1cO\xf5jg\xae\xc9t\xbf\xf9\xcb>)\x00Z'
 b')\xeb\x9c#\x00\x00\x001\x00\x00\x00\xcc]\x1e\x10\x9eJ\xf7\xbc\xbd'
 b'r\x8c\xf5\x9d\x0c\x0c\xed\xa8\xd8q\x7fD1`\xef`\xb4Jv:n:\x95\xe4$\x03\x00?'
 b'\x00\x00\x00\xf7X\x85I\x03\x00E\x00\xf3\xde\nO5E\x8dc\x02\x00\x00\x00]'
 b'\x00\x00\x00')

{'A1': 101,
 'A2': [{'B1': {'C1': {'D1': -19, 'D2': -0.22172105312347412, 'D3': 31695},
                'C2': 17},
         'B2': 1794461468},
        {'B1': {'C1': {'D1': 103, 'D2': -0.9562023878097534, 'D3': -13319},
                'C2': 62},
         'B2': -1662310054}],
 'A3': -7141926608587840528,
 'A4': {'E1': [24012, 4126, 19102],
        'E2': 22775,
        'E3': 18821,
        'E4': [909152683367972087, 3550102533217774860, 7942790956047200096],
        'E5': 1326112499,
        'E6': 1670202677,
        'E7': [38202, 9444]},
 'A5': -765298634}

Вариант №5

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

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

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

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

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

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

(b'xPHYS\x00\x00\x00P\x17\x19\xb2:|\xc9*,b\xc7\xfa*\x00\x05\x00\xa70\xbb\xa3'
 b'w?\xea\x81\xf7\x0fH\xae\xe8\xf7|\x9b~\xa1l\xacs>\\t\x0c\xcf#\xf0'
 b'Q\x8b\x9d\xdf?\xd0\xdaG\x89\xfb\xcd<\x00\x00\x00\x03\x00\xb1\xed\xb3S2!X'
 b'\xadAzi\x11?\xead\x07%\x91n\xbe\x00\x00\x00\x02\x00\x00\x00N?\xaa\x92'
 b'\x88\xb8\xc0\x95`\xc3^ygpkcge&\x02\xbd\xf6\t@\xc5|z\x0f\x98z)\x12DD\xe9\xa3'
 b'\xf4\xd9\x87I3Mm\xceP\xf1\xe7\xd3h\xe6\xcc\xe7`]"\xc7\xf0\xc4\xd2\x8b/\xdcFy'
 b'm\xbe\xba\xbe\x03\xf7w\x00u\x00\x7f\x00\x89\x00\x93\x00\x9d\x07)\xaf'
 b'f\x00\x1a')

{'A1': {'B1': 17,
        'B2': 0.8247104390861393,
        'B3': 'zi',
        'B4': 0.05189921622540328,
        'B5': 50014,
        'B6': 'ygpkcge',
        'B7': 9730,
        'B8': -67},
 'A2': 1664557501561514540,
 'A3': 1657272874,
 'A4': [{'C1': -167165755, 'C2': 2088374168, 'C3': 31273},
        {'C1': 306463977, 'C2': 2750732679, 'C3': 18739},
        {'C1': 1299041872, 'C2': 4058501992, 'C3': 59084},
        {'C1': -413115102, 'C2': 3354445010, 'C3': 35631},
        {'C1': -599361171, 'C2': 3199909379, 'C3': 63351}],
 'A5': 817603447,
 'A6': {'D1': 0.8283648775590935,
        'D2': 17833299592656759923,
        'D3': 0.21528643369674683,
        'D4': -12509,
        'D5': -4015,
        'D6': -29795,
        'D7': -33,
        'D8': 0.26332272028885817},
 'A7': [1833, -20634, 26],
 'A8': 17128125282593058113}

(b'xPHYS\x00\x00\x00P\r\\\xe2\xe6\n\n\x99\xa6\x86E\x14!\x00\x04\x00\x9dl\xbc7'
 b'\xd3\xbf\xd8\xaf\x96\xd58\xf7\xd8\x11\x89O\xf2\x0e$v\xc8>\x89\xd0\xc0\x94ON'
 b'\xaf\xbc\x1c\xa9?\xce\xed\xe5\x11\x03~\xc0\x00\x00\x00\x02\x00\xa5=\xf2'
 b'\xbaW(2+\x9dbxn?\xc9\xfdM\x16\x03Y\x10\x00\x00\x00\x02\x00\x00\x00N?\xe7\xbf'
 b'\x12X6\xe6V\xecHtuqbitmYK\xaf\x98\x9f\x88bi\xc3aM3\x19\x15&*\x10\xb4'
 b'\x93\xe4\x94\xfdo\x86wg7\xa7\xee\xb9\xcf\xf3\xf1\x8d\x80~\x9c4'
 b'\xaf\xb7\x19\xcce\x00u\x00\x7f\x00\x89\x00\x93\xe9\xa6\xbe\x9e')

{'A1': {'B1': 110,
        'B2': 0.20304263663155853,
        'B3': 'bx',
        'B4': 0.742074177068569,
        'B5': 60488,
        'B6': 'tuqbitm',
        'B7': 22859,
        'B8': -81},
 'A2': 962893897989265830,
 'A3': -2042293215,
 'A4': [{'C1': -1734375326, 'C2': 1774412109, 'C3': 13081},
        {'C1': 354822672, 'C2': 3029591188, 'C3': 64879},
        {'C1': -2038995145, 'C2': 2817440207, 'C3': 62449},
        {'C1': -1920958820, 'C2': 883930905, 'C3': 52325}],
 'A5': 1824274387,
 'A6': {'D1': -0.3857171137095725,
        'D2': 1263629071492085448,
        'D3': 0.26917076110839844,
        'D4': -27569,
        'D5': 20143,
        'D6': -17380,
        'D7': -87,
        'D8': 0.2416349728655316},
 'A7': [-5722, -16738],
 'A8': 4463835064176880541}

Вариант №6

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

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

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

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

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

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

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

(b'>VETC\x00\x00\x000\x00\x00\x009\x00\x00\x00B\x00\x00\x00K\x00\x00\x00'
 b'T\xed\x00]\x00\x04\x00\x00\x00\x82\xec\x13*\x00\x00\x00\x02\x00\x00\x00'
 b'\x92 \x1ai\xc4\x8b\xa1\x9c\xe5x\xcc*r\xc7!\xf8\x01.}\xbc\xde\x13-J'
 b'\xff\xc8\x94\xe19\xbb\xd4\x84Pe\xd4\xff\x08M\x15=4Cp\xd3\xa0}\xcf9-\xbf@.'
 b'\x8e1?\xb5\xa1\x1f\x025o\x90?\xec\x9ad\x07\xeeI\xd2\xbf\xb9\xfeGL\xe5'
 b't\x10\xbf\xef\xfe0\x08\xdbh*\xbfS\xbdr\xbe\xc4\xa3\x89?\x00\xd7g>\xa4'
 b'\xb3\x1e\x03\xf4\x8ej\xb3J\xfc\xd5\x1c\x10\xb5\xb9\x19\x8b\xea]')

{'A1': [{'B1': 14162591148433525802, 'B2': 114},
        {'B1': 14349022571737758942, 'B2': 19},
        {'B1': 3263702116939676091, 'B2': -44},
        {'B1': 9534232376629546261, 'B2': 61},
        {'B1': 3765977767644876601, 'B2': 45}],
 'A2': 237,
 'A3': {'C1': {'D1': -0.7507103681564331,
               'D2': 49,
               'D3': [0.0844897632973114,
                      0.8938465266131124,
                      -0.1015362322554696,
                      -0.9997787640561502]},
        'C2': {'E1': [-0.8271094560623169,
                      -0.38406017422676086,
                      0.5032867789268494,
                      0.3216790556907654],
               'E2': -5101,
               'E3': 42,
               'E4': [285009265356897493, 2022316039291529821]},
        'C3': 32,
        'C4': 6761}}

(b'>VETC\x00\x00\x000\x00\x00\x009\x00\x00\x00B\x00\x00\x00K\x00\x00\x00T3\x00]'
 b'\x00\x05\x00\x00\x00\x82l\x06\x84\x00\x00\x00\x03\x00\x00\x00\x96\xbd\xf0\t'
 b'\xcfd\x92\x848\xce\x11\xb7\x07^7\xe2D\xf7\t!k\xbe0$7\xd9F\xd4:_,\x02'
 b'\x8c\xfe\xb1\x10j\xb5/e\xe8S\x12\x85o\xdc\x17\x84\x96\xbc\xe1\x88'
 b'\x0e\xc5?\xdc\xd7\x89\x1du3\xb0\xbf\xe5\x19U\xdf\xcbj\xd8?\xbf\xaeG\x8b\xcb'
 b'\x9e\xf0\xbf\xe6\x1c;\x99\xd1\xa7\x08\xbfTP\\\xbf\x08\xc9\xe4\xbfbz)?b'
 b'\x83%\xbdEs"\xb3\xfe\xda\xdeC\xb8\xa2\xf8\x82F\x83\x0c\x04>d\x1b\rp'
 b'3\xfb\xa1\xbb\x91\x0b')

{'A1': [{'B1': 14944230560108515767, 'B2': 7},
        {'B1': 6789143749114536299, 'B2': -66},
        {'B1': 3468959019317869151, 'B2': 44},
        {'B1': 183801721253442863, 'B2': 101},
        {'B1': 16740744604182910852, 'B2': -106}],
 'A2': 51,
 'A3': {'C1': {'D1': -0.027530696243047714,
               'D2': 197,
               'D3': [0.4506552493738196,
                      -0.6593427058208716,
                      0.1237530437753056,
                      -0.6909463886524643]},
        'C2': {'E1': [-0.8293511867523193,
                      -0.5343306064605713,
                      -0.8846765160560608,
                      0.8848136067390442,
                      -0.048205502331256866],
               'E2': 27654,
               'E3': 132,
               'E4': [-5476699448682175752,
                      -9059409512775130085,
                      968331075727888651]},
        'C3': 189,
        'C4': -4087}}

Вариант №7

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

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

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

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

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

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

(b"MME\xe1ughfw\x9d\xba.M\xdc\xe0\xec\xeb\xbf\x89\xe6\x89',(\x97\xa6\xe2\x0f"
 b'\xd0\xc8\xbf\xfc\x80\x00\tB*?.\x81\xb8\xbb\x80[\x18\xbf>\x00\x02\x00\x00\x00'
 b'O\x00\x00\x00\x9d\x93*\x10@\x19\xc7\x18\x93v_L\xc1\x8c\xffe\xb1\xf0\x149'
 b'\xac\x91\xa7v6\xdc\t \xee\xed\xbf(\rs\xf9\xe0+\xcf\xbf')

{'A1': 'ughf',
 'A2': [{'B1': 40311, 'B2': -0.8726658156169471, 'B3': 137, 'B4': -30234},
        {'B1': 11303, 'B2': -0.19384954993182046, 'B3': 252, 'B4': 128}],
 'A3': {'C1': [0.665070116519928, -0.005630633793771267, -0.5951461791992188],
        'C2': {'D1': 199,
               'D2': [37656, 24438, 49484, 65420, 45413],
               'D3': 240,
               'D4': 20,
               'D5': -1483625415},
        'C3': [-0.9353180115301274, -0.24352657489917218],
        'C4': 271225757,
        'C5': 6464}}

(b'MME\xe1eley\xa8|\x88(\xe9\x8ay\xed\xd9\xbfO\x85]|\x84\xb8\x87s\t:s\xec?\xb9'
 b"\xe16\xb3\xa3\xae\xbe4\xc9:\xbe(\x0f'?>\x00\x05\x00\x00\x00O\x00\x00\x00"
 b'\xee\xd3f\x97\x93\x07\xc2\x07\xb3\xffL\x03\x06{\xcc\x8d\xe6~\x16\xe2'
 b'x\xc6\xb9\xd4M\xdd\xb6\x85\x14\xe6\xbf\x06\xc4\x7fGoc\xeb\xbf\xf2vL\x0c\xf0'
 b'\xbd\xed\xbf\x10\x04\xf0\xc6=\x1e\xd6\xbf\xcc\x8c\x83\xb7\n\x82\xd6\xbf')

{'A1': 'eley',
 'A2': [{'B1': 31912, 'B2': -0.40511931005006163, 'B3': 79, 'B4': 23941},
        {'B1': 33916, 'B2': 0.8890657600970746, 'B3': 185, 'B4': 14049}],
 'A3': {'C1': [-0.34109267592430115, -0.1824081540107727, 0.6525750160217285],
        'C2': {'D1': 194,
               'D2': [45831, 19711, 1539, 52347, 59021],
               'D3': 126,
               'D4': 22,
               'D5': -1178175262},
        'C3': [-0.6900051662036568,
               -0.8558880230394841,
               -0.929435752888564,
               -0.3455957834958676,
               -0.35168712540889824],
        'C4': 2540098542,
        'C5': 1939}}

Вариант №8

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

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

Поле	Описание
1	uint64
2	uint32
3	Структура B
4	double

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

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

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

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

(b"PDVB.\x8f+f\x94$'\x16\x01d*\x8c-t\xe9\xeb\xd4\x92\xbe9\x00\x00\x00C"
 b'\x00\x00\x00M\x00\x00\x00\xeb\xea\x80yE?\xe2\xac\xf1I\x83\x00\x00'
 b'\x00\xa6N\x95\x08jq\xe4\xbf\x1c\xc6\x00\x90\xd8\xf1\xe9\xc5T\xbf\xac'
 b'\x1dF\x98\xcds\xb0S\xe2\xbf\xe0\nt\x03z\xfc\xb7\xe0\xe9?\x80p\xcc\xd7\xec'
 b'\xa7t\xec^\x12\xc1\tA\xa6E\x1b&\xbc2h\xbd\xc74\xc7\xe2;\xc4\xd0\x13'
 b'\x00$\xa0\xf8\x02\xa0\x96\xcd\xc8j>`\xf39\xbeZ\xaa7\x17\x82\xcf\xf9\x0c\xbe'
 b'\xd3\xd3\xbe\x04\x00W\x00?m\x00^\x01\x8b\xc0\xa6<\xe9\x16\xec\xc3'
 b'\xbf\x04\x00\x00\x00[\x00\x00\x00\x18n\xb5\x85\x06f\xbc\x1d\x02\x00\x00'
 b'\x00{\x00\xd6\x8a')

{'A1': 78293081587592079,
 'A2': 764160612,
 'A3': {'B1': 116,
        'B2': -23,
        'B3': -0.2867806851863861,
        'B4': [{'C1': -14820, 'C2': -0.001267889463073324},
               {'C1': 7596, 'C2': -0.5727159749774351},
               {'C1': 2784, 'C2': 0.8086814814742938}],
        'B5': 2038491883,
        'B6': 16197,
        'B7': 1240575202,
        'B8': {'D1': 935006555298310746,
               'D2': -0.4137248396873474,
               'D3': [-128, 112, -52, -41],
               'D4': 27967,
               'D5': {'E1': 2332122624,
                      'E2': -0.15564237965127425,
                      'E3': [702863215749801964,
                             7508270400632366657,
                             15043214500515071933,
                             10853678368824754195],
                      'E4': 2142699700920610328},
               'D6': [0.22928161919116974, -0.18159246444702148],
               'D7': -29994}},
 'A4': -0.6388445060387837}

(b'PDVB.\x88\xfb\x9f\xb52\xf5[k\x8b\xd3Otl\xd4z\xb5\x14?9\x00\x00\x00C'
 b'\x00\x00\x00M\x00\x00\x00\xd7^<\x8e\xado\xd5E\xf0\xd6\x8b\x00\x00'
 b"\x00\x00\x8e7\tl\x1do\xbf\xe1\xa9\x84\xde\x08\xb2\xd6'\xea?*\xe0\xb4|J"
 b'PX\xb2\xe1?\x08v\xd4\xca\x9d\x83$\xc8\xe4?NQX\xd1l\xdb\xac\xba\xc6'
 b'<\x08\xcc\x8e.\xa0\xa3\x91]\xcf\x10\x80\xb9~H\x85\xfag\xa6\xba\xafUV\xfc'
 b"\x0c/)\xc2h'\r\xa0\x14;\xd3Q\xb3\x9f>\xd4(u?\xdc\xac\xb2\xbd\xaf)\xdbW\x8d"
 b'\xb7\\?\x04\x00W\x00\xbe\xd8\xd3\xf6\x8a\xcb\x00~ys\xfch\xc8\xbf\x05\x00\x00'
 b'\x00[\x00\x00\x00xYj\xd8\x17\x92f\x15\x02\x00\x00\x00\x83\x00t$')

{'A1': 7736046383083289480,
 'A2': 1951388555,
 'A3': {'B1': 108,
        'B2': -44,
        'B3': 0.5808941125869751,
        'B4': [{'C1': -22047, 'C2': 0.817363116954724},
               {'C1': -8150, 'C2': 0.553020626848499},
               {'C1': 30216, 'C2': 0.6494314737922999}],
        'B5': 2386321111,
        'B6': 28589,
        'B7': -688896555,
        'B8': {'D1': 6330699535977983196,
               'D2': 0.8621757626533508,
               'D3': [78, 81, 88, -47],
               'D4': 55486,
               'D5': {'E1': 3414882003,
                      'E2': -0.19070392263800784,
                      'E3': [14702067807784065900,
                             1211289704882777742,
                             11990827983251093888,
                             2967604957380194234,
                             15220782043276732610],
                      'E4': 1542080553533725048},
               'D6': [0.31191495060920715, 0.9576542377471924],
               'D7': 9332}},
 'A4': -0.0037982091978265853}

Вариант №9

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

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

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

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

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

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

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

(b'\xd2SFBX\x01\xbfQ\x00\xb2\x8e\xc9m a\tei5\x8f\x0fu\x91\x82)zq\xba'
 b'\xc9;\xf8\x8c%\xee?\xeb#\x91x\x97\xec\x15\xfb%rt\x95(\xd2\xc7l(\x01\xc4\xbfn'
 b'e\x91\xa4!\xa5R\xc9n]:\xcb\x91\xc0\x95\xd7\xdb\x99\x12\x08\xa3M\x98\xff3'
 b'\xd3\x02\x00\x1b\x00\xc3\xf1\xad\xcae%\xbf\xf9\x02\x00\x00\x00C\x00\x00'
 b'\x00X\x94\xc6\xac\x94\x05\xcd?\xd44\xb1\xf8\xf2G\x00\x00\x00Lr+\xae\xd6\xd2'
 b'\xbfq')

{'A1': 48897,
 'A2': {'B1': [{'C1': 0.9420838211356604,
                'C2': 9195,
                'C3': 30865,
                'C4': {'D1': [-105, -20],
                       'D2': 21,
                       'D3': 9723,
                       'D4': 29810,
                       'D5': -107}},
               {'C1': -0.1562853366045982,
                'C2': 25966,
                'C3': -23407,
                'C4': {'D1': [33, -91],
                       'D2': 82,
                       'D3': 28361,
                       'D4': 14941,
                       'D5': -53}}],
        'B2': 17996143755118113219,
        'B3': [-16239, -10347],
        'B4': 0.22673281132043388,
        'B5': -122604332,
        'B6': 242,
        'B7': {'E1': [-37, -103, 18, 8, -93, 77], 'E2': -751566952},
        'B8': 8196501666324509260},
 'A3': 7280457064529890994,
 'A4': [261043561, 696422773],
 'A5': 29050}

(b'\xd2SFBX\xf9\xebY\x003+\xe9\xfe\xc1\xd3\xa9X\xa7\xbf\xe1+\xba\xcc\x8f78H\xf4'
 b'\xd2\xaa5\x11U\xd4?\xfaE\xb9<\x94\xf4~\xd7:\xf2\x1a\xf5\xc6\xf4%\x8f\xe3'
 b'[\xe8?@E\x982\xe8\x1e:\xc8\xab\xa9{\xd5\xb4\xa1\xa4\x0e\x08\x02\x89\xa4\xe0'
 b'E`dtS5Wd\x99C\x05\xc5\xcf\x02\x00\x1b\x00\xd7\xe0"`\xd6\xc0Y*\x06\x00\x00'
 b'\x00C\x00\x00\x00\xf4\xd7\xbd\x7f\xe6E\xee?\x89&\xc1I\xd7O\x00'
 b'\x00\x00\x9e\xbb$\xd6hr\x05\xa7')

{'A1': 60409,
 'A2': {'B1': [{'C1': 0.3176920913786454,
                'C2': 17914,
                'C3': 15545,
                'C4': {'D1': [-108, -12],
                       'D2': 126,
                       'D3': 15063,
                       'D4': 6898,
                       'D5': -11}},
               {'C1': 0.7612169071068358,
                'C2': 17728,
                'C3': 12952,
                'C4': {'D1': [-24, 30],
                       'D2': 58,
                       'D3': 43976,
                       'D4': 31657,
                       'D5': -43}}],
        'B2': 3051682249488654551,
        'B3': [-24140, 3748, 520, -23415, 17888, 25696],
        'B4': 0.9460327620461144,
        'B5': 1237395081,
        'B6': 215,
        'B7': {'E1': [116, 83, 53, 87, 100, -103], 'E2': -809171645},
        'B8': -6411592699897136226},
 'A3': 6388870376560601907,
 'A4': [736214951, 932170938],
 'A5': 18488}

Вариант №10

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

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

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

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

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

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

(b'ITGZVfn\xbf\xe87J\xc7\x1c\x81\xea\x85jt?\xcb8\x9f\xc6\x07\xd5H\xde\xaa'
 b"E\xcd\x15%\xfe\thMS\x92V\xa5'\xae\x996r\xe5\x00\x00\x00\x8c\xe9|G\xfd\xbbg"
 b'\t\x7f\xa3\xd3(\xa9\xac\xa8\xbc\x97?\xeb\x8a\x99rTY\xaa?\xe7S\xcb\x9e\x1d'
 b"0\xc2?\xc3H\x0c'[\x85\xc8\xbf\xc4\xca\t\xf5\xb408?\xb7a\xe4(6\xb2 \xbf\xe6"
 b'~\xb0c\xc3l\x96?\xec6T\xe7\xf7\xdf\x1a<>\x8f\x13\x8cF\xf3\xbfN\xd3B\xec{m'
 b'\xea\xdf\xb7\x08\x00\x00\x00\x04\x00\x00\x002\x00B')

{'A1': [{'B1': 86, 'B2': 'fn', 'B3': -0.7567495240110109},
        {'B1': -123, 'B2': 'jt', 'B3': 0.21266553086722184}],
 'A2': -2402030704123314679,
 'A3': 1749898130,
 'A4': 6243440089267335909,
 'A5': {'C1': [-377731075, -1150875265, -1546442583, -1398227817],
        'C2': {'D1': [0.8606688721654809,
                      0.7289789283909374,
                      0.15063621446374342,
                      -0.16241573807963205,
                      0.09133745176104258,
                      -0.7029649685386115,
                      0.881632283270821],
               'D2': 0.011630791239440441,
               'D3': [140, 70, 243],
               'D4': -0.8079110383987427,
               'D5': -20,
               'D6': 31597,
               'D7': -354437368}}}

(b'ITGZ\x0fku\xbf\xea\xe3\xe4\x0fm\xa3 ~sj\xbf\xdd\x14\xd0\xd6\xa2\xf1h\xbf+'
 b'c\x85\xac\xfc\xbe:%\xc6\x0e;\xf4\xcc\x0c\xd6w hZ\x00\x00\x00\x90\xbb\x18'
 b'\xed\xa3\x18>\x11^\x0fA\xd4\xf8\xd8Q-\xccM3\xe8\x9d?\xce2\xe7\xb6\x00'
 b'-\xf0?\xe1\x1b\xac\x82\xee\xdaf?\xe2\xd5\xac\x8ca7(?\xe8\x1f\xb7\xafn'
 b'I\xc6?\xd5\x84\x14\x889\xb4\xdc\xbf\xea\x1cO\x8b\xfa\xdf\xc0?\xe2'
 b'7\x1c\xbc\xa1\xdc\xb8\xbf\x18\x17\t\x80\x16E\xbe\xca\x9e\xc4L\x11j'
 b'\xffu\x94\x80\x00\x00\x00\x05\x00\x00\x002\x00F')

{'A1': [{'B1': 15, 'B2': 'ku', 'B3': -0.8403187085469632},
        {'B1': 126, 'B2': 'sj', 'B3': -0.45439549408526725}],
 'A2': -4671530762682712518,
 'A3': 633736763,
 'A4': 17639487955764537434,
 'A5': {'C1': [-1155994205, 406720862, 255972600, -665768500, 1295247517],
        'C2': {'D1': [0.23592850100281693,
                      0.5346281583104655,
                      0.5885832540313674,
                      0.7538717676528044,
                      0.33618653586638714,
                      -0.8159558996185226,
                      0.5692275699829201],
               'D2': -0.5941014885902405,
               'D3': [128, 22, 69],
               'D4': -0.3957425355911255,
               'D5': 76,
               'D6': 4458,
               'D7': -9071488}}}

Вариант №11

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

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

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

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

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

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

(b'\x95SOW\x00\x16\x00(\x009\x00K^\r\x00\x02\x00\x00\x00\xba\x19.\xe5\xb6'
 b"\xca\x00\x00\x00\x02\x00\x00\x00\x14\xbf~\xcd'J\xfd\x93\xf5\x14\xb3\x00"
 b'\x00\x00\x03\x00\x00\x00%>\xa2\xefw\t\xa0\x9c\x9ay\x00\x00\x00\x02'
 b"\x00\x00\x007\xbe\xa1'\x94\xa1\xc7\xd2\xa8\xf6\x06\x00\x00\x00\x03\x00\x00"
 b'\x00H\xbe\xe3e\xef?\xeb\x88@D\xb9\x9c0\xbf\xc26\x14X0Q\xd8\xbf\xe1'
 b'\x8d\xe3\x8d\n0\x9a?\xd7\xf4\x9ak\xa76\xc4a\x00\x00\x00\x04\x00\x00\x00Z\xbf'
 b'\xc5#\x10\x9b\xcd\xa0 s\x03\xaa?\xdc\xb2\xfbYH\xf3P\xbf\xc1m\\A/\xbd@?\xeb'
 b'\xa0\xce\n-UTi\x00\x00\x00\x03\x00\x00\x00\x8e\xbf\xcf-HF\xf9\xe1\xc0f'
 b'\x82\xf8\x00\x00\x00z\x00\x00\x00\xa6')

{'A1': [{'B1': 58806,
         'B2': {'C1': 202, 'C2': [25, 46], 'C3': -0.9953178763389587}},
        {'B1': 62740,
         'B2': {'C1': 179, 'C2': [74, -3, -109], 'C3': 0.3182332217693329}},
        {'B1': 40090,
         'B2': {'C1': 121, 'C2': [9, -96], 'C3': -0.31475508213043213}},
        {'B1': 43254,
         'B2': {'C1': 6, 'C2': [-95, -57, -46], 'C3': -0.4441370666027069}}],
 'A2': 24077,
 'A3': [{'D1': 97,
         'D2': [0.8603822080884864,
                -0.14227537447062732,
                -0.5485704188045191,
                0.37430439484601785],
         'D3': -0.16513259513453793,
         'D4': [115, 3, 170]},
        {'D1': 105,
         'D2': [0.4484241840289558, -0.13614991362508455, 0.8633794974108846],
         'D3': -0.24356940713529518,
         'D4': [102, 130, 248]}]}

(b'\x95SOW\x00\x16\x00(\x00:\x00L\xac\x1b\x00\x02\x00\x00\x00\xbb\x92\x89\xe3m'
 b'j\x00\x00\x00\x02\x00\x00\x00\x14\xbf>\xda\xa1a\xca/k`\xdf\x00'
 b'\x00\x00\x03\x00\x00\x00%\xbe\xb2\x80n\xbf\xdd\xc08\xf3\xea\x00\x00\x00'
 b'\x03\x00\x00\x007?1p\x13hYu\xfc\xc8\xc6\x00\x00\x00\x03\x00\x00\x00I\xbf'
 b'\x7f\xe3\xd4?\xe9\x91\xcfW\xea~\xfa\xbf\xd8\x1e\x87&=\xff0?\xd8*W\x11'
 b'D\xb3\xb4\x19\x00\x00\x00\x03\x00\x00\x00[\xbf\xdf\xff\xc6\x07\x0f38'
 b'\xa5a\x86\xbf\xee^\x9a\xeb\xe6\x86\x1c?\xd5"ES\xd5sX\xbf\xd5\x08\x9aQ'
 b'\x04\x95\xa0\xbf\xe5\x84a\xeb\xb4F\xcc\x15\x00\x00\x00\x04\x00\x00\x00\x87'
 b'?\x97\x91n\x83\xb1\x13@\x90\xe6\x03\x00\x00\x00s\x00\x00\x00\xa7')

{'A1': [{'B1': 58221,
         'B2': {'C1': 106, 'C2': [-110, -119], 'C3': -0.7455235123634338}},
        {'B1': 27488,
         'B2': {'C1': 223, 'C2': [97, -54, 47], 'C3': -0.34863609075546265}},
        {'B1': 14579,
         'B2': {'C1': 234, 'C2': [-65, -35, -64], 'C3': 0.6931163668632507}},
        {'B1': 64712,
         'B2': {'C1': 198, 'C2': [104, 89, 117], 'C3': -0.9995701313018799}}],
 'A2': -21477,
 'A3': [{'D1': 25,
         'D2': [0.799049064360559, -0.3768632768114797, 0.3775842350613019],
         'D3': -0.4999861782969677,
         'D4': [165, 97, 134]},
        {'D1': 21,
         'D2': [-0.9490484816962552,
                0.3302167242707603,
                -0.3286500731649884,
                -0.6724099734876403],
         'D3': 0.023015715396712766,
         'D4': [144, 230, 3]}]}

Вариант №12

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

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

(b'AHSF\xca\xeeE^^\x00\x03\x00\x00\x00O\x00\x00\x00\x84\x1a\xc5\xf5MF'
 b'\xb1\xeeO\x11\x9b%.\x8e\xaa\xb8\x9dY\xbf\xc4\\\x83H/\xbb\x88\x174.\xc8'
 b"Z_r\xe9\xd1?\xee^)\xa37D>u\xd5H\xdd'\x8d\x94\x04\x0e\xbf\xe3[\xbe\xfc\xa4"
 b'\xafl\xac\x00\x1c\x00-\x00>>\x0b\xba>\xbf9q\xfd>\x07j\x05>b\xedW\xae\x83>'
 b'\xc3\xe6\xbe<\x8f1\x95=\xb6i5\xbf_p\xd2\xbd\xcd\x92i?\x1f?\x8c\xbe'
 b'\xea\x80\x87\x0etsquwi\x00\x00\x00\x04\x00UT\xe2\xfe\xe3E\xf9#\xe9'
 b'\x00e\xb8\xca\xaf\x03')

{'A1': -297443746,
 'A2': [{'B1': -7267351233407967911, 'B2': -0.15907326721886883, 'B3': 23},
        {'B1': 3760163029374921169, 'B2': 0.9489944637117629, 'B3': 117},
        {'B1': -3077967183358983154, 'B2': -0.604949468082379, 'B3': 172}],
 'A3': {'C1': 'tsquwi',
        'C2': [0.13645264506340027,
               -0.7243955731391907,
               0.13224036991596222,
               0.221608504652977],
        'C3': 6116731496007541737,
        'C4': {'D1': -20861,
               'D2': [0.38261979818344116,
                      0.01747969724237919,
                      0.08906785398721695,
                      -0.8728152513504028,
                      -0.1003769114613533,
                      0.622063398361206,
                      -0.45801183581352234],
               'D3': 14},
        'C5': 3100290819},
 'A4': 449181005,
 'A5': 70,
 'A6': -1309782255}

(b'AHSF\xcaB,\xb9T\x00\x02\x00\x00\x00>\x00\x00\x00iwn\xfa]o-/\\\xca}\x99WS'
 b'f1\xcf\x0c?\xbf\xbb\t\x03\x8fSP\xb2#\x89D<\xcd\xe5/p?\xec50Bt\x05'
 b'\x94\x84\x00\x1c\x00->\xd7D\xc4\xbe\xa8K=q\x86>_\x04\x0e=m\x9d\xd2\xbf`Q\xc0'
 b'?D\xd9\x88\xbe\xf9\xd7\xd6=\xd9\xdf\xf9=\xcb\xfdB\xe6keoztq\x00'
 b'\x00\x00\x02\x00B\x84\xcfh\xc3\xad\xb9\xbc\x0e\x00J\x07j\x83j')

{'A1': 1110227284,
 'A2': [{'B1': 9050360941886164748, 'B2': 0.12394768082533614, 'B3': 178},
        {'B1': 2560652891079913328, 'B2': 0.8814927385248432, 'B3': 132}],
 'A3': {'C1': 'keoztq',
        'C2': [0.420446515083313, -0.3286990225315094],
        'C3': 9569982922828135438,
        'C4': {'D1': 29062,
               'D2': [0.2177889049053192,
                      0.05801183730363846,
                      -0.8762474060058594,
                      0.768944263458252,
                      -0.4879748225212097,
                      0.10638422518968582,
                      0.09960414469242096],
               'D3': -26},
        'C5': 124420970},
 'A4': 2003761757,
 'A5': 111,
 'A6': 758078666}

Вариант №13

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

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

(b'rBLU\xb9pY7\xdd\xc0\x0b\xd7\x8d\x00\x00\x00\xf2\xf5\xaa\x01\xaa\xc7\x99\x1a'
 b'\xed?\xffD:\xa7\xd8\x80^\xaa\xe3\xbf@\x9c\x98\xfc\x88c\x92l\xd1\xbf\xf3P'
 b'\x06\x96\xbb/\xa9F\xe5?\xa3+\xb0\xbc\x90\xff\xfbE\xb2\xbf\x10\x00'
 b'\x1a\x00$\x00.\x008\x00\x08?\xf4\x92\xe0\x17&$G\xc3\xfdS\x85g\x8c\x80'
 b'\x1a\x95\xab\x82\xf7\xc2\xff\x06\x00L\x00\x9c\xc0\xc6O\x9f0X\xaa\x07'
 b'\x00\x00\x00X\x00N0\xa3\xdbca\r\xf9L\xa2K(\x19\xf9tL\x02\x00_'
 b'\x00\x82\xb4\xc6\x8f~\x05\x00B\x00\xd0\x90q\xbf\xa4\xbe\x07\\\xdf\x7f'
 b'\xd0?\xaeNc\x00\x00\x00%]&<\x86\xfb\xbe\x94\x01o\x8d\x89\xd8\xe7\xd0\xa9'
 b'\x136\xbf')

{'A1': -2951053074462314311,
 'A2': {'B1': {'C1': 126,
               'C2': [{'D1': -2574, 'D2': 0.9094971561135499},
                      {'D1': 17663, 'D2': -0.6145470158128099},
                      {'D1': -25536, 'D2': -0.2722516986868384},
                      {'D1': 20723, 'D2': 0.6648755962639263},
                      {'D1': 11171, 'D2': -0.07138037671460284}],
               'C3': -0.9436159133911133,
               'C4': 0.25780471789674153,
               'C5': 20142,
               'C6': {'E1': [16136, 37620, 6112, 9254, 49991, 21501],
                      'E2': -6172129828514905956,
                      'E3': [133, 103, 140, 128, 26, 149, 171],
                      'E4': 17946107171655856206,
                      'E5': 5509302130626503244,
                      'E6': [63362, 65474],
                      'E7': 2412164226}},
        'B2': 37,
        'B3': 9821,
        'B4': -0.49125850200653076,
        'B5': -3393505708905397868,
        'B6': -0.7112374901771545}}

(b'rBLU\xc3\xf0\x9a\x8c\x01<\xe0u\x84\x00\x00\x00J\x1e\xf0)\xe71\xa2M\xef?\xed0'
 b'\xf8pU\xecnr\xd5?n\xb9l\x0f2R\x16\xd0\xe2?\xbe\xd0\x94\xa0\xf6\x86'
 b'\xda\x00\xd7?\xb3\xdf\xd8\xaa\xcdpe\xe9\xc1\xbf\x10\x00\x1a\x00$\x00'
 b".\x008\x00A<E\x8d\xe1\x13S\x18\xdbM>\xf5'\x12\x04\x00L\x00\x9b\x92"
 b'\x1f"\xf7\xb7\xca\xfe\x02\x00\x00\x00T\x00CS(\x04\x99,\'\xbf}<\x95\xf6'
 b'\x89\xbbx^\x02\x00V\x00\t\n\xfc^2\x05\x00B\x00\xa3\x9c0?\x12\xe2\xfd'
 b'\xe5\x05\xf3\xe2?\x9e\xbeZ\x00\x00\x00\xc5\xb1\x1d\xe0\xf0\xd4>\xe5n\xdf[Qr'
 b'\x87\x08\xa0\x10\xbf=')

{'A1': 8493854874572353731,
 'A2': {'B1': {'C1': 50,
               'C2': [{'D1': 7754, 'D2': 0.9782267546336794},
                      {'D1': 12525, 'D2': 0.33510945395916236},
                      {'D1': -18066, 'D2': 0.5879012685186189},
                      {'D1': -12098, 'D2': 0.3594271009446939},
                      {'D1': -8269, 'D2': -0.13993518836954055}],
               'C3': 0.6898900866508484,
               'C4': 0.5921658985162728,
               'C5': 48798,
               'C6': {'E1': [15425, 36165, 5089, 6227],
                      'E2': -87054970723003749,
                      'E3': [219, 77],
                      'E4': 13774027021047321411,
                      'E5': 6807397037992393853,
                      'E6': [62782, 4647],
                      'E7': 1593575945}},
        'B2': 197,
        'B3': 7601,
        'B4': 0.41590023040771484,
        'B5': 614585567918649061,
        'B6': 0.09329342842102051}}

Вариант №14

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

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

(b'\x0eQRD\x10)\tB\x17\x8a\x88\xc7\x96\x00\x05\x00\xa9\x00V\xbc\xc3w\xbc\x18'
 b"K\xf6wi\xb0\xc9\xf7\x07\x0b\x0c\x06\xbe@*Q\xcf*\x81\x80'\x88\x19\x17="
 b'\xcb\xb1J\xb3\xce\x02\x00$\x00\x9ah\xacB\xab\x87\xc7w_\xf1\x1c(?\xddl'
 b'\xc2\xc3\x02\x009\x00\xf7vX7 ?\xdf\xf3\xf2k\xa1EK\xb6g\x15\xd2\x02'
 b'\x00N\x00\x00\xb9J?\xb7\x16\x87\xf7U\xdf\xdf\xb0,\x00A\x00V\x00\xf8`\x98'
 b'\x9f\x82O\x18\xe4\xbfVN\x85\xf3\x05?\x07T\x9d$X\x02\xefDc\x00\x83r'
 b'\x07\\O\xafg1vA\x1e\x00\x00\x00o\x00\x18XP\x0b\xa9\xbb\xe1\x8c\xee?'
 b'\x98\x84\x07i\x05\xbe')

{'A1': 14377893642877085968,
 'A2': {'B1': 16758,
        'B2': {'C1': 2039, 'C2': -0.13090531527996063},
        'B3': {'D1': [{'E1': 12919333967527090568,
                       'E2': 206,
                       'E3': [-816764352, 662733098]},
                      {'E1': 14009815804168434015,
                       'E2': 195,
                       'E3': [1118595226, 2009565099]},
                      {'E1': 1542401831804693490,
                       'E2': 210,
                       'E3': [928544503, -203473120]}],
               'D2': {'F1': -8, 'F2': -0.6279676009405755},
               'D3': {'G1': 20054, 'G2': 0.5232470631599426, 'G3': 614290439},
               'D4': [88, 2, 239, 68],
               'D5': {'H1': 0.7918853759765625,
                      'H2': -142141769,
                      'H3': [85, 223, 223, 176]},
               'D6': 3560006785840935555},
        'B4': 22552,
        'B5': 0.954697481655197,
        'B6': -104},
 'A3': [132, 7, 105, 5, 190],
 'A4': 2009316438,
 'A5': -3913512112230819652}

(b'\x0eQRD\x91N\x9d\x16(\xb9\xbb\xe9\x9e\x00\x06\x00\xb1\x001\xe4'
 b'\x19\x01\xd2\xab\xb5G\xe0?\xe6FL\xeb\xa5\xab\xf2<xG\xcd|1r\xb9>\x84\x86N\xa4'
 b'\xd4\x8d\xfb\xfb\x8f\x84\xd1QX\x03\x00$\x00\x11\xe5\xd8\xfb\xf6\xe5\x0c'
 b'\xb4[\x10D"\xebt\x15\n\xa7\x02\x00=\x00\xe1\xa2\xad\x91s\x1fGZ\x03\x03'
 b'bB^\xa6\x06\xdaK\xdb\xea\x17\\\x03\x00R\x00\x9b\x85@?)*h\x7f\x8aE \x830'
 b'\x00E\x00^\x00X<\xb1\x01\x9f\x94\xb7\xd0?\x82\xfa+\x1c$?\x93y\xbe_T\x99$\x1c'
 b'k\x00\t\x84\xc4\x06\x89\xce7\x91\x1c\xb8\x1e\x00\x00\x00w\x00\xba\xa5'
 b"x'\xc8\x01\x1a\x9d\xc3?\x8d\xd7\x10\xdc\nvZ")

{'A1': 16842258813311340177,
 'A2': {'B1': -18404,
        'B2': {'C1': 60236, 'C2': 0.029622862115502357},
        'B3': {'D1': [{'E1': 5895639141147446740,
                       'E2': 88,
                       'E3': [2093827960, 1052340785, -1538357628]},
                      {'E1': 726615468131225691,
                       'E2': 167,
                       'E3': [-69671663, -1274223114]},
                      {'E1': 1723430926249535070,
                       'E2': 92,
                       'E3': [-1850891551, 1514610547, 1113719555]}],
               'D2': {'F1': 88, 'F2': 0.261204867629903},
               'D3': {'G1': 64130, 'G2': 0.6410548090934753, 'G3': 1606318483},
               'D4': [84, 153, 36, 28],
               'D5': {'H1': 0.7520386576652527,
                      'H2': 2137532969,
                      'H3': [138, 69, 32, 131]},
               'D6': -7982684726571531255},
        'B4': -23110,
        'B5': 0.15323186003689293,
        'B6': -115},
 'A3': [215, 16, 220, 10, 118, 90],
 'A4': 18474033,
 'A5': 5108841059806718930}

Вариант №15

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

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

(b'\x15HBM/\x07\xfc\xef\xfd\xa3\xf3\xb2H\x8d[\xa5#czT\x17^\x00\x00\x00`\x00\x00'
 b'\x00b\x00\x00\x00d\x00\x00\x00W\\\x9f\xa0jvxjk\x83_\xec\xbd\xf6\xe1'
 b'\x04\x1d\x82\xf3g\xedvH\x80\x02\x00f\x00\x00\x00S\xb07?\xdf\x92-\xbfS'
 b"\xcf\x07/\x05\x05\x00h\x00\x00\x00QBur\xca\xbd'\x16\xd7\x19Ht\xcf\xf8\x9b1+u"
 b'\x9d\x19\x84\xb6\x83>\xd9\xa4\xac\xd4>iRf\xe9\xf8s\xd0\xf8\x1f')

{'A1': 4026271535,
 'A2': -6531471491191299075,
 'A3': 1417306915,
 'A4': 23,
 'A5': [{'B1': -41, 'B2': 25},
        {'B1': 72, 'B2': 116},
        {'B1': -49, 'B2': 248},
        {'B1': -101, 'B2': 49}],
 'A6': {'C1': 2694798423,
        'C2': 'jvxjk',
        'C3': {'D1': -0.11541654914617538,
               'D2': -10,
               'D3': 1249,
               'D4': 9243768997201281565,
               'D5': [43, 117],
               'D6': 0.7175342440605164},
        'C4': -0.6780223250389099,
        'C5': [83, -49, 7],
        'C6': 1327},
 'A7': [3062110621, 2765700739, 1765725356, 4176045650, 536399987],
 'A8': 1596453270127460945}

(b'\x15HBM\xe9#\xf33K\xd3\x1d\x81\xb8\xd4AP0\xea\x8e8\x8b^\x00\x00\x00`\x00\x00'
 b'\x00b\x00\x00\x00d\x00\x00\x00;\x80\x9csbiyygi\xe4\xb4\xbeN\xc5\xf8\xc4\x86K'
 b')\x98\x1f\xc5\xdf\x02\x00f\x00\x00\x00\xa4?X\xbe\xe7\x12~>6\x92m)p'
 b"\x04\x00h\x00\x00\x00s\x1d\x81'\xaf^Zt\x9aI>:j\x8d\x8a\x84bFmSn;\xb9.\xe8,"
 b"]\xaaS'\xc8\xa5\xbf\x13")

{'A1': 871572457,
 'A2': 5783137285425713995,
 'A3': 948890160,
 'A4': -117,
 'A5': [{'B1': -102, 'B2': 73},
        {'B1': 62, 'B2': 58},
        {'B1': 106, 'B2': 141},
        {'B1': -118, 'B2': 132}],
 'A6': {'C1': 1939636283,
        'C2': 'biyyg',
        'C3': {'D1': -0.3533051311969757,
               'D2': 78,
               'D3': -1851,
               'D4': 16124328779258234564,
               'D5': [98, 70],
               'D6': -0.21118026971817017},
        'C4': 0.24811898171901703,
        'C5': [54, -110, 109],
        'C6': 28713},
 'A7': [997086061, 753413817, 659794525, 331326920],
 'A8': 8384117762678660467}

Вариант №16

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

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

(b'OQM\x97\x8e\x00\xbf8h\xd8A\x10\xd8\xd1\x04\x02\x00\x00\x00-\x00\x05\x99\xcc'
 b'\x89\xd4\x91\xb7\x88\xeb\xbd\x1a+7\x86)/\xf4l\xaa|\xb7\xc3,\xbb\xfcZW'
 b'\x15\x9f\xd7!C3(o\xb3}\x1b\xdf]\xa2f\x9e\x0cd\xe2e\xda\xae3@C\xbe\x06\x00'
 b'\x00\x00\x15\x00\x00\x00\xdb\x9d\xca\x15\xde\xf3\x19\x18\xb7\x802\xe4;\xf4'
 b'\xb2\xa9\xd6\x8c\xa4X>S\x87\x16_\xcb\xa4B\xe7\xd5\xad8^\x1fL\x8f\x7f\x93'
 b'\x0b\x87&ujP\x9e\xcf\x85\xc3a\x11\xbf\x06\x00\x00\x00!\x00\x00\x00t\xb4\xc5'
 b'\x9d\xa5a\xe4\xd0:\x8b\xafm\xff\xd2\xecs\xe7Na~?&')

{'A1': -0.5021757483482361,
 'A2': 347296210620016696,
 'A3': [{'B1': {'C1': [4837384553030441724,
                       6764155392029042739,
                       -2709510681457170782],
                'C2': -82,
                'C3': {'D1': -0.1906745880842209,
                       'D2': [39173, 35276, 37332, 34999, 48619, 11034],
                       'D3': 365600219,
                       'D4': -34,
                       'D5': 243,
                       'D6': [25, 24, -73, -128, 50, -28, 59],
                       'D7': -693521676}},
         'B2': 0.21156519651412964,
         'B3': 83},
        {'B1': {'C1': [-3033382548456663417,
                       -7818372870985336659,
                       -3486260643375970549],
                'C2': -123,
                'C3': {'D1': -0.5678979754447937,
                       'D2': [34359, 12073, 27892, 31914, 50103, 47916],
                       'D3': 2646979700,
                       'D4': -91,
                       'D5': 97,
                       'D6': [-28, -48, 58, -117, -81, 109, -1],
                       'D7': -411833134}},
         'B2': 0.993672251701355,
         'B3': 38}]}

(b"OQMuK'\xbd\x19\x1b\xf4\x85z[g\xb5\x02\x00\x00\x00%\x00\xdbN\xd5MT%\xd1"
 b'hR\xd20\xb9\xcc\x03/\x96s\xad$^\xa5k\x11q\x82\xd5\xcbXt\xf5u\x1ae_\x8c'
 b'v0\x94\xf2\x0f\xb2\xb2[\xa9\xbe\x02\x00\x00\x00\x15\x00\x00\x00#\xf5'
 b'F\xa6"\x07\xcbG,\x13\xc8\xbd}\xe9\xde\x06\xb0\x81K?\xbd\xb0\xd0a\xb3\xdf'
 b'=+\xe9\xa0\xaf\x18\xf1T\x1f\x19\xb2^j\xa6Q\xd7\xf5\xd7d\x03\x01}`z'
 b'\xbf\x06\x00\x00\x00\x19\x00\x00\x00\xb1\xc0(\x9a\x16\xc6\x9f-K\xfa\xb0'
 b'j\x9be{G\xd0N\xd6\x95\xbe\xa9')

{'A1': -0.04084344580769539,
 'A2': -5375227048451892455,
 'A3': [{'B1': {'C1': [8147411558883175795,
                       1906699897316038018,
                       1149143790801149797],
                'C2': -78,
                'C3': {'D1': -0.33077770471572876,
                       'D2': [20187, 19925],
                       'D3': 2789668131,
                       'D4': 34,
                       'D5': 7,
                       'D6': [-53, 71, 44, 19, -56, -67, 125],
                       'D7': -1341726999}},
         'B2': -0.04670286551117897,
         'B3': 176},
        {'B1': {'C1': [-6851897813321424432,
                       6823544007779489967,
                       244557730664261226],
                'C2': 1,
                'C3': {'D1': -0.9780347943305969,
                       'D2': [9556, 26833, 53842, 47408, 972, 38447],
                       'D3': 2586362033,
                       'D4': 22,
                       'D5': 198,
                       'D6': [-97, 45, 75, -6, -80, 106, -101],
                       'D7': -800621723}},
         'B2': -0.29265064001083374,
         'B3': 169}]}

Вариант №17

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

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

(b'~BPUOk\xb9?\x00\x00\x00heK\x00H\xe6\t\x1fQa :\x03\x00b\x00\x00'
 b'\x00\xd8\x03\xda\x8fM\xf19\x8d\x81.\x88\xb5y\xbd\xac\r\x1b\xdf\xf5'
 b'"\x89\xe5\xfe!L\x02\x00\x00\x00\x86\x00-\xbd\xdd1\xaa[\x18\xa9\xa4\xc8)\xdf'
 b'\x11\x84>u*\xd8\x96\x15\xb4\x13?\xf3yprgk\xb4\x7fa\xfc\xda\x97i'
 b'\xa6\xe5\x9a\x9f\xb0\xbd%\x8c\x7f\x08Q\x02u\x125\xd0\xbfU\x1ea\xdas2"'
 b'\x1f&\x19\r8e\x18*\xa2\x9e\xb2\xc9\xf1\x02\x9e\x8a\xf7Sb\xb8\xeec')

{'A1': 47467,
 'A2': {'B1': {'C1': 3010837397062265393, 'C2': 0.2579488456249237},
        'B2': 25960,
        'B3': {'D1': -1764218251,
               'D2': 0.5769665837287903,
               'D3': 243,
               'D4': 'yprgk',
               'D5': -6455461624065982540,
               'D6': 229},
        'B4': 4188454654495549000,
        'B5': [{'E1': 612362168069824410, 'E2': [593, 4725]},
               {'E1': 8348091642200182837, 'E2': [8754, 9759]},
               {'E1': 11430745088485494041, 'E2': [51634, 753]}],
        'B6': 216,
        'B7': [9335181311160080899, 1949404143512029230],
        'B8': 5485946082915710431},
 'A3': [1408731806, 1676589154],
 'A4': 45,
 'A5': 56765}

(b"~BPUO\xaf\xde?\x00\x00\x00\x02\xd4K\x00\x1b]'\xd7\x9f&Z\xc4\x02\x00b\x00\x00"
 b'\x00\x186\x97\xba\xc2\n\xe7a\xd1\x1dj\x9d\xb4\xd3\xd4\xbc\xde}\xa0%i\x8d}'
 b'\xd1T\x02\x00\x00\x00z\x00#\xa3/D\xa3\x8a\x97\xf1\xc2\x9d\x92\xd9JX\xbcB'
 b"\xe8\x84P'\xd7\r?\xf8xgomnr\x82u\x88<\x05U\xbf\x1d\xef<\xc0_\xb7v,M\x1e\xd1"
 b'\x93\xc2\xd8\x04\xd5\xd2@9:9R\xe9Y\xcd\xa2c\x85\xfb\x0c\xcb\xea\x00')

{'A1': 57007,
 'A2': {'B1': {'C1': 10564814643766403908, 'C2': -0.013201438821852207},
        'B2': 54274,
        'B3': {'D1': 1350887490,
               'D2': 0.5540642142295837,
               'D3': 248,
               'D4': 'xgomn',
               'D5': -4659812481899330958,
               'D6': 29},
        'B4': 14148663647289171227,
        'B5': [{'E1': 5560950169853246703, 'E2': [53534, 49811]},
               {'E1': 4123671359388976344, 'E2': [59730, 52569]}],
        'B6': 24,
        'B7': [15087594260070569782, 16049937177775008285],
        'B8': 6111804215626408061},
 'A3': [4219823010, 15387404],
 'A4': 35,
 'A5': 12195}

Вариант №18

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

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

(b'dXUPN\x9c\x96\xf8\xcb\x0b\x11\xac\xfb\x02\x00\x00\x00U\x00\x00\x00\xa6L\x14'
 b'\x9d\x8b\xfa\x12x\xb6\xd6\x02\x00\x00\x00\x83\x00L:O\xbfI\xf4\xb0=Y\xbfq'
 b'\x0c\x07"\x00\xff\xe7\xce>\xb4\x8f\xccY\xec\x0bd\xfe_\xd7l\x8a\xe2\xd4Db'
 b'\xd2R\x94\\\xa3\\\x06\x8ek\x92\xd6\xde\xcfT\xb8l\x90H\x96DG0\xae\x0c'
 b'^\xab\x06\x8c\xa1Y\xc8v\xdb%?v\x0b9\xd6g\xb4\xd2|\x01df\xdcs=\xee\xe1k'
 b'\x89\xc8)&\\\x1c\x84g\x00\x00\x00u\x00\x00\x00')

{'A1': -872900964,
 'A2': 4222357771,
 'A3': [{'B1': 84, 'B2': 3478824649420205240},
        {'B1': 174, 'B2': 14436747703292222988}],
 'A4': 8652253311674895526,
 'A5': {'C1': -74,
        'C2': 214,
        'C3': [{'D1': [118, 219, 37, 63, 118],
                'D2': 107192163428088075,
                'D3': 100},
               {'D1': [102, 220, 115, 61, 238],
                'D2': 2043550291819326433,
                'D3': -124}],
        'C4': {'E1': -0.8094832897186279,
               'E2': -2999,
               'E3': -0.848597526550293,
               'E4': 113,
               'E5': 2230028,
               'E6': 0.4041137397289276,
               'E7': [1506578356, -26997780, -1972578465, 1648678114]},
        'C5': -8212775013760871726},
 'A6': -28053,
 'A7': 214,
 'A8': -12322}

(b'dXUPN\xe4\xbb\xffK\x84V\x97\x08\x02\x00\x00\x00U\x00\x00\x00\xd7\xa5-'
 b'p\xb9j\x1c\x12\xb5\xba\x02\x00\x00\x00\x83\x00zwL\xbe\x9c\xc8\xddD\x89\xbe5'
 b'\xc4\x85\xac\xf5X8\xa7\xbeu\xd1\x1dY\x05\x93.\x0b\x94\x87\\\x82eZ}J'
 b'\xa1\xba\xb5\\\x954$;\x958\xb1\xfb\xd84s\xf2N`\xd8t\xc4\x86\xc9\x0c'
 b'\xc9o|\x1a\xcc\x9e\x95r\xcf^\xbb+\x10\x8e\xd5\xd7PQ\x19\xf7\\\\\xbb\xd0'
 b'\xe5^~\x8e=\x13f\x90\xfe&\x15g\x00\x00\x00u\x00\x00\x00')

{'A1': 1275050980,
 'A2': 144135812,
 'A3': [{'B1': 52, 'B2': 9711015169195176563},
        {'B1': 201, 'B2': 10781278972100462860}],
 'A4': 1305035336714134999,
 'A5': {'C1': -75,
        'C2': 186,
        'C3': [{'D1': [114, 207, 94, 187, 43],
                'D2': 17805352009446297104,
                'D3': 92},
               {'D1': [92, 187, 208, 229, 94],
                'D2': 2809841985609633406,
                'D3': 21}],
        'C4': {'E1': -0.19967451691627502,
               'E2': -14180,
               'E3': -0.2681035101413727,
               'E4': 53,
               'E5': -173242940,
               'E6': -0.3266017436981201,
               'E7': [1495126389, 187601669, -2107865196, 1249729125]},
        'C5': 4261588963509516961},
 'A6': 14485,
 'A7': 177,
 'A8': -9989}

Вариант №19

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

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

(b"|RXLPn\x02\x00\x00\x00'\x00\x00\x00\xd9\xeeg\x1b\xf3s\x00\x00\x00>^(\x9a\xc7"
 b'\x87\xea\xbf\xec\xa3\x1c`V]\xe0\xbfe(\xf6>vq\xf8~\xa8#>vlC\x19\x92\xea'
 b'\xa6Co\xe2\xc2\xf8a\x83\x12\x88\x98\xf2yW\xa4\x93A\x19E!u\x1b\\\xb6'
 b':\xd6\xd7\x96B\x0b<lU\xd2\xf6\x93\xbc\x8b&\x19 \xa0S\xd2D\xdf\xdf\xa7'
 b'!\xb6\xb6E\xc7\xe7$9\xdb\xcf\xa1\x07\x005\x00\xcc\xe6tu\xc2\t^\xe8\xbf'
 b'\x03\x00m\x00\x00\x00')

{'A1': 110,
 'A2': [{'B1': 0.48077693581581116, 'B2': 'vq', 'B3': 248},
        {'B1': 0.15982243418693542, 'B2': 'vl', 'B3': 67}],
 'A3': {'C1': -39,
        'C2': -216307730,
        'C3': {'D1': [-4403835149261041127,
                      8787253533146833400,
                      8440103151445714007,
                      4798259768117845019,
                      -4858268189765911541,
                      4959118086886729355,
                      -4087660193403904033],
               'D2': 204,
               'D3': -0.7614792631171923,
               'D4': [9447, -9415, -24113]}},
 'A4': -0.8290746699230522,
 'A5': -0.5113937260804255}

(b"|RXLPR\x02\x00\x00\x00'\x00\x00\x00\x02\xdc\xa4\r\xc7I\x00\x00\x00\xcc"
 b'O\xfb\xc2\xa5\xf2\xea?\xb2\xe3\xd7V\x05z\xe5?~\xd8\xa3<zka\xb9 \xf3>cy'
 b'02\xfc@lc\xe6\xf1#\xa2\xff\x8d\xf4\xcd}\x91\x80-,\xfd\xa0\x02\x005'
 b'\x00\xf4`\xc3\xbb\x9a\xb3\xce\xb0\xbf\x02\x00E\x00\x00\x00')

{'A1': 82,
 'A2': [{'B1': 0.020000692456960678, 'B2': 'zk', 'B3': 97},
        {'B1': 0.4748590290546417, 'B2': 'cy', 'B3': 48}],
 'A3': {'C1': 2,
        'C2': -955407140,
        'C3': {'D1': [2590104575407094834, -9182419841707016286],
               'D2': 244,
               'D3': -0.06565401580497854,
               'D4': [11309, -24323]}},
 'A4': 0.8421200569377958,
 'A5': 0.6711451240690762}

Вариант №20

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

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

(b'SXKM\x00\x00\x00\x02\x00\x00\x000vmcpn\xf3\x00\x00\x002q\xab\xe8\xd0\x8c\xec'
 b'\x88\x15?\x05]\x9c\x00\x00\x00\x02\x00\x00\x00>:\xda\xf3\xb2\xfc\x07wy\xbal'
 b'\x9a\x8b?\xd2\x9c\xc8\xb3\xbe\xe2\x08\x9f\xc1q8\x11v\x15@anz5\x98\xefCl.\xed'
 b'\xd1\x08\xfeQ\x92\x1dK>\xf28]\xbaBM\x07\xa9V\x86\xb9\xaa\xfc\xf1t;'
 b'\xe6R\xf5\x05\xf3\x91\x07\x8b.w89')

{'A1': 'wy',
 'A2': 'vmcpn',
 'A3': -13,
 'A4': {'B1': {'C1': -1167287669, 'C2': 0.29081933549198924},
        'B2': 8190896329718532117,
        'B3': 0.5209596157073975},
 'A5': [{'D1': -1614712520,
         'D2': 17,
         'D3': [118, 21, 64, 97, 110, 122],
         'D4': 899215171,
         'D5': [1815014865, 150884754, 491470578]},
        {'D1': 945666626,
         'D2': 77,
         'D3': [7, 169, 86, 134, 185, 170],
         'D4': -51284933,
         'D5': [-430770939, -208599157, 779565113]}],
 'A6': 0.0016704706940799952,
 'A7': 64519}

(b'SXKM\x00\x00\x00\x04\x00\x00\x000mipel\xed\x00\x00\x004E\xb8~\xcaL\x00'
 b'D\x93\xbe\xff\x81\x02\x00\x00\x00\x02\x00\x00\x00@\xbf\x1fu\xa5sIsixxMQz\xf5'
 b'?\xe0b\xfc\xbbt\x18\xeaC\x01G\x9a6\x18@\xcb\xf1\x17\x9d\x12G\xfa\xea\xa1'
 b'f\xbb\xe3\xac4\x89\xfa\xeb\x9a\xb6\xdcH\xa7\x85tl\xb6\x9e\xf0\xb0/xK\xfa'
 b'\xf0\x1e\xf9G\x17B\x10\x88\x1b\xa4\xf0\x1a\x16\xce')

{'A1': 'sixx',
 'A2': 'mipel',
 'A3': -19,
 'A4': {'B1': {'C1': 1297185525, 'C2': 0.5120834027482293},
        'B2': 5023904791655367827,
        'B3': -0.499031126499176},
 'A5': [{'D1': 1124157338,
         'D2': 54,
         'D3': [24, 64, 203, 241, 23, 157],
         'D4': 306707178,
         'D5': [-1587102749, -1405842950, -342182180]},
        {'D1': 1218938228,
         'D2': 108,
         'D3': [182, 158, 240, 176, 47, 120],
         'D4': 1274736670,
         'D5': [-112781502, 277355428, -266725682]}],
 'A6': -0.6228888630867004,
 'A7': 29513}

Вариант №21

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

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

(b'\x80ZYS=\xe4)\xbf\xd6\x1cu\x7f|C\x8b\xfb\x00\x03\x00B\x00\x00\x00So>\xbe\xe8'
 b'\x12\xbd\x0e\x15\x83si\xbf\xb5\xbd\x1dn>\xb8\xc0\x0crm?\xc6k\x93R\x92'
 b'\xf1(\xd5pw\xbf\xd2\x97\x13\xb47&\xa8\xb1\x00!\x00,\x007C\x9a\xa1\xc4'
 b'\xc3\xc4\x83\x82RfA?\xe0J%\xf9\xa1U\x08\xbf\xca\x88FO\xe5\x87\x00\xbf'
 b'\x88\xd75\xc2$g\x80\xbf\xe2\x1d(k\x1auz?\xe8*\x10\xd4\x0f\x1d\xd0\xbf'
 b'\xd5\x17\x88\xa4)9\x18G (\x1dm\xc1\xc9\xb1?\xeb\xbe\xb0fU$\x0cY\x85U\x99\xbf'
 b'\xe0\xf1\xa9\xe5+]X\x00H\x00\x00\x00\x02\x00\x00\x00O')

{'A1': 0.11140774935483932,
 'A2': 15428335613870574587,
 'A3': [{'B1': 'si', 'B2': -0.08491691533592682, 'B3': 12},
        {'B1': 'rm', 'B2': 0.1751579430764505, 'B3': 213},
        {'B1': 'pw', 'B2': -0.29047100638545453, 'B3': 177}],
 'A4': {'C1': 0.5090513110723416,
        'C2': [-0.20728377248001806,
               -0.012129230487108122,
               -0.5660593120443729,
               0.7551349775102896,
               -0.32956138640737853],
        'C3': 5125140482808203697,
        'C4': 0.8670274733241299,
        'C5': 1501910425,
        'C6': -0.5294999576534947,
        'C7': {'D1': 67, 'D2': -102, 'D3': 2714026948, 'D4': 131},
        'C8': [33362, 26177]},
 'A5': 111,
 'A6': [0.372864305973053, -0.03468848392367363]}

(b'\x80ZYS\xbf\x7f*U\xa3\xf4\xe6q\xb7\x1c\x03\x10\x00\x03\x00B\x00\x00\x00S'
 b'\xc8\xbe=-)>.\xf7Tkw\xbf\xee\x1d{\x02V\\(Bmx\xbf\xae\x84\xbd\xb0\x0f\xb1@sj'
 b'w\xbf\xc9?\xf8>L\xcb\xb87\x00!\x00,\x007>\xf9\x06)p\x05\x8d<V\x1d#\xbf'
 b'\xe2\xafq\xa0\xc1 p\xbf\xc8\x83\xa1\xc3}\xbd\xe8?\xe0}\x049\xcb\x9d\n\xbf'
 b'\xc6\xd5\xcb\xc8\xe3\xe5\xf0?\xe6\xbc\xfb\x7f\x13\xa9\x12?\xdd\xe7\xcf\x90'
 b'<V\\zc\xd1\x95t/\xd6\x81?\xef\xd3\xd3/\x00\xd8\xb4\x9a\xaaz\x84?'
 b'\xe2\x88\xd27\xf6\xfdD\x00H\x00\x00\x00\x02\x00\x00\x00O')

{'A1': -0.9967396855354309,
 'A2': 11814321098577412880,
 'A3': [{'B1': 'kw', 'B2': -0.9410986943866009, 'B3': 66},
        {'B1': 'mx', 'B2': -0.059606483213288985, 'B3': 115},
        {'B1': 'jw', 'B2': -0.1972647003363741, 'B3': 55}],
 'A4': {'C1': -0.5839164867147826,
        'C2': [-0.19151708646266674,
               0.515260804063389,
               -0.17839953717320567,
               0.7105691415756914,
               0.46727360806958074],
        'C3': 8819122935151187585,
        'C4': 0.994607536128362,
        'C5': 2594863748,
        'C6': 0.5792018025457897,
        'C7': {'D1': 62, 'D2': -7, 'D3': 103378949, 'D4': 141},
        'C8': [15446, 7459]},
 'A5': 200,
 'A6': [-0.18474258482456207, 0.17086535692214966]}

Вариант №22

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

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

(b'FFR~\x00M\x00eeW\xaeq>x1\x92\x00\x04\x00}\xb9\xd1 Q7Y\xd9U\xfa\x1a?`\x81Z#;'
 b'\x9fJ\x81\x92`\xe8\xc9\xa99\x1d\xfa\xa7\x9a\xf0\xfc\xabJ\xe4\xed\x8dzK&\xb6'
 b"\n\xda'\xbd\x8f/v\x08\xc4I\x0fm[d\x15\xb9]>^lz9\xe9f\xb5\xd4]\xfe\x1a\xef1\n"
 b'QW\xba\xfa8\xd6\xc0\xf4\xf6? \x8d~>}\xcf\x8c\xaa6~\xc9\x87\x0eG\x9d!\x01\xcf'
 b'\x82\x99\xd30\x11ebtv')

{'A1': [{'B1': 0.21721068024635315,
         'B2': 4172979460873518618,
         'B3': 17235568593404099128,
         'B4': 3602969846},
        {'B1': 0.6271589994430542,
         'B2': 4502983405498433225,
         'B3': 9731794584983424898,
         'B4': 2580754449}],
 'A2': 1700245105,
 'A3': 0.24237659573554993,
 'A4': 'ebtv',
 'A5': [{'C1': -71, 'C2': -47},
        {'C1': 32, 'C2': 81},
        {'C1': 55, 'C2': 89},
        {'C1': -39, 'C2': 85},
        {'C1': -6, 'C2': 26}],
 'A6': 16224,
 'A7': {'D1': -9125942955930386030, 'D2': 6983052950882876071, 'D3': -102},
 'A8': [-251876534,
        -454193798,
        1260828170,
        -634929777,
        796264644,
        1225747803,
        1679145309]}

(b'FFR~\x00M\x00e\x9a\xfe\xa1\xbb\xbf<z&\x00\x06\x00}\xb5\xed\xcdd'
 b"\xf0\xc9\x1e\x01[d=Lhro\xa7\xa6\x8a\xf1\x92!'_\xe60\x8b\x7f\xf3"
 b'\xcd\x8d\x08\xefe\xe0.\x1a\xadq\x97_\t\x97+\xa6\xbd\xe5\x16\x9b\x88[\xd4\xf0'
 b'\x92\xd7:\x1c">\xfc\xc6\xc5\xd1\xb1\x17N\xc1(/\x9b\xf1\xd8\xea'
 b"\xfa\xf9\xd6\xeb\xcd\x87L'\x99?h\xdc\x87$\xbc\t\x1cle*\xb8\xfc\t\xe5"
 b'K~\xe2\x0cvGolZzqbigc')

{'A1': [{'B1': 0.4937039911746979,
         'B2': 15109883851820248987,
         'B3': 17426937121764469709,
         'B4': 2269915033},
        {'B1': 0.9096149802207947,
         'B2': 2647000698669312696,
         'B3': 18161299084762287222,
         'B4': 1198484570}],
 'A2': -1694588485,
 'A3': -0.7362388372421265,
 'A4': 'zqbigc',
 'A5': [{'C1': -75, 'C2': -19},
        {'C1': -51, 'C2': 100},
        {'C1': -16, 'C2': -55},
        {'C1': 30, 'C2': 1},
        {'C1': 91, 'C2': 100}],
 'A6': 15692,
 'A7': {'D1': 7526200693133865362, 'D2': 2388983569604902899, 'D3': -51},
 'A8': [-1928794267,
        -533849427,
        1905745673,
        -1758746947,
        -451503224,
        1540681874,
        -684057566]}

Вариант №23

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

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

(b'KFF\x91YZ\xee\x1b\xcb\xcatr\x86\x00g\x00\x98?(\x04e\xce\x8dy\xe5|\x01\xa0'
 b"1~\xe6\xb2]\xbf\xb2]7\x12H\x99p\x8f\x83\x83' Nlb<\xc6A\x80\xf8W&M\xb6K\x9b"
 b'\nc\xda\x8b\xf1\xa9\xd43\x98\xbd\xd9\x0e\x8e\xff\x93\x1d\xbf\xe0mm'
 b'\x0b\xb2\xa4\xa4\xa7\xfa?G%\x1fH\x85\xebD\xf2\xb9\x05O\x88\x89'
 b'\xa7\xd5\xbb\xbf\xd0\xd8\xf8\x05\xc2I\xcc\x0c?[S\xfd\x00\x00\x00\x05'
 b'\x00\x00\x00\\\xbf\x05`ub\x00\x00\x00\x03\x00a\x90\xbdE\x06\xc8'
 b'\xea\xcd\x89\xdd:\xb9n\x9e\xc5f\x93\x01\xbf\xeb]\xf4\x8cF\xfb\xb6\xa3?K9'
 b'\xa6\x00\x00\x00\x05\x00\x00\x00\x87>\xed\xf3\x10s\x00\x00\x00\x06\x00\x8c')

{'A1': {'B1': 89,
        'B2': {'C1': 6552205069959590534,
               'C2': [{'D1': -0.26324272692104667,
                       'D2': 12,
                       'D3': 0.8567503094673157,
                       'D4': [-21, 68, -14, -71, 5],
                       'D5': -0.5210030674934387,
                       'D6': 98,
                       'D7': [20360, -30297, -10821]},
                      {'D1': -0.8552191486158935,
                       'D2': 163,
                       'D3': 0.7938483953475952,
                       'D4': [-112, -67, 69, 6, -56],
                       'D5': 0.46474504470825195,
                       'D6': 115,
                       'D7': [-5427, -30243, 15033, 28318, -15002, -27903]}],
               'C3': {'E1': 0.6563170552253723,
                      'E2': 14883686370064310321,
                      'E3': 2129048157,
                      'E4': -0.07173484989525547,
                      'E5': [36739, 33575, 8270, 27746]},
               'C4': [15558, 16768, -1961, 9805, -18869],
               'C5': 155,
               'C6': 174316171,
               'C7': 241,
               'C8': -6209281255123906930},
        'B3': -109},
 'A2': 29,
 'A3': -0.5133576611016406,
 'A4': 43002,
 'A5': 0.7779101729393005,
 'A6': 18565}

(b'KFF\x91\x12\x89\x8e27!w\n=\x00k\x00\x9a>\xf8z\x06B\xac\xbcrg\xe97'
 b'\xbd\x87\xe7"\xdb\xbf\xd2\xaa\xdf\x95\xc3\xd8 \xdf\xb9J\x9e\xc5\xf2\xd5'
 b'\xa8\xe1l\x86\xd4\xd6\xabe\x13~\xcf\xcf\xb5{n\xe3/\x944b\x97\\@\x98\x81k<c'
 b'?\xd3\xf7^+Q\xffx\xef\x8b?Fh\x13\xa3\xe3\xc1\xa1$p,1\xdbvo\xaa\xdcg'
 b'\rI\xac\xbf\xed\xa93X\xe9\xce\x9a\x03=\xe4\xd9\x10\x00\x00\x00\x03'
 b'\x00\x00\x00\\\xbfTF\xa1\xea\x00\x00\x00\x06\x00_\xb4M\xb0h\xdc+\xa3#\xd4'
 b'{2.a?!\xbf\xd7\xc5\x8d\xadx\xc3\x10e\xbf\x1dR;\x00\x00\x00\x03\x00'
 b'\x00\x00\x8b\xbe\xdf3r%\x00\x00\x00\x06\x00\x8e')

{'A1': {'B1': 18,
        'B2': {'C1': 9911915042255079997,
               'C2': [{'D1': -0.9269043671215116,
                       'D2': 3,
                       'D3': 0.11174213886260986,
                       'D4': [-63, -95, 36],
                       'D5': -0.8292027115821838,
                       'D6': -22,
                       'D7': [28716, 12763, 30319, -21796, 26381, 18860]},
                      {'D1': -0.3714327043590382,
                       'D2': 101,
                       'D3': -0.6145359873771667,
                       'D4': [-76, 77, -80],
                       'D5': -0.43593937158584595,
                       'D6': 37,
                       'D7': [26844, 11171, 9172, 31538, 11873, 16161]}],
               'C3': {'E1': 0.4853059649467468,
                      'E2': 4804422102053107645,
                      'E3': 2280071899,
                      'E4': -0.29167928338518045,
                      'E5': [57273, 19102, 50674, 54696]},
               'C4': [-7828, -31020, -10581, 25875, 32463],
               'C5': 207,
               'C6': -1250201885,
               'C7': 47,
               'C8': -7767475055079942015},
        'B3': 27452},
 'A2': 99,
 'A3': 0.31197313528536297,
 'A4': 61323,
 'A5': 0.7750255465507507,
 'A6': 41955}

Вариант №24

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

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

(b'KRL\x00\x88\x00\x00\x00\x94j\xc0\xa8\xb98\xc4\xbf\x8f\x84m\xbf\x8fe\xd5-'
 b'\x14\xca<\xff;8\x0f\xf4\xbe[l<BsR\xf2\x00.\xcd\xd3D\xbb\xb4\\\xe0h:['
 b'\x96\x95\n\xdd\xd3\x1b\xc9\xec\xd8,\xf6\xb8\x01\xb3\x90t\xe0\x8e\x80\x96'
 b'\xe8H\xff\xc6$3\xbbX\xaa\xd6\xb2\x1e\xb1N\xd1Js\xf2\xaa\xdd\x1a\xea\xa9\x18'
 b'\x9dG\x13\xb0\x98-\x07\x8f\xfe\x1an=$\x85\x9c\x16~*\xfcU\x07\xfe\x1f\x03'
 b'j\\7\x0e\xbf\xe9\xc2\xd6\xc9\xeb)\xd0h\xd9\xd4\xa9(\x0cm\xc1Bn\xb5\x86'
 b'\x08\x0e\xb5\xd7=,\xbc\x15\xac\xb6\xd0ucr')

{'A1': {'B1': {'C1': 671903169, 'C2': 4786963041206842839},
        'B2': {'D1': 0.04217155650258064, 'D2': -1397305227, 'D3': 'cr'},
        'B3': [{'E1': [27328, 43193], 'E2': 4090604984682266511, 'E3': 26069},
               {'E1': [11540, 51772], 'E2': -55388929230218388, 'E3': 15426},
               {'E1': [29522, 61952], 'E2': 3372583988130766048, 'E3': 26682},
               {'E1': [23446, 38154], 'E2': -2462594017165562634, 'E3': -18431},
               {'E1': [45968, 29920], 'E2': -8178370998903519708, 'E3': 13243},
               {'E1': [22698, 54962], 'E2': 2211635552819868330, 'E3': -8934},
               {'E1': [60073, 6301], 'E2': 5121631368887373822, 'E3': 6766},
               {'E1': [15652, 34204], 'E2': 1620780179146669599, 'E3': 874}],
        'B4': [92, 55],
        'B5': 14},
 'A2': -0.8050340598795689,
 'A3': 26841,
 'A4': 54441}

(b'KRL\x00\x88\x00\x00\x00\x94\x82r\x94\\t\xb4\xde4W\x99\x7f\x14;\x8d\xc8'
 b'a\x08\x8ar\x99(\x02\x98\x95\xa2\x1e\xf0\xca\xbdOj\xae\xc0\xb6H\x92\x9c}.'
 b'\xed"\x1a\xa5Xf\x83g\n\x8f\xf7=\x9a\xf8\xf8\xb6\x1f=\x1cI\x00\xed1a'
 b'\x07\xbe\xc0\x1f}A\xed\xa9\x0f\xd6\xcc}\xb7\xbe\x0f\xc6\xa9\xe5\xa1\xc2'
 b"\x18\xde\x8aBmh'dG\x89\x93\xd1\x87_\x11\xdb\xf3BZ\xa8\xc88\xa3:\xd7\xa6\x13d"
 b'o\xfd\xe9f?\xc8\xd3O\xab\r6x\xa2\x12\x07j\x8e\x07\xdbG\xd2\x81Pd'
 b'\x7fc\x17\x06>\x965\x8e\xc4\xdb\xd7\xf8xx')

{'A1': {'B1': {'C1': 2382879559, 'C2': 15168493412524693254},
        'B2': {'D1': 0.2933773398399353, 'D2': -992225288, 'D3': 'xx'},
        'B3': [{'E1': [33394, 37980], 'E2': 8409590720596901652, 'E3': 15245},
               {'E1': [51297, 2186], 'E2': 8257675383375503902, 'E3': -3894},
               {'E1': [48463, 27310], 'E2': -4560377778138173715, 'E3': 8730},
               {'E1': [42328, 26243], 'E2': 7424905227726944504, 'E3': -18913},
               {'E1': [15644, 18688], 'E2': -1355195326968881283, 'E3': 16877},
               {'E1': [43279, 54988], 'E2': 9058918150445852065, 'E3': -15848},
               {'E1': [56970, 17005], 'E2': 7505077562449842567, 'E3': 24337},
               {'E1': [56307, 16986], 'E2': -6284711006277491181, 'E3': 25711}],
        'B4': [-3, -23],
        'B5': 102},
 'A2': 0.19394870617036353,
 'A3': 41490,
 'A4': 1898}

Вариант №25

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

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

(b'KLLF\x00\x00\x00\x02\x00\x1b>w\xc7\xcd\x00H\x01ry>\t\x8fy\x00\x00\x00\x92e'
 b"z\xbf\xeb\\\xf9\x80P\xfd4J\xb26N'n3\xbd\xcc\x06\xa7\xc11\xf3\xfa\xfe~/\xeb"
 b"\xf5\xb4\x98'\xd2/\x00\xa4\x16\x83\xcc\xc3E\x87\x9b\xc5\xea=\xb1P"
 b'\x18Y\x14\x1e\x00\x1d\xda\x93\x1d\t\x00\x00\x003\x00\x00\x006\x00\x00'
 b'\x009\x00\x00\x00<\x00\x00\x00?\x00\x00\x00B\x00\x00\x00E\xa3\x03'
 b"\xf6\xa2\xe0'\xf4\x088C\xb3\xdd\x02\x85K\x9e\x01Z\x8b\xfc\xc7@\x1fH\xd7\x11"
 b'\xf0GK\xd3\xc6@\xc1l\xbf\x8c\xe9\x99\xfdA\x96\xfa3Ug\xc0x\x01*5'
 b'\x00\x00\x00\x04\x00\x00\x00r\x8b\xf0\xf2-\xfd\xd0e\xe7\xccr=G\xe6\xcf\xdft'
 b'\xc4H')

{'A1': 'ez',
 'A2': 0.2419731169939041,
 'A3': {'B1': 16878841936018478110,
        'B2': {'C1': -0.8550994402102448,
               'C2': 19122,
               'C3': 3913108480499502086,
               'C4': -1480510989},
        'B3': -627892983,
        'B4': [{'D1': 64254, 'D2': 126},
               {'D1': 12267, 'D2': 245},
               {'D1': 46232, 'D2': 39},
               {'D1': 53807, 'D2': 0},
               {'D1': 42006, 'D2': 131},
               {'D1': 52419, 'D2': 69},
               {'D1': 34715, 'D2': 197}]},
 'A4': 1,
 'A5': 'ry',
 'A6': 0.13433636724948883,
 'A7': {'E1': -16020,
        'E2': -4644080268137621766,
        'E3': 3698976745299454517,
        'E4': [11746503432518235144,
               4054281851375012766,
               97544259732774728,
               15497431981764101696],
        'E5': 10083825845028283879,
        'E6': -3714839363602882700,
        'E7': 50248}}

(b'KLLF\x00\x00\x00\x07\x00\x1b\xbf\x17\x8a\x06\x00M\xf0bp\xbc\xa3\xdd\x16\x00'
 b'\x00\x00\x97yjbcrvx?\xd0nd\x0e\xad\xac\x8c\\\xec\x9b/Lj\x1a\x07\xe2\x08'
 b"B\x03\xc6R\x8f\x1b!\xec\xa1a\x8a\xb0\x96\xdd_6\xc5\xab\xd0\x95)'\xb8\xb1"
 b'G5 \xa6N\x10\xdf\xd0\x00\x00"\x80\xf3\x1eb\x00\x00\x008\x00\x00\x00;\x00'
 b'\x00\x00>\x00\x00\x00A\x00\x00\x00D\x00\x00\x00G\x00\x00\x00J!=p\xcb\xfc'
 b'\xda3\xbc\xd2\xb29,\xd4\xa0\xdf\x88H\xb4\xec\xa09\xa9|\xa0\x80\xe0\x9bo0'
 b's\xfbe&\xcc\x9b\x880\x8a`\xf2 \xfa 1t.\xea\xb8=R\x00\x00\x00\x04\x00\x00\x00'
 b'wP\xe6\x1b\x98\xabI\x00\xd4O\xeeC\x17q\xfcq8\xc5\xa2')

{'A1': 'yjbcrvx',
 'A2': -0.5919498205184937,
 'A3': {'B1': 3828242537485684736,
        'B2': {'C1': 0.2567377227157486,
               'C2': 23788,
               'C3': 11182240418371199496,
               'C4': 1107543634},
        'B3': -2131550622,
        'B4': [{'D1': 36635, 'D2': 33},
               {'D1': 60577, 'D2': 97},
               {'D1': 35504, 'D2': 150},
               {'D1': 56671, 'D2': 54},
               {'D1': 50603, 'D2': 208},
               {'D1': 38185, 'D2': 39},
               {'D1': 47281, 'D2': 71}]},
 'A4': 240,
 'A5': 'bp',
 'A6': -0.020002882927656174,
 'A7': {'E1': 9932,
        'E2': -7239483030107971334,
        'E3': 2319763027927776594,
        'E4': [2395194598253802428,
               15182260158528020360,
               5239072439445060768,
               9286593333494545253],
        'E5': 5829377110200352980,
        'E6': 5759614741429121336,
        'E7': 50594}}

Вариант №26

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

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

(b'WGGK\xc2\xc69\x8e\xf2 \xd9B\x00{Y_ t\x07\xbe3!1\xa8>\xe7\xab\xa1'
 b'\x9c\xbe\xd6\xff\xb9<\xa2\xf9B>\x92mY\xbf\xd5\x130>\xd63\xa8\xbe6\x00M?m\xe8'
 b'y\xbe+\xf1?\xbf\x80RP>\x02\x00\x14\x00\x03\x00\x1e\x00\x00\x00\x04\x00*\x00'
 b'\x02\x00\x00\x00:\x00\x00\x00\xb0')

{'A1': 4069407174,
 'A2': -9952,
 'A3': {'B1': [{'C1': 51, 'C2': 0.32849982380867004},
               {'C1': -25, 'C2': -0.30592092871665955}],
        'B2': [0.022704999893903732, 0.19040539860725403, -0.8493281602859497],
        'B3': [0.17195065319538116,
               -0.3285204768180847,
               0.8007844686508179,
               -0.24405069649219513],
        'B4': [-0.7497736811637878, 0.20343971252441406],
        'B5': 176},
 'A4': {'D1': 22907, 'D2': 95},
 'A5': -0.1322789192199707}

(b'WGGK\xc2-E\xa4#\xf6}F\x00yu\xe8\xf0\x8fV\xbf5\x08\xd6\x82>n\xa4\xdd\r?c{'
 b'\xbd>p\x12d?\xa6g:\xbf{\x91\x919z\xd1\x08?\x89\xd0\xe0>\xf2=\xbb>TE'
 b'\t\xbf\x8cq2\xbfQl\xa5>\x02\x00\x14\x00\x03\x00\x1e\x00\x00\x00\x05\x00*\x00'
 b'\x02\x00\x00\x00>\x00\x00\x00\xd5')

{'A1': 597968173,
 'A2': 32246,
 'A3': {'B1': [{'C1': 53, 'C2': 0.2555391788482666},
               {'C1': 110, 'C2': 0.5541632175445557}],
        'B2': [0.37008199095726013, 0.8909063339233398, -0.7281440496444702],
        'B3': [0.00027764946571551263,
               0.5344463586807251,
               0.4390909969806671,
               0.3657069802284241,
               -0.5362141132354736],
        'B4': [-0.697045087814331, 0.3230920135974884],
        'B5': 213},
 'A4': {'D1': 30073, 'D2': 232},
 'A5': -0.8381338119506836}

Вариант №27

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

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

(b'pJKUE\x01>\x00\x00\x00\xa0r\xcb\xcfx\'\xb90\xf8\xb6\xdc("x\x9c\xdct1'
 b'O\x16\x06\x96to\xaa\x93\xe1\xbf\x04\x00P\x00\xd5J\xc1\xa9\x17m'
 b'\xb2\xc8\xfc\xcf\x02\x00\x00\x00z\x00\x00\x00vn\x02\x00<\x00\x00\x00'
 b'\x83.\xf3p>\x1a\x08kD\xaa\xa0\rsnjl\xa2\xbbg\xbe\xe6J\x97\xa2\x8dN\xe88'
 b'\x01+1\xdda\xfd)\\\xa6"\xbe)\xdd\xe0\xdc\xbe\x8cp\xeb;9@\xe7\xd6'
 b'\xdf\xf5T\x00\x00\x00g\x00\x00\x00')

{'A1': {'B1': 1,
        'B2': {'C1': 'vn', 'C2': 7712443217357254275, 'C3': 228633156},
        'B3': 29344,
        'B4': -5262402592793112629,
        'B5': 10460,
        'B6': 1607557969981765666,
        'B7': -0.5492756058562811,
        'B8': 'snjl'},
 'A2': 19157,
 'A3': 14987074328642169281,
 'A4': [{'D1': -0.22630169987678528,
         'D2': [19174, -23913, 20109, 14568, 11009, -8911, -671],
         'D3': 41},
        {'D1': -0.15883773565292358,
         'D2': [-8919, -8992, -29506, -5264, 14651, -6336, -8234],
         'D3': 245}]}

(b'pJKUE\x18?\x00\x00\x00\x96\x0c\xcf\xf9]\x88\x9b*\xe0\xdb\xd5\rp\xeb'
 b'\xd3\xb2\x8d\x8c\xdbgP,\xfbm\xc6\x17\xce\xbf\x02\x00Q\x00\xc9\xe7T\xa27\xd8'
 b'hp\x1f\x95\x03\x00\x00\x00\x8c\x00\x00\x00ban\x03\x00<\x00\x00\x00:\x98\x8a'
 b'K\xb1K\xc4d\x03d\xc0\xc5tz\x02\xec->\xb1\xc6\x16\x12\x00\xea\xbc\x1c\x1e'
 b'\xbc_\xae7\xb4\x9d\x7f\xf0V?E\x15XC)\xe7w\x9d\xfe\x9d{\xdcY?\xd3\xa6\xae\x0c'
 b'?\xd5E\xd5P3iR\xe1\x16{O\xc2\xbbVES\x00\x00\x00f\x00\x00\x00y\x00\x00\x00')

{'A1': {'B1': 24,
        'B2': {'C1': 'ban', 'C2': 7261011724076750906, 'C3': 3317720067},
        'B3': 3222,
        'B4': -2603033737123989041,
        'B5': 3541,
        'B6': 7483729746024721264,
        'B7': -0.23510055895016757,
        'B8': 'tz'},
 'A2': -6199,
 'A3': 10745430831535727188,
 'A4': [{'D1': 0.1698456108570099,
         'D2': [-14671, 4630, -5632, 7356, -17378, -20897, -19401],
         'D3': 157},
        {'D1': 0.8396071791648865,
         'D2': [5445, 17240, -6359, -25225, -25090, -9093, 16217],
         'D3': 211},
        {'D1': 0.5495399236679077,
         'D2': [17877, 20693, 26931, -7854, 31510, -15793, 22203],
         'D3': 69}]}

Вариант №28

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

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

(b'$CFL$\x00\x00\x00\xaa\xc5\xc7_\xa5\xfc\xe1\x91\x9ad~4i\x92\xf1%\x11&\xc1\x1f'
 b'S\xbe)\x00T\x00\x7f\x00\xd4`\xba\xbe\xf0\xa3\xc9F\xbepvpxf\xd2*'
 b'\xd4\xeb\x1c\xcf\tB\x14\x15\x02\xf80AJ\x93\x1c\x98Q,J4\x19\x9e\x1cs'
 b'9\xbcK\x01$\xa43\xe1\x08kN\xbfkjmpo\x9e\xd1\x05%\x84t7\x84\x10\xb6a'
 b'\x16\xc1N\xbd\xd5,\xd8\xa4xs\x057C\xa0q\xceN]\xb3\xe728lv\xed\xa4>jqmgw'
 b'I/\xe9c\xc1&\xc4\xff\xc8&\x16\xdf\x96"(\x07,\xf1*\x81\x1b\xeb\xd9\xf0'
 b'\xb7A3\xcf/\x87\n3/\xe4')

{'A1': {'B1': -0.3640199899673462, 'B2': -16},
 'A2': -14934,
 'A3': 7249266949998600135,
 'A4': 2743015367519057022,
 'A5': 3193118657,
 'A6': [{'C1': -0.19412855803966522,
         'C2': 'pvpxf',
         'C3': {'D1': 4758562204416223954,
                'D2': -134081260,
                'D3': [2471117104, 743544860, 2652451914, 3157881628]},
         'C4': [75, 1, 36, -92, 51, -31]},
        {'C1': -0.8063206672668457,
         'C2': 'kjmpo',
         'C3': {'D1': -8919532426078334562,
                'D2': 375502352,
                'D3': [3585953473, 2024069164, 1127679347, 1322152352]},
         'C4': [93, -77, -25, 50, 56, 108]},
        {'C1': 0.322124183177948,
         'C2': 'jqmgw',
         'C3': {'D1': -16845886555869367,
                'D2': -552196408,
                'D3': [120070806, 2167075116, 4040813339, 3476242871]},
         'C4': [47, -121, 10, 51, 47, -28]}]}

(b'$CFL$\x00\x00\x00\xb7\xf6&\x0eRN=\xbb\xbb\xcf{H\x06\xf2\xc0^\xa6\xe5\xe0\xf3'
 b'\xb9\x9c)\x00T\x00\x7f\x00M\x10N?)\x8d.\x1e\xbejgjcr\x12\x0b\x04(\xba\x04'
 b"\xb9\x8a\xbb\xad\x83'\x8f\xfc\xb9\xef\xc4e\x1ah\xf0!T|\xe1\xe6"
 b'\xe2\x1d\xf8\xde:\x02\x80\xdf\x97\xcb\x16\xbfsvcbg\xb3\xc8\x0fMU~s'
 b'\x8d\x8dh\xfd\xb2x\xb2\x135\xc2yt,\xac\x86\x00\x1a\xd1\xca\xf3_u\xe3l'
 b'\xf3"F\\\x83{?ihgtb\xcd\xe1\xc2 \x81\xc75\xc6\x8b\xf8\t\xbb<\xfd \xbb'
 b'\xf8\x16\xdf\x13\rD?Q\x8cX\x95\xc6R)\xe8\xd6\xa9!')

{'A1': {'B1': 0.8049362301826477, 'B2': 41},
 'A2': -2377,
 'A3': -3477980415232176602,
 'A4': 16548018063606696059,
 'A5': 2629432288,
 'A6': [{'C1': -0.15447445213794708,
         'C2': 'jgjcr',
         'C3': {'D1': -8450718028202243310,
                'D2': 662941115,
                'D3': [4021943439, 1746560452, 2085888496, 501409505]},
         'C4': [-8, -34, 58, 2, -128, -33]},
        {'C1': -0.5890440344810486,
         'C2': 'svcbg',
         'C3': {'D1': -8254114787209787213,
                'D2': -1292015475,
                'D3': [890483320, 745830850, 436242092, 1609812689]},
         'C4': [117, -29, 108, -13, 34, 70]},
        {'C1': 0.9824731349945068,
         'C2': 'ihgtb',
         'C3': {'D1': -4164202923019804211,
                'D2': -1156974453,
                'D3': [3139501372, 333387512, 1363100685, 3331676300]},
         'C4': [82, 41, -24, -42, -87, 33]}]}

Вариант №29

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

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

(b'\xd9HIS)\x11P#\x02\x00\x00\x00j\x00n\x00\x00\x00\x16\xdb\xc4\x07\r\xb7'
 b'\x07\xf9\x98\xa6_\xf9\x1b\xe9\xf8\xc5L\xca3m\x90\x02\xf4\xe3\x17\x0b'
 b'\xf47\x93\xd2^\xd6\xe0\xb5z\xc5B\r\xd6?\xdfs\x04\x00\x00\x00 \x00\x00\x00'
 b'\x1c\xf7z\xa5\x99\xb4\x1f\xb8\xbe2\xeb\x1c\xce\xeee\x98\x1d<~\r\xa5\xd2?R'
 b'6\x02\x00\x00\x00I\x00\x00\x00HZ\xd1\x9fz0\x00Q\x00o\xcf\xaa\xbcT!'
 b'_\x02\xb8\x97\xe6\x19?')

{'A1': 4393,
 'A2': 9040,
 'A3': [{'B1': 94,
         'B2': 214,
         'B3': 0.3445593765744359,
         'B4': -33,
         'B5': {'C1': 115,
                'C2': [-900938248, 43019571, 186115060, -762103820],
                'C3': 28,
                'C4': -1717208329}},
        {'B1': -18,
         'B2': 101,
         'B3': 0.291324017788122,
         'B4': 82,
         'B5': {'C1': 54,
                'C2': [-1095229516, -836965582],
                'C3': 72,
                'C4': 2057294170}}],
 'A4': {'D1': [-1129656465, 39788884], 'D2': 184, 'D3': 0.6011747717857361},
 'A5': [130341654, 4178032397, 4183795352],
 'A6': -5861}

(b'\xd9HIS"(\x08\xca\x03\x00\x00\x00\x9f\x00\xa5\x00\x00\x00\xbc!'
 b'\xd3\xfd\xb7\xa9\x9d\xce\xc5::DFc\xd8\xa1\xa4\x91xB\x15$7@\x93\x93\xe6C\x0bD'
 b'\xb8`\xae\x16Z\xec\xca\xf5&\x06\xda\x16\x7f\xd7y=\xe7?*?\x06\x00\x00\x00'
 b' \x00\x00\x00\x81@7\xfe\xadO\x18\xcb&a\x8b\x02\x15\x04\x11\x0e\x8f\x15\xf9-'
 b'\x14\xf2\xb84\xd6\r\xe60\xd00\xda\xb5\xe6\xc8\xbf/e\x05\x00\x00\x00Q\x00\x00'
 b'\x00i\xfc\xa5\xf7\x1d6\xbd\xaa\xecN\x9b\x9c\x98\x99\xeb\x90z\x85\x9b'
 b'\xcb\xbd\xb6\xbf\xba3\x02\x00\x00\x00~\x00\x00\x00\xf9\x96\xcc\xbd\x858'
 b"\x00e\x00\x86\x00'\x08C\xf5\xacF\x05\x88\x814\x12\xd3\xbe")

{'A1': 10274,
 'A2': -13816,
 'A3': [{'B1': 38,
         'B2': 6,
         'B3': 0.7262543877520458,
         'B4': 42,
         'B5': {'C1': 63,
                'C2': [-1851481640,
                       605373048,
                       -1819066313,
                       1141588966,
                       380526776,
                       -171250598],
                'C3': 129,
                'C4': -1375848640}},
        {'B1': 13,
         'B2': 230,
         'B3': -0.19454072145311008,
         'B4': 47,
         'B5': {'C1': 101,
                'C2': [650844239,
                       352488289,
                       -1894903548,
                       338557205,
                       -701187854],
                'C3': 105,
                'C4': 502769148}},
        {'B1': -103,
         'B2': 235,
         'B3': -0.0888335470858499,
         'B4': -70,
         'B5': {'C1': 51,
                'C2': [-324354762, -1734567090],
                'C3': 249,
                'C4': -2051158890}}],
 'A4': {'D1': [-180156377, -2012920148], 'D2': 129, 'D3': -0.41224825382232666},
 'A5': [4258472380, 3466439095, 1144666821],
 'A6': 25414}

Вариант №30

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

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

(b'lAOVT\x00d?\x9a\t\xb2\xedr\xec\x00\xbe\xa9\x9fz\xbc\x0b\xa6<=\xecf\x0c\xbf'
 b'y\x89\x9b?,\x8d\xb0\xbe\x00\xf2b\xba\x00\xc1\xdd\xff\xa6,f\x16\xc2\xcf"\xa3'
 b'n\xa6QC\xed&P\xfd\xf1\xa65?\xe9\xd1>\xaa\xdfT\xba%k\xa89\n"j\xfc@'
 b'\x92\xfd\xa0\x04?\xe8\x08uQ\xbc-f\xbf\xda\xe9\x9b\x08\x88\xa7\x18'
 b"`\x00\x02\x000\xbaTQ#\x90'N\x9a\x00:\x04f\x90\xe1\xfc\xacG\x14\t9\xbc\r\xc7"
 b'v\x00\x00\x00K\x00\x02\x00\x00\x00T\xbf\x00J\xe4')

{'A1': {'B1': 96,
        'B2': {'C1': [{'D1': -1026612573, 'D2': 110},
                      {'D1': -1504623635, 'D2': 38}],
               'C2': 13426445602282491546,
               'C3': {'E1': [80, -3, -15, -90, 53],
                      'E2': 0.8067925774909306,
                      'E3': 627812409},
               'C4': 4,
               'C5': 102,
               'C6': 10439903228078590265,
               'C7': -0.008653512224555016,
               'C8': {'F1': 10, 'F2': 2480071899095080964}},
        'B3': [0.7510325046909372, -0.420508154233731],
        'B4': -0.5011427402496338},
 'A2': 0.025427623503428975,
 'A3': [-0.33129483461380005,
        -0.008523520082235336,
        0.11542901396751404,
        -0.9747559428215027,
        0.674036979675293,
        -0.12592461705207825],
 'A4': -70,
 'A5': 54568760579483158}

(b'lAOVT\x00d\xbf\xe7\x87\xee\xe5\xe0\xaa\x02\xbfv\xf8\xcc\xbe\xd4\x19\x01\xbd'
 b'\xb1_\x08\xbeP4F\xbe\xa8E}?z\x96\x18\xcc&\x9b\xf7\xcd\xf2\xc9\xf5\xa7\xb585P'
 b'-\x82 }\xfb\x93\xd4\xd0\xdcz\xc3?\xda\xda\xf3\xba>0(b,\n:{jrZ\xc6'
 b'[\x1a\x88\x8a\xbf\xe3S\xd6\x0e.\xd2N\xbf\xb6\xeb\x85\x97\x14\xaf\xc0'
 b'\xee\x00\x02\x000P-\xae\xfdx\xb8\xc8\xc0\x00:\xe4XZ\xf58\xb2}\x9bQ\xf8\xbf^Q'
 b'\xd9\x00\x00\x00K\x00\x02\x00\x00\x00T?(xy')

{'A1': {'B1': 238,
        'B2': {'C1': [{'D1': -1254607536, 'D2': 45},
                      {'D1': -2111799813, 'D2': 147}],
               'C2': 5777466300661549248,
               'C3': {'E1': [-44, -48, -36, 122, -61],
                      'E2': 0.4196137732294596,
                      'E3': 1647053370},
               'C4': 228,
               'C5': 88,
               'C6': 6554207171970290168,
               'C7': -0.8684363961219788,
               'C8': {'F1': 123, 'F2': 7670292923343865994}},
        'B3': [-0.6039839055070588, -0.0895312780236841],
        'B4': 0.6580882668495178},
 'A2': -0.7353434076115379,
 'A3': [-0.9647338390350342,
        -0.41425326466560364,
        -0.08660703897476196,
        -0.20332440733909607,
        -0.3286551535129547,
        0.9788527488708496],
 'A4': -52,
 'A5': 2782089658745091495}

Вариант №31

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

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

(b'\nIOEH\x00\x00\x00}\xb4\xd0F\x96mgqou\xe2\x00\x9a\xb9\xff\xd2'
 b'\x17\x00\xb2\x96\xea\xd9\xc2`\xf0\xbe\xe8W\x12\x94g\xb3\x8c\x9d\x10\xcc'
 b'\x04.\x0f\x8e\xe6\xcb\xa7O=\x9b}\x1c\xe2\xbfsw\xee\xa7\xbdl\x07\xc3]<'
 b'\xbf\x19\xcb\xf9\xa9\xe5(\xeb\x07\xcb\xcdw\xbc\xd6\x96\x0b\xe7\x92\xc3d'
 b'\x14\xf0\xf0\x82\xc6A\x13\xed\x9bi\x99\xe0NU\xc0\x07<\xa2eH\x03\xb9R\x00'
 b"\x1b\x00'\x003\x00?\x00K\x00W\x00cslaoc\x00\x00\x00\x07\x00o\x10|\xb6\xc6"
 b'\x1d\x9dU8J\x03\x10\r"\r\xc5]G4!\xbb\xf2\x00<\xc0\xb1m\x94\xf7\x9aS\xba\x92'
 b'\xcb\x8f&\x88.\x0fz\x8d.\xd2\xa8\x93\xc7')

{'A1': {'B1': 'slaoc',
        'B2': [{'C1': -1762993726, 'C2': 6985292927154164839},
               {'C1': -1282630384, 'C2': -3745818345708532825},
               {'C1': 1329437565, 'C2': 2081436480452863933},
               {'C1': 1812448093, 'C2': 4377245726685127976},
               {'C1': -351810611, 'C2': 8628006926068191939},
               {'C1': 1679094000, 'C2': -9023453249543640679},
               {'C1': -531737152, 'C2': 521470212751735122}],
        'B3': 1188025363735598392,
        'B4': 18947,
        'B5': 269296141,
        'B6': -983742668},
 'A2': -1261418858,
 'A3': 'mgqou',
 'A4': 226,
 'A5': {'D1': 2430802506729697645,
        'D2': [-27401, -26029, -17774, -13425, 9864, 11791, 31373, 11986]},
 'A6': 3120550423,
 'A7': {'E1': -22381, 'E2': -57}}

(b'\nIOEH\x00\x00\x00\x8b=t\x86\xafbwhgzE\x00\xa8\x08<\xbc\x08\x00\xc0\x9c'
 b'\x05;B\xceou\x81\xf2h>\xfb\xfa\x16\xd7tD"\xf4\xa3\xfe\x80\xc2>P\xd8\x1c\xd8~'
 b'\x9aV\xef\xda\x13nN\x1b\x1d\xfd\xb0\xa6\xe0\xad2\x91\xb1\xe3\xddf'
 b'C\x83\xe3\xb5\xc7\xc5rB\r\xddsU\x19[V\x0c,\xb8+\xc0\xb2\xb7\x07\xf5'
 b"\xcf\xe1]a\x7fo\x16=e\x11Xz\x06\xf0\xa3\xd8pUE*B\x9c\xe3\x00\x1b\x00'\x00"
 b'3\x00?\x00K\x00W\x00c\x00odfisi\x00\x00\x00\x08\x00{SA\xa3\xc5r\xda'
 b'\x1a\xbfc\xc7^\xe3\xf7\xf5\xd0\xb1O \xeaR\xe2\xf9P\x00}\x13\xde\xfbPv'
 b'\x05\xcdQ\x98\x1e?7\xef\x1eU\xbb\x96\x16\x01\xca')

{'A1': {'B1': 'dfisi',
        'B2': [{'C1': -1677378750, 'C2': -3571506778503364869},
               {'C1': -99166348, 'C2': 4909755528973959742},
               {'C1': 1356340440, 'C2': 9122699583348239950},
               {'C1': 454950320, 'C2': -6421942635926002723},
               {'C1': 1715700707, 'C2': -5348088937954026125},
               {'C1': 1427725142, 'C2': 877278525486446343},
               {'C1': -170925731, 'C2': 7025456085031260504},
               {'C1': 2047275171, 'C2': -2850684808575410973}],
        'B3': 5999256247064992447,
        'B4': 25543,
        'B5': 1591998453,
        'B6': -793686240},
 'A2': 1031046831,
 'A3': 'bwhgz',
 'A4': 69,
 'A5': {'D1': -1561936560327197421,
        'D2': [-8453, 20598, 1485, 20888, 7743, 14319, 7765, -17514]},
 'A6': 138198024,
 'A7': {'E1': 5633, 'E2': -54}}

Вариант №32

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

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

(b'RZJJu#\x00\x00\x00\x15%+1(\x87\xa1@+\xb3\x08\x00\x00\x00\x0b\x00\x00\x00\x1e'
 b'0\x91\xf1\xfcO\xc4\x80\x95\x08\xda?\xe2\x1c\x0cRF\xc5\xb9\xacd?O\x01I'
 b'\x06\xc0\x18\x91>\xc6x\xda\xbbl\x04\x10?\x13\x00\x89b].\xc6\xf1\x80*\x11'
 b'8\xf7\xa3q\xa5w;\xb7\x86\xe3\xcf\xd5\xe8\x14\xc00\xdc\xee?\xe0\xb6O\xa1\xfe'
 b'v\xa6y')

{'A1': {'B1': 2197,
        'B2': 16346,
        'B3': {'C1': 7394,
               'C2': [{'D1': 3309720076, 'D2': 0.8932605385780334},
                      {'D1': 105447759, 'D2': 0.28339195251464844},
                      {'D1': 3151657158, 'D2': 0.5625674724578857}],
               'C3': {'E1': [43, 49, 40, -121, -95, 64, 43, -77],
                      'E2': [30, 48, 145, 241, 252, 79, 196, 128]},
               'C4': 777872009},
        'B4': [713093574,
               2750887953,
               997696881,
               3487794871,
               3222595797,
               1072618544,
               2706355936,
               2040952574]},
 'A2': 9493}

(b'RZJJu\x1f\x00\x00\x00\x10\x91\xae8b\xe6\x04\x00\x00\x00\x0b\x00\x00\x00&'
 b';\x1b\xa2\x08\x87\xa0\x9bJ\x87||\x14pu\x9b\xb3\x04y\xa2\xd6>\xc492'
 b'\xde\x88\xd9\xec=\xf5{\x9f\x1a?V\xf8>\x0f\x00\x15\x8f\xce#\x00'
 b'\x8a\x13\xc0\x8c\xafi\xd8\xfd\x1c\xd6\x9eu\x17Lp\xf4L\x9f0^\x81\xf9i\xbe'
 b' \xee\xef\xffD_\x08')

{'A1': {'B1': -30902,
        'B2': 31868,
        'B3': {'C1': 28692,
               'C2': [{'D1': 78879605, 'D2': 0.4192083179950714},
                      {'D1': 3727833540, 'D2': 0.1156492829322815},
                      {'D1': 446659573, 'D2': 0.4850330054759979}],
               'C3': {'E1': [-82, 56, 98, -26],
                      'E2': [38, 59, 27, 162, 8, 135, 160, 155]},
               'C4': 600739605},
        'B4': [3222505984,
               3630804876,
               2664832253,
               1884034933,
               815746292,
               1777959262,
               4025360574,
               140461311]},
 'A2': -28400}

Вариант №33

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

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

(b'RLSZC7\x00\x03\x00_\x00\x00\x00\xa8*\x84uO:S!~\xed\x045\x95\x00\x00'
 b'\x00\xb8@\xb7\xed\xdc\x1es\xa40\xaemA\xc8N?\xf5\xc1\xe7\x16\x19\x06\x1e\xc8'
 b'\xcfgw\xcd\xf0\x91a\xd4\xc1NI\x02\x005\x00\xec\x12\x99=\x02\xfbR?\x97ox\xbfJ'
 b'-\x88\xbe\xce\x82\x0e\xbfx+U?\x01\xcf\xcd\xbe\xdd\xdf\x88\x8e\xdc79\xbf\x02'
 b'\x00\x00\x00C\x00\x8e>y\xe7\x85\x8d\x17\xb5\xc3\xdbb\xbe\x02\x00\x00'
 b'\x00K\x00\xb6\xb6\xb1\xe6U9\xb6@\xcf/O\xbf\x03\x00\x00\x00S\x00K\x81;'
 b'\x1e\xb0+\xaf]\xa2`')

{'A1': {'B1': {'C1': 5282372530866352333, 'C2': 'gw'},
        'B2': [{'D1': -1903632419,
                'D2': -0.7235085964202881,
                'D3': [0.0747431218624115, 0.824142575263977],
                'D4': 16014,
                'D5': 59257},
               {'D1': -1256747643,
                'D2': -0.22154144942760468,
                'D3': [-0.9704527258872986, -0.26597052812576294],
                'D4': 46774,
                'D5': 59057},
               {'D1': 1085684053,
                'D2': -0.809323251247406,
                'D3': [-0.5566834211349487,
                       0.8326945304870605,
                       -0.40196993947029114],
                'D4': 33099,
                'D5': 7739}],
        'B3': 1971595944},
 'A2': 559102543,
 'A3': 889515390,
 'A4': {'E1': 1571761072, 'E2': 24738},
 'A5': -72,
 'A6': {'F1': [64, 183],
        'F2': 7903307878945971437,
        'F3': 0.8077431321144104,
        'F4': 384287221,
        'F5': 1561},
 'A7': 30,
 'A8': 53192}

(b'RLSZC7\x00\x02\x00W\x00\x00\x00\xeb\xde\xc11\xca\x17\xb5\x08)\xee\x11'
 b'\xf9{\x00\x00\x00\xfd\x97\xfc\xac\xaf\xb4\xa1j\x93q\xc1\xaa\x95\x17\xbd'
 b'\xbd\x9c\xa4\xd6\xb1c\xf5\xb1+thW\xa5\xfc\x83\x96\x8a\xee\xf0\x02\x005\x00,'
 b'\x88E?xZ\xd8>\x1e\x15q?\xe4\x95o\xbf\xfc\xff\xcd>\xda\x0f\xff\xa4M\xd9.?\x02'
 b'\x00\x00\x00C\x00\xa8\xf7\xb2\xaa\x0b\x18\x85T\xc2\x8f\\>\x03\x00\x00'
 b'\x00K\x00\xddb\xd4e\xca\xb4\x88Z\x08\x12')

{'A1': {'B1': {'C1': -1085778081085610665, 'C2': 'th'},
        'B2': [{'D1': -1526788134,
                'D2': 0.6830032467842102,
                'D3': [0.7716090679168701, 0.422565221786499],
                'D4': 63400,
                'D5': 43698},
               {'D1': 1418008587,
                'D2': 0.21539214253425598,
                'D3': [0.9417284727096558,
                       -0.9358808994293213,
                       0.40234363079071045],
                'D4': 25309,
                'D5': 26068}],
        'B3': 834789099},
 'A2': 146085834,
 'A3': 4178701865,
 'A4': {'E1': 1518908618, 'E2': 4616},
 'A5': -3,
 'A6': {'F1': [151, 252],
        'F2': -4507659665832366164,
        'F3': -0.03700796514749527,
        'F4': 3601112253,
        'F5': 25521},
 'A7': -11,
 'A8': 11185}

Вариант №34

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

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

(b'\xcdRBW}\x00\x00\x00\xfb\x1fM\xa2\x03\x00\x00\x00\xaa\x00\x00\x00'
 b'\xb8\x03\xef\x1c\x0c*\x83~Ol\xe2\xf5\x03\x00\x00\x00\x1c\x00\xda\x9d'
 b'\xf2\xcd}p\x05\x00\x00\x00&\x00Yq\x81Y\xbf\x04\x00\x00\x002\x00\xc8;<'
 b'P\x86U\x05\x00\x00\x00=\x00\x1f\x00+\x006\x00B\x00\x19~\xfa\xfd\xae"\xba'
 b'\xe1\xbd\x006\x95\x04\xda\x8a\xbc\xc9i\xf5\xe3h\x99\x13:\x1fF\xd1\xcf:\xa7_'
 b'\x9d\xdd\xe2\xcfm\xcf\xc4\x10\x86h\xcf\xe8\xe7\xadx$\xa4\x04\x00I'
 b'\x00Q\x00\x95C\x7f\xb9\x1fJ\xedB)\xcd\xabl*\xd8KO\xa9!\xde\x82\x08'
 b'\x1b\x81\xd2\t\xfb\xf2>\xday\xbf\x08\x9e+\xbfGD\xe3')

{'A1': {'B1': 2753853613,
        'B2': [{'C1': -11, 'C2': [79, 108, -30]},
               {'C1': 112, 'C2': [-38, -99, -14, -51, 125]},
               {'C1': -65, 'C2': [89, 113, -127, 89]},
               {'C1': 85, 'C2': [-56, 59, 60, 80, -122]}],
        'B3': {'D1': -2181392934526878183,
               'D2': [2503344317,
                      3163216388,
                      3824511433,
                      974362984,
                      3486598687,
                      2640291642],
               'D3': -7459,
               'D4': 14945342770008518095,
               'D5': [232, 231]},
        'B4': {'E1': 4822592276100236181,
               'E2': 5713898228973030697,
               'E3': -3278309330379726423},
        'B5': {'F1': 64265,
               'F2': -14,
               'F3': -0.9759863615036011,
               'F4': -0.6703801155090332}},
 'A2': -1572003845,
 'A3': {'G1': [71, 68, -29], 'G2': 9116176302241416120}}

(b'\xcdRBW\x88\x00\x00\x00\xfa\xb68A\x06\x00\x00\x00\xb5\x00\x00\x00'
 b'\x1f\xd8\x01G\xf4\xc6\xfa\xe0T\x00\xf8\xaf\x03\x00\x00\x00\x1c\x00]\x84'
 b'^\xba\xb2\x04\x00\x00\x00&\x00\xa4\x1f\xa9\xcdo\xac{\x06\x00\x00\x001\x00 |'
 b'\xc2E\xea\x04\x00\x00\x00>\x00\x1bL\xf9\x02\x00\x00\x00I\x00\x1f\x00'
 b'*\x007\x00B\x00K\x00\xa2.\x81\xa6\xe3\x1dC\xa1\x9d\xd9J\xdb\xf1\xbfW\x8b'
 b'\xbc\xdfQ4\xb0\xe8B@\x17:\x9f\x1b\xcc\xb2\xf7T\x99\xad\xe3\xe0\x19,\x9b\xfe'
 b'J\x91bs\r\xdfBA\x05\x00R\x00\\\x00q\xf885\x83\xd3\xabC\xd3,1\xfd\x06\x00'
 b'\xd4\xad6#\xec\x83\xd4\xdbV\x9cj\xcf\x9fj>\xcd>\xeap\xe4>\xd2\xa0-+\xcd\xd3')

{'A1': {'B1': 1094901517,
        'B2': [{'C1': -81, 'C2': [84, 0, -8]},
               {'C1': -78, 'C2': [93, -124, 94, -70]},
               {'C1': 123, 'C2': [-92, 31, -87, -51, 111, -84]},
               {'C1': -22, 'C2': [32, 124, -62, 69]},
               {'C1': -7, 'C2': [27, 76]}],
        'B3': {'D1': -6826579746575274334,
               'D2': [3679115677,
                      2337783793,
                      877780924,
                      1078126768,
                      463419927,
                      1425519308],
               'D3': -21095,
               'D4': 10469460226189418723,
               'D5': [98, 115]},
        'B4': {'E1': 4876223582045796465,
               'E2': 12525636493641854163,
               'E3': -7181310850002836682},
        'B5': {'F1': 53098,
               'F2': -97,
               'F3': 0.4008668065071106,
               'F4': 0.4461739659309387}},
 'A2': 1094235898,
 'A3': {'G1': [-46, -96, 45, 43, -51, -45], 'G2': -2235255512570406881}}

Вариант №35

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

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

(b'\xb1PGDD\x99\xdc\xd1\x1f\xb4\x07^\x8d\xcf\xb5\xe1\xbf;\x00?\x00d\x00\xd4'
 b"\xb0\x8a\xfc\x9d\x81\xfd \r\xf8'E\xdb>7\xb7\xe2\xbe\x12\x9eN\xbe\xf5\x82\xae"
 b'>\xc0\xfa\x95>GVP\x95\xa3\xb64\x89\x01\xdb\xf3\xfc*D{\xcf.\x9d\xba'
 b'r\xec\x86\xe5\xef\xeckAD\xde\xdc?\xe0\x11\xa29\xb1\x1d\xb5\xa0.W\x03\x00'
 b'Q\x00\x00\x009\xcd\x04\x1cH\x91)@\xa5\xb4\x94y\xabLa\xcf\xa6\x06\x03\xe7'
 b'\xbf\x10\xae/?@\xe9)b\xbdm\xae?C\x00\x00\x00T\x00\x00\x00\xc1\x16L+\xf9o9'
 b'N\xc1\xbf')

{'A1': 533847193,
 'A2': -0.553443695171373,
 'A3': [{'B1': -30412, 'B2': -9471}, {'B1': -781, 'B2': 17450}],
 'A4': {'C1': {'D1': 4623386231366274361,
               'D2': 46245,
               'D3': {'E1': -108,
                      'E2': -21639,
                      'E3': -0.7191193826684326,
                      'E4': 0.6862497329711914,
                      'E5': 0.05943099807059804},
               'D4': {'F1': 53115,
                      'F2': -1160372978882798290,
                      'F3': 27628,
                      'F4': 17473},
               'D5': {'G1': 966922720,
                      'G2': 7601,
                      'G3': 1462673589,
                      'G4': [-34, -36, 63]},
               'D6': 5636659524594833089,
               'D7': -16447},
        'C2': {'H1': 4236947668,
               'H2': -32355,
               'H3': [-3, 32, 13, -8],
               'H4': [0.42826196551322937,
                      -0.4428040683269501,
                      -0.20177486538887024,
                      0.3408428728580475,
                      0.29292869567871094]}},
 'A5': 71,
 'A6': 86,
 'A7': -1230793392}

(b'\xb1PGDD\xb4\xb2K\xd1N\x01z\x05\x8e\x0f\xed\xbf;\x00?\x00c\x00\xa8E\xcc\x816'
 b' \x8f\xd3S\xca\x10\x02\xe5\xbe\x15Zq\xbf\xf6\xe2J?\x9f!\xa3>].p\xbcA\xc5\xee'
 b"\x01i\xa6\xbc\xa1\x16\xc8|+@\x1f\x98\x17t\x99\x1e\x8b\xed\xf4\x99',\xb8{"
 b'\xb5]>o\xdb]\x97-;\x0f\xec\x8ce\x02\x00Q\x00\x00\x00\xf5tc\x0f\x1d/\xe6JZ'
 b'\xfd\xbe\xa44\xa8-\xdb\x8a!\xd6\xc9\xbf9\xc0c\xbf$5\x1f\xa6\xe6*\xef\xbf'
 b'C\x00\x00\x00S\x00\x00\x002r$\x89\x14\xde\x12\xeer/')

{'A1': -783568204,
 'A2': -0.9081487757648945,
 'A3': [{'B1': -24132, 'B2': -14314}, {'B1': 11132, 'B2': 8000}],
 'A4': {'C1': {'D1': 5397053005308851445,
               'D2': 64858,
               'D3': {'E1': -66,
                      'E2': 13476,
                      'E3': -0.2018472602852459,
                      'E4': -0.8896518349647522,
                      'E5': -0.9739869350975465},
               'D4': {'F1': 6040,
                      'F2': 2853581139994384756,
                      'F3': -18388,
                      'F4': -19077},
               'D5': {'G1': -1755456657,
                      'G2': 15149,
                      'G3': 1703734287,
                      'G4': [93, 62]},
               'D6': -1291725963320331726,
               'D7': 12146},
        'C2': {'H1': 2177648040,
               'H2': 8246,
               'H3': [-113, -45, 83, -54],
               'H4': [-0.4472813606262207,
                      -0.9427807927131653,
                      0.7925256490707397,
                      0.3186158835887909,
                      -0.014659491367638111]}},
 'A5': 65,
 'A6': -59,
 'A7': -1503067666}

Вариант №36

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

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

(b'ZJIf\x9b\x06?\\NC\xbf\xc4\x9fE>\xd6y/?#\x00\x89\x84\xa9\xbe]\xfa\x90P%bC'
 b'\xe6^\x00\x80.\xc0\x8b\x00\x04\x86\xbf\x87\xdc\x08P\x9b\xa6\x05\xb0\xee'
 b'\xc9\xc6\x93A \xc9\x17\x0e\xbc!\x04\x00\x00\x00,\x00\x00\x00\xc7\x02'
 b'\xd9x\xf3\x02\xa4\x17\xe6\xea\x1a&>\x04\x00\x00\x000\x00\x00\x00\xcd'
 b'\xfa3\x0c\xf2h>\x87\x02\x00\x00\x004\x00\x00\x00')

{'A1': [0.5258086919784546,
        -0.7629144191741943,
        0.19299226999282837,
        0.6854528188705444],
 'A2': {'B1': -0.010749820961812206, 'B2': -121},
 'A3': -0.3310892879962921,
 'A4': 16592213364568029789,
 'A5': {'C1': 0.22748583555221558,
        'C2': 135,
        'C3': [{'D1': -14647,
                'D2': 2430833394194596243,
                'D3': [220, 8, 80, 155],
                'D4': [199, 2, 217]},
               {'D1': -3208,
                'D2': 4478296475651515394,
                'D3': [166, 5, 176, 238],
                'D4': [205, 250, 51]}]}}

(b'ZJIg\t/\xbef\x04\x81\xbe\xa4\xf46?uX\x02?#\x00~\xa5\x9b\xbe\x1f\xc2*'
 b'\xb9\xc2\xad}\xa6\x8c\x00\xb0\xf5\xb8x\xf7\xde\xb1\xbf\xe6- h\r\xbd\x00.\x0b'
 b'=\xc0q\xa3\xb55S8Y\xcf\x1d\x86*\xc2\x02\x00\x00\x00,\x00\x00\x00\xbf\xc3'
 b'\xc2\x85\x1fBM\xd5[L\xf2\xec_\x04\x00\x00\x00.\x00\x00\x008\xa4\xba\x15x'
 b'W\xd6\xce\x80\xff1G\xd6\x03\x00\x00\x002\x00\x00\x00}"\xf5\t\xban\x08f'
 b'@\xdb\x07\x07U\x03\x00\x00\x005\x00\x00\x00\x07\x8b\xecG\xec\xc8>'
 b'x\x04\x00\x00\x008\x00\x00\x00')

{'A1': [-0.1709343045949936,
        -0.25198668241500854,
        0.7146704196929932,
        0.5091622471809387],
 'A2': {'B1': -0.06980845162703164, 'B2': -26},
 'A3': -0.3039969801902771,
 'A4': 11996936034226717215,
 'A5': {'C1': 0.3924276530742645,
        'C2': 120,
        'C3': [{'D1': 13749,
                'D2': -4455601418738780077,
                'D3': [45, 32],
                'D4': [191, 195, 194]},
               {'D1': 8069,
                'D2': 6912165937879010626,
                'D3': [104, 13, 189, 0],
                'D4': [56, 164, 186]},
               {'D1': 30741,
                'D2': -3006379252799056297,
                'D3': [46, 11, 61],
                'D4': [125, 34, 245]},
               {'D1': -17911,
                'D2': 6126874456320510062,
                'D3': [192, 113, 163],
                'D4': [7, 139, 236]}]}}

Вариант №37

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

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

(b'&ERJg\x00\x04\x00\x00\x00q\x00\x04\xa5\x98\t\x9a\xfbv\xeb\xcb\xd0L\n'
 b'\xe3\xdcFCj\xc4j\xe9\x96\x7f\rr\xf4\xe0\xcd\x97\xaf\x16\xbb\xbc-\xaf\xb8A'
 b'\xfa\xf9\xad\x11\x00\x00\x00"\x00\x00\x00\xc0\xfb\x05\xe3~X\xc1f\x8dMM8,'
 b'\x08\xa1\xc3\x93\xb4gX\x89\xaa\x08\x83A u\x03L\xc3\x16\x87l\x92\xd1?BP\x89Xj'
 b'\xf8\xe2\xbf3\x00\x9e\x99mfZ\x83vL\x9f\xa5z4\x82\xc6\x1f\t\xbc\xb9m'
 b'\x83sI\x88\xfa')

{'A1': {'B1': {'C1': [{'D1': [30459, -13333, 19664, -7414, 18140],
                       'D2': [67, 106, 196, 106, 233, 150, 127]},
                      {'D1': [29197, -7948, -26675, 5807, -17221],
                       'D2': [45, 175, 184, 65, 250, 249, 173]}],
               'C2': 3808820160,
               'C3': 1723947134,
               'C4': 944590221,
               'C5': 3282110508,
               'C6': [1483191443, 2198383241, 58007617],
               'C7': 0.2745620078304014,
               'C8': -0.5928241471506299},
        'B2': 5509735618423134622},
 'A2': [880453023, 153077378, -2089961028, -91731597],
 'A3': 160998660,
 'A4': 154}

(b'&ERJg\x00\x03\x00\x00\x00q\x00$Z\xd80\xacH\x1d\xd8\x1a\xfb\x8d\x8b\xa9&%P'
 b'Yk\xa4\x11eW\x14)\x9d\xc2%\xb5\x11\xe1\xf4[\x04\xd8!GOw\xb9\x11\x00\x00\x00"'
 b'\x00\x00\x00\xe7\x0f\xe9\xdep\x0f\xba\x8eO\x14\xe7\x1e\xb8a\xeaE('
 b'\xe3\x98\xdc\xbe\xc7\x19\xc9\xd7<U\xab\x18\xe1\n\xdf%\xc5\xd7\xbf\xb8'
 b'c\xf9b\xcc\xcb\xd3?3\x00\x94F\xac\xcc\x15t\x8bZo.&\xc7\x17TB\x13x\xf8@\x82')

{'A1': {'B1': {'C1': [{'D1': [7496, 6872, -29189, -22133, 9510],
                       'D2': [80, 89, 107, 164, 17, 101, 87]},
                      {'D1': [10516, -15715, -19163, -7919, 23540],
                       'D2': [4, 216, 33, 71, 79, 119, 185]}],
               'C2': 3739815911,
               'C3': -1900408976,
               'C4': 518460495,
               'C5': 1172988344,
               'C6': [3701007144, 3373909950, 2874490071],
               'C7': -0.37140795499318946,
               'C8': 0.30931386628577284},
        'B2': 6524436122153272980},
 'A2': [-953799057, 323114007, -2109671304],
 'A3': 819485220,
 'A4': 172}

Вариант №38

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

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

(b'JCB\xb9(\x00\x932\xb6qC\xee\n\x85\xa6\xe7{\xad\xcd{\x03\x00d\x00\x00\x00ch'
 b'ZF\xb8^\x08t\xea\xbf\xf3\xd6bjQ\n\xd4\xc8\xaa\xf1\x8c\xb4\x14\x00\x11\xa5'
 b"\x06Q\x02\x00\x00\x00\x1a\x00\xde\x1c\x004L\x0f\xfcEl'7\x02\x00\x00\x00&"
 b'\x00q\xc4\xb9A\xc6=\x15\x8e\xc7\x1c\x01\x18\x193\xc5\x00\x9b\xd68 \xdc1\xd7'
 b'U\x00\x00\x00Z\x00\x00\x00_\x00\x00\x00')

{'A1': -71,
 'A2': {'B1': {'C1': 3369339473, 'C2': 61866, 'C3': 1356940, 'C4': 1359389969},
        'B2': 'ch',
        'B3': -34,
        'B4': {'D1': -0.8266641473766854, 'D2': -10509},
        'B5': 3974264244015156276,
        'B6': 'bj',
        'B7': 1102693489,
        'B8': -1911210554},
 'A3': 9586736730249507475,
 'A4': -1384388698,
 'A5': 31693,
 'A6': [{'E1': -57, 'E2': [28, 1, 24, 25]},
        {'E1': 51, 'E2': [197, 0, 155, 214]},
        {'E1': 56, 'E2': [32, 220, 49, 215]}]}

(b'JCB++\x00\xe1\xab\xdc\xdc\x11\xfd`\xa3@\x11\xa2\x08\xf30\x02\x00b\x00'
 b'\x00\x00vsovx\x1c7\x8e;\xb6\xc0\xef\xbf\x998ng\xde]\xa6_MK\xddj\tm\x8a\xdfL'
 b'\x98\x05\x00\x00\x00\x1a\x00\xda\x1f\x00\x96\x8f\x86\xe8\r\x1c\xdcP\x02\x00'
 b'\x00\x00)\x00\xaa/\x04\xb4v\xbe\x88\xe0\x05\xd2(\\\xe7\xc0\xc1o\x02\x14X\x00'
 b'\x00\x00]\x00\x00\x00')

{'A1': 43,
 'A2': {'B1': {'C1': 1604738526,
               'C2': 19277,
               'C3': 1829333725,
               'C4': 2555174794},
        'B2': 'vsovx',
        'B3': -38,
        'B4': {'D1': -0.9922743952936091, 'D2': 14489},
        'B5': 5826562863971864470,
        'B6': 'ng',
        'B7': -1274794070,
        'B8': -527909258},
 'A3': 11772687679108197345,
 'A4': 144838976,
 'A5': 12531,
 'A6': [{'E1': 5, 'E2': [210, 40, 92, 231]},
        {'E1': -64, 'E2': [193, 111, 2, 20]}]}

Вариант №39

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

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

(b'\xb5SRY:\x00@\x00F\x00L\x00R\x00X\x00^\x00d\x00\xf1\x10[\xfa\x9bZ\x91\xe5'
 b'\xcc{T\xc9\xac\xb9\xe4?e\xae\x1b\x9b\x9e\xa06^\x05\x00\x00\x00j\x00\x00\x00'
 b'\xa9\x00.\x1f\xc2\xff\xf7*=\xbe\xcb\x96\xbam\x18\x04\x01V\xa5\xca'
 b"\x06\xb3'\x15\t\xf3\x0b)I\xae-\x82\xb7\x1c\xcf\x90sE\xcf\xc1<\xbeq\xe4"
 b'f\x86\xc0U\x94\x85>\xc2\x00\xa1akwwa>?&\x8f\xccnv\xaaN\x82\x84J\x99'
 b'\xc2p\xf5\x1f\t\xa7I\xb2\xd6^Pm_\xed\xe7\xed\xbf\xf7[\x0bY\xda2C'
 b"\x96\xbe\x08\xd7\x05%\xa8\xf6\xd8O\x1b'\xc5\xfc\xddd\xbf\x84\xc8\xd7"
 b'=\x03\x00o\x00{\x00\x02\x00\x00\x00\xa1\x00')

{'A1': [{'B1': 3191679735, 'B2': -26933},
        {'B1': 68709818, 'B2': 22017},
        {'B1': 3003566757, 'B2': 5415},
        {'B1': 688648969, 'B2': -20919},
        {'B1': 481788461, 'B2': -28465},
        {'B1': 3251586419, 'B2': -16836},
        {'B1': 2254890097, 'B2': 21952},
        {'B1': 3258877332, 'B2': -24320}],
 'A2': -1904641541434306319,
 'A3': 0.6476653988100849,
 'A4': 6788790091375160933,
 'A5': 'akwwa',
 'A6': {'C1': [-1893318850, -1435078964, 1250198094],
        'C2': {'D1': -15719,
               'D2': [112, -11, 31, 9, -89, 73, -78, -42],
               'D3': -0.9345614303406469,
               'D4': 10827553842506980343,
               'D5': 15633868033428490430,
               'D6': 3307674447},
        'C3': [-0.8940122127532959, 0.1053629219532013]},
 'A7': 4290912046}

(b'\xb5SRY:\x00@\x00F\x00L\x00R\x00X\x00^\x00d\x00M\xdaV\xe6\xc9\x15(\x8f'
 b'(b\xa0)\x10\xa1\xee\xbf\x8b\xfesB,u|-\x02\x00\x00\x00j\x00\x00\x00\xa6\x00}g'
 b'\x0c\xdd\x15\xc5\xed\x82\xd2\xb2\x9bT@\x97\x9d\x80\xd0\xc3(\x10\xc6\xde'
 b'X0\x1e\x90Z4H\x08\xf4\x062u\xce\t\xdaz\x196<\xf91[w\x15\xe4t\x94h\xd5\xd6hi'
 b'\xcc\x96\xb9\xe4\xeb\xab\xfb\x95\xc6\x1a\x1e@\xdc#\xd7E\xa5D\xc7]'
 b'\x8f\xb3:\x8d\x98?\xf1\x07\xee\xbfs%p\x11\xea\xa6\x81\x02\x03\xa2\xe3\xb8b.'
 b'\xab\xb1E:\xcb\xf3\xe5 \x13?\xcd\x94\xb9\xbd\x03\x00l\x00x\x00'
 b'\x02\x00\x00\x00\x9e\x00')

{'A1': [{'B1': 2196620565, 'B2': -19758},
        {'B1': 2537575579, 'B2': -32611},
        {'B1': 271107024, 'B2': -8506},
        {'B1': 2417897560, 'B2': 13402},
        {'B1': 116656200, 'B2': 30002},
        {'B1': 2061109710, 'B2': 13849},
        {'B1': 1530001724, 'B2': 5495},
        {'B1': 1754559716, 'B2': -10539}],
 'A2': -8131225170320369075,
 'A3': -0.9571610272424254,
 'A4': 3277623461772787339,
 'A5': 'hi',
 'A6': {'C1': [-457599284, -1778668565, 1075714758],
        'C2': {'D1': 9180,
               'D2': [-41, 69, -91, 68, -57, 93, -113, -77],
               'D3': -0.9384695283992308,
               'D4': 180608984316650867,
               'D5': 12802377367274365443,
               'D6': 4090182213},
        'C3': [0.5747206807136536, -0.09061584621667862]},
 'A7': 3708577661}

Вариант №40

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

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

(b"\xb5FBB\n\x99X2\x03\x00\x00\x004\x00\x00\x00\x11\xb7\xc1'\xb6,\x1b\xf1"
 b'^\x992\xaa\x04\x00\x00\x00:\x00\x00\x00\xbc\xdb\x12\xc3\x06\x00J\x00'
 b"\x82\xa8g\x16\xfa\x86\x00\xb2\xfeK/\xe5\x98\xb4\x935\xc3\xbb'\xa8"
 b'\xfdR\xc1\x1d\xf5\xc9\xc5\x89\x8bM\x04\xac@4\x1a\x99\xd9\xbf\xce}\x86\xb5C*'
 b'\xe8?\xac\xe8\xd3S\xb2\xf1\xd8?r\x9eI_ \x01\xed?\xd8\x99G]\xcc&'
 b'\xc0\xbf\x84\xc5\xbd\x86\xc8*\xea?\xec\xe2h>di\xd8>\xa6\x10e?S\xf0'
 b'\x04\x16\x04\xb7\x14\x8a\xb5\xe8\x05\x84yf\xd5\xe2\xfa\x02\x03\x00z\x00')

{'A1': 844667146,
 'A2': {'B1': [{'C1': -2, 'C2': 75},
               {'C1': 47, 'C2': 229},
               {'C1': -104, 'C2': 180}],
        'B2': -1073214925335054575,
        'B3': {'D1': -1439524514,
               'D2': [-1144834669, 1392355367, -906682943, 1300990405],
               'D3': 3272793020,
               'D4': [-0.39996962645335565,
                      0.7551592393319255,
                      0.38975198923402377,
                      0.9063875065884999,
                      -0.12618403010055945,
                      0.8177225715318603],
               'D5': 130},
        'B4': 168},
 'A3': 5735,
 'A4': 250,
 'A5': {'E1': 9949778704945442899,
        'E2': 181,
        'E3': -24,
        'E4': 214733338428670981,
        'E5': [0.227428138256073, 0.42267906665802, 0.8947852849960327]},
 'A6': 178}

(b'\xb5FBB\xd1\xe3\x8f\xca\x04\x00\x00\x004\x00\x00\x0076\xdd\xcb\xc9\x83#z'
 b'\xcc\x8e\xa3\x17\x04\x00\x00\x00<\x00\x00\x00\x82\nW\xd6\x08\x00L\x00'
 b'\xf9\x0b\x83f\xa9\x94\x00\xab\xc4\xed\x91\x9dzb\x99. (\xf2RC\x06\x00\xa0'
 b'\xb2\\H\x15XKs\xbd01\xae\xa2\xae\xe2\xcd\xbf\xb0T\xf5\xbb\xca\xf7\xb2?'
 b'6\x1d\x85#\xbc\xd2\xe9\xbf\xac8\x07)\xdc`\xdf?\xfe.,\x0fV\x96\xe2\xbf'
 b'x\xa7\x851\xcer\xe5\xbf\xb0\xa8\x97\x9a<\x88\xee?\xa8\x9bEi\r\\\xd6\xbf'
 b'F\xf6n?\xb9\x1dH\xbf\xb8u\xe8\x04^2E?\x150\xc7\xa9&\xe0@~\xbd\xa7\x02\x00'
 b'\x8c\x00')

{'A1': -896539695,
 'A2': {'B1': [{'C1': -60, 'C2': 237},
               {'C1': -111, 'C2': 157},
               {'C1': 122, 'C2': 98},
               {'C1': -103, 'C2': 46}],
        'B2': 8801022999544018487,
        'B3': {'D1': 396594892,
               'D2': [1391601696, -1610611133, 357063858, -1116517544],
               'D3': 3596028546,
               'D4': [-0.23348029082661403,
                      0.07409350479913956,
                      -0.806974477171855,
                      0.4902868652978991,
                      -0.5808515831317604,
                      -0.6702643363216643,
                      0.9541304606803092,
                      -0.3493684318586312],
               'D5': 249},
        'B4': 11},
 'A3': 26243,
 'A4': 169,
 'A5': {'E1': 4559105577173153208,
        'E2': 21,
        'E3': 48,
        'E4': 12086955792035916231,
        'E5': [0.9334453344345093, -0.781703531742096]},
 'A6': 171}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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