ИМБО-01-22

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

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

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

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

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

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

(b'DMX\xbf\x14\x1e\x01\xab2;Y\x00\x00\x00/\xb8\x0cU9\x19\xa9\xe1\x0b\x00'
 b'\x02\x007Fahs\x00\x00\x00\x02\x00\x00\x00Y\x00\x00\x00\x04\x00\x00\x00a\xa6'
 b'#u\xfcRI\xdf\xfcqy\xbe\xa4D^\xbe9K\x96T^\x00\x02\x00\x00\x009?R:_>\xb3\xb3'
 b'\xebv\x96\x00\x02\x00\x00\x00I\x00\x00\x00A\x00\x00\x00Q?+\xa3\xbf=Y8\xb7?x?'
 b'\xec\xbe\xbf\xe48')

{'A1': -0.5785828232765198,
 'A2': 43826,
 'A3': 15193,
 'A4': {'B1': {'C1': 2787341820, 'C2': 21065, 'C3': 223, 'C4': -4},
        'B2': 13262068706431328523,
        'B3': 'qy',
        'B4': 70,
        'B5': 'ahs'},
 'A5': [{'D1': 21598, 'D2': [-0.32083410024642944, -0.18095239996910095]},
        {'D1': 30358, 'D2': [0.8212031722068787, 0.35098204016685486]}],
 'A6': [0.6704673171043396,
        0.05303260311484337,
        0.9697253704071045,
        -0.3747880458831787]}

(b'DMX>\xd9\xbf\x9d\xa4\x88\x81\xaa\x00\x00\x00/x\xa6U\xc5\x90W\xac\xa6\x00'
 b'\x06\x007prbn\x00\x00\x00\x02\x00\x00\x00]\x00\x00\x00\x03\x00\x00\x00e\xbe'
 b'UC\xb9\x08K\xe7~aftpzp\xbfA\xe7\xda\xbdM\xf7M\x0c\x15\x00\x02\x00\x00\x00'
 b'=>\x07\xcd\xcc?z\xb8\xfa\xcf5\x00\x02\x00\x00\x00M\x00\x00\x00E\x00\x00\x00'
 b'U\xbf;\xb0\x9b? \\\xa1?QG\xbe')

{'A1': 0.4252900183200836,
 'A2': 42120,
 'A3': 33194,
 'A4': {'B1': {'C1': 3193258937, 'C2': 2123, 'C3': 231, 'C4': 126},
        'B2': 8693730437703904422,
        'B3': 'aftpzp',
        'B4': 112,
        'B5': 'rbn'},
 'A5': [{'D1': 3093, 'D2': [-0.7574440240859985, -0.050284672528505325]},
        {'D1': -12491, 'D2': [0.13262099027633667, 0.9793850183486938]}],
 'A6': [-0.7331635355949402, 0.6264134049415588, 0.8175009489059448]}

Вариант №2

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

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

Поле	Описание
1	int64
2	uint64
3	int16
4	Адрес (uint32) структуры B
5	int16
6	Структура D

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

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

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

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

(b'\tGTQE \xe3\xb1|u\xd7\xda\x97\x1f+$\x0e\xc5\xd77}\x00W\x00\x00\x00O\xd8'
 b'P$\x98\\{\xce\x97Y\xed\x02\x01\xcf\x90\x0e\x00\x00\x00b<\xcf\x86\\\xd2\xb1'
 b"\xdce+)\xae\xe0EF\x85\x05,*J$\xe8\xc3/\x9a\x07\x19\xe5@\xe7'fn\xf8\xbf"
 b'\xd3\xb0^=\x16\xb7$e\xba\x00\x03\x00\x00\x00C\xd9q\xa43\xf9\xcd\xd5\xf0>'
 b"s\x00\x0f^\xd2\xf5\x9cgY\xa1\x8c2\xda.'L\xd2\xa1\x1c\x9cF\xebE\xeay\x1d")

{'A1': 2369932977038154391,
 'A2': 2245928485041682301,
 'A3': 87,
 'A4': {'B1': -0.3076396557397507,
        'B2': 26042,
        'B3': [{'C1': [-61, 47, -102], 'C2': 7},
               {'C1': [25, -27, 64], 'C2': 231},
               {'C1': [39, 102, 110], 'C2': 248}],
        'B4': -9871,
        'B5': -92},
 'A5': -10160,
 'A6': {'D1': 2636959268642183661,
        'D2': [2, 1, 207, 144, 14],
        'D3': {'E1': [872009173,
                      4030624512,
                      257872629,
                      2624018849,
                      2352142894,
                      659346081],
               'E2': 7324,
               'E3': 1189823978,
               'E4': 31005},
        'D4': 4381868695684766821,
        'D5': 3110209295934194949,
        'D6': 44,
        'D7': 709502184}}

(b'\tGTQE\x13\x0bb\xab\x9a\xa1=\xa4\xcb\x92\x1d?\xc2\xb1\xa0\xb8l\xc3\x00'
 b'\x00\x00OZ\xa4\xf8\x10\xb3|\xec~\xcfW>\x1a\xac\x02\xb0\x00\x00\x00bp\x00'
 b'\x00\\\x0f\x84\xecX\x8f`\x1c\x9f\xd7\xd3\x80\x03\x9ah\xb9|\x1a\xad}+\x95W'
 b'4\xf4\xb9\xfcK\xfc\xab\xbf\xee\x98\x9ed{*\x88\xeb\xd4\x00\x03\x00\x00\x00Ce'
 b'x\xe2\xb2\xb42\xb6\x0cu\xf9\xc2\xed\xdd\xeb\x99P\x8dq=\xf6a\xa7q\xe8\xcc'
 b'\x934\x97\x8c\x10\xb1\x15\xcb\xfd\xe9')

{'A1': 1372299000637636004,
 'A2': 14668819095985692856,
 'A3': 27843,
 'A4': {'B1': -0.9561302149316626,
        'B2': -5164,
        'B3': [{'C1': [-83, 125, 43], 'C2': 149},
               {'C1': [87, 52, -12], 'C2': 185},
               {'C1': [-4, 75, -4], 'C2': 171}],
        'B4': 25976,
        'B5': -30},
 'A5': 23204,
 'A6': {'D1': -571759803551002793,
        'D2': [62, 26, 172, 2, 176],
        'D3': {'E1': [2998153910,
                      209058242,
                      3990743961,
                      1351446845,
                      4133594993,
                      3905721140],
               'E2': -26740,
               'E3': 280040907,
               'E4': 65001},
        'D4': 8070450927645289560,
        'D5': 10331289018034257923,
        'D6': 154,
        'D7': 1756986394}}

Вариант №3

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

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

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

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

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

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

(b'MAX\x1dp\x0e-\xfa|\x03<\xda#BZu\xf8?6U\x99\x9b\xcd\xb2\xaf\xa4cenorc'
 b'\xdb3\xc7\xcf\xcbE\x1c\xc2\x00\x83\x04-\x82\xdaO$js\xbe\xbf\x16|\x9e/'
 b'?\xd3\xce\x05_\x84\x05\xc4\xb2\xab\xf6\x03\x93\xda\xb2LN\x89Blrqmlk\xc5\x861'
 b'\t[K\x99\x05\x00\x8f\xc2\xb7\xa8^0\xa0\x7f7\x98p\xda6\xec\x87?\xe7\xc9'
 b'f\xad\xc0\xaa\x12]8\xb2\xc15\xbd\x16\xe2\xedP\x00\x06\x00\x00\x00'
 b'\x9b\x15\x1e\xbf|h\x10\xaa\xe0\xc7#\x1b\x07`\xf5\xbf\x01\xdat\xd5'
 b"\xca\xf0y\xbc\x91\xfc'[\xf1\x84\xd9l\xf1.!\xcf~\x16\xac")

{'A1': 29,
 'A2': 1879977466,
 'A3': 8936052993225284213,
 'A4': [{'B1': 4164892245,
         'B2': -1717842510,
         'B3': 175,
         'B4': -92,
         'B5': 'cenorc',
         'B6': [-617363505, -884663102],
         'B7': {'C1': -0.9859628677368164, 'C2': -1428109533, 'C3': 453468405},
         'B8': {'D1': 1069,
                'D2': -32038,
                'D3': 20260,
                'D4': 7670684318267383343,
                'D5': 0.30944952323633523,
                'D6': 178}},
        {'B1': 2885026707,
         'B2': -625849266,
         'B3': 137,
         'B4': 66,
         'B5': 'lrqmlk',
         'B6': [-981061367, 1531681029],
         'B7': {'C1': -0.507239580154419, 'C2': -708120455, 'C3': -1131283417},
         'B8': {'D1': 49847,
                'D2': -22434,
                'D3': 12448,
                'D4': 9166963177000725639,
                'D5': 0.7433350938420651,
                'D6': 93}}],
 'A5': 56,
 'A6': -5566108578204160688,
 'A7': [23537, -31527, 27889, 11809, -12418, 5804],
 'A8': 5406}

(b'MAXlQ\xb9\x1f\n\xbb\xc2/}\xf5\x94\xca\xb7z\t\xcfh1v\x98\xd7w\x98fxnpwc'
 b'\x1fh\xda2\x95\xf2Z\x1a\x00\x83x\xf1\x7f`\x18\xc8\x1b\x8b\xb5\xbe'
 b'\x11\xf6\xaai\xbf\xecn8pm[\x12\xb1\x88\xd6kN\xbar\x888\xe8\x14lydnc'
 b'w\xd7\xf3B\'\x17\xd6\xfb\xfd\x00\x8f\xc9"\t\x9fv\x0fH\xeb\x87\xe1_\x91\x9d'
 b'??\x9e1`\x9d H\xc0\\G\xed\xfeY3\x0b\xfao\xba\x00\x06\x00\x00\x00'
 b'\x9b\xef\x88>\xbfK\xcbfb\xd7b$y>x>\x027\xbd\xecV \xfd\xe0\xa8\x05\x9f\xcc'
 b'?\x7f\xf0_\xc60\x9c\xd4\x14\xb6J')

{'A1': 108,
 'A2': 1371086602,
 'A3': 13529428448611977911,
 'A4': [{'B1': 2047463272,
         'B2': 829855959,
         'B3': 119,
         'B4': -104,
         'B5': 'fxnpwc',
         'B6': [526965298, -1779279334],
         'B7': {'C1': 0.37362512946128845, 'C2': 1717753698, 'C3': 611925624},
         'B8': {'D1': 30961,
                'D2': 32608,
                'D3': 6344,
                'D4': 1984879888736627305,
                'D5': -0.8884546466677838,
                'D6': 177}},
        {'B1': 2295753550,
         'B2': -1166899144,
         'B3': 232,
         'B4': 20,
         'B5': 'lydncw',
         'B6': [-671923673, 399965181],
         'B7': {'C1': 0.127165749669075, 'C2': -329899779, 'C3': -525859425},
         'B8': {'D1': 51490,
                'D2': 2463,
                'D3': 30223,
                'D4': 5254442792298585407,
                'D5': 0.02948523482343357,
                'D6': 92}}],
 'A5': 71,
 'A6': -1297501566856958022,
 'A7': [-13249, 32752, 24518, 12444, -11244, -18870],
 'A8': -4216}

Вариант №4

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

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

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

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

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

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

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

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

(b'EXM\xc0?\xed\x93\x90J\xf6!\xc6\x18`\x1f\x03l\x7f\x0cI}\xd3?/\r\x8dX\x1b'
 b"\xfeU'\x02\\\x8b\x01>\xde\xf3?\xebM\x1d\x94\x9c\xcf\x0e\xbf~\xdf\xcd?\xe8"
 b'\xef>\xdf\x7fQ\xec\xbe\xa2\x08#?\xc1\xc7P\x99y\x8f\xd0=\r\x7f\xc1\xbf\xaa'
 b"'d\x82G8\xc0?,\xa1G\xad\xb7\xe9\xfc?Ck\xd9\xbf+T1=J}\xaa\x9f>"
 b'\xdb\xb4\xf9\x00\x00\x00\x02\x00\x8b\x00\x04\x00\x00\x00\x8f\xbf'
 b'\xe6\xba\xe9\x8dkql\xfb\xa8\x19\xc2\xbe\xf1\x14\x1e\xe2\xa9+\xa5\xed'
 b'^\xbb\x9c\xde}\x98\xbb\x9f\xd8PI')

{'A1': 0.9242631401148678,
 'A2': 1756437954240121929,
 'A3': {'B1': 32211, 'B2': 0.6838005185127258},
 'A4': {'C1': 22555, 'C2': -120146923959418562},
 'A5': {'D1': -8461,
        'D2': [{'E1': 0.8531635191525042, 'E2': -0.9956024289131165},
               {'E1': 0.7792047848875518, 'E2': -0.31646832823753357},
               {'E1': 0.1388951062573356, 'E2': 0.0345456637442112},
               {'E1': -0.05108179178533723, 'E2': 0.6743358969688416}],
        'D3': {'F1': 2914511356,
               'F2': 0.7633643746376038,
               'F3': [-0.669253408908844, 0.04943624883890152],
               'F4': 159,
               'F5': 0.42911508679389954,
               'F6': [60766, 48028]},
        'D4': [-8579, -26437, -24616, 20553],
        'D5': -0.7103164445975785},
 'A6': 4222097858,
 'A7': -0.47085660696029663,
 'A8': -492229723}

(b'EXM\xc0?\xe9\xa0\x96\x97j\xf0\xe8\xbd\xd8\xe6\x95`\xa4z\x10H+?M'
 b'\xf1\x9f\xec\x8d\x96\xc5\xa4E\xcb\x9f\xde\xb9\xb8\xea?\xca\xaa\x02\x1c\xe5'
 b'\xe2\x80\xbf56"?\xd4\xf4\x89\xc2\x81\xe8t?"\xc5\xab?\xe0\xcd5}\xce'
 b'a\x02\xbe\x7f\x11\xb5\xbf\xee\x12?\x9aE{H\xbfj\xe3X\x0f*\x17E\xbf2\xf0\xd7?z'
 b')\x8b\xbfw\x8b\xf9m>\xafa\x1e\x00\x00\x00\x02\x00\x8b\x00\x02\x00'
 b'\x00\x00\x8f?\xef\xd9k\xbd\x83\x92\\\xdc\xdc\xdf]\xbe\x13\xc1(\x1c\x89i\xceF'
 b'\x9d\x80\x07\xfb\xd2\x9e\x14')

{'A1': 0.8008530576112465,
 'A2': -4766806676325762544,
 'A3': {'B1': 18475, 'B2': 0.8044680953025818},
 'A4': {'C1': -4979, 'C2': -7582473777932411207},
 'A5': {'D1': -18198,
        'D2': [{'E1': 0.2083132401565031, 'E2': -0.7078572511672974},
               {'E1': 0.327425422619519, 'E2': 0.6358286738395691},
               {'E1': 0.5250499207641328, 'E2': -0.2490909844636917},
               {'E1': -0.9397275937188647, 'E2': -0.9175314903259277}],
        'D3': {'F1': 254416709,
               'F2': -0.6989874243736267,
               'F3': [0.9771963953971863, -0.9669795632362366],
               'F4': 109,
               'F5': 0.3425378203392029,
               'F6': [18077, 32775]},
        'D4': [-1070, -25068],
        'D5': 0.9952906323856712},
 'A6': 3705462621,
 'A7': -0.14429152011871338,
 'A8': 478767566}

Вариант №5

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

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

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

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

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

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

(b'KFIFE\xd2\x96G?\xa5f)\xe7\xe7\x18}\xbf\x8f\xc8\xa3Z\x1b\x97\xa2'
 b'\x00\x00\x00\x96\xf6D\xbd)9yw\x034\xa1\xe9n\xc8\xee\xd0\xc8\xa2\x97\xd2@'
 b')S\xaf\xbe,\x1do?\x91N?\xbf\x8bp\xa8\xbd\x1f\xe4\xfa>\xd3\xeb{\x86'
 b'\x04\x00\x00\x00\x1f\x005\x18!y\xdb\x04w\x01\x00\x12.\x07\xf9T\x1fW\xbfh'
 b'\xe7\x11?\xbe\x07P\xbf\x03;0\xbf\xc2;h\xbf7\xbc.D\x03\x00\x00\x00N'
 b'\x00_\x02\x01Nb\xf0\xcd\xb3\xb6 y\x1fe{\x11|\xc7Cp\xda|\xab^3\x92v\xc3'
 b'\x8c\x81\xa2\x07Lh\x9enyQ#\x8e\xf3)/\x00\x00\x00Z\x00\x00\x00y\x00'
 b"\x03\x00\x00\x00\x8a\x00\x9c'\x17\xc0")

{'A1': 0.7796450853347778,
 'A2': 26277,
 'A3': -3994763800444672215,
 'A4': -1759815005,
 'A5': {'B1': [{'C1': 64,
                'C2': [-0.34243133664131165,
                       0.9340388774871826,
                       -0.7472925782203674,
                       -0.08224590867757797,
                       0.490021675825119],
                'C3': -2038699053,
                'C4': [2004433193, 3919655939, 3505309806, 3533152968]},
               {'C1': -7,
                'C2': [-0.8403217792510986,
                       0.5699372291564941,
                       -0.8126181364059448,
                       -0.6884004473686218,
                       -0.9071618318557739],
                'C3': 1143913527,
                'C4': [2032212021, 24577243, 120459776]}],
        'B2': {'D1': 12956276008020935263,
               'D2': 8374,
               'D3': 8057,
               'D4': 101,
               'D5': 3346796923},
        'B3': [10534868043976831043, 7515390272714097526, 3022916057237647006],
        'B4': -1072224356},
 'A6': -0.04808672517538071}

(b'KFIFE 8\t\xbe)\x18\xe0b2\xf9\\W\xde\xae\x8dF5-\xa2\x00\x00\x00\xb2 M\xbe\xb5'
 b"\xebo\xa8G\xff8\xbc\x95\xb4\x92\x0f7'\x84\xcf\xa2z\xd8\x15??<i\xbe"
 b'\x13?\xa8\xbdh\xc8{?)kY?\xb8\xb6N\x97\x04\x00\x00\x00\x1f\x00\x84\x1c'
 b'\xa9\xa6\x00\x84;\x1eR=UB\x9d\xf8\xb5\x11\x84\x93\xe9M\xe3\xe0c">\xef'
 b"\x13c\xbf\xdc\xc9\xb9\xbe\xe3\xd0%\xbf-M\x89>\x03'j\xef\x05\x00\x00\x00N"
 b'\x00\x9e\xfc;!4;&\xb6\x98\x98=\xfe~1\x9b\x8d/T}f\x93\x15\xf0S< \x1c'
 b'\x82P\xf5\x9c\x9fW/\x00\x00\x00b\x00\x00\x00\x81\x00\x02\x00\x00\x00'
 b'\x92\x008dHy')

{'A1': -0.1340031623840332,
 'A2': 6185,
 'A3': -5846139209450888480,
 'A4': 758466189,
 'A5': {'B1': [{'C1': -94,
                'C2': [0.5853344202041626,
                       -0.2277688831090927,
                       -0.08215155452489853,
                       0.9835267066955566,
                       0.8492913842201233],
                'C3': -1756449096,
                'C4': [2825907125, 3157851975, 261272725, 3481544503]},
               {'C1': -29,
                'C2': [0.1585841178894043,
                       -0.8870229125022888,
                       -0.36286818981170654,
                       -0.647718608379364,
                       0.2681669294834137],
                'C3': -278255869,
                'C4': [2796100740,
                       507216896,
                       1112882514,
                       297138333,
                       1307153284]}],
        'B2': {'D1': 13125243259099806878,
               'D2': 39064,
               'D3': -451,
               'D4': 126,
               'D5': 797809457},
        'B3': [4347082040800607572, 6313937780028349472],
        'B4': 2034787384},
 'A6': -0.2003200352191925}

Вариант №6

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

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

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

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

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

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

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

(b'HONR4\xec\x88f?k!H#O\xa9\xa0P\xfd\x85\xb3An\x06m\x83\xc0\xb7\xf2\x7fZ,\xbf'
 b'\x95:-?a\x00w\x00\xf4\x85\xa4Y\x82\xde{?\xf2\x813\x99<\xb4\xf7\xf0'
 b'\xed\x9b\x1e\xd2?\x13_\x01\xa4\x7f\x87\x0e\xea\x18@k\xe9\x02\x00\x00'
 b'\x00\x81\x00\xfb\x94s\x19\xcb\x8a\xa9\xd9\x1bZ/E\x8cABTw7\x05\x00W'
 b'\x00\x00\x00)\xc5x\x82\x83TbT\xad\xe0\xdf\xb2\x15<u\x81\x06\x00k\x00\x00'
 b'\x00\xcdZIl\xdf\xdeF\xd0\xdbO\x0b\x0e\xec\x00\xe0\xf0o\xbd\xa3n')

{'A1': 0.900526762008667,
 'A2': 8555,
 'A3': {'B1': {'C1': 9654961827117736776,
               'C2': -77,
               'C3': -957084725090554303,
               'C4': -0.6732558608055115},
        'B2': 0.6766751408576965,
        'B3': {'D1': [{'E1': [23067, 17711, 16780, 21570, 14199],
                       'E2': -2106014423},
                      {'E1': [21635, 21602, -8019, -19745, 15381, -32395],
                       'E2': 1816746701}],
               'D2': 1503954420,
               'D3': 0.9838639497756958,
               'D4': 2570289650,
               'D5': 60,
               'D6': 0.2831182311673459},
        'B4': 19,
        'B5': [95, 1, -92, 127, -121],
        'B6': -5618},
 'A4': -378847208,
 'A5': [1011990346785545951, 7972424053856141548],
 'A6': 15684219782204462331}

(b'HONR4k\xa9\xca\xbd\x0c\xaf\xdb\xb7\xbc\xf1\x0e\xe0\xd6\x08\xa9\xa8\xc9s\xab'
 b'\x17\x93~\x9d\x18\x80^\xbe\xf5<\x87\xbda\x00w\x00Zc\xa68\xec\xf5P?'
 b'\x1c\xe8)\xb8\xa4t\xeb\x02\x087\x88\xe3\xbfC\xd3\x81<<\x10\xda\xf3\xe8\x82C'
 b'$\x03\x00\x00\x00\x81\x00/\x8e\xdd&\xb0\xec\x1a\xd2\xec\x9e\xd3\xc7\x7f'
 b"6O.\x1c=\x05\x00W\x00\x00\x00\xe0\xb3\xb0'5\xf9\xa5mY~\xebA\x90[\x91\xd2\x06"
 b'\x00k\x00\x00\x00\xea\xfd\x93\x9b10\xff\xc8e?\xe0\x96O\xdc0]k\xa0 '
 b'\x85\xec>\xf9\t\x8a\xad\xf1e')

{'A1': -0.09895595163106918,
 'A2': 44812,
 'A3': {'B1': {'C1': 636942752109344731,
               'C2': -87,
               'C3': -7098074232819299928,
               'C4': -0.21728551387786865},
        'B2': -0.066034235060215,
        'B3': {'D1': [{'E1': [-24852, -14381, 13951, 11855, 15644],
                       'E2': 665891808},
                      {'E1': [-1739, 28069, 32345, 16875, 23440, -11631],
                       'E2': -1684800022}],
               'D2': 950428506,
               'D3': 0.8162524700164795,
               'D4': 3089754140,
               'D5': -92,
               'D6': -0.6103778034661063},
        'B4': 67,
        'B5': [-45, -127, 60, 60, 16],
        'B6': -3110},
 'A4': 608404200,
 'A5': [-7574984866840760271, -8853900484424967089, 7345843275602411244],
 'A6': 15139673338669796911}

Вариант №7

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

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

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

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

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

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

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

(b'\xe9OYQO2\x00=\x00H\x00S\x00^\x00$tijxsd\x00l\x00$\xe7\x14\x07Q\xb7Y:yc\x03'
 b'\x00t\x00\x00\x00w\x00\x00\x00\xc1\x9c\xff(\xc8-\x00\x00\x00\x9e\xb5'
 b'^\x834\xa3X8\x00\x00\x00\xb4\x05:` o\xe4C\x00\x00\x00\xe5\x12\xf5\xe6'
 b'\xa5\x85\xb6N\x00\x00\x00\xf7\x9a\x9e\xe6\xdc\x05\x07Y\x00\x00\x00\xba+'
 b'\np\xc4d\x08\xcdv{\x97\'G@"\xb7\x15\xe1\n\x1c\xc1$fZM\xa7pT;\xb9e\xa7\\')

{'A1': [{'B1': {'C1': 40129, 'C2': 10495, 'C3': -56}, 'B2': -19042},
        {'B1': {'C1': 33630, 'C2': -23756, 'C3': 88}, 'B2': 1460},
        {'B1': {'C1': 24634, 'C2': 28448, 'C3': -28}, 'B2': 4837},
        {'B1': {'C1': 59125, 'C2': -31323, 'C3': -74}, 'B2': -25865},
        {'B1': {'C1': 59038, 'C2': 1500, 'C3': 7}, 'B2': 11194}],
 'A2': 36,
 'A3': 'tijxs',
 'A4': [{'D1': 1690595338, 'D2': 2071383304},
        {'D1': 1078405015, 'D2': 3776296738}],
 'A5': [59172, 1812, 46929, 14937, 25465],
 'A6': [10, 28, -63],
 'A7': {'E1': 1297770020, 'E2': 6676416818838794407}}

(b'\xe9OYQO2\x00=\x00H\x00S\x00^\x00.bdgacd\x00l\x00\x11SLP\x9b\x10\x81'
 b'EK\xbb\x02\x00t\x00\x00\x00v\x00\x00\x00\xa8Vg\x84\xc2-\x00\x00\x00\xd9\xbd'
 b'L\xca\xea|\x148\x00\x00\x00T\xa2\xd5\xf8@\x1e\xb4C\x00\x00\x00\xaa!\x87\xf8'
 b'jh\x82N\x00\x00\x00\xd5\xc5J<l\xd1,Y\x00\x00\x00\xa3\xaem\xcc\xc3\xf0'
 b'TV\xfc\xe6\xb8\xd9g\xc3c\xcb\x8f\x89\x1fy\x0b\x9em\x06y\xbe.\x9f\xedQ'
 b'\x88\xe1')

{'A1': [{'B1': {'C1': 22184, 'C2': -31641, 'C3': -62}, 'B2': -16935},
        {'B1': {'C1': 51788, 'C2': 31978, 'C3': 20}, 'B2': -23980},
        {'B1': {'C1': 63701, 'C2': 7744, 'C3': -76}, 'B2': 8618},
        {'B1': {'C1': 63623, 'C2': 26730, 'C3': -126}, 'B2': -14891},
        {'B1': {'C1': 15434, 'C2': -11924, 'C3': 44}, 'B2': -20829}],
 'A2': 46,
 'A3': 'bdgac',
 'A4': [{'D1': -255603603, 'D2': 3875296852},
        {'D1': -1016604232, 'D2': 2307902307}],
 'A5': [21265, 20556, 4251, 17793, 47947],
 'A6': [31, 121],
 'A7': {'E1': 107847179, 'E2': -2195414737323377031}}

Вариант №8

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

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

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

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

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

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

(b'\xc3ZKCV?\xb8\x8d\xb7\r\x17~`\x00\x02\x00 \xce\x00\x03\x00"\x00\x00'
 b'\x008\xdaV\xed]g\x0bljS?\xd2\x10\xdftn\xe0&\xd5D(\xdc\x0f\xb1\xb7\x0f\xad'
 b'\x88\xbbI\xf1\x00\x02\x00\x00\x004\x9b\x08%\xf5\x1f]\x9f\x9c\xbf\xc6'
 b'~\xd7\xb9q\xed\xb0')

{'A1': 0.09591239995597212,
 'A2': {'B1': 'lj',
        'B2': 206,
        'B3': [{'C1': 1396691472, 'C2': 57204},
               {'C1': 1860183765, 'C2': 17448},
               {'C1': -602951241, 'C2': 4013}]},
 'A3': {'D1': [-30533, 18929],
        'D2': [-25848, 9717, 8029, -24676],
        'D3': -0.17574593119557624},
 'A4': -9642,
 'A5': 3982321419}

(b'\xc3ZKCV\xbf\xe4\xe2\xb1\xabu\x13\x00\x00\x03\x00 R\x00\x02\x00#\x00\x00'
 b'\x003\xabADC\x98\x0cdzl\xb4C\xde!\x97O\xbd{\xba%:W\xf7\xa3?\xb5\x00'
 b'\x02\x00\x00\x00/\x9e\xcc|\xb2P\xd6\xfec\xbf\xec#`=\xdd\x97D')

{'A1': -0.6526726101661495,
 'A2': {'B1': 'dzl',
        'B2': 82,
        'B3': [{'C1': -1270620639, 'C2': 38735},
               {'C1': -1115964891, 'C2': 14935}]},
 'A3': {'D1': [-2141, 16309],
        'D2': [-24884, 31922, 20694, -413],
        'D3': -0.8793183525383275},
 'A4': -21695,
 'A5': 1145280524}

Вариант №9

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

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

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

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

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

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

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

(b'\xe8JGJD?\xd6\xd5VGT\x00\x10(\xaf\xc8o\x98$\xa5\xaeh\x1a\xae\xae\x88"U'
 b'\xd2\xb5le\xe8-\xe8pajmxa\t\xd8?\xd4;\xe8\xa3\x85\x9fD?\xec\x1c\n\x93'
 b'\xb5\xee\x08\xb9\xbf\xda\xfc\xb5OaT\x0c\xd3\xbe\xb7P\x85T\x9f\x9dLklzkejb'
 b'd\x16o\xf8\x1d\xbf(\xb3\xae\x00\x00\x00\x02\x00\x00\x00\x8b\xbe\xb4k'
 b'S\xbd\x0e\x006\xbfx&z\x00\x03\x00e\x13\xa2m\xber\x19`\xbd\xecg6?w\x85\x8a'
 b'\x00\x03\x00x\x95\x9c\xe8\x00q\x00\x84')

{'A1': 0.35677105870854664,
 'A2': 682608751,
 'A3': {'B1': {'C1': 38948,
               'C2': 11938594126014875682,
               'C3': 6184204715503922664,
               'C4': 'pajmxa',
               'C5': 2520},
        'B2': 0.3161565396207957,
        'B3': 0.8784230122541326,
        'B4': -71,
        'B5': -0.4216740870663791},
 'A4': -742475952,
 'A5': {'D1': -123, 'D2': 1419746636, 'D3': 'klzkejbd', 'D4': 376436765},
 'A6': -0.6589916944503784,
 'A7': [{'E1': [-0.35238131880760193,
                -0.03466816991567612,
                -0.9693371057510376],
         'E2': 19,
         'E3': -23955},
        {'E1': [-0.23642492294311523, -0.11543123424053192, 0.9668813943862915],
         'E2': 149,
         'E3': -25368}]}

(b'\xe8JGJD?\xe4\x93[l8S\xa8Q\x0eJ\x1b\xd6\xbca5\x80y\xe2\x17\x00\xa6]'
 b'\x0f\xb4\x8b\xbdc\x91\xe7esmhwr\x98\xaa?\xdd|^\x8e\xdcg\x94\xbf'
 b'\xe5\xc9\xf8\xee\xcc\xe4\x1c\xe5\xbf\xe6\xa2\xc9\xd0\x0f!|8\xb9A\x9a'
 b'\x94`\x85Q\xe6sefwbrwh\xd1\x11\xbe\x8b?P\x1fC\x00\x00\x00\x02\x00\x00\x00'
 b'\x87\xbe\rI\x0c\xbe\xb4\xd9L>\x9a\xeaC\x00\x03\x00e\xa3$\x82\xbf\x15\xbe='
 b'\xbf@\x18w\x00\x02\x00x\x91\xe8\xda\x00q\x00\x80')

{'A1': 0.6429879296944039,
 'A2': 1359890971,
 'A3': {'B1': {'C1': 54972,
               'C2': 7004646056417231014,
               'C3': 6705776882448830951,
               'C4': 'esmhwr',
               'C5': -26454},
        'B2': 0.4607159037710684,
        'B3': -0.6809048332280585,
        'B4': -27,
        'B5': -0.7073716224340809},
 'A4': 951665050,
 'A5': {'D1': -108, 'D2': 1619349990, 'D3': 'sefwbrwh', 'D4': -787366261},
 'A6': 0.8129770159721375,
 'A7': [{'E1': [-0.13797396421432495, -0.3532203435897827, 0.3025685250759125],
         'E2': 163,
         'E3': 9346},
        {'E1': [-0.5849340558052063, -0.7503733038902283],
         'E2': 145,
         'E3': -5926}]}

Вариант №10

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

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

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

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

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

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

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

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

(b'\xf3BEFG\x00\x00\x00\x15\x00f\x00\x06\x00\x00\x00\x96\x00\x00\x00'
 b'\x9c\xd5\xfd2\xb3\xcf?\xce\xd6\xee\xf7\x01n\xa0\\2\x97\xa2\xec\xee'
 b'\x9d\x9bw\x93\x97Tr>E\xc4|?\x13\xda\x8c\xfe3\xca\xf5\x00m\xa1s;'
 b'\xb5\x05\x03\x86\xbfg3\x81\xbfe73\xa9\xa4I\xf6\x92\xee=\x1f\xdf$\xd3r'
 b"\x1b?Q\x01S=7\xbd7,M\x8a\x95qy\x00'\xdb\xd54\xafL\x00<\xf6\x0b\x00\x04"
 b'\xd0\x00Q\xbf\xb1\x0b*\xb8\xbe\n\x88\xd3?\x07~\x8b\xbe\x92\xce\x05>\x85\xf7-'
 b'c\xa7\xc7\x05\xd9\xc6\xfdU\xb4\x17\ndF\x97\xb6\xaf\xdd\x8e\x88\xac'
 b'\n\x0e\xefbdn\x95\xbd\x95\xb7\xfbu')

{'A1': {'B1': -704826701,
        'B2': -49,
        'B3': 0.24093424855060608,
        'B4': 1546819490,
        'B5': -20},
 'A2': {'C1': 121,
        'C2': [{'D1': {'E1': 61085,
                       'E2': 2608305047,
                       'E3': 21618,
                       'E4': [0.19313234090805054, 0.5775535106658936],
                       'E5': 254,
                       'E6': 868939008},
                'D2': 3688182959,
                'D3': 76},
               {'D1': {'E1': 28065,
                       'E2': 1933292805,
                       'E3': 902,
                       'E4': [-0.9031296372413635, -0.895373523235321],
                       'E5': 169,
                       'E6': 2756310674},
                'D2': 4127916036,
                'D3': -48},
               {'D1': {'E1': 60989,
                       'E2': 534717651,
                       'E3': 29211,
                       'E4': [0.8164264559745789, 0.0448581837117672],
                       'E5': 44,
                       'E6': 1300927857},
                'D2': 3216050986,
                'D3': -72}],
        'C3': [-0.1352875679731369,
               0.5292746424674988,
               -0.28672805428504944,
               0.2616514265537262],
        'C4': 7180926958808005973,
        'C5': 46103},
 'A3': [10, 100, 70, 151, 182, 175],
 'A4': {'F1': -2481896072150061214,
        'F2': 100,
        'F3': [110, -107, -67, -107, -73],
        'F4': -1163}}

(b'\xf3BEFG\x00\x00\x00\x15\x00f\x00\x04\x00\x00\x00\x96\x00\x00\x00'
 b'\x9a\xa2\x14#\x11\xb7?\xe3\xc9\x82s\xa0(\xe47\x12\x0f\xee8\xe2\x9e{\x81\xa0'
 b'\xbc:\xda>\xd7\xa8\x1a<`+!o\xb8Dj\x805\x11\xe5\x1a\xf9@\xcd\xa5>e\xf6U'
 b'\xbf\x01\xb6D\x1d\x1e\xa2\x90}[\xd3\x00\x9f\xd3\x96zv\xbe\xa4\xd1'
 b"h\xbe\x9c\x8b\x10\xfb\xc7\xad(\x8f\xcb\x00'Q9\xaez\xc5\x00<\t\x1d>*"
 b'\xa7\x00Q\x80\xfd\xe4i,>\xc7\x8c\xaa>\xb5w\xde=\xe8\xf2\xfb\xbfDG\xe7'
 b".\x1c\x07\xec\x1c\xb1\x88\xbaO\x0eV\x1cc\xf49\x11uP'b\xe6D\xa8\xa2"
 b'o\xea\xdf\x02Zv')

{'A1': {'B1': -1575738607,
        'B2': -73,
        'B3': 0.618348337012574,
        'B4': 923930606,
        'B5': 56},
 'A2': {'C1': 203,
        'C2': [{'D1': {'E1': 58014,
                       'E2': 2072092860,
                       'E3': 15066,
                       'E4': [0.4212043881416321, 0.01368215773254633],
                       'E5': 111,
                       'E6': 3091491456},
                'D2': 1362734714,
                'D3': -59},
               {'D1': {'E1': 13585,
                       'E2': 3843750208,
                       'E3': -12891,
                       'E4': [0.22457249462604523, -0.5066874027252197],
                       'E5': 29,
                       'E6': 513970301},
                'D2': 152911402,
                'D3': -89},
               {'D1': {'E1': 23507,
                       'E2': 10474390,
                       'E3': 31350,
                       'E4': [-0.32191014289855957, -0.30574846267700195],
                       'E5': 251,
                       'E6': 3350014095},
                'D2': 2164122729,
                'D3': 44}],
        'C3': [0.3897450566291809,
               0.3544301390647888,
               0.11374469846487045,
               -0.7667221426963806],
        'C4': 3322539335767656634,
        'C5': 20238},
 'A3': [86, 28, 99, 244],
 'A4': {'F1': 4112196921884599876,
        'F2': 168,
        'F3': [-94, 111, -22, -33, 2],
        'F4': 23158}}

Вариант №11

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

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

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

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

(b'GATH\xaa\x93\xac\x042\xac\x1d=\x03\x00k\x00\x00\x00kcn\x7fx\x1e\x0f\x0e\xaeP'
 b'MCC~Ee\xa6\x0e|\xcd\xe09\xbf\x04\xae7DT\x91sh\xaa\xc0}\x8e\xc04J:<\xe5\xbf'
 b'\x03\x00\x00\x00w\x00J\xf0\x88\xb4\xecj\xe2\xbf\x1d2\x17v\x8d\xa4'
 b'\xe1H\x91\x18\xfb\xea\x1a\xbd\t\xc7Kc\x08\x069>Q\x08\xfd\x94U\x19m\x87yzrJ'
 b'\x00\x00\x00U\x00\x00\x00`\x00\x00\x00\xc9n\xa5')

{'A1': 78418858,
 'A2': 0.0384942963719368,
 'A3': [{'B1': 29, 'B2': 5938, 'B3': -353372828539253386},
        {'B1': -22, 'B2': 48410, 'B3': 4483621537119454985},
        {'B1': 81, 'B2': 64776, 'B3': 8249039290040407444}],
 'A4': {'C1': 'kcn',
        'C2': {'D1': 127, 'D2': [7800, 3599, 20654, 17229, 32323, 25925, 3750]},
        'C3': 124,
        'C4': -0.726086437702179,
        'C5': 44548,
        'C6': -4563720426817829833},
 'A5': {'E1': 125,
        'E2': -0.6636020135247394,
        'E3': [201, 110, 165],
        'E4': -0.5755523229668225}}

(b'GATH*\xf7\xf8G\xeel\x04?\x03\x00k\x00\x00\x00mle\x8c\\G)\xfc\x1dWA\xca#\xa6'
 b'\x8f\xe7\xad=\x10\x11\xe7\x9c\xbe\xd8\xd2\xf5y@\x1ft\xf6 \xa7\x8f\x10\xa8+:'
 b'\xf0\x11\xc5?\x03\x00\x00\x00w\x00H\x05o\xde\xfc0\xd0?\x96\xbde6\x8d\xbe'
 b'\x1d\xb0\xa2\x00HB.X\xc9YP#JT\x8f\x8a\r}J\x05\xbcR\xe1\xf0\x88\xadqJ'
 b'\x00\x00\x00U\x00\x00\x00`\x00\x00\x00\n\x12\xc5')

{'A1': 1207498538,
 'A2': 0.5172871351242065,
 'A3': [{'B1': -106, 'B2': 26045, 'B3': 5188325648027782454},
        {'B1': 66, 'B2': 22574, 'B3': -8462452497409091127},
        {'B1': 13, 'B2': 19069, 'B3': 8191353865410624517}],
 'A4': {'C1': 'mle',
        'C2': {'D1': -116,
               'D2': [18268, -983, 22301, -13759, -23005, -6257, 15789]},
        'C3': 16,
        'C4': -0.30645039677619934,
        'C5': 53976,
        'C6': -6403847691519886859},
 'A5': {'E1': -113,
        'E2': 0.16460993614538255,
        'E3': [10, 18, 197],
        'E4': 0.25298997613943586}}

Вариант №12

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

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

(b'YJLW,}\x9f\xb0\xe9\xae1\xaf7\x00\x00\x00&\xad \xee\xca\x88\xed!f\x00\x00\x00'
 b'\x81\x00\x00\x00\x9c\x00\x00\x00jqrbtzc\xb7\xec\xcc\x9bY?\xc3m\xccwll$'
 b'\x00b\x9c\xdf/q\xc5\x92\xc7SP\x1a\xc3\xe6\x8e\xa0/#Y?\xda\xebz\xb1'
 b'\x83w\x03\x00\x00\x004\x00\x00\x00\x941\x8c\xe6\xe0\xe0\xb3\xfax\xbf'
 b'\xa0D\x84\xd4e8aT\x03\x00Z\x00b\x11\xb2KHl\xbav\xf0\x86\xfb(\x10y\xb5\x10'
 b'\x81 \xb8\xc0\xe7h\n\x02\x00y\x00Pj\xf0E7\x96u \x97^\x94\xf6\x9d\xa2~\xcf@'
 b'\x0b\xd0\xe8\x04O\xa8\x02\x00\x94\x00\xafK|\x147\xe7\x13<>')

{'A1': 3580055698605419607,
 'A2': -81,
 'A3': {'B1': {'C1': 106,
               'C2': 'qrbtzc',
               'C3': 183,
               'C4': 14730644633052499180},
        'B2': 14380773650072575074,
        'B3': 3431900037823221843,
        'B4': -8957243030465717981,
        'B5': 119,
        'B6': 'wll'},
 'A4': 2444760577891937574,
 'A5': [{'D1': 946197636,
         'D2': 21601,
         'D3': [-427019884, -88874784, 1151385464],
         'D4': 8555269499907084642,
         'D5': 240},
        {'D1': 3888166944,
         'D2': 2664,
         'D3': [271121286, -2129611399],
         'D4': 2338940745629592144,
         'D5': 151},
        {'D1': 82366475,
         'D2': 43087,
         'D3': [-1644784546, 1087340194],
         'D4': 4329057890586086319,
         'D5': 62}]}

(b'YJL\x07\xf4\xb1\xdcKy{\xc8h7\x00\x00\x00\xeb0C1\n_\xe2[f\x00\x00\x00'
 b'\x85\x00\x00\x00\xa0\x00\x00\x00ryplhpkyO\xb5IYD!\xca\xc6wuf$\x00\xea5h'
 b'\x9do\xe9D\xf4\x18)\x05{#]\xc7\x18Qi\x99\rw\xa2B\xa2\xc5\x03\x00'
 b'\x00\x004\x00\x00\x00q6\xa2=\x9c\x03\x02\x85l3\xd8\x83\xf6\x8b\xd8`\x0b\xd2'
 b"\x03\x00Z\x00\x94\xc4\xb9\xe5\xe2\x83\xc1s6l'\rk\x81\x17K]\xa1v\xce"
 b'\xda\x1b\xcfN\xe2\xc1\xf5\x03\x00y\x00+\xe7\xcf\xf5\xfbI_Sv\xc3~\x99\xea'
 b'\x93`\xfbd&\xfei\xc4\xf9/\x02\x00\x98\x00w\xa0\xae&\xcc\xa4\xe6\x8e2')

{'A1': -4000470477256395769,
 'A2': 104,
 'A3': {'B1': {'C1': 114,
               'C2': 'yplhpk',
               'C3': 121,
               'C4': 14324298142244779343},
        'B2': 17601449909262235114,
        'B3': 1785498184244865304,
        'B4': -6754657858889356975,
        'B5': 197,
        'B6': 'wuf'},
 'A4': 6620958899568849131,
 'A5': [{'D1': 1624804342,
         'D2': 53771,
         'D3': [1034040945, -2063465572, -2082983060],
         'D4': 8341092995406873748,
         'D5': 54},
        {'D1': 3796815643,
         'D2': 62913,
         'D3': [1796024172, 1565202305, -624003423],
         'D4': 6007601774445193003,
         'D5': 118},
        {'D1': 3295280678,
         'D2': 12281,
         'D3': [-359039293, 1694195859],
         'D4': -8149645278951071625,
         'D5': 50}]}

Вариант №13

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

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

(b'NYSJ\x0b8\xbb>.>#\x00\x00\x00\xdc")\x00\x00\x00{\x00\x00\x00\x8f)D^\x8f3>5'
 b'&\xf0C\xeb\\\xce\x82\xf6\x94T\xd1 5\xea\xa8\xe0\xb6\xa0\xcf\xfc\xb9\xe7\xd0i'
 b'\x97\xc1Zc\x018\xc1VO\xab\xbf\xda\xbf\xc0\xeay\xd9g\x1b\xd3? \xc9U'
 b'E\xb2\xa8\xa2\xbf,\xd1\x13q\xda\x8e\xed\xbf\xc8k\xd6\x90w(\xe8?\xe5\xec\xf9'
 b'g\x992\x19CO\xec\x12\xa0-\xf81\xf2\x1fcY\xcf\xa8\xceM\xf5c\xb5L6\x1e\x03\xc3'
 b"{\x1f\x8ft7x\xe4/\x00\xdb\x13\xa4\x90r455}B'\xc7\x8eP\x8b\xfcJC\xb1\xf0Fbi"
 b'\xa7\x9f:\xe0')

{'A1': 0.36566194891929626,
 'A2': [{'B1': 15918, 'B2': {'C1': 23787, 'C2': 2499183310}},
        {'B1': 8924, 'B2': {'C1': -11948, 'C2': 2833921312}}],
 'A3': {'D1': {'E1': [3043226957, 52311628, 2401205187, 3833083764],
               'E2': {'F1': -3393539298734065952,
                      'F2': 1522636649,
                      'F3': 355,
                      'F4': [-0.41794855831087174,
                             0.2985477088729276,
                             -0.03644330116630301,
                             -0.9236881454985784,
                             0.7549398259028459],
                      'F5': 1744432357,
                      'F6': -6912202652887993703,
                      'F7': [63533, 62001, 25375, 53081, 52904]},
               'E3': -1868295205,
               'E4': 892679282,
               'E5': 125,
               'E6': {'G1': 10050, 'G2': -5673608657027166521},
               'E7': -2289341919188072720},
        'D2': 143,
        'D3': 17449},
 'A4': 4895454805070417758}

(b'NYSJxjq\xbf\xa4~#\x00\x00\x00v1)\x00\x00\x00{\x00\x00\x00\xd8m\x92\x80'
 b'\xe7\xea&\x82\rX\xe5\x88\xdby\xd7\x8c\xdc\xee1mA\x96\xad\xe2\xe1\xcd\xa7\x84'
 b'\x86N\xcf\x93\xd5re\x99\x9eF\x80\x83\xce\x8f\xf0\xeb?.)e\xe2S\x01\xef'
 b'\xbf\xa0b`\xf7H\xbb\xe7\xbf\xc8\x9at\x9d\x98\xec\xdd?\xca"Y\xae\xe18\xe3'
 b'\xbfwO\x9c)\xe9\x16}O\xe3B\xfd\xff\x8a$\xef\x13j|\xe3\x95d\xef\xa0n\xc4I)'
 b'\xd3\xf5a\x87\x80y\xc3\xf0\xf8.\xfd/\x00\xcd\xa1X3\xc9G\xba\xf0}s\x8e'
 b'\x041X\x10\xa9}8\xe7\xb9\xfe\x12\xd3\xf7\xaa\xe2+')

{'A1': -0.943030834197998,
 'A2': [{'B1': 32420, 'B2': {'C1': -9336, 'C2': 3700217721}},
        {'B1': 12662, 'B2': {'C1': 12782, 'C2': 2912305517}}],
 'A3': {'D1': {'E1': [1237610144, 1643500329, 3279519879, 4247714032],
               'E2': {'F1': -3508719155365944862,
                      'F2': 1702024595,
                      'F3': 40601,
                      'F4': [0.87311544737532,
                             -0.9689120694904767,
                             -0.7416119414875375,
                             0.46756568314087277,
                             -0.6006935506094007],
                      'F5': 698109815,
                      'F6': -770880871524631,
                      'F7': [9354, 5103, 31850, 38371, 61284]},
               'E3': 861446605,
               'E4': 4038739913,
               'E5': 125,
               'E6': {'G1': -29069, 'G2': -1785539087175241468},
               'E7': 3162277869742390969},
        'D2': 216,
        'D3': -28051},
 'A4': 16525973685285873536}

Вариант №14

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

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

(b'SYMP\xcc\x00"sbla\x00\x90\xb9>\xad\xbaV\xbf\xe8\x13\xc73\xbc\x88r2\xdf'
 b'\xdc\xea\x98(H\xb6N\x98Q\x1fhb\x96U|\x7f\x01\x92w\xe0\xfa=\xbf\xe0'
 b'\x19\x14\x87\x17\xfe\xf8\xff\xbf?\xef\xd8\xc1\x9cL\x8d\xe2\xdb\x07]\xa8'
 b'\xd0\xbf\xea7\xe9\x15\x12>\xf8?\x17?\xc3\xea\x9bJQ\t p$\xc3\xa9M?\xec>\xde'
 b'\xe0E\xa0\xcaP\x8e\xbf\xec?\xd3\xcc\x10\xf5\xba:\x80H\x91\xe4?\xd1"s\x08'
 b'\xf8K4w\x99\xbf\xcf@G\xb7G\xcd\xc8U\xf3Ek\xa0\x85\xc8\xbe\x0f\x89\xeb'
 b'\x002\x00I\x00`\x00w\xdb\x926y\x00\x02\x00\x8e\x7f\x05\x91\x1c\x7fS2X')

{'A1': {'B1': 5663365726755526229, 'B2': 8970890711333403197},
 'A2': 'sbla',
 'A3': {'C1': -0.14017455279827118,
        'C2': [{'D1': -0.5030615461873529,
                'D2': -65,
                'D3': 0.9952095082011818,
                'D4': [-37, 7],
                'D5': 93,
                'D6': -22320},
               {'D1': -0.8193250094936664,
                'D2': 16151,
                'D3': 0.1555971253274686,
                'D4': [112, 36],
                'D5': 195,
                'D6': -22195},
               {'D1': 0.8826746349632455,
                'D2': 20622,
                'D3': -0.8827914224308906,
                'D4': [58, -128],
                'D5': 72,
                'D6': -28188},
               {'D1': 0.2677276218029647,
                'D2': 30617,
                'D3': -0.2441491742061841,
                'D4': [85, -13],
                'D5': 69,
                'D6': 27552}],
        'C3': -37,
        'C4': {'E1': -28106,
               'E2': 121,
               'E3': [133, 200],
               'E4': 2131071260,
               'E5': 2136158808}},
 'A4': 185,
 'A5': 0.33931225538253784,
 'A6': -0.7524143228986431,
 'A7': 853531882,
 'A8': -1742190410}

(b'SYMP\xcc\x00"fzwe\x00\x90\x82>\xbe\x03x\xbf\xbe\xea\xfb\x0804\xa0b\x9a'
 b'\xfd\xd8S@#S\xdb7\xb4\xd9\xb0\xa2y\xf1\xe2abA\xc8\x88O\xba?\xea'
 b'\xe8\x08\x12\x93P\xc8l@?\xb7\xe3\x08\xf6H\x03\x00\xab\xb5Es:?\xdd\n'
 b'\x91D\x8d\xac(\xf7"\xbf\xdd\x06\xc6\x19\xad\xec\x1c\x83>\xe4\xa7\xcf'
 b'?\xc8\xc7<\x14\xe70\xc0Z"\xbf\xc2\x0efR\xdaa({\xd2,T|?\xea\x0ep\xe6'
 b'\xc9\xb0\xf2\x174?\xe3\xdf\xecM\xe4\xd8:\xfeb\xeb\r\xdcK\xc9?c\xf46'
 b'\x002\x00I\x00`\x00wG\xfe\xb2T\x00\x02\x00\x8e\r\x7f\x06\x9eq\x01nZ')

{'A1': {'B1': -2650451008619906575, 'B2': 16312427359989419962},
 'A2': 'fzwe',
 'A3': {'C1': 0.8904451131820679,
        'C2': [{'D1': 0.84082416179674,
                'D2': 27712,
                'D3': 0.09330802929617832,
                'D4': [-85, -75],
                'D5': 69,
                'D6': 29498},
               {'D1': 0.4537699861018063,
                'D2': -2270,
                'D3': -0.4535384417319521,
                'D4': [-125, 62],
                'D5': 228,
                'D6': -22577},
               {'D1': 0.19358016033800673,
                'D2': 23074,
                'D3': -0.14106444402273977,
                'D4': [123, -46],
                'D5': 44,
                'D6': 21628},
               {'D1': 0.8142628200125996,
                'D2': 5940,
                'D3': 0.6210843583455763,
                'D4': [-2, 98],
                'D5': 235,
                'D6': 3548}],
        'C3': 71,
        'C4': {'E1': -334,
               'E2': 84,
               'E3': [75, 201],
               'E4': 226428574,
               'E5': 1895919194}},
 'A4': 130,
 'A5': 0.3711202144622803,
 'A6': -0.12077301931295148,
 'A7': 1654324696,
 'A8': 1396712275}

Вариант №15

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

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

(b'GJYt\x00L\xea$*B\xf4\xff:\xe6\x94\xd2ar\x02e\xbb\x15\x08M\xc5C\x00;'
 b'\xb9\xd2B\x0b\xcaD\x97\x9c\xe0?k6\xc9>,VW\x8f\x94\x1cv\x04!Pa>\x08oF<KD'
 b'\xbf<\xe7n\xa9D\x14\x9b\x17\x00\x00\x00*\x00\x00\x00d\x84\xefV\xb4\xa0J\x9b'
 b'\xd0\x9c\x0c\xd9\xd7y\x07\x00=\x00\x00\x00\xa5\xba9!\xe8~\xbf\x17\xc7;\xd8?'
 b'\x98\xf3\x0c\x97\xfc\x18\xf7\x01\x85"\xfa\xa23\xdeq\xd6\x93*\x14\xa3'
 b'\xf8!D\x00')

{'A1': {'B1': 8837,
        'B2': 3068031555717014266,
        'B3': 569942804,
        'B4': {'C1': [{'D1': 77,
                       'D2': 989873093,
                       'D3': 188928697,
                       'D4': [-54, 68, -105, -100, -32, 63],
                       'D5': 0.392993301153183},
                      {'D1': 44,
                       'D2': 2492421974,
                       'D3': 553940508,
                       'D4': [80, 97, 62, 8, 111, 70],
                       'D5': -0.766772985458374}],
               'C2': [100, 132, 239, 86, 180, 160],
               'C3': 8779724646775823178,
               'C4': [60, -25, 110, -87, 68, 20, -101],
               'C5': 557431461,
               'C6': 0.3786485416330678,
               'C7': 141609386430493592}},
 'A2': [707062348, 989852738, 1641190630, -1151008142],
 'A3': 2069}

(b'GJYq\x00\xd7\xa17K\xf6\x81\x05\xa4\x90\x00\xd6\x16-(\xc3<e0L\xbd\xbd\t?'
 b'\xe5C\xd3j3\xa9~\x1b\xcf\xa4\x8b\xd4 =n\x83\xc6 }\xcc\xf5\x91i\x99\xc5\xcan-'
 b'\xcb4\xc7\xa3=\xfe\x83{\xee\x17\x00\x00\x00*\x00\x00\x00\x9e0_\xcfc\xd5\xef'
 b'\x0f\xf3\xe7\xf9\xce\xddE\x04\x00=\x00\x00\x00\xec\x86\xaa\xef\xcc\xe9a'
 b'&O\x92\xd7?\x00:H\x8e\x05#\xee\x17 \xc8*%#\xd7\xc8/\x83\xe3S\xfd\\gA\x00')

{'A1': {'B1': 51232,
        'B2': 16393999608208106794,
        'B3': 1734147411,
        'B4': {'C1': [{'D1': 76,
                       'D2': 1057603005,
                       'D3': 1792230373,
                       'D4': [51, -87, 126, 27, -49, -92],
                       'D5': 0.03926519677042961},
                      {'D1': 110,
                       'D2': 2099299971,
                       'D3': 1771173324,
                       'D4': [-103, -59, -54, 110, 45, -53],
                       'D5': 0.07996979355812073}],
               'C2': [158, 48, 95, 207, 99, 213],
               'C3': 5034407531203727343,
               'C4': [-2, -125, 123, -18],
               'C5': -274037012,
               'C6': 0.36830500362671326,
               'C7': 1724354214098385408}},
 'A2': [1261937111, -1543142922, 383123600, 1019422765],
 'A3': 12389}

Вариант №16

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

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

(b"HEZJ\x0f\x00\x04\x00\x00\x00t/\x88\xd9\xefA\x05\xb3&[\xff2;\xd4\x93'}D"
 b'n\xc31\x03>L\xd0\xf8,\xa1al3}\xf8\xa4\x19\x91x\xbbf&\xf1\xd4V\x9b\xf3\xf8'
 b'\x0fUZ\xa0\xb2\xedo\\F\x83v\xc2\x00\x00\x00\x84xU\x80\x94p\x81/\x8a'
 b'&\xfc\x91q\xfe\xee\xff\x066\x07\xb5O\xfc\x95\x17\xbe\xbd\x88\x0b\xe9Q!Z\xbd'
 b' \x07!\xa3\x00\x05\x00\x00\x00\x98\x96>yvgf\xbe\x06\xd6\x0c\xbe1\xddN>\xe4?O'
 b'\xd3\xc7\xc0\x1b\x11V\x01\xfd\xfd\xd3\x81|\x1b\xd3\x00\x00\x00\x03\x00x'
 b'4\x8dq\x165\x0b\xe5>\xe0\x1b')

{'A1': 'yvgf',
 'A2': [{'B1': 12168,
         'B2': {'C1': 217,
                'C2': 4014015923,
                'C3': 9819,
                'C4': -206,
                'C5': 15316}},
        {'B1': -27865,
         'B2': {'C1': 125,
                'C2': 1148109617,
                'C3': 830,
                'C4': 19664,
                'C5': -2004}},
        {'B1': -24223,
         'B2': {'C1': 108,
                'C2': 863893668,
                'C3': 6545,
                'C4': 30907,
                'C5': 26150}},
        {'B1': -3628,
         'B2': {'C1': 86,
                'C2': 2616457231,
                'C3': 21850,
                'C4': -24398,
                'C5': -4753}}],
 'A3': 92,
 'A4': 1183020738,
 'A5': {'D1': {'E1': -11321,
               'E2': -4604067132957917741,
               'E3': 2172394451,
               'E4': [-0.13167589902877808,
                      -0.17369577288627625,
                      0.4457955062389374]},
        'D2': [120, 85, 128, 148, 112],
        'D3': -9137933218860666370,
        'D4': 61183,
        'D5': 447553688282371351,
        'D6': {'F1': -0.37017855048179626,
               'F2': -380559014,
               'F3': -1121974495,
               'F4': -93,
               'F5': [13453, 28950, 13579, 58686, 57371]},
        'D7': 150},
 'A6': 62}

(b'HEZJ\x0f\x00\x03\x00\x00\x00t\xd2\x1bG\xc6SM\xa9\xaeg\xe8\x9f\x9f\xe5'
 b"\x13f\x1d\xd1O\xc6J\xf5e\xa8\xe0\xd4\xe4\xe8\xf9\xc8'\x0c\xb4\xd6\\\x89\xd7}"
 b'\xac\xb3\xc9\xee\xe2?p\xda\x13cJ\xa1\x9c\x97\xb1wwj\x07O\x00\x00\x00\x8b'
 b"g\xf2\x13:\x9d\x0e\xa0\xa5\xed\x81\x02D\xbe\xe9\x89'h\xa5\x16\xdd"
 b'\x8b\xd0\xef\xbe\x81\xb7&\xfa1\x16\x85bS\xa9qI\x00\x07\x00\x00\x00\x9f.Gtuy?'
 b'\x0eB\x8b>\x14\xca\x1c?H\\\xa5>.R;>\x8a\xf0AY:/\xf2\xc0\xa52\xfe1}\xf9=\x83'
 b'@\x00\x00\x00\x05\x00w1\x02\x9c\xbah\xbci\x03}\xcc\xd2a\x00\x0b')

{'A1': 'tuy',
 'A2': [{'B1': -11749,
         'B2': {'C1': 71,
                'C2': 3327348137,
                'C3': -20889,
                'C4': -5985,
                'C5': -24603}},
        {'B1': 4966,
         'B2': {'C1': 29,
                'C2': 3511666250,
                'C3': -2715,
                'C4': -22304,
                'C5': -11036}},
        {'B1': -5895,
         'B2': {'C1': 200,
                'C2': 655144150,
                'C3': 23689,
                'C4': -10371,
                'C5': -21325}},
        {'B1': -13842,
         'B2': {'C1': 226,
                'C2': 1064360467,
                'C3': 25418,
                'C4': -24164,
                'C5': -26703}}],
 'A3': 119,
 'A4': 2003437391,
 'A5': {'D1': {'E1': 22842,
               'E2': 3455035679904248189,
               'E3': 4181558080,
               'E4': [0.5557028651237488,
                      0.14530223608016968,
                      0.7826636433601379,
                      0.1702355593442917,
                      0.2713642418384552]},
        'D2': [103, 242, 19, 58, 157],
        'D3': 1054024752294937790,
        'D4': 59785,
        'D5': 2839701082681889007,
        'D6': {'F1': -0.2533504366874695,
               'F2': -97446267,
               'F3': 1649650033,
               'F4': 73,
               'F5': [12546, 40122, 26812, 26883, 32204, 53857, 11]},
        'D7': 46},
 'A6': 71}

Вариант №17

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

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

(b'MFGP\xf4 \x00\x00\x00\xa0b;]\xb8\x04\xb9\x8a\xfd\xa9\xd8\x97\x00c?6\xfbY?'
 b'j\x1c\xd2\xaa\xe5?\xa4\xf8\x969\x12\xa5\xed\x1b?U\xa5\xb5\xbf\x1b'
 b'\x82q\xd7\x17|\xa29\x1d\xd3\xe8qI\nB\xb3\xd3a\xea\xd9\xf3\x00\x00\x00\x05'
 b'\x00\x00\x002Ij\xbf]o{>\xc5U\xcd\xab\xe1s(\xfc2\x10\xf7\x9b:\xcc\xb4\xdc\xc6'
 b'\xc4\x00\x00\x00\x02\x00\x00\x00V\x96t\xbb=\xb3\xd9\xbe\xb0\xb1\x8b\x06'
 b'tY\xd4\xcf\x96\x9bXP\xb9\x04\x84U92\x00\x00\x00\x02\x00\x00\x00w\xd5:'
 b'<1\x8d\xf0\xbe\x88\n\x06\xe0\xb7\xd8\x02\xe6\xd8\xb2\x8f\x8d\xad\x00\x02'
 b'\x00\x00\x00\x0c\xd6\x00\x00\x007\x00\x00\x00X\x00\x00\x00y\x00\x00\x00'
 b'\x02\x00\x00\x00\x98?\xe9nJ\x17\xa9\xbbN\xda')

{'A1': -3040,
 'A2': {'B1': -29267,
        'B2': [{'C1': 6753152836189399512,
                'C2': -26880,
                'C3': 99,
                'C4': 0.7147727608680725,
                'C5': 0.9145022630691528},
               {'C1': -6132425339817281262,
                'C2': -23059,
                'C3': 27,
                'C4': 0.8345597386360168,
                'C5': -0.6074591279029846}],
        'B3': 214,
        'B4': [{'D1': 500426865,
                'D2': 73,
                'D3': 739351009304435187,
                'D4': [-41, 23, 124, -94, 57],
                'D5': 18794,
                'D6': -0.8649823069572449,
                'D7': 0.3854202330112457},
               {'D1': 1932065842,
                'D2': 16,
                'D3': 17841918999640458948,
                'D4': [-85, -31],
                'D5': -27020,
                'D6': -0.002894630888476968,
                'D7': -0.34510454535484314},
               {'D1': 1507118998,
                'D2': 155,
                'D3': 6363789702525696306,
                'D4': [6, 116],
                'D5': -10950,
                'D6': 0.010837063193321228,
                'D7': -0.2657014727592468}],
        'B5': [-524822526, -422006129],
        'B6': 0.7947130644005058,
        'B7': -38},
 'A3': 25147}

(b'MFGP\x94P\x00\x00\x00\xa3\xca\xeb=p}\x16\xbdmM\xba\xfekH\xbe\\\x121?'
 b"\x03\xb1\xa9\xb5\x93\x18\x94\xb6\x84\xbd7\t\xcft\xbf1'\x9e?\x0b+zY\xd4"
 b'\xf4\xd6\x13\xcc\x9a\xa2\xdf\x1f\x9f\x1a\x05\xc3\xc6\xd0\x19\x14'
 b"\x00\x00\x00\x05\x00\x00\x002\x862\xbf5\x14u\xbe\xfd3%\xff'\xbe\xcc\xd7\xed"
 b'\x8e\x1f\xda\xb9X\xb0,c\x90\x00\x00\x00\x02\x00\x00\x00V\x1cE\xbfu\x04\xf7>'
 b'\xf9\xc4\xabVq\xe7\x8eZ\xd3B\xf0\xed\xc9\xc8J)\xe2\xcev\x9e/\x00\x00\x00'
 b'\x05\x00\x00\x00wSw?z"\xd3\xbe\x94N\x19pVz6\xb96h\xdfN\xaa\x00\x02\x00'
 b'\x00\x00\x0c3\x00\x00\x007\x00\x00\x00X\x00\x00\x00|\x00\x00\x00\x02'
 b"\x00\x00\x00\x9b?\xef'\x89\xc1\xcez\n\xd0")

{'A1': -27568,
 'A2': {'B1': 20138,
        'B2': [{'C1': 4427175970326007226,
                'C2': -405,
                'C3': 72,
                'C4': -0.21491314470767975,
                'C5': 0.5144296288490295},
               {'C1': -5362915704271749833,
                'C2': 2511,
                'C3': 116,
                'C4': -0.692010760307312,
                'C5': 0.5436321496963501}],
        'B3': 51,
        'B4': [{'D1': -862280993,
                'D2': 31,
                'D3': 11464482139837307156,
                'D4': [89, -44, -12, -42, 19],
                'D5': -31182,
                'D6': -0.7073433995246887,
                'D7': -0.4945308268070221},
               {'D1': -1093871635,
                'D2': 142,
                'D3': 2295350750662648720,
                'D4': [-1, 39],
                'D5': 7237,
                'D6': -0.9571070075035095,
                'D7': 0.4878285825252533},
               {'D1': -750587667,
                'D2': 201,
                'D3': 14432394009965403695,
                'D4': [86, 113, -25, -114, 90],
                'D5': 21367,
                'D6': 0.9770938754081726,
                'D7': -0.2896583378314972}],
        'B5': [1884715574, -1187616545],
        'B6': 0.9735764298710035,
        'B7': -48},
 'A3': -13589}

Вариант №18

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

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

(b'SFMZd\xf5\xd0\x00\x00\x00k\xbf>\x7fb\x1a\x89V\x00\x00\x02\x00\x83\x00'
 b'\x04\x00\x8d\x00\x02\x00\x00\x00\x95:F\xfc*\xd7k?\xf1\x08]i\xb9\xb4\xa7\x16'
 b'\x8a\x01\xdd\xbc\xae\x95\x11\xf9\x02\x1b\x92\xfc\x90\x90)\xf9\x9b\xbb0\x8a'
 b'\xca\xca$\x07\x1fP\x17\xdfO\xf2\xf1\xff\xd0\xa0Hj\x00\x00\x00!'
 b'\x00\x02\x00\x00\x00@v\x10[s-\xe0\x01+\xbd\xf0\xf3S\xcbn\x00\x00\x00H'
 b'\x00\x00\x00^\xed\xcd\xd6\x84\xe3\xa7/D\x8c\x08\xa8\xa6\xd3\x9d\xf9>'
 b'\xdaj\x18\x1d\xbd\x08\x9e.[\xce\xcea\xf4\xe5\xaf\x9d\x8d\xea\xd5\xf2'
 b'\xd3\x1a\x9fMV\x1d\x91\x91\xe4\x93QF\x11')

{'A1': 62928,
 'A2': {'B1': 110,
        'B2': {'C1': 2256329661199086079,
               'C2': 3500165226,
               'C3': {'D1': 977730602,
                      'D2': 3614130161,
                      'D3': 2141,
                      'D4': 105,
                      'D5': 13381504108071083452,
                      'D6': [44693, 4601, 539, 37628, 37008, 10745]},
               'C4': [-1682231158, -892722169]},
        'B3': {'E1': 8507400246351888683, 'E2': 3186684755, 'E3': -53},
        'B4': {'F1': -305277308, 'F2': 16404132139173980326},
        'B5': 54173,
        'B6': -7},
 'A3': -0.7441312074661255,
 'A4': 445208064,
 'A5': [{'G1': 0.4265906810760498, 'G2': 29},
        {'G1': -0.03335397690534592, 'G2': 91}],
 'A6': [-12594, 25076, -6737, -25203],
 'A7': [-1525045910296375978, 2130644509633103377]}

(b'SFMZd\t\n\x00\x00\x00w\xbf\x08\x9f;^\xdd\xab\x8a\x00\x02\x00\x8f\x00'
 b'\x03\x00\x99\x00\x02\x00\x00\x00\x9f\x0b\xd4\x18\xc7\xaf\xc2\x04\x97j\xd0#'
 b'6\xcb\x05\x02\xbb\x18\xb8K(]\xf5\xb7\xc2\xbaI\\\n:\xb6\xdc0\xc1\xa0\xdb'
 b'\x19\xf1 \n\xc5\xd9\xf2(\x03_ti\xf2~\xa6\x97\x06\x93\x9bA\x8e:`s'
 b'\x99<\xcf\xda\x00\x00\x00!\x00\x05\x00\x00\x00@\x81V\xe8\xc1\xb4\x88'
 b'\xd7\xab-\xdf\xd2\xa5s\xcd\x00\x00\x00T\x00\x00\x00j\xfe\xe0\x11\x81'
 b'i\xc8\xa6f\xacu\x9fWx\xcf\xa7?wt\x8b\xe6?p\x8bx\xba\xc32*\xc6G\xd1\xc5'
 b'\x15\xfa\xcc\xcc\xffl\x96\xa6,\x1c1\xbe\x8c\xc9\x8a')

{'A1': 2314,
 'A2': {'B1': 205,
        'B2': {'C1': 473893091665404019,
               'C2': 2570899418,
               'C3': {'D1': 198449351,
                      'D2': 2948727959,
                      'D3': 27344,
                      'D4': 35,
                      'D5': 3948255007607404619,
                      'D6': [10333, 62903, 49850, 18780, 2618, 46812]},
               'C4': [817995995, 435232778, -975572440, 56587369, -226580841]},
        'B3': {'E1': -9126851676164532309, 'E2': 769643173, 'E3': 115},
        'B4': {'F1': -18869887, 'F2': 7622525329234829143},
        'B5': 30927,
        'B6': -89},
 'A3': -0.5336796641349792,
 'A4': 1591585674,
 'A5': [{'G1': 0.9666220545768738, 'G2': 230},
        {'G1': 0.9396281242370605, 'G2': 186}],
 'A6': [-15566, 10950, 18385],
 'A7': [-4245211316207260522, -6472767564462372470]}

Вариант №19

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

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

(b'LKV\xad`q\xdc\x83\x00\x00\x00\x1a\x00\x00\x00&\xbdiP\t%g\x00\x00\x00J?0'
 b"}'\xbf\xe6\xfcw\xbf\xde}0\xbfQ\xd9\xf9\xbf\xbd\x92\xbaK\xf7F\xe0\xbf\xed"
 b'2\xc3\xa4*!B\xbf\xecN\xc9%=\xb4$4\xa5+z\xd4\x1daU?\x92\x82g0\x7f'
 b'\x07\xc0\xdc\xbf\xecWH2l\x0ex\x81\x87\xe5\xc6$AA\xf1\xeej\x00\x02\x00'
 b'\x00\x002\x00\x02\x00\x00\x00B\x85\x1e\x92\xdb\xf3w\xf7\xa6\x1e>\xc6'
 b'94\xad\x1b\x062\x06\x19(\\X\x85\r\xfc\xe8\xb4\xc2\xc1\xc6?2-\xef\xac[$?\xe5'
 b'\x16\x83E\xe3\xfd\xd2?\x10\xae\xde\x84')

{'A1': 1618074755,
 'A2': [{'B1': 0.6894096732139587, 'B2': -0.7183188197558703},
        {'B1': -0.8197322487831116, 'B2': -0.11552013735424849}],
 'A3': -0.056961093097925186,
 'A4': 9575,
 'A5': {'C1': {'D1': {'E1': 0.01807557328698528,
                      'E2': 220,
                      'E3': -0.8856545433813627,
                      'E4': -9113062681786367503,
                      'E5': 61034},
               'D2': [-0.9124468046511895, -0.8846173980106227]},
        'C2': [883239802, -736272043],
        'C3': -123,
        'C4': {'F1': 512941043,
               'F2': 2012718622,
               'F3': 0.3871551752090454,
               'F4': [-1390737870,
                      102312028,
                      1485114876,
                      -390806847,
                      -968936915,
                      -273917148],
               'F5': 0.6589981427240963,
               'F6': 0.5651682615280151},
        'C5': -124}}

(b'LKV\xad1\xe5\xd8\xe2\x00\x00\x00\x1a\x00\x00\x00&>\t\x12HC\xc8\x00\x00'
 b'\x00J?|\xb0\xb5\xbf\xb6\x82r\xfd<\x9b\xd0?T_*?\xd1\x05: )\xfe\xe8?\xcf'
 b'\xa1<\xe4\xf6g\x08\xbf\xe7\xc3Xz\x08\xa7\x12{\xf7BR\xcf\xc7\x0e\\\xbf\xde'
 b'\xf9\xb4\x81\x82\xe2 \x7f\xbf\xe2\x85\xe6Hh\xf5D\xea\x1dI %\xe6\x9cG\t'
 b'\x1a\x00\x02\x00\x00\x002\x00\x02\x00\x00\x00B\x16\x9b!\xb5\x1ej\xba'
 b'\xd1V?\x121g\xc88M\xdf\x87g\xe4~\xc7\xd1Rq/\xbfB\xd5\xee\xfa\xb4\x8f\xb4\x82'
 b'\xd8f\xbf\xed\xf4\x8f(]\xc1\xfe?QIGi')

{'A1': 837146850,
 'A2': [{'B1': 0.9870713353157043, 'B2': -0.08792799646890548},
        {'B1': 0.8295770883560181, 'B2': 0.26594403401393985}],
 'A3': 0.1338587999343872,
 'A4': 17352,
 'A5': {'C1': {'D1': {'E1': -0.4839907898672511,
                      'E2': 127,
                      'E3': -0.5788451589830079,
                      'E4': -1577023892086154169,
                      'E5': 2330},
               'D2': [0.24710808925447503, -0.7425958999130862]},
        'C2': [2079801938, -809038244],
        'C3': 22,
        'C4': {'F1': 2602677534,
               'F2': 1790628182,
               'F3': 0.5710663199424744,
               'F4': [-935834145,
                      -2023234434,
                      -942583183,
                      801063637,
                      -285559665,
                      -1266493338],
               'F5': -0.9361034191516067,
               'F6': 0.8175243735313416},
        'C5': 105}}

Вариант №20

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

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

(b'AVCr\x00\x02\x000\x004?+\xf4B\x00\x03\x00\\GY\xe6\x8c\xb2\xcdzfqxxqv\x00'
 b'\x07\x00\x00\x00\x18\xddxqw\x00\x03\x00\x00\x00&`\x00\x1f\x00)\xbf\xd4t('
 b'#^0\xcc?\x9e)\x1e\xb5\x00q@?\xed\xbe\xc4\xa8_b\xd4\xb8\x01\xdfJ\t\x04o\x04'
 b'\x00\x1a\xcd\x8a_(\x0c\x92X\x18\xc2lKo\xc6M6\xfc\x11,')

{'A1': [{'B1': 'zfqxxqv', 'B2': -35}, {'B1': 'xqw', 'B2': 96}],
 'A2': {'C1': [-0.3195896478071176, 0.029453735158413652, 0.9295371330764177],
        'C2': -5187619786682241276,
        'C3': 7544343580118162},
 'A3': {'D1': 0.6716958284378052,
        'D2': [1478017644, 1265616461, 922489132],
        'D3': 1197074060,
        'D4': 45773}}

(b'AVCr\x00\x02\x004\x008\xbe\xc8=;\x00\x03\x00`\x92R\x87\xe5F\x7fnwarqwc\x00'
 b'\x07\x00\x00\x00\x18\xddrxugjez\x00\x07\x00\x00\x00&\xad\x00\x1f\x00-'
 b'\xbf\x95\x99\xf4\x9fP\xf3@\xbf\xd4\x81B\xd0|\x02X\xbf\xc2{\x0e"\xc9\x9d\xd0'
 b'G\x04\x1d\xff\x8e\xc7rm;qS^\xb7w\xd4\x82Q\x04\xc0O\xba\xee\x01\xd6b\x03<\xc4')

{'A1': [{'B1': 'nwarqwc', 'B2': -35}, {'B1': 'rxugjez', 'B2': -83}],
 'A2': {'C1': [-0.021095106338395953,
               -0.3203894649487089,
               -0.14438034723865067],
        'C2': 5117248060049027693,
        'C3': 4283296386876167298},
 'A3': {'D1': -0.3910921514034271,
        'D2': [1359265871, 3136160214, 1644379332],
        'D3': 2454882277,
        'D4': 18047}}

Вариант №21

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

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

(b'MBGV\x0e\xa9\x94\xe4tw\xaa \xb9\xef\x9b\x076W\x7f\x00\x00\x00\x8e\x04'
 b'\xaa9\x07\x05\xcc\xd4\xbfV\xd58\xf2N\x80\x1fc}E4\xec\xb4\xe6\x8f\xf1A'
 b'\xac\x9d\xc7\x97\t\x02\x00\x1f\x00\x00\x00\xe8 \t\xbf\x02\x00#\x00\x00'
 b"\x00\xa3\x8b\x04=\x02\x00'\x00\x00\x00yKa\xbe\x02\x00+\x00\x00"
 b'\x00\x8b\xfd\xec\xbe\x02\x00/\x00\x00\x00\xdbB\xf8\xbe\xc9\xa3\xf5\xc1^'
 b'\xf4\xf8\xca\xbd\xffk+|\x94\xce\x13T\x01}\xdd|3P\xe53\x00\x02\x00\x00'
 b'\x00g\x00\x02\x00o\x00\x00\x00\x1bg}g\xcc\xf2\xb9\xda\x17\x8b@(8\xc9H'
 b'\xd0\xff\x03O\xd8\xc4\xfaNH\x7f\xbc\x93\xb0\xd7\x17M\x8eB\x81\x88'
 b'\xca\xd2\xd1\xf6&\xbbq\xa5\xc2M\xb5\xe0fE\xc1,\xbf\xc9\xb4}\x16')

{'A1': -460019442,
 'A2': 116,
 'A3': 119,
 'A4': 6284218696365318314,
 'A5': {'B1': {'C1': 2455,
               'C2': [{'D1': [-10922, -3528], 'D2': -0.5356583595275879},
                      {'D1': [-32690, 25375], 'D2': 0.03235973045229912},
                      {'D1': [17789, -5068], 'D2': -0.22001446783542633},
                      {'D1': [-6476, -3697], 'D2': -0.46287187933921814},
                      {'D1': [-21439, -14435], 'D2': -0.4848850667476654}]},
        'B2': [-1040866359, -889654178],
        'B3': [1427241392948379581, 16523763644207268180],
        'B4': -2685848743026268389,
        'B5': [15008467001242848023,
               5210377542263833599,
               10253878141740366975,
               2807662120983363906,
               7413124332234568123],
        'B6': -0.674824059009552,
        'B7': 377337033},
 'A6': -114,
 'A7': -0.3249523706969344}

(b'MBGVPT\xcdm?T\xb8f\xa3\x95\x97\xaa`\xde\x7f\x00\x00\x00\xcdTN,\xfc7'
 b'\xfb\xe3?b.\xa2\x1f\x08\x17`\xae\xff\xf5\x96\x12x\x18\xca\xb3bB%}\x18'
 b'\xf4\x02\x00\x1f\x00\x00\x00\x86\xd5\x89>\x02\x00#\x00\x00\x00\x86_.'
 b"\xbf\x02\x00'\x00\x00\x00\x9e\t!\xbf\x02\x00+\x00\x00\x00`t+?\x02\x00/"
 b'\x00\x00\x00:\xe2\x18\xbf\x14\xfb\xb2$\xce%\xa7\xeeG"\xe4\x18\xed'
 b'\x05\xef\x99\xffF\xda&\x82\xc3\x82\xa53\x00\x02\x00\x00\x00g\x00\x02'
 b'\x00o\x00\x00\x00\x96\x10O\x06\xf0\x1f<\x986\x05\xfc\xc5+:\x821\xa3\xd8\x97'
 b"\xbb\xf2\xfd\x0e\x08\xb06\x03O\x93\xca4\x86\x88K\x1e\xde0#I')o\xbe\x1bz\x15u"
 b'\xb1=\xcd ?\xaf\x9a\x8eF')

{'A1': 1842173008,
 'A2': 63,
 'A3': 84,
 'A4': 16023995042211522232,
 'A5': {'B1': {'C1': 62488,
               'C2': [{'D1': [11874, 8098], 'D2': 0.2692071795463562},
                      {'D1': [5896, -20896], 'D2': -0.6811450719833374},
                      {'D1': [-2561, 4758], 'D2': -0.629052996635437},
                      {'D1': [6264, -19510], 'D2': 0.6697444915771484},
                      {'D1': [16994, 32037], 'D2': -0.597201943397522}]},
        'B2': [615709460, -291035698],
        'B3': [11092090923119813191, 11926309726995498751],
        'B4': -7477066165583409002,
        'B5': [3567477814510486838,
               580680620948576419,
               9670577033905911472,
               2830832533570997128,
               12787150331184049961],
        'B6': 0.6281316876411438,
        'B7': 1183750831},
 'A6': -51,
 'A7': 0.6244163441901471}

Вариант №22

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

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

(b'\x88FSYI\xa4(\x8b\xf3\xd1\xfc\xd7\x1b33\x83>\xa8\x03\x00\x00\x00\\\x00'
 b'Z\xda7\xfd\xd5;\xf4jNl\x00\x00\x00\x04\x00y\x00\xa0\x11\xa2\xa3B\xc3\xd8'
 b'\xbf\xa3\x00\x00\x00\xffyf\xc8\n\x08A\x83@\xf4\xaf\xd1C\xe2\xc7?\x81Fx'
 b'z\xce\xed\xd4\x84?\x11qL\x8a\\w\x9c\x81\n\x9ewz;\x84G\x00\x00\x00'
 b'N\x00\x00\x00U\x00\x00\x00\xcb\xb7+\x89\xbf_\xa8\x10\x8e\x02\x00\x00'
 b'\x00h\x00\x00\x00\x9dH\x14\x8e\x97\xf8\xba?hA+X\xfc\xaf\x86:\x9e\x02\x02'
 b'kX\x80\x02d\x9e\nu\xf5\xcb\x04\x90\xf9\xb1)]d\xac\x84\xdaW\xcf:<'
 b'|\x05\x00\x00\x00\x99\x00\x00\x00x')

{'A1': 2006350137681193124,
 'A2': 0.2562499940395355,
 'A3': 168,
 'A4': {'B1': [{'C1': 3989731960, 'C2': 212, 'C3': 16260},
               {'C1': 2320265489, 'C2': 92, 'C3': -25481},
               {'C1': 2006846081, 'C2': 122, 'C3': -31685}],
        'B2': {'D1': 90,
               'D2': 5650597220320098266,
               'D3': {'E1': -65, 'E2': 2383456351, 'E3': [-18485, -30421]}},
        'B3': [4592256099865086109,
               4217251599424897384,
               7206463470986986142,
               -463865487576200546],
        'B4': -0.3869177434901534,
        'B5': {'F1': 31804,
               'F2': [10673, 25693, 33964, 22490, 15055],
               'F3': 120},
        'B6': 9457849534859606527,
        'B7': {'G1': 0.1865925573219176, 'G2': 18049}}}

(b'\x88FSYI\x8cn\x94\xb7\xc2m\xc0\x8d\xcd\x9eT?\x91\x04\x00\x00\x00c\x00'
 b'\xfcv\x9d\x9e\xfc\x05\xbe\xe5\xfaw\x00\x00\x00\x03\x00\x84\x00\x004w'
 b'<\xdd\x1d\xdc\xbf\xa2\x00\x00\x00\x0b\x96\xf2:\x87\xf0uL0\x10\x85'
 b'\x0c\xf1\xfb\xc0?\x94U\xb0\xca*\x87{\xbe#\x17\xf0\xafM\xb8\x02\xf4\x06\x17c'
 b'<p\x89@\x01\xbfI\xaaM\xa4\x96G\x00\x00\x00N\x00\x00\x00U\x00\x00\x00\\'
 b'\x00\x00\x00%&\x85\x8b\xa0M\x13l\xf0\x02\x00\x00\x00s\x00\x00\x00'
 b'\xbf\xdb\xd9\xec\xff\xc3\xf5r\xf3m\x00\n\ndv\x0e\x90\x193\xb5\xe1Oe~\x1aE.A'
 b'\x02m\x8cT\x03\x00\x00\x00\x9c\x00\x00\x00\xe8')

{'A1': -8232459435762225524,
 'A2': 0.830548107624054,
 'A3': 145,
 'A4': {'B1': [{'C1': 2267728560, 'C2': 123, 'C3': 9150},
               {'C1': 1303375895, 'C2': 184, 'C3': -3070},
               {'C1': 1013126918, 'C2': 112, 'C3': 16521},
               {'C1': 2856959745, 'C2': 77, 'C3': -26972}],
        'B2': {'D1': 252,
               'D2': 18079065212071091574,
               'D3': {'E1': -96, 'E2': 4033614669, 'E3': [9765, -29819]}},
        'B3': [8283742593575672767, 1042130358063099379, 9107773652252957072],
        'B4': -0.43932276635024436,
        'B5': {'F1': 21644, 'F2': [17690, 16686, 27906], 'F3': -24},
        'B6': 5509574182757897739,
        'B7': {'G1': 0.1326886473781328, 'G2': 21908}}}

Вариант №23

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

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

(b'UBX\n\x1b\x00WL\x00@\xda\x03\x00\x00\x00n\x00\x00\x00\x02\x00\x00\x00z'
 b'\x00\xd2\x83yysbdp\xe9\xd7VO\x1aG\x8b\xf5\x1e)\x07t+&\x9b\xfe\x88p\xaf'
 b'\x00\xe67=\x87J\x8a\xbd\xaf\x8aFr\x98\x992\x00\x00\x00:\x00\x00\x00\xea\x01'
 b'({\xe9\r\xc6\xd1\xd9\xbf\x02\x00B\x00\xb0\x83\x18R\xa0\x96\xe6\xbf'
 b'\x02\x00\x00\x00J\x00\xf9\xbb\xba\x00\xeb\xcb\xaa\xc2\x7f\xdcI\x18[\x8b'
 b'\xcf\xec\x9aZ\x7f\x8d7(x6')

{'A1': {'B1': 'yysbd',
        'B2': -5776,
        'B3': 441407191,
        'B4': 519408455,
        'B5': 9871498021482792745},
 'A2': 87,
 'A3': {'C1': -0.4034285674915048,
        'C2': [{'D1': -436162704, 'D2': 1250377015},
               {'D1': -1968194166, 'D2': 2576904774}],
        'C3': -0.7058869937355805,
        'C4': [234, 1],
        'C5': -4419495874120729607},
 'A4': -9664,
 'A5': [407493759, -321942693, -1921033574],
 'A6': {'E1': [10295, 13944], 'E2': 33746}}

(b'UBX\n\x1b\x00\x8fL\x00\x1b\xb1\x02\x00\x00\x00n\x00\x00\x00\x06\x00\x00\x00v'
 b'\x00\xbc\x0covars"M\xaf\xbd:\x91\x04\r(\xe4\xc0\x00\x1a\x86~\xd0'
 b'G\xed\x98\x83K\x0c-\xae|\xab\xb8?#\x0e]\x8b\x8c\x982\x00\x00\x00:\x00'
 b'\x00\x00S\x80\x80L\xd53}t\xca?\x02\x00B\x00@\xa9j\xb9\xbe\xa8\x9e?'
 b'\x02\x00\x00\x00J\x00\x84\x14\xb4\xcd\x18\xc5 ]\x14\xce(W\x19\x97\xf6q\x8dM'
 b'x)\x95\xa8_\xcdi7\x89\xe1')

{'A1': {'B1': 'ovars',
        'B2': 19746,
        'B3': 2436545967,
        'B4': -467137276,
        'B5': 17097863752169685184},
 'A2': 143,
 'A3': {'C1': 0.2066799643604078,
        'C2': [{'D1': 206275480, 'D2': 2877074989},
               {'D1': 237191096, 'D2': 2559347549}],
        'C3': 0.029940586153921034,
        'C4': [83, 128],
        'C5': 6710580155103057028},
 'A4': -20197,
 'A5': [1462291988, 1911985945],
 'A6': {'E1': [19853, 10616, -22379, -12961, 14185, -7799], 'E2': 3260}}

Вариант №24

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

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

(b'FJJ\x12A\x00\x00\x00q\x9b#\xe5n\xc7\x9c\xca\x02\x00\x00\x00s\x00\x00\x00'
 b'%\xae\x90p\xc0nkyezl\xa4H\xaax)\xa3\xd4I\xc8+Pg{G\x80\xcf\x15?p\xee6'
 b'\xa5fy\xe9H#\x000\x00\x18\x00\x00\x00\x02\x00\x00\x00=\x00\xfd\x13\xe3\x03N'
 b'y\n\x03\xc8\x9eE:\xe4\xb3\x87\xa9\xc5ap|\x04,\x8f^\xf6+\x88X\xa3'
 b'\xc0\xd7\xe5\xe6\xc1\xd2\xe2\xe8\xecE\xae\xba\x9b\xc9\xd3\xe6\x06q\xb5')

{'A1': {'B1': {'C1': 37, 'C2': 3228602542, 'C3': 'nkyezl'},
        'B2': [{'D1': 18596,
                'D2': 30890,
                'D3': -23767,
                'D4': -44,
                'D5': -14263,
                'D6': 2070368299},
               {'D1': -32697,
                'D2': 5583,
                'D3': 28735,
                'D4': -18,
                'D5': -23242,
                'D6': 1223260518}],
        'B3': [219120907860513789,
               -6230813766632235320,
               6813713159014080965,
               -1884826111233741834,
               -5889040452735024666]},
 'A2': -3846980702576600207,
 'A3': [3553205178, 3044083430]}

(b'FJJ\x12A\x00\x00\x00\xab\x91O\\\xb7\xc1\x00\x95\x02\x00\x00\x00s\x00\x00\x00'
 b'\xb7\xb1\x10\xc7\xc5isodgxO\xe48:\xe5kA/1M\xfd\x11\xb4b\xa5)\xee'
 b'\x8d\x02g\xae9\xd4\x00\x16x#\x000\x00\x18\x00\x00\x00\x02\x00\x00\x00=\x00t'
 b'y\xf4!b_k\xa1\xeaT\xb5\xde\xa4\x99\xfco\xeb\xa6\xaa\x86x\x0b39\xcc'
 b'\xf1\xa1\xa9\x03\x02\xc0\xf3|\x02"\xb2\xfe)\x1f\xfb\x1d\xec\xde\x05({>\x0f')

{'A1': {'B1': {'C1': -73, 'C2': 3318157489, 'C3': 'isodgx'},
        'B2': [{'D1': -7089,
                'D2': 14904,
                'D3': 27621,
                'D4': 65,
                'D5': 12591,
                'D6': -1273889459},
               {'D1': -23198,
                'D2': 60969,
                'D3': 653,
                'D4': 103,
                'D5': 14766,
                'D6': 2014707924}],
        'B3': [-6815248736014009996,
               8069493565731198186,
               4121650696257447659,
               -882703312210497076,
               -351516072024604036]},
 'A2': -7709949568786394709,
 'A3': [98495517, 255753000]}

Вариант №25

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

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

(b'HOID\x8avcirgy\x02\x00\x00\x00C\x00\x00\x00\x02\x00\x00\x00G\x00\xa7r#'
 b'\xbe\xda\xa7\x92\x07\xa04\xfb\xf2\xfd\xe9\xda\xbf{\x92W\x06W\x00\x00'
 b'\x00\xfb\x9d\x9a\\\xac^\xcb\xde\xd8]\xae\x84\x86iFK\xaf\xfe9\x00>\x00 '
 b'w\xad\xf7_\xb4\xcf?\xc4\xa2\xea\xd4\x06$\xed?\x1b\x06\x10[\x04\x9bhUb'
 b'!d\xd5\xec\xec7D,\xa9\x18\xce')

{'A1': 'vcirg',
 'A2': {'B1': 121,
        'B2': [{'C1': -2068947496, 'C2': 134}, {'C1': -1354021271, 'C2': 254}],
        'B3': [0.2476921042788769, 0.910647788860921],
        'B4': 545683062799954599},
 'A3': -0.4205317376007063,
 'A4': 106402427,
 'A5': {'D1': [1563, 23312, 39684, 21864, 8546, 54628],
        'D2': 14850805778842381548},
 'A6': 16054029391073287675}

(b'HOID\x8aslibt\xf9\x02\x00\x00\x00C\x00\x00\x00\x02\x00\x00\x00G\x004y|'
 b'Eu\x88\xe8P\xa4+\x06%\xf6\xc3\xd9\xbfy\x94\xd9\xc9W\x00\x00\x00>\xfb\xe3'
 b'9\x0e,\x1e\x9ceJN\xcd\x96!\xfb\xc9\x05\xcb9\x00>\x00\xa4\xd5\xf2\x87\xe0'
 b'Y\xe4?\xea\xa2b;\xea\xea\xe5\xbf\rVM7\x1d.\xfdXmJy<\xf0\x17\x8d\x91\x9d'
 b'\x8b\x80v')

{'A1': 'slibt',
 'A2': {'B1': 249,
        'B2': [{'C1': -850507163, 'C2': 150}, {'C1': 97123105, 'C2': 203}],
        'B3': [0.6359713225598864, -0.6849261436337575],
        'B4': 5830059754889443636},
 'A3': -0.4025855409205923,
 'A4': -908487559,
 'A5': {'D1': [22029, 14157, 11805, 22781, 19053, 15481],
        'D2': 8538978402362529776},
 'A6': 11249477358830484286}

Вариант №26

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

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

(b'\xf0TMXm\x00\x18"\x8dr\x8c\x19]\x86\xd7\x11\xd2\xbd`\xa93\xb8<\xa0'
 b'\xad\xbf\x980\xb4j\xfb\xbe\xbek\xc5l\x0c{)\x08\xf1\t\xd5?\x05\x00\x00\x00'
 b'\x81\x001\xa7\x02\x00\xa0\x00\x00\x00\xf6\xb9u\xbdj\xbdv\xbf\x0b\x9c'
 b'\x01\xbf\xfc\x08n\xbfs\x1f\xf1\xbd\x02\x00\xa8\x00\xd5^\x0e(\xaf\xf6'
 b'\xf6\xe7\xbf\xb1\xb7\x9aC\xf0\x99\xe6\x12r\x17\xb1m2?\xc0)A\xbf\x00\x9am'
 b'j\xf3m\xe7\xc2\xa0\x15xO=\x13\xcclR\x00\x00\x00qlgtt*\xb9u\xa2\x8c\xab'
 b'\x8a\xde\x1d\xb3\xd7\xbf\xda\xab\xff\xeez\x18m\xa2*B\xb0\xe1\xbf\xf9'
 b'\x86\x00\x00\x00\x93\x00\x00\x00\xe2\x1b~\xbeMz\x99\xbe')

{'A1': {'B1': -4402429218501322240,
        'B2': 160,
        'B3': 1028618261,
        'B4': 19,
        'B5': 27852,
        'B6': {'C1': 213,
               'C2': -0.7488969250702657,
               'C3': -18511,
               'C4': 17306,
               'C5': -26128,
               'C6': 393351910,
               'C7': 0.6969862580299377,
               'C8': -0.7545433044433594}},
 'A2': 9681922864924402200,
 'A3': {'D1': -0.10257308930158615,
        'D2': -0.05786313770825546,
        'D3': {'E1': 12440,
               'E2': 7837789193500322484,
               'E3': 0.3287317828852998,
               'E4': 'qlgtt'},
        'D4': -22735,
        'D5': [{'F1': [47402, 41589], 'F2': -0.3703074143656344, 'F3': 218},
               {'F1': [65451, 31470], 'F2': -0.5527659256653434, 'F3': 249}]},
 'A4': [-0.05999179929494858,
        -0.9638277292251587,
        -0.5062872767448425,
        -0.9298245906829834,
        -0.11773576587438583],
 'A5': [-0.24815323948860168, -0.29976120591163635]}

(b'\xf0TMXm\x00\x1f\xb6l\xc5\xd73\x1a\x02\xe0\xa0/?\xd0v\xa2\xc2\xb4\xce'
 b'\xd4\xbf\x94k\x9cA\xc5)\x0eh0\xc3&;\xf4E\xbfC\xe9?\x05\x00\x00\x00'
 b'\x81\x00\x12\xa1\x02\x00\xa0\x00\x00\x00\x1b\x00q?\x10\xdf"\xbfn\r\xc8>\x00I'
 b'%\xbex\x11\xa3=\x02\x00\xa8\x00`\x08\x8fU\x94\x91P\xcc\xbf*!j\x8fW'
 b'\x8d\xc8\xcc\xc8\xc2\x86\x97b\xbf\xad H\xbf*B9\xe9\xaf\x96\x18qf\xb2\xb0'
 b'\x1d\xf2\x08\xe8\xbaR\x00\x00\x00veuiw\x05\xd8*\x81\x92\xbe\xeaY\x9cJ'
 b'\xe7\xbf\xcf\xb1\xf2\x11\xa1&U\xecD\xac\x8b\xec\xbft\x86\x00\x00\x00'
 b'\x93\x00\x00\x00\xad=\x82\xbec\xecw\xbf')

{'A1': {'B1': 8149429208003199530,
        'B2': 102,
        'B3': -232935246,
        'B4': 8,
        'B5': 47848,
        'B6': {'C1': 96,
               'C2': -0.22120876067048578,
               'C3': 8490,
               'C4': 36714,
               'C5': -29353,
               'C6': -1027027768,
               'C7': -0.8851245641708374,
               'C8': -0.7817485928535461}},
 'A2': 151490539293554207,
 'A3': {'D1': 0.6860485076904297,
        'D2': -0.32511633879935875,
        'D3': {'E1': 27540,
               'E2': -4381888027391868516,
               'E3': 0.7895199171342469,
               'E4': 'veuiw'},
        'D4': -24302,
        'D5': [{'F1': [55301, 33066], 'F2': -0.7278577572050884, 'F3': 207},
               {'F1': [62129, 41233], 'F2': -0.8920499178081271, 'F3': 116}]},
 'A4': [0.9414078593254089,
        -0.6362161636352539,
        0.3907274603843689,
        -0.16141128540039062,
        0.07962316274642944],
 'A5': [-0.2543767988681793, -0.9684507250785828]}

Вариант №27

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

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

(b'ZPYH\xbf\xde\xc8l\xf4\x9a\x114\xb3\x04\xc9\x0f\x93d\xeeLT\xb1\x8c\x8a'
 b'\xbajf\x94\x1c(\x18o\x00\x02\x00/\x00\x00\x00;\xc1\x00\x00\x00x\x1fxf'
 b'\xa8\xed%]K\xc3ERW!Wo31D\xa5_,\x8d\x07A\x19\xc3\x16\x1b5\xce\x1cvF\xad\xa4'
 b'\x95\x9d\x81mh$\x070\xf0\x10\xe2\x1d3\xfa\xaeA\xa7m\xfe\xc5(w=\xfe\xc6&4\x00'
 b'\xc0&\xbaL\x8c,\xe1\xf9\xf6\xb2\x91\xab\x06\xb6\x8d\xf8\x00\x04\x00X')

{'A1': -0.4809830082597444,
 'A2': [-1291532017, -1822101940, 1420921994, -1167432044, 472389743],
 'A3': [{'B1': 102, 'B2': 2834113885, 'B3': 75},
        {'B1': -61, 'B2': 1163024161, 'B3': 87}],
 'A4': {'C1': 1865625924,
        'C2': 11916292123269339587,
        'C3': [370881998, 477513389, 2761268609, 1835541511],
        'C4': 48},
 'A5': -63,
 'A6': {'D1': 112627192,
        'D2': [-1148169289925480895,
               -6382164974173209090,
               -4168587227256407476,
               -8346047545722367573]},
 'A7': 8056}

(b'ZPYH?\xa5\xff93\xf3k 9\xec\xa6G+\xb1\xb4+:\xa8\xdex\x025R\xce'
 b'\x84\xa6\x9b\x1c\x00\x02\x00/\x00\x00\x00; \x00\x00\x00p\x99C\xae\x91\xab!8'
 b'r\xdf\xa4g\x14\xa6\n\xfd{Vf\xac\xe2\xf0I\xc8\xc3\x1b\xc3.\x91\xb3>\xc0'
 b'9\xa4+\x07\x1aj}ov\xc5S\x93.\xe0\xc6\x9f\x1b\xe1v\x87\x81;\xd0\x93'
 b'E\r\xef\xf4\xe9.\xc5\xcd\xe5\x8c\xa5\x93\x95\xdaD\x1c\x00\x03\x00X')

{'A1': 0.04296282538572016,
 'A2': [971810375, 733066283, 984145528, 37049038, -2069456100],
 'A3': [{'B1': -82, 'B2': 2443911480, 'B3': 114},
        {'B1': -33, 'B2': 2758218918, 'B3': 10}],
 'A4': {'C1': -42248602,
        'C2': 12457783718951721923,
        'C3': [781300542, 3225003051, 119171709, 1870054739],
        'C4': 147},
 'A5': 32,
 'A6': {'D1': -1780857828,
        'D2': [3377918107197732487,
               -9134478088253607948,
               -1644159325833484909]},
 'A7': 39235}

Вариант №28

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

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

(b'WTT\xad\xcc^?\xcd\xc4\x08\x00)\x00\x0091\x00H\xb34?\xad6\x82Z\xe4T\xd3'
 b'[\x01\x15gvrevx\x02\x00:\x00jgdqhrmy\xcc\xac\x94Oo\xf7\xe3\xbf\xd0{p'
 b'2\xe7R\xf4\x90\xfc\xfd\xd9\x9dq\x18\x05\xeb\xe9\xdf\xe7?7/\x8f\xfe\xbe')

{'A1': {'B1': 0.8703106045722961,
        'B2': -15155,
        'B3': 'jgdqhrmy',
        'B4': 14592,
        'B5': {'C1': -0.6239544443427802, 'C2': 208},
        'B6': 0.7058606147766113,
        'B7': 6616725617285150381},
 'A2': 5377,
 'A3': 'gvrevx',
 'A4': [{'D1': 28795,
         'D2': 50,
         'D3': 21223,
         'D4': [-12, -112, -4, -3, -39, -99, 113]},
        {'D1': 1304,
         'D2': 235,
         'D3': -8215,
         'D4': [-25, 63, 55, 47, -113, -2, -66]}]}

(b'WTT\x934\xed><\xba\x04\x00)\x00\x8ew-\x00Wa\xa0\xbdX{P\xc2\xf1\xd9\xc9b_wv'
 b'zjjki\x02\x006\x00rfnu\x08\x15\x0c\xb3m\xf3\xd3\xbf\xf9\x84\t\xe5\xe3\xf8]'
 b'\xf4\xe5\xd7?\xe0\xf8\xd0\x04`\xd8\xa6}v\xd3\x9duo\xb9')

{'A1': {'B1': 0.463291734457016,
        'B2': -17860,
        'B3': 'rfnu',
        'B4': 30606,
        'B5': {'C1': -0.31173269734456754, 'C2': 249},
        'B6': -0.07831066101789474,
        'B7': 7118460318406179672},
 'A2': 30559,
 'A3': 'vzjjki',
 'A4': [{'D1': 2436,
         'D2': 229,
         'D3': -1821,
         'D4': [93, -12, -27, -41, 63, -32, -8]},
        {'D1': 1232,
         'D2': 96,
         'D3': -22824,
         'D4': [125, 118, -45, -99, 117, 111, -71]}]}

Вариант №29

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

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

(b'JDE\x02\x00\x00\x00A\x0b\xa3V~D(p\xc0=\x82\x9c\xbbN\xe0\x89\x15\xbfnH\xf1'
 b'\xeb&\xc2.\xbf`\x81\xe4W\xb0+\xac\xbe\x96\xb2e\x00\x07\x00\x00\x00Z\x00m'
 b'\x8ey\xd6>\xe0\xbf\xe2;fP\xcc\xb2\xe0\xcbA\x16K\xdf\x1a\xbd\x16\xcb\xd4\xbf'
 b'\xe2\xd9\xbc2\x99\t\x9d-)}oztzstzpnem`\xc0\xe3*\xf2#\xc0\x9c\xf6\xda\x91'
 b"\xd2\xc3w\xb8!\xd0\x19\xd6;'\xa6\xb2Y\x06\xa2\x9bV#B\x06\x14A\x06\x82"
 b'\xb2\xac\n\x96\xecb\xa2l\xe6\xa3\x9d\x83\xb6\xd5\xed\xf9W\x00\x00\x00'
 b'\x03\x00\x00\x00a')

{'A1': {'B1': -13503,
        'B2': 1606622998022245332,
        'B3': -1075652164,
        'B4': 50,
        'B5': 2567544109,
        'B6': 696086394,
        'B7': 'tz'},
 'A2': 195253886,
 'A3': [{'C1': 1143500992, 'C2': 0.06377550214529037},
        {'C1': 1323338005, 'C2': -0.9308004975318909},
        {'C1': -349781458, 'C2': -0.8769819736480713},
        {'C1': 1471163308, 'C2': -0.29432979226112366}],
 'A4': 'stzpnem',
 'A5': {'D1': 14084928814989301307,
        'D2': 2857167109046311766,
        'D3': [9026, 1556, 16646, 33458, 44042, 38636, 25250, 27878],
        'D4': 11789724220822255959,
        'D5': [1623253802, 4062429340, 4141519314]},
 'A6': -1904617922,
 'A7': 224,
 'A8': -0.5697509363286279}

(b'JDE\x02\x00\x00\x00A}g\xf0\x95z\x12\x1bp>\xda\x9b\xf2\x8f>`1\xbe\xe04\x0e'
 b'\x139\x00\xfd\xbe\xfbG\xc3@\xb3R\xf6\xbe\x99\x93.\x00\x02\x00\x00\x00Z\x00h'
 b'\xaew\xc0\x10\xe3\xbf\xe7\xcf\xf6!\xa1A\xa4\xd7\xbd-\x93\x86\xf5C'
 b'\xb0\xab\xc0\xfe\x17Fl\xb4U\t\xce\x90\xce\xae\xac\xa3lmff\x1b\x15\x01S'
 b'k\x19\x95\x1a\xd12|q0\x82\xaf\xdeL\xa8t%\x87Z\xcd\xdfA8\xda*d9\xdcR'
 b'\x91\xaa\x867\x9b\xa7\xf74\x99M\xff\x93\xe7\xeaL\xee\xd8\x8f\xb6\xcf'
 b'\x00\x00\x00\x03\x00\x00\x00\\')

{'A1': {'B1': -10307,
        'B2': 3284116941243984832,
        'B3': -32029076,
        'B4': 180,
        'B5': 1426706064,
        'B6': -827413341,
        'B7': 'lm'},
 'A2': 2103963797,
 'A3': [{'C1': 2048007024, 'C2': 0.4269710183143616},
        {'C1': -1891737551, 'C2': -0.4378971457481384},
        {'C1': 322502909, 'C2': -0.49078187346458435},
        {'C1': 1085494006, 'C2': -0.2999510169029236}],
 'A4': 'ff',
 'A5': {'D1': 3495549630096634917,
        'D2': -8693409771929675222,
        'D3': [25657, 56402, 37290, 34359, 39847, 63284, 39245, 65427],
        'D4': 16711253956030871247,
        'D5': [454361427, 1796838682, 3509746801]},
 'A6': -1367883760,
 'A7': 227,
 'A8': -0.7441359192690027}

Вариант №30

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

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

(b'\xb4TTAG\x8d"V\xc4>:\x00n\xbeG\xe0\x1b\xd8\xcd\xd0\x94)\xd8\xb5f}\xbd4'
 b'1*\xf3\xb9\xeb\x1d\x8fG\x98\x94\xc9\xbc9\xd6\xd4?cd\x08d\x03\x00\x00\x00'
 b'\x10\x00\xdbI\xd3\xe2\xa0\x9fd\x86\x11\xdad\x93\xd2?\xfe\xf4\xcba'
 b'\xe1\xf5\xee\xbf\xa4\x04!\xce\x80\x1ag{\xb6\xb5\x97Y\x1c\xb1w\x05A2\xa8\xf6'
 b'\x16\x00\x00\x00\xaaR')

{'A1': 141,
 'A2': 0.3834696412086487,
 'A3': {'B1': 40864,
        'B2': [0.29024621291873687, -0.9675146970836577],
        'B3': 1188,
        'B4': [{'C1': 33, 'C2': 32974},
               {'C1': 26, 'C2': 31591},
               {'C1': 182, 'C2': 38837}],
        'B5': 89,
        'B6': 17773511184263655708,
        'B7': {'D1': 2103883224,
               'D2': [13501, 10801, -17933, 7659, 18319],
               'D3': 0.3255752891184982,
               'D4': 1678271587,
               'D5': [55323, 53453, 10644],
               'D6': 18907,
               'D7': -45,
               'D8': 226},
        'B8': 21162},
 'A4': -16786,
 'A5': -8121}

(b'\xb4TTAG\xb8\xa6\x01I\xbf:\x00\xaf\xfcf\x14\xdb]Xm\xc3\xf2Zh$\x97i\xaf'
 b'7\x82\x9b\x8c\xd2dA)\x1eP\\\xf8\x88\xf4\xef\xbf\x83\xbd\xb5\xcf'
 b'\x03\x00\x00\x00\x10\x00S\xaeX\xc0p\xa9\xc8\xcd1\x8f\xff\x15\xdd\xbf'
 b'\x00\xeas\xeeJ\xba\x8f\xbf\x9d\x84s8/L\xa5\x17\xf6AN3\xd0\xb3\x19i'
 b'U\x8e\xde\xd8\x16\x00\x00\x00\x85\xe7')

{'A1': 184,
 'A2': -0.7851814031600952,
 'A3': {'B1': 43376,
        'B2': [-0.45446766837923436, -0.01549204387855685],
        'B3': -31587,
        'B4': [{'C1': 115, 'C2': 12088},
               {'C1': 76, 'C2': 6053},
               {'C1': 246, 'C2': 20033}],
        'B5': 51,
        'B6': 15627084254508856272,
        'B7': {'D1': -1759221670,
               'D2': [-20631, -32201, -29541, 25810, 10561],
               'D3': -0.9986004687111778,
               'D4': 3484794243,
               'D5': [24027, 27992, 62147],
               'D6': 44627,
               'D7': 88,
               'D8': 192},
        'B8': -6267},
 'A4': -849,
 'A5': 5222}

Вариант №31

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

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

(b'GYA\x84\x0f\x0b\xaa\x94G\xa3\xeb\xbe:\xa4\x07\xbfH\x00gldv\x8bt'
 b'\x04\x00\x12\x005\xf5\xaa>G\xb1d\xfa\xbe\xf2~=E\x02 \xe8\xbb\xb9\xb5\xd0'
 b'\xb4>\xf5\x0e\xbfpS\x06i\x13++C\xcb/\xe4\xe0\xd8\xad{\x84\xb1\x85f'
 b"\x16\x00\x00\x00 \x000\x00\x02\x00\x00\x00@\x009'\xb8\xf0R\x86\x01n")

{'A1': 2494171919,
 'A2': -0.4602300822734833,
 'A3': -0.529849648475647,
 'A4': {'B1': {'C1': 139, 'C2': 116, 'C3': 'gldv', 'C4': 0.3339020311832428},
        'B2': [{'D1': 4200902983,
                'D2': [62142, 15742, 581, 59424, 47547, 53429]},
               {'D1': 250953396,
                'D2': [28863, 1619, 4969, 11051, 52035, 58415]}],
        'B3': [2074990816, 1720037764],
        'B4': 7926764509932824377}}

(b'GYA\x84\xaf>z\xc7\xfb\x9e-?\xc7\x956>F\x00zqt\x9c\x02\x00\x12\x00\xf1O'
 b'q\xbf&8nIo\xa3\xe8#\xf7\x13^\xac\x03\\q\xde\x0b\xda\x9a\xa6\xa6"'
 b'\x054\xc3\x99\x9eK\xb8\xb4\xe2\x81%gj\xfc\xf3\xb9{!\x14\x00\x00\x00\x1e\x00'
 b'.\x00\x02\x00\x00\x00>\x00\x9c\xc6\x1b(\n\x89\xb9\x1c')

{'A1': 3346677423,
 'A2': 0.6782070994377136,
 'A3': 0.1783057302236557,
 'A4': {'B1': {'C1': 116, 'C2': 156, 'C3': 'zq', 'C4': -0.9426260590553284},
        'B2': [{'D1': 1231960102,
                'D2': [41839, 9192, 5111, 44126, 23555, 56945]},
               {'D1': 2795166219,
                'D2': [8870, 13317, 39363, 19358, 46264, 33250]}],
        'B3': [-60135643, 561756659],
        'B4': 2069836180469040796}}

Вариант №32

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

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

(b'KFCB\x1a]\x02\x00@\x00B\x00U\x00h\x00{\x00\xb2\xff\xcd\xe5\xb0[\x03\x11\xd1}'
 b'\xc8\xbf\x1c@\xb8>OS\xc4\x10U\xb6\x07\x03\x1c\xd7\xe8\xab,x\xa1\xc9\x9c\xfc'
 b'P\xf3\xd1\x8eo\xea\xcf[\xe2-w\x12tnv\x11y\xe10\x0c\xf8\xdf\xaa\xa8\xee2\xfc '
 b'#\xf8 \xc3\x86\xc8t\xe9\xce\x89\xc8l\x0cn\xd7\xb6\x1c\x9f\x84I\xd91\x04\xc0'
 b'\xb9\xb1\r\xd64\x02\x19\xd3\x19\xb9\x89\xa4k\xc3G\xcd\x1dWKY\xeeW\x08d'
 b'l\x95\x98#\xf0\xaaJ\xb1x\x1ad~\x9bx')

{'A1': 26,
 'A2': {'B1': 93,
        'B2': 'tn',
        'B3': [{'C1': -512159370,
                'C2': 3670056198209014832,
                'C3': [-4, 32, 35, -8, 32, -61, -122]},
               {'C1': -823561016,
                'C2': 2069077946478151817,
                'C3': [-97, -124, 73, -39, 49, 4, -64]},
               {'C1': -703745607,
                'C2': 11856211014596493876,
                'C3': [107, -61, 71, -51, 29, 87, 75]},
               {'C1': 139980377,
                'C2': 5380376740521929828,
                'C3': [-79, 120, 26, 100, 126, -101, 120]}],
        'B4': {'D1': 3855482802, 'D2': -0.19133961992949144},
        'B5': 0.35986411571502686},
 'A3': 79,
 'A4': 50259,
 'A5': [16, 85, -74],
 'A6': [8659485200056320775, -8155469921030190687, 1330582665137482351]}

(b'KFCB\x142\x05\x00@\x00E\x00X\x00k\x00~\x00p\x8d\xa5K\x88\x052eU\xdd'
 b'\xc8?\x01\xddq?\x0c\x84\xd9\x8f\'\xbetc\x04\x0c(4"\x80\x9b\x8c\xb5\x8f'
 b'7\x81\xf1 \xa2\x99\x80\xe8\xc9$\x0f\x1cjkqhq5\x8f\xeeE\x8a\xe6:\xadn\x02_'
 b'+\xe3\x8cZ\xe05M,\xdbi\x93\xd1*\x17\x05\xc6\xff\xe2\x9d\xd2 \x18\x04D'
 b'\x06\x85\x1d3j\xefgy!&\x9c\xa7\xa6\x04i,>I\xf2-\xe4\xcfvR\xaa\x8ed\xc7'
 b'[\xf9\x1d:\xd5\xaf\xa6\x98\r,\xe40I')

{'A1': 20,
 'A2': {'B1': 50,
        'B2': 'jkqhq',
        'B3': [{'C1': 1173262133,
                'C2': 3125219340794390154,
                'C3': [-29, -116, 90, -32, 53, 77, 44]},
               {'C1': -778868261,
                'C2': 15176535907475199786,
                'C3': [32, 24, 4, 68, 6, -123, 29]},
               {'C1': 1743743539,
                'C2': 7567356512698769785,
                'C3': [44, 62, 73, -14, 45, -28, -49]},
               {'C1': -1901440394,
                'C2': 12670097027088762724,
                'C3': [-90, -104, 13, 44, -28, 48, 73]}],
        'B4': {'D1': 1269140848, 'D2': 0.1942545646780156},
        'B5': 0.9447785019874573},
 'A3': 12,
 'A4': 55684,
 'A5': [-113, 39, -66],
 'A6': [-9213744541041663116, 2373820554235186331, 2021875207320410530]}

Вариант №33

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

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

(b'\x15CKT=\xecR\x1f\x83\x00\x02\x00\x00\x00C\x00qew\x10)3\xc5F\x9c\xf8\xd0\xbf'
 b'_Ej\xbem\xa7\xc3\xbej;v>\xf4R\t\xbf\x16\xfe\xf7?=\x897?s\x9f\x93>c\xd7\x10>'
 b'\xc7bF?T\xbe\xe4O\x9bc\xe0\xbf\xdd\xc0kS$\xea\xc8\x00\x05\x00\x1b\xa1'
 b'q\xbe\x10\x92!\xbf\xe6j\x91\xc8w\xacB\x00\x05\x00/\xbf\xae\xe6\xb9\xec\xd1_'
 b'\xa0}=\xf5\xd5\x00\x00\x00\x02\x00g<\x9dj\x89\x00\x02\x00\x00\x00o\x1bt\xaa'
 b"'8hV\x17\x04wL\x15/\xfb\xc2g\x96b\xf8\x8eM\x82#\x16")

{'A1': 0.11539100855588913,
 'A2': {'B1': -125,
        'B2': {'C1': [{'D1': 1335583712,
                       'D2': -0.46486933822204124,
                       'D3': [-0.8721529245376587,
                              -0.23208527266979218,
                              -0.22874245047569275,
                              0.477188378572464,
                              -0.5898279547691345],
                       'D4': -95,
                       'D5': 113},
                      {'D1': -1106210271,
                       'D2': -0.7005089679127041,
                       'D3': [0.7403749823570251,
                              0.9516536593437195,
                              0.22250008583068848,
                              0.38942164182662964,
                              0.8310377597808838],
                       'D4': -65,
                       'D5': 174}],
               'C2': {'E1': [3870944465, 1604353341],
                      'E2': 1016949385,
                      'E3': [-11, -43],
                      'E4': 1978393221749298711,
                      'E5': 321809552263332455,
                      'E6': 10836496943476253462},
               'C3': 25975,
               'C4': 16},
        'B3': 41},
 'A3': 868566684,
 'A4': 63696}

(b'\x15CKT?\x16\x8da\xd8\x00\x02\x00\x00\x00+\x00]\xc5\x8al\x8eM\xde\x04'
 b'\xf3\xce\x9c\xbf}\xcbq>\xa7w\x7f\xbeD!d?6\x8e\x08\x91\xc1{\xf0\xbf\xd6\xfb]i'
 b'\xe3bx\x00\x02\x00\x1b\xac\xce\xc4\xd6\x7f\xd6?\xc2\t\xae\xf4\xba\x86'
 b'h\x00\x02\x00#|| K\xee\xeb\x1e\xbd1\x0fNj\x12\xb6\xa9\xf8\x00\x00\x00'
 b'\x03\x00O/\x99\xe1:\x00\x02\x00\x00\x00[F\xb6\xae\xe7\xb5v\xce'
 b'\xee\xb8\xef\xbaB\x87G\xf7Z\xa6\xdb\xc6\xf3-\xff\xb3V')

{'A1': 0.5880947709083557,
 'A2': {'B1': -40,
        'B2': {'C1': [{'D1': -1849590800,
                       'D2': -0.3590920957626973,
                       'D3': [-0.9913855195045471, 0.327083557844162],
                       'D4': -84,
                       'D5': 206},
                      {'D1': -992575530,
                       'D2': 0.14092051458014798,
                       'D3': [-0.191533625125885, 0.7131047248840332],
                       'D4': 124,
                       'D5': 124}],
               'C2': {'E1': [541847275, 515715343, 1315574454],
                      'E2': 798613818,
                      'E3': [-87, -8],
                      'E4': 5095452338621435630,
                      'E5': -5120669456396716198,
                      'E6': 12023422377946755926},
               'C3': -14966,
               'C4': 108},
        'B3': -114},
 'A3': 1306395891,
 'A4': 52892}

Вариант №34

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

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

(b'KORSSc\x00\x00\x00\x03\x00\x00\x00\x85\x00\x0e\x80\xb0\x0c\xe5\xc5,\xfc\x94'
 b"\xd2\xc8\xeb\xf4\xf6'\xc5\xdfC\xa2\xc3\xf0Vl\xd5\xb6\xd5\x19ho"
 b'\xb3\xe2\xcc\xbc\xa4\xc9\x95\xc3\xeb\xd2fS\x92o\x9e\xf0\xbc&F\x18\xac\xd3PK'
 b'@a\xacg\x1d*\x02#\x06\x00\x00\x00\x88\x00\x00\x00\x95\xaa0\xec\x8f\x80Bk'
 b'\x08\x1a\x83l\x00|\xb7\xbb6I\xbdkI\xb9\xd7!\xa6\x8b\x80B\x7f\xc0\xc7s'
 b'?\xce\x91\xae?\x00n\x15;X\x8c\xc8?S\x96ATiyix\xca\x1a\xd2\x1b\xaf\x0e\xb1'
 b' \x0b\xb7\xac]q/\xf3\xf0\x83`8?E5\x9d')

{'A1': {'B1': 3175691963,
        'B2': -9184064350808618645,
        'B3': 66,
        'B4': 127,
        'B5': 0.05970615887225916,
        'B6': 0.1917829788679768,
        'B7': 1413584467},
 'A2': {'C1': 'iyi',
        'C2': 14,
        'C3': 3842814080,
        'C4': 17648420371549662405,
        'C5': -540727306,
        'C6': [{'D1': 67, 'D2': 1458619298, 'D3': -709438100, 'D4': 26649},
               {'D1': 111, 'D2': -1127423309, 'D3': -1013593692, 'D4': -11541},
               {'D1': 102, 'D2': -1636855213, 'D3': 1176943856, 'D4': -21480},
               {'D1': 211, 'D2': 1631603536, 'D3': 706570156, 'D4': 8962}],
        'C7': [-769996168,
               -1324437733,
               -1397290208,
               -214994595,
               945849328,
               -1657453249]},
 'A3': {'E1': -21867,
        'E2': -5072,
        'E3': 1799520399,
        'E4': [8, 26, 131, 108, 0, 124]},
 'A4': -73}

(b'KORSSc\x00\x00\x00\x06\x00\x00\x00\x85\x00\x8b\xfcu\xf8L\x8fk\xb9\\(v\xd9.'
 b"\xadZ\xda:'\xcbU\x9bR\x9e\xcc\x11V\xc1\x9dV\x88N\x0f\xf56\xc9\x1d\xc6"
 b'\x85\xe9.\xe2\x18\xe0\xdf\x93r&\x05^\xe9\x16\xb3=\x1aU\xcfoF\x04V\x9d'
 b'\x03\x00\x00\x00\x8b\x00\x00\x00\x84\x14\xb3\x97\xf6\xef\x84\x9a\x8f\x06NX'
 b'/\xa2\x9dC\xb2M\x95\x80c^U\xcc\x9ci\xdc\x9e\xcb\xc0\x82\xe2\x0c]\xe8\x90'
 b'?\x00\xd9{\xa8s<\xc7?\xf3J\xec\x94iacurt\x90Y\xf9k\x95:\xcd\x93\x9b'
 b'\xf1\xcc\xe7')

{'A1': {'B1': 2504897091,
        'B2': -2564346111391276160,
        'B3': -98,
        'B4': 203,
        'B5': 0.01651139632361054,
        'B6': 0.18153234221217218,
        'B7': 2498513651},
 'A2': {'C1': 'iacurt',
        'C2': -117,
        'C3': 1291351548,
        'C4': 3375859311417322383,
        'C5': 987388589,
        'C6': [{'D1': 39, 'D2': 1385911755, 'D3': 1444007070, 'D4': -25151},
               {'D1': 86, 'D2': -183546232, 'D3': -971126474, 'D4': -5755},
               {'D1': 46, 'D2': -538961694, 'D3': 86405779, 'D4': -5794},
               {'D1': 22, 'D2': 1427783091, 'D3': 71725007, 'D4': -25258}],
        'C7': [1811503504, -1815266667, -405999205]},
 'A3': {'E1': 5252,
        'E2': -26701,
        'E3': -1702563850,
        'E4': [143, 6, 78, 88, 47, 162]},
 'A4': -99}

Вариант №35

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

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

(b'IIYD\x86\x04\x00\x00\x00!\x00\x05\x00\x00\x00%\x00\xc4\x0eE!\xa1\x00\x00'
 b'\x00\x06\x01\x0e\x99rN@\xfcyupfo#\xea\x97\x81\x13\xc5\xf9f`\xd9\x13~\x01l'
 b'\xf6RD\xac\x85K\x8a\x03\x00\xa9\xb7T+\xb0\xa1\xfa\xb3\x9e\xbf\x9a6f\xae\xa6'
 b' \xbbm\xff\x1e\x81\xff\xab\x05\x93H`H^P\xf0\x05Qh\xe8X R\xca\xf5\x02\xe1\xd2'
 b'\xf6\xff\xbewV\x07\xd8\xe3.\x02\x0f\xbf\xb1\x859\x19\xd5\xdb5\x19'
 b'\x15\xf9\xd3\xf3\x97\xdd\xa0YE\x99\x81F\xfc\xfc\xf8\x06\x00k\x00\xe2'
 b'\x92"\x9a\xf9\x89\xc6N\x88\x94\xc8\xd7\x03\x00w\x00\x00\x00\xec\xcf\xe6'
 b"\xd6\xb4\x83\xeag1\x11\x85\x84\xfcUk\xba\xbb'\xa8%z\x00\xd7(r\xbc")

{'A1': 'yupf',
 'A2': [{'B1': 9071, 'B2': 6946514100096702442, 'B3': 25039833},
        {'B1': 63084, 'B2': 996481899971666, 'B3': 726972329},
        {'B1': 41392, 'B2': 12566791848491660282, 'B3': 1840980134},
        {'B1': 7935, 'B2': 5215248164787584897, 'B3': 99635294},
        {'B1': 26705, 'B2': 16213791857797257448, 'B3': 3204445906}],
 'A3': 558173892,
 'A4': {'C1': 3605450732,
        'C2': 9549057488803496884,
        'C3': 2713462462730687996,
        'C4': {'D1': 53,
               'D2': -6855155984298863335,
               'D3': -505251678420122279,
               'D4': [22135, 55303, 12003, 3842, 45503, 14725],
               'D5': [37602, 39458, 35321, 20166, 38024, 55240],
               'D6': [25, -43, -37]},
        'C5': 3161598167},
 'A5': 2567831814,
 'A6': 4232072818}

(b'IIYD\x86\x02\x00\x00\x00!\x00\x04\x00\x00\x00#\x00\xfdT\x90\xa5\x89\x00\x00'
 b"\x00\xf1bhq\xb4\xb7o\xd4bo\x1b\x8au'km\x0f\xc1\\\x05\x8dB\x17\xa3\xb4R_"
 b'\xd4\x1f\x91\xf3{\x9bt\x8d\xe4(?/ F\x81NF"t7\xb94\n\x90\xdc\xd5P[O`F\xeb"zXR'
 b'iE9\x1f\x00W3\xb0:\xaek\xc2\x0f\xc3\x11\x0c{v%U\x03?\xb8|\x04\xb5H\x02'
 b'\x00[\x00\xce\x1e\x9f\xb8+\xdaD\xc8J5\xe6\x94\x03\x00_\x00\x00\x00#\xf3\x95'
 b'\xcad\xd5R\x0b\xb6{1\xf1kF\x11\x1f\xeb\xaa\x88\x1fb\x003\x9c\xabH')

{'A1': 'bo',
 'A2': [{'B1': 35355, 'B2': 386395940051429237, 'B3': 2736210573},
        {'B1': 21172, 'B2': 8402445815831843935, 'B3': 1059644557},
        {'B1': 8239, 'B2': 13346263711293014342, 'B3': 3700427316},
        {'B1': 20693, 'B2': 6375446616389734235, 'B3': 960850258}],
 'A3': 2777699581,
 'A4': {'C1': 3398824739,
        'C2': 17379808458803696996,
        'C3': 2272253938823677547,
        'C4': {'D1': 107,
               'D2': 2699480318423011266,
               'D3': 5239098675229033301,
               'D4': [31, 13143],
               'D5': [7886, 47263, 55851, 51268, 13642, 38118],
               'D6': [-80, 58, -82]},
        'C5': 1219206195},
 'A5': 1902666481,
 'A6': 3564091316}

Вариант №36

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

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

(b'LZDUtx\x00"\x00(\x00.\x004\x00:\x00@\x00FP>\xd9\xd2\'\x00\x00\x00L\xc2\xe56'
 b'\x81\x8eY\xd5\xb8:-, \x8bC\xd4\xaaOR\xb5\xe5/\xbdn:\xf4\xbb\x03'
 b'\xbe\x04\xa5\xe3\x0e\x1e#V\x1a\x8ew\xefO\xd4\xfe+i\xb3\n\xef\xbf\xdf^\xc9'
 b'\xb0\xbbcX\xbf\xea\x18\xad\x91\xe0aD\xbf\xd6\x11\xaa\x1d w\x98\xbf\xc7j\xb9'
 b'\r)+\xb0?\xd8\x1f\x8a\xc3\xd5\xae\x9c?\xd4\\h\xd9\xe9\xf3\x98?\x9a\x9dW'
 b'\xc06\xde\xc0\xfe\x11z(1\x9e\xb9\x91?\xd7\x01\xe4\x90#\xbbLo\xfe\xba"'
 b'\x9dE#\xbc`~?m\x83t\xce\xd5')

{'A1': {'B1': 'tx',
        'B2': [{'C1': 1507178554, 'C2': [45, 44]},
               {'C1': 545997780, 'C2': [170, 79]},
               {'C1': 1387652399, 'C2': [189, 110]},
               {'C1': 989117187, 'C2': [190, 4]},
               {'C1': 2783120926, 'C2': [35, 86]},
               {'C1': 445544431, 'C2': [79, 212]},
               {'C1': 4264257971, 'C2': [10, 239]}],
        'B3': 80,
        'B4': 0.4254314601421356,
        'B5': {'D1': [-0.49016039141638634,
                      -0.8155124520444947,
                      -0.3448281559411668,
                      -0.1829444231283026,
                      0.3769251739929389,
                      0.318140232855336,
                      0.025990840060073905],
               'D2': -139195800422008431,
               'D3': 0.3594905288327268,
               'D4': 8070092240124715964,
               'D5': 6953064614296080085}},
 'A2': 194,
 'A3': 3845554574}

(b'LZDUan\x00"\x00(\x00.\x004\x00:\x00@\x00F\x1b?\x06\x92\xc6\x00\x00\x00'
 b"L\xd6\x9c\xb1\x8a\xf0N_v\x0c\x10O'\xbfKR,\xb7\xe71\xd4\x83.s<O{\xbd"
 b'\xe75\xc7\xcd,Z\x13\xb1\xaa\xa5C\xdf\xfb\xa4\xce\xde\xe3\xd0O\x8b'
 b'?\xe5\xb9\x8f\xf4\xcc\x18\x84?\xee\x10\x84\x18\xaf\xc3F\xbf\xe3(\xff'
 b'\xe4\x857\xea?\xe9\x9d\xe7}\xf02z\xbf\xe0\x02\x8f\x974\x1d\x96\xbf\xd1%\xfe'
 b'widt\xbf\xe4\xa4mJ\xac\x8e\xa6\xfd\x15\xf6\x11Y\x001\xbe?\xe5V\xe6'
 b'\x8ev\x85\xf4\xd6\x90\xc3\xa3\x80\x136N\xa4\x0e\x0f\xa0\xeba\xe4\xad')

{'A1': {'B1': 'an',
        'B2': [{'C1': 1314878988, 'C2': [16, 79]},
               {'C1': 666848082, 'C2': [44, 183]},
               {'C1': 3878802563, 'C2': [46, 115]},
               {'C1': 1011841981, 'C2': [231, 53]},
               {'C1': 3352112218, 'C2': [19, 177]},
               {'C1': 2862957535, 'C2': [251, 164]},
               {'C1': 3470713808, 'C2': [79, 139]}],
        'B3': 27,
        'B4': 0.5256770849227905,
        'B5': {'D1': [0.6789016514965316,
                      0.939516113487209,
                      -0.5987548316277274,
                      0.800525423024353,
                      -0.5003126099772313,
                      -0.2679439703111435,
                      -0.6450716455915042],
               'D2': -209991253234798146,
               'D3': 0.6668579847793681,
               'D4': -2985671445950810546,
               'D5': -6625340817997175635}},
 'A2': 214,
 'A3': 2628881136}

Вариант №37

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

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

(b"IBZ\x00\x00\x00\x19\x00\x02\x00\x00\x00'\x00\x00\x00A,\x08\xfa\x19M\xe2m"
 b'\xd4>\x0b\x9a3zj\xe1cd\x88\xd2\xf4\xcf\x19?\xc4\xf0w\xc4\x8cr \xbdg!\xa7?'
 b'v\xe6\xc1m\x057\x00\xbf!\x01\xf6\x82\x0c\x00\x02\x00\x00\x00?\x8d\xdc')

{'A1': {'B1': {'C1': 0.13633041083812714,
               'C2': 'zj',
               'C3': -2205808853663822055},
        'B2': [{'D1': 0.16358849618053828, 'D2': -0.05642857775092125},
               {'D1': 0.00559115941025623, 'D2': -0.6289361715316772}],
        'B3': {'E1': [130, 12], 'E2': [-115, -36]}},
 'A2': 11272,
 'A3': -6,
 'A4': 25,
 'A5': 19938,
 'A6': 28116}

(b"IBZ\x00\x00\x00\x19\x00\x02\x00\x00\x00'\x00\x00\x00A\xa1Z*\xe91\x0b\xab"
 b'\xa9\xbft\xe9{fyzI\xb4K\xb7W2\xab?\xe9\xb3\xe2-4\xca(\xbd\x9a\xe17?'
 b'\xb3\x9d?\xb9\x95\x9e0?z\xc5\x95\xb5\xc8\x00\x02\x00\x00\x00?o\xce')

{'A1': {'B1': {'C1': -0.9566876292228699,
               'C2': 'fy',
               'C3': 8811772383218578091},
        'B2': [{'D1': 0.803208435338381, 'D2': -0.07562487572431564},
               {'D1': 0.07661817818517913, 'D2': 0.979577362537384}],
        'B3': {'E1': [181, 200], 'E2': [111, -50]}},
 'A2': -24230,
 'A3': 42,
 'A4': 233,
 'A5': 12555,
 'A6': 43945}

Вариант №38

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

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

(b'SGA\x94\x00\x00\x00\x9aJ \xf2\x90\x94\xb9\x15\x1f\xfb\xe49O!K\x1e\xa9'
 b'\xc5\x0f\xc3G\xbe\x8a\x0c,\xd7\xe7$|n:\x90\x9b\xa3\xe4\xbeq\x86\x1d\xc2\x01'
 b'Xl+[\xb34t\x87w\xa1\x93\xae\xa7\xba\xde\x9e\x97\x94\x8c?w\x07\x0b\x8b'
 b'sT\xed\xf0\x98\xa9\xe5\xba\x0bR=\xcf\xa2\xe3!\xdf\x81\xabA\xaadb\xd9\xc7'
 b'Esf\xe7\xfc?QF\x1e\x0c\xbf|x)\x04\x8e\xd0\xb73;\xa8\x08\xa7d\x18\xaa\xbd\xaf'
 b'-\x10\x00\x00\x00\x1c\x00\x00\x00C8\x11\xdf\x05\xaf\xe9\x05\x8b\x9fG'
 b'\xae\xde7_\x91\xa4\xb1\x1a\xb7^\x00j\x86\x86\x98h\xe14\x8af\x90\xd7\xc5/'
 b';\x0bU\x8c\xd6')

{'A1': -108,
 'A2': {'B1': {'C1': -0.9862084984779358,
               'C2': 76468407,
               'C3': 3691729074681813162,
               'C4': -0.08553516864776611,
               'C5': [{'D1': -0.26962411403656006,
                       'D2': -41,
                       'D3': 231,
                       'D4': 36,
                       'D5': 31854,
                       'D6': [4220043979065815430,
                              2144277851865308083,
                              3779794935152357031],
                       'D7': -1159815529,
                       'D8': -27508},
                      {'D1': 0.96495121717453,
                       'D2': -117,
                       'D3': 115,
                       'D4': 84,
                       'D5': -4624,
                       'D6': [11000576152045764047,
                              11737262297694552490,
                              7233583401397348071],
                       'D7': -62959290,
                       'D8': 7692}],
               'C6': 4040255556247160203,
               'C7': -1622692130,
               'C8': 3990067931405530974},
        'B2': 134,
        'B3': [34456, 26849, 13450, 26256, 55237, 12091, 2901, 36054]},
 'A3': 1243673232,
 'A4': [10716620015419013455, 2399044941009371975]}

(b'SGA\xb3\x00\x00\x00\x9a\x149\xbb)r\x14\xcf\x80\\7\x1e5\xc8\xb2\x1a\x10'
 b'@\x10=g\xbe\xd8Z\x89\x8e\xdd\xf0\xc4[&\xc0\xf26\xb7\xe5y\x11\x99:\x04'
 b'\xa1`\x1ai\xbaH\xf9\xecT9\xba\xb2\x00Wf\xc7:\x7f\xd3\xbd\xa0;P*CcA\xc6'
 b'\x93\x07y\x813x\x11;{\xef\x04\x8a<\xd9\x89\xfe,\x81\x15\xf8\xff\x12\xae\xa1'
 b'\xab\x96wb\x90\x96\xbf1!9\xc4\xc7:E\xa7\x9e\x02\x92gM\xac\xe0>\xc0'
 b'\x99\xb3\x00\x00\x00\x1c\x00\x00\x00CIE\xcc\xc8\xe1\xc7pK\xb6M'
 b'\xb1\xe6\x89\x1eHL\x8e\x82\xbb\xee\x00j\xb8\xd6:\xa7}\x0b\xd4q\x8f<r\x90'
 b'\xfbH\xc2\xfd\x02')

{'A1': -77,
 'A2': {'B1': {'C1': -0.6919131875038147,
               'C2': -993576379,
               'C3': 12078094078475873504,
               'C4': 0.37617263197898865,
               'C5': [{'D1': -0.4225657284259796,
                       'D2': -114,
                       'D3': 221,
                       'D4': 240,
                       'D5': -15269,
                       'D6': [2792498085797132561,
                              11041142527600781754,
                              5258493886421709312],
                       'D7': 1466353466,
                       'D8': 32723},
                      {'D1': -0.07823812961578369,
                       'D2': 42,
                       'D3': 67,
                       'D4': 99,
                       'D5': 16838,
                       'D6': [10594570244233630011,
                              8930361577871870462,
                              3206868568839990945],
                       'D7': -1416202398,
                       'D8': -28522}],
               'C6': 5279851301315244107,
               'C7': -1236422170,
               'C8': -8566329947566457874},
        'B2': 184,
        'B3': [54842, 42877, 3028, 29071, 15474, 37115, 18626, 64770]},
 'A3': 339327785,
 'A4': [8220423370067877429, 14461650010536688999]}

Вариант №39

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

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

(b'\xe2BHEI\x00\xabT\xd8H\x80\x1aD"\xfdb\x01\x92&\xe5?\x085\x12/\x81=H'
 b'\xcb\xde*\xb4ebS\xb7\xb2\xd0_\x99\xbd\x95\x8f\x02\xb6\xb3\xc0\xe4'
 b'\x16\x91\xc4\x02\x11\xb1:\x1d\x96R\x9fC\xca\xc8\xed\x12\xbd\x1dRnP\x115\xaa'
 b'\x06iI/\x023\x1b|\xc1\xe72q\x7f\x0c4\x8dcMe\x17\x00$\x00\xe6\xba\x89\xbe\xec'
 b'O\xcf\x1b\x06\x001\x00')

{'A1': {'B1': {'C1': 36653417,
               'C2': -1048831181,
               'C3': 13031,
               'C4': 7299600029152214897,
               'C5': [{'D1': 12050,
                       'D2': 15745,
                       'D3': 72,
                       'D4': 13210010320961724107},
                      {'D1': 53426,
                       'D2': 39263,
                       'D3': 189,
                       'D4': 1649655241609744277}],
               'C6': -0.26900404691696167,
               'C7': [236, 79, 207]},
        'B2': 27,
        'B3': [285394065,
               -1776469327,
               -901537966,
               -1122832952,
               1349407261,
               111818001]},
 'A2': [171, 84, 216, 72, 128, 26, 68],
 'A3': 0.6609582926829811,
 'A4': 13576}

(b'\xe2BHEE\x00\xec\xe9\x881\xf88\x8f\xf4* \x16\xfd\xc6\xd2?C\xa5z'
 b'\xb6\xdb\x14\x1b\x9d\xe1\x8a\xa7_hVV#\xb1y6j\x94\x12\xd7\xb9\x17R\xf7'
 b'\x9d\xa1\x9f\xcc\x98\x80\xe3\x01\x90\xb7\xf2\xbb\x90\xfe\xdf\xe7\xf70!\xb6'
 b"\xfa\x92MD\xa1\x88\xbf(\xb7U\xb9q\xfd\xbb5\x8d'k\xa3\x17\x00$\x00=D_<\xb7"
 b'\x9ch\x1a\x05\x001\x00')

{'A1': {'B1': {'C1': -1589359214,
               'C2': -1222066296,
               'C3': 47445,
               'C4': 11775549138135678321,
               'C5': [{'D1': 46714,
                       'D2': 5339,
                       'D3': 27,
                       'D4': 6221274695300997533},
                      {'D1': 45347,
                       'D2': 13945,
                       'D3': 106,
                       'D4': 11382656845057823380}],
               'C6': 0.013627109117805958,
               'C7': [183, 156, 104]},
        'B2': 26,
        'B3': [-1731420255, -1878924416, -1866730825, -135798786, -88727248]},
 'A2': [236, 233, 136, 49, 248, 56, 143],
 'A3': 0.29339530144413506,
 'A4': 42307}

Вариант №40

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

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

(b'QGN\x00\x04\x00\x00\x00\x13\x00\x00\x000\x00\x00\x00\x91n2hfliEczhc\xc8ohg'
 b'z\xd3kyvo\x90\x98\xf3\xbd\xefJ\xe1\xf0\xc87\xbf\xc4\xd3(\xdee\xde\xa0'
 b"\x9as\x1c\x80F\x0b]\x7f\xa4\x00\x05\x00\x00\x00'\xbe\x93Q\x8a}"
 b'\xfd\xc8\x0b\xbf\xdb\xe2W\xd3\xa9?(\x1110)\x1c\xa7#D\xc3J\xc7\xe0?p\xd1\x88p'
 b'\xdb\xff\xf2\x00\x00\x00\x02\x00,\xd6\x1a\x94\xc1k\xa7\x8d\x9c?]\xd4R\xbfJv'
 b'7\xbc\x88\xdd\xaa\xbetZ\x99\xbe\xb5\xd3\t>\xaef\xc7\x02B\x00\x00\x00\x06\x00'
 b'\x00\x00y')

{'A1': [{'B1': 'hfli', 'B2': 69},
        {'B1': 'czhc', 'B2': -56},
        {'B1': 'ohgz', 'B2': -45},
        {'B1': 'kyvo', 'B2': -112}],
 'A2': {'C1': -0.1626940809180626,
        'C2': {'D1': 2591235200, 'D2': 1175149951, 'D3': -92},
        'C3': [-104, -13, -67, -17, 74],
        'C4': -0.28773146867752075,
        'C5': 2113783819,
        'C6': {'E1': -0.435689884853661,
               'E2': 288436265,
               'E3': 2064657732413868000,
               'E4': 0.940697193145752,
               'E5': 1893466098,
               'E6': [57840, 51255],
               'E7': 3592066241,
               'E8': 1806142876}},
 'A3': {'F1': 578,
        'F2': [0.8665210008621216,
               -0.7908663153648376,
               -0.01670726016163826,
               -0.2386268526315689,
               -0.35512569546699524,
               0.34062787890434265]},
 'A4': 28210}

(b'QGN\x00\x03\x00\x00\x00\x13\x00\x00\x00(\x00\x00\x00\x91\x9e\xaadfrzXvwfo'
 b"\xc9xzvb9\xe8\n\x9a'\x96\x05?\xedE\xf2\x1b\x83\x96|\xd4\xa6\x10\xa4"
 b'"\x04\x11\xa5~\x00\x02\x00\x00\x00">\xf8Q\x8c\x10\x81OM?\xe8\xeb\xc3\xf6'
 b'\xbb\x1fR}\xe9\xeaa\x9d\xbc\x94\xb4\xf4/\xcb\xd9\xbfD=>\x89\xb0\x9d(\x00'
 b'\x00\x00\x02\x00$\xd8+\xf7\xe9V"\x90\xd6?]eB\xbegy\xb0\xbfw\x96G;\x1a,'
 b'\x18\xbf\x12Ko?Fa\r>\xe5\xfe\xcd>\x9erR\t\xda\x00\x00\x00\x08\x00\x00\x00q')

{'A1': [{'B1': 'dfrz', 'B2': 88},
        {'B1': 'vwfo', 'B2': -55},
        {'B1': 'xzvb', 'B2': 57}],
 'A2': {'C1': 0.9147882974036317,
        'C2': {'D1': 3567653028, 'D2': 570692005, 'D3': 126},
        'C3': [-24, 10],
        'C4': 0.4849971532821655,
        'C5': 276909901,
        'C6': {'E1': 0.7787799662555506,
               'E2': 2112481889,
               'E3': 11366123064488086489,
               'E4': -0.7665594816207886,
               'E5': -1984914136,
               'E6': [39463, 38405],
               'E7': 3626760169,
               'E8': 1445105878}},
 'A3': {'F1': 2522,
        'F2': [0.8648263216018677,
               -0.22605013847351074,
               -0.967136800289154,
               0.002352481707930565,
               -0.5714635252952576,
               0.7749183773994446,
               0.449209600687027,
               0.3094659447669983]},
 'A4': -24918}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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