ИКБО-35-22

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

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

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

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

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

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

(b'\xceQRDJ\xe3\x93@7\xbf\x0c\xf74\xb5\x00\x00\x00Qan\x17\x08\xeczM\x1evd'
 b't\xab]\x00\x00\x00\x03\x00\x00\x00\x1a\xaeB\xb13\xb3\xca\x0f\xfbT\x1a:M\xfe'
 b'*\x08\x1e\xc1\xe5\x1f\xa3\x84\x91\x1cB\xf4\x10\x99\xfa(;\xc62\xf9\xe8b\xa6<'
 b'\x81fE\xd2\xe6+N2\xa4\xef\x07\xfe+\x00\x1d\xbfB\x9b\t\x00\x00\x00\x06\x00'
 b"\x00\x00'j\x14\xf1R\x0e\xf4\x9e\x00\x00\x00\x02\x00\x00\x003\x80G\xed=\xd6V"
 b'\xdb\x00\x00\x00\x06\x00\x00\x007\x1f\x1f\xaa\x82\x82\x85\xef'
 b'\x00\x00\x00\x07\x00\x00\x00CV\xcb\xaf\x18\xf7\xf6$:4\x86\x0c\xfd,\xd9=\x9b'
 b'R\x12\xd7\xc5\x9b\x06LW\xac')

{'A1': 58259,
 'A2': 16439,
 'A3': -0.5506470203399658,
 'A4': 181,
 'A5': {'B1': 3120487275780636203,
        'B2': {'C1': -21667, 'C2': 'vdt'},
        'B3': -0.7601781487464905,
        'B4': [{'D1': [-20926, -20173, -19510, 4091, 21530, 14925],
                'D2': [106, 20, -15, 82, 14, -12, -98]},
               {'D1': [-470, 2078], 'D2': [-128, 71, -19, 61, -42, 86, -37]},
               {'D1': [-15899, 8099, -31599, 7234, -3056, -26118],
                'D2': [31, 31, -86, -126, -126, -123, -17]},
               {'D1': [10299, -14798, -1560, 25254, 15489, 26181, -11546],
                'D2': [86, -53, -81, 24, -9, -10, 36]}],
        'B5': [14900, -31220, -724, -9923, -25774, 4823, -14949],
        'B6': 105666476},
 'A6': 7020574196211797278}

(b'\xceQRDJ\xff-;\x1b>\x99dv&\x00\x00\x00R\xd8\x19\xe4\x08q\xbc\x8c\xaeqa'
 b'ef\xc9\xd1\x00\x00\x00\x04\x00\x00\x00\x1a;o\x8d\xdb\xaf\x90\x83&'
 b'\xda\xba+\xd3\x83@\x119~\xde #>\x95\xdea\xbe\x9c\xfb\x1c\xfc\x0e\xe5l'
 b'\xd6\xc7\xe5\x808\x88m\xdfI4\xe8y\xde\xd6\xc9D\x1dE\x00\x1e=Q\xc6^'
 b'\x00\x00\x00\x07\x00\x00\x00(\xd9\xe9\x0e\xd8\xad\xdd&\x00\x00\x00\x06\x00'
 b'\x00\x006e`\xf0N\x93\x84\xcd\x00\x00\x00\x06\x00\x00\x00B\x06\xf4}\xbcy\xec'
 b'm\x00\x00\x00\x02\x00\x00\x00N\xfd8\xd2V\x84\xe2~\x1e<\xa60\xc1\xa1\x02\xf1'
 b'FQ\x19\xb5\x83GOo\x9d\x0f')

{'A1': 65325,
 'A2': 15131,
 'A3': 0.29959458112716675,
 'A4': 38,
 'A5': {'B1': 16751665303062322501,
        'B2': {'C1': -13871, 'C2': 'qaef'},
        'B3': 0.05121456831693649,
        'B4': [{'D1': [15215, -29221, -20592, -31962, -9542, 11219, -31936],
                'D2': [-39, -23, 14, -40, -83, -35, 38]},
               {'D1': [4409, 32478, 8227, 16021, -8607, -16740],
                'D2': [101, 96, -16, 78, -109, -124, -51]},
               {'D1': [-1252, -1010, -6804, -10553, -6784, 14472],
                'D2': [6, -12, 125, -68, 121, -20, 109]},
               {'D1': [28127, 18740], 'D2': [-3, 56, -46, 86, -124, -30, 126]}],
        'B5': [7740, -22992, -15967, 753, 18001, 6581, -31929],
        'B6': 1332714767},
 'A6': 15571727911529254062}

Вариант №2

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

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

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

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

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

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

(b'ZREC3\x82\x00\x06J\xfaj?\x95\xf84\xe4P\xb6$\x9e\xc1;B\x98\xb4\xec\xbdT'
 b'`\xc1\x01\xc9\xe8\xb4\xa2\x1c\x99\xf7\xdd\xbfP\xbe\x15\xda\x15\x99\x13\x1e'
 b'\xf3\xec\x002\x08\xe4\x96\x92\xd6\x14m^u\xd11\xb4R@\xae@\x0c\xcc\\\xf8'
 b'\xf9j\n>\x0c\xc0\x99\xba@\x93\xfa\xd9)\x90\xe8N\x95\xb7\xee\xb9\xb17\xef\xdc'
 b'\x01\xa8\rZ\xbd\xc8>\xf4\xdc\x05\t\xc7&I\x92\x9e\x15L\xcc\x89\xfc\x84\x94c'
 b'\xb3\x15\x90\xa2\x8f\xde\x12\xd5\\*\x02\x00S\x00\x00\x00\x02\x00W\x00'
 b'\x00\x001\x02\x00Y\x00\x00\x00\x05\x00]\x00\x00\x00A\x02\x00b\x00'
 b'\x00\x00\x04\x00f\x00\x00\x00\xe7\x02\x00j\x00\x00\x00\x03\x00n\x00\x00'
 b'\x00\xb1\x02\x00q\x00\x00\x00\x04\x00u\x00\x00\x00]\x02\x00y\x00\x00'
 b'\x00\x05\x00}\x00\x00\x00y\xe0\xe2\xfa>)?\x15\xd2\x98\xa2\xf1\x8f<\x16(TH')

{'A1': {'B1': [{'C1': [10713, -6000], 'C2': [78, 149], 'C3': 49},
               {'C1': [-4425, -20039], 'C2': [55, 239, 220, 1, 168], 'C3': 65},
               {'C1': [23053, -14147], 'C2': [62, 244, 220, 5], 'C3': -25},
               {'C1': [-14583, 18726], 'C2': [146, 158, 21], 'C3': -79},
               {'C1': [-13236, -887], 'C2': [132, 148, 99, 179], 'C3': 93},
               {'C1': [-28651, -28766],
                'C2': [222, 18, 213, 92, 42],
                'C3': 121}],
        'B2': {'D1': 58080, 'D2': 0.6611171960830688},
        'B3': -11755,
        'B4': 6064121347623199384,
        'B5': 72},
 'A2': [1794787846, 888706367, 615928036, 1111212446, -1108560744, 29450324],
 'A3': [-2452323123812046647,
        1412183984569209023,
        -7573919662473415906,
        3589779426408453778,
        6686733018679235252,
        -7367875529775842824],
 'A4': -91012934}

(b'ZREC3\x81\x00\r\xc2\x19\xbb3\x94g\xb4\\\xc2:\xec\x04w;\r\xf8a{\xea@'
 b'\x1d}\xd5\xe1\xed\n\xf6%\xbfw#\xf9\xd2$\xdb\xc4O\x88W"\xd1V\xb2\xa5Z\x010b'
 b'\xdb\xd6\xf99rVp\xdd\xa4B\x17\xa3\x13\xbe\xcb\xc6\r\x05]?\xe8s\xe8\xb5'
 b'|3\x0b5\xc3Gy\xc7\x19\xc1\x1ci\xaad\xbb\xb7Z\xb21\xef\xed\xb4n[\xbf2gF'
 b'\xc4\xd3\xf1UfC6\xea\xb7\xd4*\x82|\xfd=\x16\xc9\x93I\x9bh\x02\x00S'
 b'\x00\x00\x00\x03\x00W\x00\x00\x00\xfa\x02\x00Z\x00\x00\x00\x05\x00^\x00'
 b'\x00\x00\xb4\x02\x00c\x00\x00\x00\x02\x00g\x00\x00\x00\xc0\x02\x00i\x00'
 b'\x00\x00\x04\x00m\x00\x00\x00\x85\x02\x00q\x00\x00\x00\x03\x00u\x00\x00'
 b'\x00\x8c\x02\x00x\x00\x00\x00\x05\x00|\x00\x00\x00,\x7f\x92\x99"\x85'
 b'\xbe?\xea?<[5\x032S\xdf\xca')

{'A1': {'B1': [{'C1': [-15563, 31047], 'C2': [199, 25, 193], 'C3': -6},
               {'C1': [26908, 25770], 'C2': [187, 183, 90, 178, 49], 'C3': -76},
               {'C1': [-4625, 28340], 'C2': [91, 191], 'C3': -64},
               {'C1': [26418, -15290], 'C2': [211, 241, 85, 102], 'C3': -123},
               {'C1': [13891, -18454], 'C2': [212, 42, 130], 'C3': -116},
               {'C1': [-644, 5693], 'C2': [201, 147, 73, 155, 104], 'C3': 44}],
        'B2': {'D1': 37503, 'D2': -0.2600295841693878},
        'B3': -5569,
        'B4': 16092260882886376511,
        'B5': -54},
 'A2': [-1155939827,
        -1268280269,
        -331693476,
        222000900,
        -361012744,
        -713220800],
 'A3': [2555721483318652385,
        6307378985041187577,
        3459145656505389346,
        8094782973575355234,
        -3765550647244315427,
        -1696757275747349050],
 'A4': 187923637}

Вариант №3

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

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

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

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

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

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

(b'\x92BQWUB\x00\x00\x00|\x84p\xf0\x9bd\x03\x00\x00\x00_\x00\n\xfaU'
 b'\xef\x0e\xd8\x96\xe1?\xcc\xf0\xc1s\x9d!\xe5\xbf\x8bD\xfbl\x82\xba'
 b'\xb9X\xe8\xe1\xe8,\x9ch!|\xc8\xbfm\x16\xaa\x92CZ\xe7j\x14]Kv2h\x0cc'
 b'\xeb\xc5\xa6\xeb\xd2\xbfoq\x02\x00\x00\x00\x1e\x00\x03\\\xbb\xf8Sd\xc82\xbfA'
 b'\xcfnL\xc9\x81 \x08\xc91\xa6\xdaJ\xce\xe8\xd9\xa1h\x85a\x9f\xaa3a')

{'A1': {'B1': 1748137547,
        'B2': -0.2956330235297606,
        'B3': 'oq',
        'B4': [{'C1': -0.6603533993616337,
                'C2': 1828406411,
                'C3': -17790,
                'C4': -504866631},
               {'C1': -0.19128816230691048,
                'C2': 2460620397,
                'C3': 23107,
                'C4': 1561619175}],
        'B5': [3, 92, -69, -8, 83],
        'B6': -0.6983702182769775},
 'A2': {'D1': 124,
        'D2': 2616225924,
        'D3': 100,
        'D4': [585610653128904513, 15702026921718460873, 7004129447003908257],
        'D5': 10},
 'A3': 0.5496635715196014}

(b'\x92BQWUB\x00\x00\x00\xb9H\x91\xe7\x18\\\x02\x00\x00\x00_\x00,`X/)\x0f\xbe'
 b'\xd6?`s\xcc\x00\xb4q\xa2\xbfj\x0c\x89\xa7\x87\xebC\x16o \xb82e\xd1a\xb9\xe1?'
 b'\xe8\xe1\xf0\xb0\xf68!\x80\xf7\xc8\x8f\xb6a\xdd\x96\xe8\xcd\xc7\xd8$'
 b'\xe2\xbfdl\x02\x00\x00\x00\x1e\x00\xde6\x94\xe5\x96\xd5u\xc0>\xe1F\xfd\xb97'
 b'\r\xbfCp4\x17[U\t\xbd!')

{'A1': {'B1': -580798833,
        'B2': -0.5669979002407384,
        'B3': 'dl',
        'B4': [{'C1': -0.03602373609303444,
                'C2': 2810776682,
                'C3': -5241,
                'C4': 544151107},
               {'C1': 0.5538796510459951,
                'C2': 2968576488,
                'C3': 14582,
                'C4': -923303903}],
        'B5': [-34, 54, -108, -27, -106],
        'B6': 0.37589898705482483},
 'A2': {'D1': 185,
        'D2': 417829192,
        'D3': 92,
        'D4': [4881635054087653089, 2431109636055053424],
        'D5': 44},
 'A3': 0.35535029432265297}

Вариант №4

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

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

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

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

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

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

(b'JPWOo\x02\x00\x00\x00G\x00\x00\x00wC\xb0\xb0\x08DEg[\x8f\x88\xfb\x05\x8aL'
 b'\x9b\xe1\xffz\xb1\xed\xe2a\xe8.>w;-\xbf\x8191\xbfy\xdc:\xbeH\x95\x0c?\x9b'
 b'p\x0e\xbfQ\x00ymdW\x96tfbaq=\x00\x00\x00B\x00\x00\x00\xb5\xcbT>\xe8'
 b'\xf1\x90\x9c\xdf?\xbaC;\xbf\x02\x00\x00\x00O\x00')

{'A1': [{'B1': 'ymd', 'B2': 38487}, {'B1': 'tfb', 'B2': 29025}],
 'A2': [{'C1': -1330625673, 'C2': 17416},
        {'C1': -1889835195, 'C2': -1144},
        {'C1': -1689482747, 'C2': -31},
        {'C1': -487739014, 'C2': -6047},
        {'C1': 997670446, 'C2': -16595}],
 'A3': [-0.6922836899757385,
        -0.18248166143894196,
        0.5491528511047363,
        -0.5564057230949402],
 'A4': {'D1': 0.4939310419440279, 'D2': -0.7315021753311157, 'D3': [181, 203]}}

(b'JPWOo\x03\x00\x00\x00L\x00\x00\x00\xceQ\x08\xafeh\x14|B\xa7z\x9e6\x10\xa2'
 b'l\xb9c\x1d|\xa9\xfd\xe8\x86G\x84\xf72\x18rl\xc2\x80\xbe\x1eb\x82>\xc3'
 b'ec\xbf\x14Q\x13?[\x00uwbZRxqxm\xa2ekr\x167=\x00\x00\x00B\x00\x00\x00'
 b'G\x00\x00\x00\x12\xf6Z\x081!\xc9\x16\x9f\xda?p\xd2U?\x03\x00\x00\x00X\x00')

{'A1': [{'B1': 'uwb', 'B2': 21082},
        {'B1': 'xqx', 'B2': 41581},
        {'B1': 'ekr', 'B2': 14102}],
 'A2': [{'C1': -1358409266, 'C2': 26725},
        {'C1': -1488815084, 'C2': -24966},
        {'C1': 1822560310, 'C2': 25529},
        {'C1': -39224291, 'C2': -31000},
        {'C1': 855082055, 'C2': 29208}],
 'A3': [-0.25148332118988037,
        0.25465482473373413,
        -0.8882715106010437,
        0.575455904006958],
 'A4': {'D1': 0.4159600223690778,
        'D2': 0.8352422714233398,
        'D3': [18, 246, 90]}}

Вариант №5

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

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

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

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

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

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

(b'GUR\x02\x00\x00\x00s\x00\xf7\xcf\x11\xe0q<\x93E\xf0 0\x9b\xb5\xb6\xc9'
 b'\xbf\xf6\x88\x12M\xa4\xf7q\xa6E*\x05\xeaT\xba\xa3qkPu\xec?\x8d\xee'
 b'y\x00\x00\x00\xe4\x14\xbdGBP\xbcu\xde\x19GzQ[\xe3\xbf\x8a\x8e\xb6!'
 b'\xda\x18\xbb\xe7\x7f\xdb \x8f1\xdes\x13\x11\x12\x99\xe8?\xb3\xa3\x9b'
 b"\x00\x00\x00\x1e'\x95\xbe\xfe\xcfK\xe7;k\xe0\xbf;6\xff\xc35h1{vp\xc5\xfe\xd0"
 b'\x10\xdc\xfe\x90\x82\xf4\xaa\x9a\x05\xa1#\x84\xe9\xf5\x1a\x9c\x07\xb5X\x02'
 b'\x00\x00\x00u\x00\x00\x00\x85Y\x05\x9e\xe1Y/\xa5\xc3\x05\xde\x03L'
 b'A\xc8\xd0\x9fv\x18Kwq\xa1\xa3\xee\xb6\x02\x00\x00\x00\x97\x00\x00'
 b'\x00\xbc\xecjP')

{'A1': 'vp',
 'A2': [{'B1': [-12297, -8175],
         'B2': {'C1': 1167277169,
                'C2': -0.20088834836520375,
                'C3': 246,
                'C4': 5018824143178371720,
                'C5': 1424622890,
                'C6': 0.8893205736650238,
                'C7': -4467},
         'B3': {'D1': 2190540508,
                'D2': -1620130791455806732,
                'D3': [-11, 26, -100, 7, -75, 88],
                'D4': [65221, 4304],
                'D5': -1643816571}},
        {'B1': [5348, 18365],
         'B2': {'C1': 1975275586,
                'C2': -0.6048972500073508,
                'C3': 138,
                'C4': 9216540877850261134,
                'C5': 831463643,
                'C6': 0.7686853726878515,
                'C7': -23629},
         'B3': {'D1': 64882115,
                'D2': 5411205381060313420,
                'D3': [119, 113, -95, -93, -18, -74],
                'D4': [23009, 42287],
                'D5': 1349184700}}],
 'A3': -0.2913140654563904,
 'A4': -0.5130900876524718,
 'A5': 8876990920654796347}

(b'GUR\x02\x00\x00\x00s\x00\x03;=\xd3\xee\xa0\x99z\xbe\x9f\xde\xad\x12{\xed'
 b'\xbf\x08\xff\x08\xac\xff\x00\x0f\x9cS\xf5(\xca\x9a0\xeb\x16\xc8\x9aF'
 b'\xd8?\x1a\xf4y\x00\x00\x00\x1f\xd9O\xb9\xa2V\xd0r\xd0\xf1\xc4X\xd7\x1b\xba?'
 b'\x02\x94\x03\x95\xdb"\x82\x84\xb1^h\xcf\xb5@m\xf1x\x12\x11\xb0'
 b'\xbf\xd1\xa2\x9b\x00\x00\x00\x8b\xfcd?\x18\x89a\x8a\xc6T\xdf\xbfQ[\t&\x99'
 b'E-\xc1gnI\x81No\xf5\x87?\x18v\x7f\xd0\xac&\\\xcb70\xbb\x13\x8a\xaf\xfc\x02'
 b'\x00\x00\x00u\x00\x00\x00e\x1f-)te&\xe3F?\xe3\xf4\xeb\x80\xfc&\x91\x02?\x1bp'
 b'~So\xc5\x12\x02\x00\x00\x00\x97\x00\x00\x00?\x8f\x82\xa0')

{'A1': 'gn',
 'A2': [{'B1': [15107, -11459],
         'B2': {'C1': 2056888558,
                'C2': -0.9212735553637612,
                'C3': 8,
                'C4': 6024706898478762239,
                'C5': 2596940021,
                'C6': 0.3793093637465743,
                'C7': -3046},
         'B3': {'D1': 406816757,
                'D2': 4020408413536157558,
                'D3': [48, -69, 19, -118, -81, -4],
                'D4': [33097, 28494],
                'D5': 690823013}},
        {'B1': [-9953, -18097],
         'B2': {'C1': 1926256290,
                'C2': 0.1019873229715309,
                'C3': 2,
                'C4': -5655252145846025324,
                'C5': 3050268766,
                'C6': -0.06276050045692205,
                'C7': -23855},
         'B3': {'D1': 4108533574,
                'D2': 1963290785004421355,
                'D3': [112, 126, 83, 111, -59, 18],
                'D4': [25972, 58150],
                'D5': -1602056385}}],
 'A3': 0.8944784998893738,
 'A4': -0.48954928888100957,
 'A5': -4526885526367020207}

Вариант №6

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

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

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

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

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

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

(b'CNYP\xda\xbb:\x1a\x9d>\xf5\x00\x00\x00\x05\x00\x00\x00\x1d\x02r\x00\x06\x00'
 b'F\x00R\x00\xaeuqnjy>Pn\xad\nf\xbfB\xaf\x04\\\xf2\xbfsZ\xe6\xb5\x08\xbeI{\x14'
 b'\xb7O?1\xa6\xc9\x19\x95\xbfSf\x829R\x00"\x00(\x00.\x004\x00:\x00@\xbf\xee'
 b'\xcf\n\x0fz<j?\xe6\x9d\xd3\\P\x0c\x88\xbf\xbdn\xadTS\xdd\x10\xbf\xe1'
 b'\xd8\xf9\x90\x1d\x9e\x08\xe3\x13\xa5NJR+&\x7f\x9c{\x96\xf5\xa2GK\x05F'
 b'\xcdl\xe8 \xee\x14.\xff\xe6\x8e\xdd\xcf\x85\xd8\xf3\x98d\xe9Df'
 b'\xae\x0e\xf4\xc4(c\xaf\xc7\x9fI=2EW\x1fE\x99\x17\xc9\xbf\xac\x9f\xc8>ta_\xcf'
 b'\xb6\x1f\x84>Ohk\xfe\x12\xfb')

{'A1': 5826174926186168053,
 'A2': 'uqnjy',
 'A3': 626,
 'A4': [{'B1': 0.20354719460010529, 'B2': 2662},
        {'B1': -0.7604830265045166, 'B2': 23794},
        {'B1': -0.9506057500839233, 'B2': -19192},
        {'B1': -0.19675856828689575, 'B2': -18609},
        {'B1': 0.6939511895179749, 'B2': 6549},
        {'B1': -0.8257828950881958, 'B2': 14674}],
 'A5': {'C1': [-0.9627733518881432,
               0.7067658236486674,
               -0.11497004803446864,
               -0.5577361883887884],
        'C2': [16362603626840075046,
               9195360427480074059,
               380217086194019860,
               3386678946087011800,
               17552890500714245646,
               17637266449305673545,
               4409663225638263063],
        'C3': 3384781983},
 'A6': {'D1': [-935431071, 1607448095, -2076291224], 'D2': 1811813115}}

(b'CNY\xedJ\xa8m\xa1e#\xa6\x00\x00\x00\x05\x00\x00\x00\x1d\x85B\x00\x05\x00'
 b'@\x00J\x00\xa6ioxfa\xbfw\xaa\x1a\x01_\xbekc^,\xba?:\xa7\xfcF\xc9>\x91\x9d)'
 b'~\x00\xbe\xbc51\x84\xe6\x00"\x00(\x00.\x004\x00:\xbf\xe3\xccT0('
 b'\x13\xf8\xbf\xa4\x9f4z\xf2\x9f\x00\xbf\x86\xe4\xf7N\xb0\xd4\x00?\xef'
 b'7\xa15\x86\xbf\xe2\x02^Oj\x1b\xe9\xf3\xb2\x9d\x93{\xa3\xd5f\xab\xc9\xfch'
 b'9I\xee\x02u+i\xb3\xf2jf*\x12\xfa\xa6wdC\xaf\x864\xc6`\x0cK\x88\xb6\x03'
 b'm\xe6\xe4\xd4\xaa\xc8\x13\xf3k\xa3DP\x12\xebI\xd34\xc8\xb5\x0f'
 b'\x13\xda\x9f\x97\xcc\x981\xa8\xd7\xfb')

{'A1': 17098664124078171046,
 'A2': 'ioxfa',
 'A3': 34114,
 'A4': [{'B1': -0.9674392938613892, 'B2': 351},
        {'B1': -0.2298712432384491, 'B2': 11450},
        {'B1': 0.7291257381439209, 'B2': 18121},
        {'B1': 0.28440216183662415, 'B2': 32256},
        {'B1': -0.36759331822395325, 'B2': -31514}],
 'A5': {'C1': [-0.6186924877698621,
               -0.04027713776423347,
               -0.011178905571890496,
               0.9755407376705956],
        'C2': [170661153040102322,
               11354555029121313737,
               18187850084824282411,
               7616697933608129274,
               11995166374395000006,
               6920989777902923238,
               16488991912015129507],
        'C3': 1146098411},
 'A6': {'D1': [1238578376, -1257303078, -1617441640], 'D2': 833148923}}

Вариант №7

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

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

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

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

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

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

(b'PGFY\x0e\xae\xf5\xd9P\x1f)\xde-+\x00\x00\x00\x86\x91\xac\xc1ce\x07'
 b'\xabX\x1c\x8aw\x92\xb9h(p\xaa\x02\x00\x00\x00\x1d\x00\x00\x00\x8b\xbfJp\xae'
 b'L\xd8L\xf8w\xfe\xd9\xfd~\xc4}\xf9N\x03\xbfd\x9dy\xa8!\x00\x00\x00\x10'
 b'\x12}\x12(\x99\xc0{O\xb5\x85!\xcdJi\xbfA\xa0*\x18\xfe\xee\xc9IQ\xfce\x117'
 b'\x92\x1b\x98\xa7\xfa\x9a\xa5UQ\xdc\xc5\xb0\xd7\x83)\x9c\xdby\x87\xd7'
 b'\x18\xe1\x93\xe3w')

{'A1': 3305124391013709230,
 'A2': {'B1': [{'C1': 1883946891, 'C2': 15708124458639707310},
               {'C1': 2110029565, 'C2': 12139907326580838137}],
        'B2': {'D1': -21904, 'D2': [47506, 10344]},
        'B3': [310186512, 2076219688, 562410831],
        'B4': -0.911297619342804,
        'B5': [41025, 6186, 61182, 18889, 64593],
        'B6': [2453082469,
               4205287451,
               1364567450,
               3618686428,
               3684444547,
               416778105,
               2011403233]},
 'A3': -6122813689261420154,
 'A4': 7256,
 'A5': -118,
 'A6': 119}

(b'PGFY\x0edD\xa6\xbc\x89jH\xc0-\x00\x00\x00=r@\xb6\xa5\xc0\xcc\x9b\x1a}\xef'
 b'@\x94\xed\x11\xe4}\xe1\xef\xac\x03\x00\x00\x00\x1d\x00\x00\x00\xae\x9a\x8e'
 b'\xdd\xc9\x9a \xad\x98\x80^\xe8\xbe\x89\x98\x0fX\x00;J\xf1\xe8\xb9'
 b'\xbc#\x00\x00\x00L\x83\xfb\x10\x8a74\xf4\x1f\xc2M\x05\x8d\x83e?p\xf2\xc4'
 b',\x02\x90\x9d\rU\xe2\x9a\xcf\xf1\x02oe\xa7\x9d\xe4m\x9eB.<\xcb\xccBm]b\x0f'
 b'P\x9d\x10\x05\x00W\xf7')

{'A1': -4591302680296143772,
 'A2': {'B1': [{'C1': 3717110446, 'C2': 16743961857838062281},
               {'C1': 261654974, 'C2': 13599156672852066392}],
        'B2': {'D1': -21265, 'D2': [60820, 58385, 57725]},
        'B3': [284918604, -197904502, 88982047],
        'B4': 0.8965385556221008,
        'B5': [62064, 11460, 36866, 3485, 57941],
        'B6': [49401754,
               2644993391,
               1117679076,
               3435871278,
               1650289986,
               278745103,
               4149673989]},
 'A3': -7220184284621934019,
 'A4': 32026,
 'A5': -17,
 'A6': 64}

Вариант №8

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

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

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

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

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

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

(b'BHD*\x00\x00\x00W>\xdc\xa5\xc2\xdf\x9cc#\x82Y\n\x122FI\xe1Y\x9a\xe5\xc9'
 b'\x92:\xa1\\\xde\xdd\xcd\x16\x9c\xcf\x02\x00b\x00\x81\xbf:\x99X\xba'
 b'\x19\x13\xba\x9f\xa8\x91\xe53\xa9\xce}\xc7>>l\xbe[\xbb\xa7\xbe\xa4\x804\xbf'
 b'B\r\\\xbf\xe0\xd6\x07?\xc7\x00\x84\xbe\x82\xfa\xb2>\x1e\xee;\xefQ:J\x88'
 b'\x9c\xc0\xffY5\x18\x03\xe8\xf0\x92')

{'A1': {'B1': {'C1': 49025,
               'C2': [{'D1': -1168598726, 'D2': 2679771929},
                      {'D1': 870683048, 'D2': 3346910889}],
               'C3': [-0.23070618510246277,
                      -0.32760128378868103,
                      -0.7050879001617432,
                      -0.8595772981643677,
                      0.5306224822998047,
                      -0.25781843066215515,
                      0.3495674729347229],
               'C4': 4013682206,
               'C5': [81, 58, 74],
               'C6': 136,
               'C7': -16228},
        'B2': 15959,
        'B3': -36,
        'B4': 6449756527088616101,
        'B5': [4618, 17970, -7863]},
 'A2': -907699623,
 'A3': 14994,
 'A4': 14959857135664389281,
 'A5': [406149631, 2465261571]}

(b'BHD*\x00\x00\x00\xd7\t\xf0\x89\xadkA\r\x1b\xe0R\xabJs\x0eJd>G\xe1\xcb'
 b'\ra\xc1\xf8B\xea\xf8\xf0\x13P\x03\x00b\x00B\x07h\xb7b3\x07\xd0JD'
 b'\xe9C\x87\xd3\x83\xa1\x9b\xffb\xe9z?\xc03Q\xbe[\xd3\xfc\xbe\xa9x0?'
 b'\xa6\x9by\xbf\x04\xedA?\xcd\x00S\xbe\xc1\x10~K`\xcd\x88\x1b]!\x87\xf0'
 b'fg\xc5\x91+u\x00\xf0\\\xc3')

{'A1': {'B1': {'C1': 1858,
               'C2': [{'D1': 862107496, 'D2': 1145753607},
                      {'D1': -746109975, 'D2': 4288389507}],
               'C3': [0.9801236391067505,
                      -0.2042989730834961,
                      -0.49380001425743103,
                      0.689341127872467,
                      -0.9750312566757202,
                      0.7575228214263916,
                      -0.20605774223804474],
               'C4': 1266553025,
               'C5': [96, 205, 136],
               'C6': 27,
               'C7': 8541},
        'B2': 2519,
        'B3': -16,
        'B4': 5971802849639378313,
        'B5': [19115, 3699, 25674]},
 'A2': -874428610,
 'A3': 24845,
 'A4': 5770220499464550593,
 'A5': [1734799495, 1965789637, 3277647872]}

Вариант №9

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

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

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

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

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

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

(b'TVJK\x84\xbe\xc0\x97\xad#\xf4fz\xc1N\xf20\x00\x02\x00{\xbf}\xd2\xb3G\xf2\x88'
 b'@\x80\xa5\xba7\x84\x15\xd3\x8f\xa6>\x00\x00\x00\x04\x00\x83\xe8\xb6\x1a'
 b'N{\xed\xee\xa1\x8e\x95g\xb2!\xc3\xebyu\xe7\xa4\x00\x02Wc\x92\xbfkj'
 b'\xbd\xf5\x10\xa3F\x05R\x84\xf6\xcb;\xb6*\xbcCm6\x94\xf6\xad?\xe8\x8a\x1f'
 b'``\x7f\xe6\xf0R\r\x05z\xf6\xc7UXkfs@vJ\x19\x7f:\x9bTchq\x00\x00\x00e\x00'
 b"\x00\x00p\xa7\x13\xf2s\x0b\xc1'\xfe")

{'A1': -0.3761571943759918,
 'A2': 2590808363060097584,
 'A3': [{'B1': 5912387911491736920, 'B2': 'kfs'},
        {'B1': 4644981539048430420, 'B2': 'chq'}],
 'A4': {'C1': -0.9914962649345398,
        'C2': 18418,
        'C3': 9817988636949840917,
        'C4': -745560514,
        'C5': {'D1': [-22765, -3469, 3009, 10238],
               'D2': 3904248398,
               'D3': 123,
               'D4': -4626,
               'D5': -95,
               'D6': 2392156082,
               'D7': 2433047130611885056},
        'C6': 2,
        'C7': 1466143423,
        'C8': [27498, 48629, 4259]},
 'A5': 5045529688568183734,
 'A6': [716981101, 915732141],
 'A7': 0.7668606645929656,
 'A8': 240}

(b'TVJK\x84>[J\x83v8+\x85\xab\x9f\tr\x00\x02\x00{?M\x1biV]\x00)\xdb\xe2\xe5'
 b'\x06\x9e\x82\xf0\xf3\xd9\xd5\x00\x00\x00\x04\x00\x83\xda\xcd>P\xe1}\x05'
 b'\xfd\xa9C\x18\x94\x87Z\x0cH\x8a\xe0(\x9d3\xb1V\xb1\xc91\xbb\x91\x8e\xca\xcd'
 b'\xd3\xb3\xd4\xf9mG.\x9c\xdc\xbe={/\xec\xfd;\xbf\xc5\xbf,\xcd ]\xa8'
 b'\xa4\x85\xabO\x1d\xc3G\xc62veu\xe1\x13AG)\xe3\xbe\xdbcde\x00\x00\x00e\x00'
 b'\x00\x00p\xe7~A^\x08\xaak\xe2')

{'A1': 0.21415142714977264,
 'A2': 8518606548281264498,
 'A3': [{'B1': 9631879217310844466, 'B2': 'veu'},
        {'B1': 16218378456992562907, 'B2': 'cde'}],
 'A4': {'C1': 0.8011994957923889,
        'C2': 22109,
        'C3': 11782241596644994,
        'C4': -252454443,
        'C5': {'D1': [-6274, 16734, 2218, 27618],
               'D2': 3670883920,
               'D3': -31,
               'D4': 32005,
               'D5': -3,
               'D6': 2839746708,
               'D7': 9753121448731355293},
        'C6': 51,
        'C7': 2975248841,
        'C8': [12731, 37262, 51917]},
 'A5': -3191973543130222948,
 'A6': [-591512197, 804060475],
 'A7': -0.16989669815005226,
 'A8': 164}

Вариант №10

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

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

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

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

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

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

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

(b'SJNSt\x00\x00\x00\x89\x9a\xe1\x90\xf9\x8a\xc0\x0fY\x18\x97\xa2'
 b'\x81\x00\x00\x00\xdc\xe6\xff+\x07\x17\xf2\n\xe7\xb3\xe4\xc0\x8e\x00\x00\x00'
 b'\xbf=G\xee&\xd2\xe6\xdb\x0cU\xf2=&\x88\x0fA\xbf\x18&\x86\xd8\xa3f"'
 b'\xa3\x94\xfaR,\xe4h\xbfV\t{\xdb \xd2Q#\\}~>\x02\x00\x9b\x00\x00\x00\x03\x00'
 b'\x9d\x00>r\x7f\xe9\xf5s( [\x94T\x1c\xbf)\xea\xbb\t_j\xd8\xe9\x7f~\x92d\xbf'
 b'\x00P\x8b\x15\xc2\xf0\xe5?\xe9\xde;-\xbf\x96\x00\xc4u\xb6#\xee\xbft$D'
 b'+?\x12\x92\xf4uz\xcc\xef\xbf\xd3jzN)O\xbe\xa8\xfaB\xbf\xad\x0b\xf1\xbe')

{'A1': [{'B1': {'C1': -0.8928602933883667, 'C2': 0.6856394215378714, 'C3': -23},
         'B2': 1135059910579559049,
         'B3': 2727811161},
        {'B1': {'C1': -0.6766947507858276,
                'C2': -0.9418594646558798,
                'C3': 116},
         'B2': 788718204313659100,
         'B3': 3236213735},
        {'B1': {'C1': 0.6690084934234619, 'C2': -0.9937107375922685, 'C3': -45},
         'B2': 15845583403597905343,
         'B3': 1039291660}],
 'A2': 38,
 'A3': -0.754143238067627,
 'A4': 24,
 'A5': {'D1': 10710442163048056358,
        'D2': 21242,
        'D3': -0.9097316265106201,
        'D4': 3682273622,
        'D5': 53792},
 'A6': {'E1': 9041,
        'E2': 0.24852508306503296,
        'E3': 'jz',
        'E4': [-0.20230600237846375, -0.7616372108459473, -0.4707922041416168],
        'E5': [62, 114, 127, 233, 245, 115],
        'E6': 8232,
        'E7': 91,
        'E8': -0.6106655597686768},
 'A7': 41,
 'A8': 9217136063763037162}

(b'SJNSt\x00\x00\x00>\xb5\xbbe\x89\x0bs\xbd\xe1\x83>@\x81\x00\x00\x00'
 b'\x98\xe1\x9c\x80b\x80\xd9\xd2\x07\xa0\x95B\x8e\x00\x00\x00\x11\x9e\xfa\x14'
 b'x\xe4\xaa_\xef\x1ao\xa7\xae\xf4\x0e\x12?\xb5\xe4\xcd\xc2\x048\xee'
 b'\xed\xd0\xea\xf5\x19CF=\x96F\xf2x\x8f\xc8\xab\xa7U\x16\xf2=\x02\x00\x9b\x00'
 b'\x00\x00\x04\x00\x9d\x00\\\xd1\x07n\xae\xff\xe8(g)\x95\xcb\xbeS?\xba\x18T'
 b'0(\x9a\xce\x06\xa2~\xbf\x10\x8d\x18\xf8U\xed\xd7\xbf\xc2n]I?X\xac{'
 b'\x03\xa4\xf2\xec\xbf\xd6\x19\x96P\xbf\x8e\x01`\xb6d\xb2\xe3?\x82q'
 b'q\xe1\x1b\x07?\xf7\x1a\x1b?\x9c\x19\x10?\xfb\xdc-\xbf')

{'A1': [{'B1': {'C1': -0.9946597814559937,
                'C2': -0.37386082866778825,
                'C3': -62},
         'B2': 13651267580235330878,
         'B3': 1077838817},
        {'B1': {'C1': 0.7865818738937378, 'C2': -0.9046192234067219, 'C3': -42},
         'B2': 15193315978463994264,
         'B3': 1117102087},
        {'B1': {'C1': -0.8147903084754944,
                'C2': 0.6155265390407736,
                'C3': -126},
         'B2': 6893573384043142673,
         'B3': 2809076463}],
 'A2': -82,
 'A3': 0.5705406665802002,
 'A4': -75,
 'A5': {'D1': 15054951053734890980,
        'D2': -2582,
        'D3': 0.04840383306145668,
        'D4': 2029143702,
        'D5': 51343},
 'A6': {'E1': 42923,
        'E2': 0.11820665746927261,
        'E3': 'qq',
        'E4': [0.527769148349762,
               0.6058802008628845,
               0.5628907680511475,
               -0.6791531443595886],
        'E5': [92, 209, 7, 110, 174, 255],
        'E6': 10472,
        'E7': 103,
        'E8': -0.39762237668037415},
 'A7': 83,
 'A8': 14887255706261043775}

Вариант №11

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

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

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

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

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

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

(b'pBPP\x000h\xaf\xa6{\x0b\xf40\xd5\x00X?\xd0;\xec\xf4\x03\x94D\xbb\xff\xc5\xce'
 b'c4\xbf\xe1\xe8\xc0\x08\xb6\xef\xa1\xaci\x00\x00\x00\x03\x00\x00\x00u'
 b'^\xc3\xd6T\xc4\xfb\x8a\x8c\x13Ic\xbb\xf9\xf9$Ib\xe2\xc8\t6.P\x7f\x97\xcb=v'
 b'tzvu>\xe1\x81e\xbe\xe9#\x99\x00\x00\x00\x05\x007\x00\x05\x00\x00\x00K'
 b'\xd7\xebr_6\x1e\x84D\x00\x02\x00\x00\x00P\x8b&9#uv\x02\xacn')

{'A1': {'B1': 24259, 'B2': -42, 'B3': 1422195594},
 'A2': 7543430948280611029,
 'A3': {'C1': [{'D1': -29677, 'D2': 73, 'D3': 99},
               {'D1': -17415, 'D2': -7, 'D3': 36},
               {'D1': 18786, 'D2': -30, 'D3': -56},
               {'D1': 2358, 'D2': 46, 'D3': 80},
               {'D1': 32663, 'D2': -53, 'D3': 61}],
        'C2': 'vtzvu',
        'C3': -2888088982772612028,
        'C4': [0.4404403269290924, -0.45534971356391907],
        'C5': -117,
        'C6': 9785},
 'A4': 0.2536575682591471,
 'A5': -4899980379337474079,
 'A6': 16771414594125147241,
 'A7': [9077, 30210, -21394]}

(b"pBPP\x000B\x8d\xcd4O\xdf.\xd0\x00Q\xbf\xdd\x05.\xffp\xa4\xa0\xc4~O'"
 b'\xb1[\xa9i\x13\xec\xcb\x9a\x92\xeeAC\x00\x00\x00\x04\x00\x00\x00n\xd2\x13zD'
 b'^\x8f\x9e\xff\xf3\xf9\xc91\xb6;\xc0mp\xbf\x11\xaa\xe7\xbe\x91\xa4'
 b'\xa7\xbe~\xd9\x18\xbfS\x9e\xa9\x00\x00\x00\x02\x007\x00\x02\x00\x00\x00'
 b'?\xe2-\xdbF\xeb\x9b\xc5Q\x00\x04\x00\x00\x00A\xde\x96\x10\xa8zE\xfdE\xef'
 b'\xe0\xf9')

{'A1': {'B1': 53779, 'B2': 122, 'B3': 1147047838},
 'A2': 4795714802781466320,
 'A3': {'C1': [{'D1': -13, 'D2': -7, 'D3': -55},
               {'D1': 12726, 'D2': 59, 'D3': -64}],
        'C2': 'mp',
        'C3': -2148820349538810543,
        'C4': [-0.5690140128135681,
               -0.28445932269096375,
               -0.24887502193450928,
               -0.826639711856842],
        'C5': -34,
        'C6': 38416},
 'A4': -0.4534413809329383,
 'A5': -4287902763312240279,
 'A6': 1435746245974835523,
 'A7': [-22406, 17917, 17903, -7943]}

Вариант №12

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

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

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

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

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

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

(b'VPVV1\x17\x00\x02\x00\x00\x00_\x00jT\x02\x00\x00\x00c\x00\x00\x00zefin'
 b"i\xd8X\x9f\x1a\xd8.\x1by\xe7\xa14\xc8\x1a#\x7f\xbf\x88'\xfb\x80\xe2\xb6\xc9"
 b'3hi,\xcb\x86\xd6\xf9G\x0fH{\x10\xfb\xa0\xc9q\x15\x92\xcdd\xbf\x03\x90'
 b'\x8ar\x8b\x90\xafVI\x9a\xac\xc6DE\xb3"\xc7(q\xff\xf2%\x00B\x00\xc2'
 b'\x9dD\x97\x18\xfb\xe1:')

{'A1': {'B1': 'zefini', 'B2': 8726620208654932184},
 'A2': [{'C1': {'D1': 3358892519,
                'D2': -0.9966293573379517,
                'D3': 10120,
                'D4': 7595377713010082043,
                'D5': 44,
                'D6': [-31029, -1578, 3911, 31560],
                'D7': 16},
         'C2': 251},
        {'C1': {'D1': 359778720,
                'D2': -0.8937617540359497,
                'D3': -28669,
                'D4': 11117512467185103498,
                'D5': 172,
                'D6': [17606, -19643, -14558, 28968],
                'D7': -1},
         'C2': 242}],
 'A3': 21610,
 'A4': [2537856450, 987888408]}

(b'VPVV1\x17\x00\x03\x00\x00\x00|\x00\x90\x95\x03\x00\x00\x00\x82\x00\x00\x00k'
 b'rgauwmpXp/0\xe3\xf5\xe3\xe2\x06\xdb=\xf9.=\x80\xd7kx\xcd\xd9\xa6\x07\xc2Op'
 b'}\x95\x00\xeb\x18\x97K\xc0t\xfcy\xd5\xb6%\xb2s\x80>\xf1\x13\x02O\x06%'
 b'\xbb\x18p\x9b\x8a\xbdv\x8e\xd4\xe2\xf8\xf1\x7f\x9a\xd9jDfyr\xdf\xd2\xbe\xdd'
 b'\x10T\x8co\xbb\x9cZ\xe6\xc1-\xae*\xc6U\x99\x02r\x8b\x05n%\x00B\x00_\x00,\x92'
 b'\x1b\xd4v\x8c2\x88`\xc8rs')

{'A1': {'B1': 'krgauw', 'B2': 17718058339312103533},
 'A2': [{'C1': {'D1': 3674661603,
                'D2': 0.04271816089749336,
                'D3': -10368,
                'D4': 5747164487678261355,
                'D5': 112,
                'D6': [-27267, -5376, -26856, -16309],
                'D7': 116},
         'C2': 252},
        {'C1': {'D1': 632739193,
                'D2': 0.25088268518447876,
                'D3': 5105,
                'D4': 11200479465329544962,
                'D5': 138,
                'D6': [30397, -11122, -1822, 32753],
                'D7': -102},
         'C2': 217},
        {'C1': {'D1': 2036745322,
                'D2': -0.41186100244522095,
                'D3': 4317,
                'D4': 13971954523169590356,
                'D5': 45,
                'D6': [10926, 21958, 665, -29838],
                'D7': 5},
         'C2': 110}],
 'A3': 38288,
 'A4': [3558576684, 2285014134, 1936902240]}

Вариант №13

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

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

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

(b'NVNKD\x04\x00\x15\x00\x17\x04\xa6\xee\xaf9\x00\xc2\xa20\xf3\xd3L\xb1\x86'
 b'\x94\x0e<\xc3\xc6jT\\\xe0\xc2\x7fIl\xd6\xe10["3o\xbe\xa4\x8cK~\xec;V'
 b'\xb9\x9f\xc8\xa8\xd6\xd9\x9b\xed5.\xbf\xea/\x02\x00-\x00\x00\x00t'
 b'g\xb9\x05\x00/\x00')

{'A1': [{'B1': 45388, 'B2': 1007588486},
        {'B1': 50883, 'B2': 3764147306},
        {'B1': 32706, 'B2': 3788926025},
        {'B1': 23344, 'B2': 3194958626}],
 'A2': [23, 4, 166, 238, 175],
 'A3': {'C1': 39897,
        'C2': -0.6805103421211243,
        'C3': 12266,
        'C4': [164, 140],
        'C5': {'D1': 116,
               'D2': 103,
               'D3': -71,
               'D4': [32331, 15340, 47446, 51359, 54952]}},
 'A4': 194,
 'A5': [162, 48, 243, 211]}

(b'NVNKD\x08\x00\x15\x00j\xd9\x17"\xb6M\x00J\x08\xb6\x0e\xa3\xdb\x8er'
 b'\xb4\x1b\xbc\xed\xc1\xf2\x04\xe0eh\x91\x8e\xea\xe6\x8f\xa7H"\x9a\x8e'
 b'\r\xd4\x95U5\x93\\T\xc6\x95\xbaS\xd8\xe7\x80*\xf8\xf7}"Y\x98.\xa9e\xae\xedp'
 b'\xae\xcfs\xf57/ \x12\xfcG?~H\x02\x00E\x00\x00\x00\xef0\x8b\x03\x00G\x00')

{'A1': [{'B1': 36571, 'B2': 3155932274},
        {'B1': 49645, 'B2': 1709180146},
        {'B1': 37224, 'B2': 2414275214},
        {'B1': 18599, 'B2': 227449378},
        {'B1': 38356, 'B2': 1553151317},
        {'B1': 50772, 'B2': 3629365909},
        {'B1': 32999, 'B2': 2113402922},
        {'B1': 22818, 'B2': 1705586328}],
 'A2': [106, 217, 23, 34, 182],
 'A3': {'C1': 8239,
        'C2': 0.781190037727356,
        'C3': 18558,
        'C4': [174, 237],
        'C5': {'D1': -17, 'D2': 48, 'D3': -117, 'D4': [44656, 29647, 14325]}},
 'A4': 74,
 'A5': [8, 182, 14, 163]}

Вариант №14

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

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

(b'\xfdMDYI\'\xa6"?\x02\x00\x15\x00\x00\x00L\x96\x9a\x00\x00\x00voe\nA8\xc0'
 b'\xfc\xa0l\x92\x9b\xbc,\xa8Ny\xbecn\x96.\x98}\xcd\x94\xc2?\xc7\t\xe8'
 b'\xdas=\xdc\xae\x8b\x16C\xd8\xee\xdd~\xc3\xe8\xe6\x04\x9d\x13\xbfR'
 b'\x7f\xc4%\x9a_\xd74gP*\xda\xc9\xf6o\xbf\xa4?&X\xb8b\xb4\x8a\xbd\x1b"\xb2S'
 b'\xaa:?,\x06\xb5\xb5A\x87vNk\xe1\x1a\xe0p.\x0b\xde\x06E\x97B\\p\xa91\xd4'
 b'\xf7@%\xb4,3\xc9\x96\xbf\xb1\x94\x8d>\x86\x89f\xcb\x83\x10\x88\xeb\x15\x1e]'
 b"\xfcO\x17\x00\x00\x00'\x00\x00\x007\x00\x00\x00G\x00\x00\x00W\x00"
 b'\x00\x00\x81O\xea.?\xa9\xc8\xbf>g\x00\x00\x00\x06\x00\x8e\x00\x93F\x8f\xbe')

{'A1': 0.6353477835655212,
 'A2': 'vo',
 'A3': 38476,
 'A4': {'B1': [{'C1': 7827534054877629029,
                'C2': 750558098,
                'C3': -0.24346411228179932},
               {'C1': -7724379693300421021,
                'C2': 164052930,
                'C3': 0.059534937143325806},
               {'C1': -2454786964217680164,
                'C2': -420953218,
                'C3': -0.5766146183013916},
               {'C1': 3807617125628280658,
                'C2': -634761113,
                'C3': -0.9373593926429749},
               {'C1': -8452022056775172188,
                'C2': -1306387523,
                'C3': 0.7291614413261414}],
        'B2': -127,
        'B3': 0.6832627654075623,
        'B4': 0.3745777904987335,
        'B5': {'D1': [5653855098501400108,
                      -2446810910214659733,
                      3578514920479081734],
               'D2': -2092,
               'D3': -0.022251891711708938,
               'D4': 0.2765250504016876,
               'D5': 134},
        'B6': [26249, 33739, 34832, 5611, 23838, 20476],
        'B7': -0.2798353135585785}}

(b"\xfdMDYI1\xcd'\xbf\x02\x00\x15\x00\x00\x00\xe8*\x9e\x00\x00\x00jyF"
 b'}\x14\xd6\xf72P)t\xady\xc5\xb5\xbe\x92\xbe[\x17|x\xfb\x82\xdd0\x85'
 b'7\xac\xcc\x91\xeaG?\x8d\xd4\xd5\xf73\xdbO\xc7\xe9\x8fY\x0f\x9f\xd66?\x8f'
 b'\x8b\x9d\x02z\x8e\x1c2\xe0\xde\xdcH\xfa]\xa8\xbe\x7f>\x08c#\xac(\xfb\xc9'
 b'4\xe5\xc9s\x97\x04?\xae\x87a\xb6\xa1\xcb\xba\x15\xa6h\xe6\xa7\x9e\x7f\x0f$6'
 b'\x1c\xcd\x0en\x03\xaf,4\xeb \x01\xfbf\xaed\xcd\xbf*\xf1\xa2\xbe4\x8e\xe8'
 b"ou\x85,\rY 1\xff2\xd6\x05I\xa5\x17\x00\x00\x00'\x00\x00\x007\x00"
 b'\x00\x00G\x00\x00\x00W\x00\x00\x00\x82\xb1\x91\x16\xbf\x91\xa7\x8c\xbeg'
 b'\x00\x00\x00\x08\x00\x8e\x00\xcb\x9aY?')

{'A1': -0.6554747223854065,
 'A2': 'jy',
 'A3': 10984,
 'A4': {'B1': [{'C1': 2976935393721875782,
                'C2': -981881484,
                'C3': -0.2866112291812897},
               {'C1': 3521114500243396443,
                'C2': -861128827,
                'C3': 0.7809229493141174},
               {'C1': -4084805320753949555,
                'C2': 257527785,
                'C3': 0.7142123579978943},
               {'C1': 3610917655925328783,
                'C2': 1222434528,
                'C3': -0.3288419842720032},
               {'C1': -348839703135895937,
                'C2': -907725623,
                'C3': 0.5179359316825867}],
        'B2': -126,
        'B3': -0.5881605744361877,
        'B4': -0.27471593022346497,
        'B5': {'D1': [1565787715874686894,
                      2598435829414520998,
                      3219796029822802998],
               'D2': -5324,
               'D3': -0.22963504818290748,
               'D4': -0.31824618577957153,
               'D5': 52},
        'B6': [59534, 30063, 11397, 22797, 12576, 13055, 1494, 42313],
        'B7': 0.8500182032585144}}

Вариант №15

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

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

(b'LVKI\xc0L\x00b\x00\xdb\x02\x00\x89\x00h\xf5\x89FT/\xdc\xbf\xec\xaf'
 b'\x1d6\xc7\x9c\xef\xbf\x8aZ\x18a\x16\x88\xe8\xbf>\xf0\x9d\x14\xeeL\xe2?>\x8f'
 b'\xeb\x04\xa9\xa7@\xf3\x91\x84h\xaa6Ak\xaf\x89\x14\x07s\xa4\xee'
 b'\x04\x00\x91\x00\x9e{\xe9\xaa)\x17\x89>\xe2\x1d\x81!\x9d\x11\x14|P \x9e\xfc'
 b'a\xd3<8\xa8\xf48(\x89\xbd\xe0dqkjoipH\xc4~\x8e\xbe\xcd\r\xde\xbf\x9afbtq'
 b'uau\xd4\xe8z\xcew\x13\xbc\xdd?bg\x00\x00\x00x\x00\x00\x00o@\x15S\xd7\x14j'
 b'\xcf\x0b\xecvm\x07:\x89\xa4r\xc6\xdc\x0b\xfa\x07-\xe4\xdc\x9a\x99'
 b'\xca\x84^\x12q')

{'A1': {'B1': 0.26775482296943665,
        'B2': 562109922,
        'B3': 2081690013,
        'B4': 8272,
        'B5': -817341498472137570},
 'A2': {'C1': -0.06697124242782593, 'C2': -32},
 'A3': -37,
 'A4': [{'D1': 'dqkjoip', 'D2': 72, 'D3': -0.46959251030964944, 'D4': 154},
        {'D1': 'fbtquau', 'D2': 212, 'D3': 0.46460425090655955, 'D4': 98}],
 'A5': {'E1': -0.4403887451988653,
        'E2': [-0.9878879601433233, -0.7666122337712562, 0.5718908693957088],
        'E3': 62,
        'E4': 60303,
        'E5': 7531304950818121988,
        'E6': 13994,
        'E7': -6596921244376929471,
        'E8': 238},
 'A6': [14945781228426838127,
        11856071297605233675,
        16441806585121785458,
        8147678600294406876],
 'A7': -1427539042}

(b'LVKI\xc0L\x00b\x00+\x02\x00\x89\x00\xda\xf5_\x95a1\xe4\xbf \xba\xc4\x82i\x99'
 b'\xa5\xbf\x98\xde\xe6\x96h~\xda\xbf\x80(\xd9\xc1f_\xa5\xbf\xd8rS\x0b\xaap'
 b'\xfdvT\xa1\xad\x8da\xcd\xe8zi\xa5m\xe1\xbd\xea\x02\x00\x91\x00\xbe]\xb3\xbb'
 b'~%e\xbf\xc0\xff\n\x1c\x9c3nM\x96m\x1e\x93\x9cS\xb4\x8a\x06\xbb\xf9\xb8'
 b'\x90>\x14zpjmtsyf>\xa2\x88\x07A\x07\xe4?4cmifaud\x9f2Gv;\x06%\xe1?'
 b'\x11g\x00\x00\x00x\x00\x00\x00r\xc0\x83`\x9e\xad\x1e8\xb2,\xf3\xfbdc\xc1'
 b'\x9d')

{'A1': {'B1': -0.8951033353805542,
        'B2': 470482880,
        'B3': 1299067804,
        'B4': 28054,
        'B5': -4970132631655247074},
 'A2': {'C1': 0.28266122937202454, 'C2': 20},
 'A3': 43,
 'A4': [{'D1': 'zpjmtsy', 'D2': 102, 'D3': 0.6258855006354407, 'D4': 52},
        {'D1': 'cmifaud', 'D2': 159, 'D3': 0.5357695733420995, 'D4': 17}],
 'A5': {'E1': -0.6310279767491764,
        'E2': [-0.0421860668305849,
               -0.41396536575801113,
               -0.041743479884261525],
        'E3': 216,
        'E4': 21362,
        'E5': -5935369963862709749,
        'E6': 24973,
        'E7': -4764406373574580019,
        'E8': 234},
 'A6': [4043860411160969330, 11367476219834739890],
 'A7': -1145872962}

Вариант №16

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

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

(b'XHGX2\x00\xfb\x1e\xbd>iypz\xcd\x8c)\x9b\x8e\xeb#-\x1e\xc8\xfe?\x03\x00'
 b'\n\x00\x00\x00\xd6ctt\x18\x83\xa0\x89\xe1\xc9\x93u\xd3[|\xe2\xba\xca\xfe\xb9'
 b'\xb3\x1a \xad\xde\x84\r\x00k\xdb\xfe\x94\xf0\x8d\xc7h\x13K\xaf_.\xe9\xbf\xc6'
 b'\x05\x8eVY\x08\xbez\n\xc8T\x1f\x88\xed\xbf|\xd5\x1edv\xb6\x84\x00{\x1d'
 b'8\x95\xa5\x90\xbf\x08\x00"\x00L\x17M\xc2\x88r\t\xbf\'\x03')

{'A1': {'B1': -8872463862474753538,
        'B2': {'C1': 697093498,
               'C2': 18358957060200828571,
               'C3': 63,
               'C4': 'iyp',
               'C5': 25558},
        'B3': [{'D1': -9365,
                'D2': [254, 148, 240, 141, 199],
                'D3': -0.7869108604141788},
               {'D1': 1478,
                'D2': [142, 86, 89, 8, 190],
                'D3': -0.9228665023695861},
               {'D1': -10884,
                'D2': [30, 100, 118, 182, 132],
                'D3': -0.016256648588178102}],
        'B4': [29812, 33560, 35232, 51681, 30099, 23507, 57980, 51898],
        'B5': 3259832140,
        'B6': -0.5369038581848145,
        'B7': 39,
        'B8': 3},
 'A2': 0.3693769872188568}

(b'XHGX(\x00\xfc\x90u>xwhras\x82\\bRb9\x15\x06j,L\x90\x05\x00\n\x00'
 b'\x00\x00e\xa8,Z\x7f\xa5P\xbeTZ\x9fk\xd4\xe8\x0f\x00\xce:\xaf\x02\xe0#G@<\x82'
 b'\xcca@\xab\xbf\x19\x83\x1b\xaa\xaa\\\xd0\xe2?\xea\x9c\xd8X\xed? l\xf24'
 b'\x8aG\x85\xe8\x1a\xf5[\xa9\xd8\xc7\xbf\x02\x00$\x00\xcci\xccb\xf9\xafp?\x1b'
 b'p')

{'A1': {'B1': -1669591229688136112,
        'B2': {'C1': 1650229875,
               'C2': 5488878620216222290,
               'C3': -112,
               'C4': 'xwhra',
               'C5': 43109},
        'B3': [{'D1': 15054,
                'D2': [175, 2, 224, 35, 71],
                'D3': -0.05322557088322144},
               {'D1': -31975,
                'D2': [27, 170, 170, 92, 208],
                'D3': 0.9170954766032049},
               {'D1': 27680,
                'D2': [242, 52, 138, 71, 133],
                'D3': -0.1862994860659548}],
        'B4': [23084, 42367],
        'B5': 1657563596,
        'B6': 0.9401851296424866,
        'B7': 27,
        'B8': 112},
 'A2': 0.23981088399887085}

Вариант №17

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

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

(b'YAU\x07\x00"\x00\x08N\xeei1\x00\x00\x00I\x00\x00\x00\xe5l\xbb\x8f+?H\x17S'
 b'\x11\xdd\xda\xcb?\x82mulidybD\x18\xc8\xc3n\xbf\xeeB\x04\x00)\x00\xdf\xe4\xad'
 b'\xf1\x9c\x14\xf3\xb1[\x93\x98\xe4\x06\x18\xdai\xbc\xf9\xcd\xf4\x02\x00E'
 b'\x00\xf1\xb3\x06\x07\xb3,e\xa8\xf3u\xfdt\xb2\xda\xa60')

{'A1': {'B1': {'C1': 'mulidyb', 'C2': 1777225224},
        'B2': [{'D1': [6212, -15416, -16530, 17134],
                'D2': [-5624128845353458465, 7627435336789431131]},
               {'D1': [-1604, -2867],
                'D2': [-6312590155261234191, 3505729819956311539]}]},
 'A2': 27877,
 'A3': 0.6701619029045105,
 'A4': 0.21761668535162415,
 'A5': -126}

(b'YAU\x02\x00"\x00p\x19\x8fA,\x00\x00\x00F\x00\x00\x00\x97,\xfctg'
 b'\xbf\xa0\xc2\xf2\xbe\xe5\x1f\xad\xbf\xbced\xcc\xa0\xb6\xc6\xea:\xbf\x82'
 b'\x04\x00$\x00M\x91\xe1\xf9\xe0\x13\t\x7fU\xce(\x82T\x9e\xd4\x027\xe9\xf8\x08'
 b'\xe0W\x03\x00@\x000I\xdb\x037\x07\x9e[n\x84\x87s4\xcf\x1f&')

{'A1': {'B1': {'C1': 'ed', 'C2': 1099897200},
        'B2': [{'D1': [-24372, -14666, 15082, -32065],
                'D2': [9153869574593155405, 203961968936668757]},
               {'D1': [-5833, 2296, 22496],
                'D2': [6601722036641024304, 2747142121902802030]}]},
 'A2': 11415,
 'A3': -0.9041287899017334,
 'A4': -0.05688398319160126,
 'A5': -68}

Вариант №18

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

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

(b'BOY\xb1Ac\xc9\x11\x8c-\x9c3a\x00\x169\xcb\xbf\xbb\xbedU-\x98X\xa1\x8aP'
 b'\x02;6TF\xe7\x8db\xd4\x00\xb9\x90\r\x03A\xd1\xd4\xba\x9d\x18\xe9\x15\x1d\x82'
 b'\xfe\x9f\x0c\xa1Q2\x9fi\xef\xf6\x04\x00\x93\x00\x00\x00\xb9\xec\xed\xd9'
 b'K\xf7;\xbf\x8cn>&;\xfd\xbbz\xc8a\x88;z\xd1s\xf5\xcb]\xc3\xe4\x9bA;\x92'
 b'%6\xedo\x81\xd0 d\xa7\x9e\x07\xd9\xb6\xe0\x1c\x1f\x98\xaaDdXw[,\xde\x19\xb6$'
 b'(ziW\xfew\xacPh\xd0\x1e?\xe1k\n\xdb.\x87\x9a\x03\x00}\x00\x00\x00\x11\x07K'
 b'\xbf\x03\x00\x83\x00\x00\x00d(\xd1\xbe\x03\x00\x89\x00\x00\x00x\xd0Y'
 b'?\x02\x00\x8f\x00\x00\x00\x821{\xbf')

{'A1': 25409,
 'A2': [{'B1': 4553, 'B2': 865873292, 'B3': -4702954506301341599},
        {'B1': 21860, 'B2': -1588029395, 'B3': -1781644010683477878},
        {'B1': 25229, 'B2': -1866923820, 'B3': 1773779251460375309},
        {'B1': 5609, 'B2': -1610710499, 'B3': -653187288480505588}],
 'A3': [{'C1': [-18919, 10276, 27002], 'C2': -0.7930765748023987},
        {'C1': [-425, -21385, 26704], 'C2': -0.40851128101348877},
        {'C1': [7888, -7873, 2667], 'C2': 0.850837230682373},
        {'C1': [11995, -25977], 'C2': -0.9812241792678833}],
 'A4': [3656248505, 3208378187, 641625740, 2059140411, 998793672],
 'A5': 53626,
 'A6': 115,
 'A7': {'D1': 4269865328556493813,
        'D2': 9618,
        'D3': 12061801781901913398,
        'D4': 1950,
        'D5': [46809, 7392, 38943, 17578, 22628]},
 'A8': 3727448951}

(b'BOY\xb1\xa5\xc7\xea\x82Q3\xa8\xbb\x9eNY(M&\x97\xae\xb8$Q\xb6\x8a\x05\x94\x85'
 b'\xe8>\xffdb\xb9\x17\xf1\xff>\xdf\xbf\x13\xf7\x8c\xe2l\xc0\x08\xc6\xa8)]\xc0'
 b'\xeeJ\xd0^\x9e\xa1#\x05\x8a^\x03\x00\x89\x00\x00\x00\x99\xcc\xa2M'
 b'\x9c\xde\xb0c\xa4\x9b|9\x94\xbb\xb6\xdad\x82\x0f\x01GJ\x90\xbb\x8e\xf3`4'
 b'\x9b\\\xea\xb2\xfb\xbd\xd8\x85\xbf\x9bn(\x8e\t\xab\xe0[w\xcf&i\xe0N\xd0'
 b'Ia\x97\x0b\xdc\x86\xefo\x00\xd2$ \xd6\xc8c\xa2K\x02\x00}\x00\x00\x00\x84'
 b'\x10\x15?\x02\x00\x81\x00\x00\x00\x8c\x99\xb4>\x02\x00\x85\x00\x00\x00\xb1'
 b'\xb7\xc9\xbd')

{'A1': -14427,
 'A2': [{'B1': -32022, 'B2': -1146604719, 'B3': -5866177876795502946},
        {'B1': 9400, 'B2': 92976721, 'B3': -5088393581540375148},
        {'B1': -3817, 'B2': -1075888385, 'B3': -4176877080496244973},
        {'B1': 10664, 'B2': 1257160797, 'B3': 6812263036944801488}],
 'A3': [{'C1': [-4218, 111], 'C2': 0.5822832584381104},
        {'C1': [9426, -10720], 'C2': 0.3527339696884155},
        {'C1': [25544, 19362], 'C2': -0.09849489480257034}],
 'A4': [1302514841, 1672535708, 964467620, 3669408660, 17793636],
 'A5': 19015,
 'A6': -112,
 'A7': {'D1': 16887543351999696571,
        'D2': -1102,
        'D3': 10243558967666399421,
        'D4': 43785,
        'D5': [23520, 53111, 26918, 20192, 18896]},
 'A8': 3691747169}

Вариант №19

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

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

(b'SZXKW\x9c\x93OO\xc4\x02\xc5\xc0o\x04\x004\x00\x00\x004\xce%m<\xeeK\x0f'
 b'cS\x9b\xe38M\xf9\xd78\x00\x02\x00\x00\x00x\x00\x00\x00\x895I\xb5\r\xbfnigi'
 b'p\x1f\xa6\xa2\xf61\xe3?V\x1cg\x8dE.\x87pkkfzs#\x87/t*\xe9=#\x81F\xfb'
 b'\xc1\x05\xee\xd4qp\xec\x13^\x1eB!5\x90\xaap{~\xcdt\xc3\xb9\xc22'
 b'\x9a\xba\x97\x9av\x95\xad\xfc\x04\x00M\x00\x05\x00\x00\x00]\x00\x90\xc8'
 b"\x1c=\xd5\xc46}\xa5\xc8\x13K\xec\xbe'\xfd\x04\x00b\x00\x06\x00\x00\x00r\x00"
 b'\x07\xb9\x1e=\xc1_\x17\xd4\x1bzX\x81\xd5\xef\xb6<')

{'A1': {'B1': -4556232405847927908,
        'B2': 111,
        'B3': 'nigi',
        'B4': 1102236477118860852},
 'A2': 15562554894087574371,
 'A3': {'C1': 0.5998490502106346,
        'C2': {'D1': 7254, 'D2': 103, 'D3': 2267956621},
        'C3': 'pkkfzs'},
 'A4': [{'E1': [1949271843, 591259946, -1040497023, 1909779973],
         'E2': [112, 236, 19, 94, 30],
         'E3': 0.03827720880508423,
         'E4': 2100741333,
         'E5': -204985335940921179},
        {'E1': [-1875566270, 2122018986, -1178372915, -1164299582],
         'E2': [151, 154, 118, 149, 173, 252],
         'E3': 0.038750674575567245,
         'E4': 3558301633,
         'E5': 4374947788314147355}],
 'A5': -119,
 'A6': 53,
 'A7': -0.5535474419593811}

(b'SZXKW\x86\x88\x8b\x00U\xe5-\x08\xb0\x06\x004\x00\x00\x00\x18)+\xac\x7f\x8c+1'
 b'&\xcb\xd0\x0f\x87\xc7\xd4\xc4:\x00\x02\x00\x00\x00t\x00\x00\x00\t\x9b5:I\xbf'
 b'vmvfnsL8:\xe1\x8e\x89\xda?\n^\xd1T\x9c@|fdguuo\xc6p\xb42\xec\xc13w\x94'
 b'\rM{\x8e\xaa\x04\xf5f4f\x8d\xf0\x1a\xf6\xafg,Q=\x01\x1fPJ&`\x1e\x97c'
 b'\x03\x00O\x00\x03\x00\x00\x00[\x00y\x97K?\x89\xb33\x16\xb1SU\x9f\xb9\x13'
 b'\xe5}\x04\x00^\x00\x06\x00\x00\x00n\x00\xa8V?\xbf\xc5\xc6\xaa\x82'
 b'\x16\xb4\xb8\xf1\xb6<\xc9\x0e')

{'A1': {'B1': 589379279499528326,
        'B2': 176,
        'B3': 'vmvfns',
        'B4': 3543080011834272024},
 'A2': 14183180509396388646,
 'A3': {'C1': 0.4146458816038645,
        'C2': {'D1': 24074, 'D2': -47, 'D3': 2084609108},
        'C3': 'fdguuo'},
 'A4': [{'E1': [850686150, 1999880684, 2068647316],
         'E2': [142, 170, 4],
         'E3': 0.7952800393104553,
         'E4': 372487049,
         'E5': 9071678712370779057},
        {'E1': [1714710261, -166006643, 1361864623, 1344209213],
         'E2': [74, 38, 96, 30, 151, 99],
         'E3': -0.7474160194396973,
         'E4': 2192230085,
         'E5': 1065449543286961174}],
 'A5': 9,
 'A6': 155,
 'A7': -0.7860444188117981}

Вариант №20

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

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

(b'EQTV\x81\x00\x00\x00<\xf5\xdaL\xc4zI\xee\xff2w\xbex\xb6\x93\x9b\xd9n\xeb\x89'
 b'\xb0\xc6\x06\xbf;;\xa4\x00\x00\x00\x0b\x00\x00\x00\x17\xe1\x03\xe7\x99\xf1'
 b'N\x08\x19)\xe3M?\xd1\x89\xd9\x94}?\xd8\xcb\xf91\xc73t\xe0\xd3`\xfb\xbfQ_\x07'
 b'\x00\x02\x00#\xa1\x1b\x00+\x92\xc2\x0eW')

{'A1': {'B1': 0.3874495493044414,
        'B2': -523017989,
        'B3': -0.8178562521934509,
        'B4': [{'C1': [76, 196, 122, 73],
                'C2': 4009702007,
                'C3': -0.24288396537303925},
               {'C1': [155, 217, 110, 235],
                'C2': 2310063622,
                'C3': -0.7313787937164307}],
        'B5': 41243,
        'B6': {'D1': [57603, 59289, 61774, 2073, 10723],
               'D2': [77, 63, 209, 137, 217, 148, 125]},
        'B7': 2462191191},
 'A2': 62938}

(b"EQTV\x81\x00\x00\x00<\x8eV\xa4\x07MdB'\xe6\x9f\xbe5\x98n\x1a\xda\xd5r\x9a"
 b'/\xaa\xaa>\xc26J\x00\x00\x00\x0b\x00\x00\x00\x17=\xf2\x07dvd\xe8\xcd\xdc'
 b'n\x19\x87\xd7C\x032\xd3?\xe7 ]\xe5\x9f\x0e\x0c\xc4A\x8dl?\x0f\xcb\x84'
 b'\x00\x02\x00#\xb5\x9e\x00+\x18\x83m!')

{'A1': {'B1': 0.7227010235587286,
        'B2': -1002336916,
        'B3': 0.5616991519927979,
        'B4': [{'C1': [164, 7, 77, 100],
                'C2': 1109911199,
                'C3': -0.17733928561210632},
               {'C1': [26, 218, 213, 114],
                'C2': 2586815146,
                'C3': 0.3793204426765442}],
        'B5': 46494,
        'B6': {'D1': [15858, 1892, 30308, 59597, 56430],
               'D2': [25, 135, 215, 67, 3, 50, 211]},
        'B7': 411266337},
 'A2': 36438}

Вариант №21

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

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

(b'XLYQ\xd8\x9e\xf0bBW\xcf\xbf\xe9\xe6aR\xabCA\x97\xb2s|p\x89\xc6\xe7W'
 b'\xff\xc4?jzcb\x04\x00\x00\x00;\x00\x00\x00\xf8GK\xbb?\x00\x00\x00O'
 b'\x00\x00\x00_\x00\x00\x00wlew#\xf7\x00\x18\xccQ\x7f\x06\xe0\xa6\x03\x8fL'
 b'<p\xe5\x12\x07\xa09\x1c*j\x9a}\x89Z\x86\xacE\xefk\x92\xa0I0a\xe2)\xd6\xd1'
 b'#\xd2\xf5\xca\x1bI\xdd')

{'A1': -0.24485044318247762,
 'A2': 1382147817,
 'A3': {'B1': 2537636779,
        'B2': {'C1': 178,
               'C2': 31859,
               'C3': 0.16404246155895974,
               'C4': 'jzcb'}},
 'A4': 'wlew',
 'A5': 3142273016,
 'A6': [{'D1': 468182823287715619, 'D2': [2399381216, 3849337932]},
        {'D1': 11126752130086471442, 'D2': [2254080381, 1810843052]},
        {'D1': 15432114505211551890, 'D2': [4124189649, 3712555978]}]}

(b'XLYQ\x80hxW\x87\xcf\xd9?\x80"\x01\xc7R\xaa\xcf\xfa\x9f\xb8\xd8\x04\x945@\xda'
 b'&\xe0\xbfmwaa\x02\x00\x00\x00;\x00\x00\x00t\xd9\x01!=\x00\x00\x00M'
 b'\x00\x00\x00]\x00\x00\x00byy\x11\xc3\xa4\x94\xb9.N\xf7\x0c|\xee\x15My'
 b'7\x8cj\x1e\xc9\x8a\xd0\t\x01\xcat\x9bGW\xdbQE\x82\xbc|J\xc1\xfe\xa5'
 b"d\x80\xf1\xc2\t'5N\xc0")

{'A1': 0.4032915453150352,
 'A2': 3338740352,
 'A3': {'B1': 4207913554,
        'B2': {'C1': 159,
               'C2': -10056,
               'C3': -0.5047427419746104,
               'C4': 'mwaa'}},
 'A4': 'by',
 'A5': 553769332,
 'A6': [{'D1': 5633644231957614969, 'D2': [4001107191, 930696469]},
        {'D1': 74820163326601868, 'D2': [1201370314, 1162992471]},
        {'D1': 7252482881081883778, 'D2': [163770752, 3226350887]}]}

Вариант №22

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

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

(b"UEM'\x00\x02\x00\x00\x00{L\xefx\x86\xda\xbf\xe1<\x1e\xb0\xb7aL\xbf"
 b'\xe3\x83\xbeT?\xc5\xe3\x8e\x92\x84\xfe`\x92\xbb\x9e\xea4?\xe67>\xdai\x7f'
 b'\xfc&\x8cy*\x1c?\xedG\x81\xdfD\xee\xfc\xe3\x13\x8f\xbb\xaf\xbf\xe3 \xb1\x99'
 b'\xab0\x0e\xae4\x87\x12~?\xc8\xfc2D=\x84p\x9b+>\xe4\x8c\xdc\x1e\x1d'
 b'\xbf\xd5\xa14%\xd3\xcc@3\x8f\x15x\xbb\x16\xa1y\x00\x00\x00\x02\x00\x00\x00}'
 b'<K\xaagf\x92)^\xc0\xd8\xa1\x9c\x91\t\x8c\xb7uxIu\xea')

{'A1': {'B1': 'gf',
        'B2': [{'C1': [76, -17, 120, -122, -38], 'C2': -0.538588853024558},
               {'C1': [-65, -29, -125, -66, 84], 'C2': 0.1710069861819532},
               {'C1': [-110, -69, -98, -22, 52], 'C2': 0.6942438379155642},
               {'C1': [38, -116, 121, 42, 28], 'C2': 0.9149789200523339},
               {'C1': [-29, 19, -113, -69, -81], 'C2': -0.5977409364072643},
               {'C1': [-82, 52, -121, 18, 126], 'C2': 0.19519642192884445}],
        'B3': 2603302628},
 'A2': -1931731427,
 'A3': {'D1': -0.33796409315181464,
        'D2': 3715211825883029881,
        'D3': [10532053385943817361, 688126558237980138],
        'D4': 60,
        'D5': 19370}}

(b"UEM'\x00\x02\x00\x00\x00{n\xd3U2k\xbf\xcc\xb9\x97z\x96-x\xe7:W\xfdy"
 b'?\xe6\xff\xfe\x90K\x1c\x02>e!1(\xbf\xdd\xc49\xa1\xd5?\x04o\xd6\x129\x89?\xd7'
 b'\xe1T\xa7\xa6{\x1c\xb1\xd7\xc3%\xd3?\xe7\xe1m\xe9\xda\x0cdX\xda>~t'
 b'?\xd1\x08\xa8\xa7\x10@4\x87\xfc\xf1-\r\xf3S\xd5\xbf\xe4\x1d\xea\xca\xe5\xbd>'
 b'WM\xfc\xee\xe5\xc4O\x0f\x00\x00\x00\x02\x00\x00\x00}4\xbb\x14fishN\xbej\xd4b'
 b'\x93Fm\x1a\x7f\x19\r\xe4\r')

{'A1': {'B1': 'fi',
        'B2': [{'C1': [110, -45, 85, 50, 107], 'C2': -0.2244138096396957},
               {'C1': [-25, 58, 87, -3, 121], 'C2': 0.7187493150930779},
               {'C1': [62, 101, 33, 49, 40], 'C2': -0.4651016312027283},
               {'C1': [111, -42, 18, 57, -119], 'C2': 0.37312809345341846},
               {'C1': [-79, -41, -61, 37, -45], 'C2': 0.7462682311455748},
               {'C1': [88, -38, 62, 126, 116], 'C2': 0.26615349116127907}],
        'B3': 2281500973},
 'A2': 234050517,
 'A3': {'D1': -0.6286519968834126,
        'D2': 6290962357493714703,
        'D3': [8315983291682677395, 5074741488299926541],
        'D4': 52,
        'D5': -17644}}

Вариант №23

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

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

(b'MUU\x00\x00\x00\xb0\xa9Fe3?\x0c&\x9d\x96\x00\xc1\x1e\xa7\xe6\xcc\xb1\x13'
 b'\xbb\xbc;\x8d\xf45\xf7#\xb0>\xa9\xfe\xef?h\x92-\x00\x00\x00\x02\x00\x00\x00'
 b'!\x17\xfa\xe0\xd6+\xbf:\x0eK\xbfzt@\x00\x00\x00\x02\x00\x00\x006\xc1\x93'
 b'\x11\xcb\xf3\xbf\x07v@\xbf!W5\x00\x00\x00\x02\x00\x00\x00K\x14\xe5\x9a~\xf4'
 b'?s\xd5\xcb=\x8d\xa1\xbd\x00\x00\x00\x02\x00\x00\x00`\xd9\xe5\xc7M.\xe2e\x1b'
 b'\xea\xa8\xe3\x934\xa3\xa6\xb5\xa0\xb3E\x834m\xcdrq\xb3\xb8\x90J%7I'
 b'e\xaa\xe8\x07]$d#N\x07<\xae<\x96Q\x0b\x99\xbfl#\x17%\x00\x00\x00\x03\x00\x81'
 b'\x8e\xa5\xed\xd4\x86*\x8e\x00\x00\x00)\x00\x00\x00>\x00\x00\x00S\x00'
 b'\x00\x00h\x00\x00\x00\x06\x00\x00\x00u\x00\x00\x00\x84i\x1b@p\xc3'
 b'\xb1^\xc0\x9f5\xbf|\xc5\xc5A\xe8!\x0f\x94')

{'A1': {'B1': 134,
        'B2': 42,
        'B3': -114,
        'B4': {'C1': [{'D1': [0.33202311396598816, 0.9084804654121399],
                       'D2': 23,
                       'D3': -85928405},
                      {'D1': [-0.7267805933952332, -0.9783363342285156],
                       'D2': -63,
                       'D3': -1827550221},
                      {'D1': [-0.5291481018066406, -0.6302369236946106],
                       'D2': 20,
                       'D3': -442859788},
                      {'D1': [0.9524809718132019, 0.06915614753961563],
                       'D2': -39,
                       'D3': -439923410}],
               'C2': [57957, 7146, 43235, 37684, 41894, 46496],
               'C3': {'E1': [3777901553851283600, 5342737321322801159],
                      'E2': 1562666019,
                      'E3': 5622529378833813771,
                      'E4': 39359,
                      'E5': 1814239013,
                      'E6': [179, 69, 131],
                      'E7': -1901728300},
               'C4': 26907,
               'C5': 4643426382385291061,
               'C6': -65},
        'B5': 8990809117973090196},
 'A2': -1455004365,
 'A3': 0.5474641919136047,
 'A4': 10808851443099290801,
 'A5': 5051,
 'A6': -0.011447418481111526,
 'A7': 905388976}

(b'MUU\x00\x00\x00\xac\x83\xbc,{<\x88b)\x18\xf9%\xd4G\xe3\x07\x06m\xed\xbc\xdc3'
 b'\x98\xd4#&\xe4\xbf5\xd9\x1e\xbfc^\xa5\x00\x00\x00\x02\x00\x00\x00!_\xce\x16'
 b'\x1f_\xbe\x8d\x0fl>y\xbco\x00\x00\x00\x02\x00\x00\x006\xfd\x8eu\xe9\xb0\xbf'
 b'\x14*!\xbfD\xaf>\x00\x00\x00\x02\x00\x00\x00K^\xe3\xd8\x9b\x8f=\xc1\x9cD'
 b'\xbf}\xfar\x00\x00\x00\x02\x00\x00\x00`\x0e@\xcbV\x90\x98\xa4\xa0\xfcY?\xb2'
 b'\xeb\x01\x9a\xcc\xc5\x95|\xc0\x8ft\x83\xef\x99\xb5\xe4\xff\xb68\xfeY'
 b'\x82T\xd0\xbah4\xd8\xffVT\xeb\xa5\xd9\\E#\xed,\x00\x00\x00\x03\x00}'
 b'b\xe2\xd6\xa30A\x18\x00\x00\x00)\x00\x00\x00>\x00\x00\x00S\x00\x00\x00h\x00'
 b'\x00\x00\x04\x00\x00\x00u\x00\x00\x00\x80g#\x86d\x91\xe8\x81;\x83\xafqS\x93'
 b"F\xf1LO'\xc8")

{'A1': {'B1': 48,
        'B2': 65,
        'B3': 24,
        'B4': {'C1': [{'D1': [-0.7103441953659058, -0.8881629109382629],
                       'D2': 95,
                       'D3': -837410977},
                      {'D1': [-0.2755082845687866, 0.24388287961483002],
                       'D2': -3,
                       'D3': -1904875088},
                      {'D1': [-0.5787678360939026, -0.7682989835739136],
                       'D2': 94,
                       'D3': -472343665},
                      {'D1': [0.09453633427619934, -0.9921027421951294],
                       'D2': 14,
                       'D3': 1087067792}],
               'C2': [39076, 41212, 22847, 45803],
               'C3': {'E1': [14237422963484034031, 11076010645512584793],
                      'E2': -2108370758,
                      'E3': 7508865069910125477,
                      'E4': 55644,
                      'E5': 1159982380,
                      'E6': [1, 154, 204],
                      'E7': 1659033251},
               'C4': 26403,
               'C5': 9684025526540010415,
               'C6': 113},
        'B5': 6022235128905803720},
 'A2': -2084819845,
 'A3': 0.016648368909955025,
 'A4': 1799511119780579078,
 'A5': 28141,
 'A6': -0.026880070567131042,
 'A7': -735893788}

Вариант №24

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

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

(b'WTPZ"g\xfa\xe5\x04,\xe6?m\xa0\x9czg\x00\x00\x00\xacb\x80\x8a\r\x02\xa2\xb8'
 b'\x99-\x82Jo\x04\xdeM\x14\x00\x00\x00\x1c\x00\x00\x00=K\xa4QN\x9d\xbc\xb7'
 b'F>\xad,\xf2iJt\xe7k\xffE\xb3AHz\xc4%\x9f\xc2\xa5\xeeq2\xdd\xc8\x92\x88'
 b'\x1c\xbbD\xf9\xf3\x14\xa6\x83\x01\x1b!B\xd5\xdb(\xa1a=\xb8a\\\x05\x0fixpjz'
 b'\x02\x00\x00\x00$\x00O\xfd.\xb9\xc8\xcb\xeb+\xc3\xfaw\x85=7\xc9\x15c\xac'
 b'\xfb\xdd\x14\x07\x00\x00\x00,\x00\x00\x00\xe0\n7\x8e\xca7\xcd\xbf\x8e'
 b'\xbc \x130T\xe2?\x1c]`\xec\xbf0\xd4\xbf\x03\x00\x00\x00d\x00\x00\x00')

{'A1': 0.6928734294662926,
 'A2': 2057085037,
 'A3': {'B1': 'ixpjz',
        'B2': [{'C1': 2323669676, 'C2': 3097625101},
               {'C1': 1250045337, 'C2': 1306395759}],
        'B3': 79,
        'B4': {'D1': -927387907, 'D2': 4433081327116086219},
        'B5': {'E1': 1662372151,
               'E2': -1108,
               'E3': 5341,
               'E4': [13239629964265147197,
                      8379626545528782406,
                      8811364909179694055,
                      3634948769966925252,
                      17961686945085180125,
                      4765119574052312307,
                      7041445506918702037],
               'E5': -0.22826511329738874,
               'E6': 0.5727768300620413,
               'E7': -0.31547544559130514,
               'E8': [92, 5, 15]}}}

(b'WTPZ\x00`\xdf\x9c\xb4\xbb1\xbfo\xa9C\xfcW\x00\x00\x00\xdb\x91\xfb\x1e'
 b'\xe8\x14\x97O\x16c#\x92$w\xe2\xbb\x14\x00\x00\x00\x1c\x00\x00\x00'
 b'\xc6\x19\xd1\xc9\xb4\xbb\xf20\xcat\x03\xbb\x1e\xe5X\x91\x94u\xc1M\xdd\\P\x00'
 b'\xa3n\x9f;\x19\xd8_\xd2?g=\xd0\x97}\xf8\x16\xab)Mapkeh\x02\x00\x00\x00'
 b'$\x00P/I\xdb\xe9\xa5\xb8\xb0 7Q0\x08\xc2\xf4k3\x1f\xe6f\t\x05\x00\x00\x00,'
 b'\x00\x00\x00\xb0\x02\xdb\xacEp\xc1?\x80}\xc9X\x14d\x9f?\x8c\xe4\x9b\xb49'
 b'\xe2\xde\xbf\x03\x00\x00\x00T\x00\x00\x00')

{'A1': -0.00027058753482611664,
 'A2': -62674577,
 'A3': {'B1': 'apkeh',
        'B2': [{'C1': 519803355, 'C2': 1335301352},
               {'C1': 2451792662, 'C2': 3152181028}],
        'B3': 80,
        'B4': {'D1': -371504849, 'D2': 590060848399038629},
        'B5': {'E1': 862713026,
               'E2': -6625,
               'E3': 2406,
               'E4': [3527087843338951110,
                      10473372853599433930,
                      22620103698904468,
                      15159072473638465187,
                      1655210954045876031],
               'E5': 0.1362387746830982,
               'E6': 0.030655210417874112,
               'E7': -0.4825577033767068,
               'E8': [171, 41, 77]}}}

Вариант №25

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

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

(b'PXMG\x0eU\xd7Z\x8a\xfeW}\x82icjh\x02\x00/\x00\x00\x00v\x00&\x08\x92'
 b"'\xbbe\xcfZ\xd74\xe6\x9b\xa0\xa2J/\xf9l|k\x7f\xb5\x1f\x00\x1f\xac\r"
 b"\xf3'\x00e\x87\xe7\x9e\xbd\x1du\x1b\xf5\xceN\x80\xe8?2\xb4\xc7S\xe4JF"
 b'\xf0k\xd6\xf1\x15\xc3\x9eC\xe0\x8bPS\x0e\xe0\x9ek\x9c\xdau\xe2\x15mV\xe0'
 b'\xa3\xc7\xc0D\xfc)\xa9^_J\x1chs\xe0\xbf\x15;\xd8\xccGI\xd0\x08\x1a'
 b'\xde\x10;\x00f')

{'A1': 9402768347773982549,
 'A2': 'icjh',
 'A3': [{'B1': {'C1': 886528719, 'C2': 2728434662}, 'B2': -217207777},
        {'B1': {'C1': 1828269898, 'C2': 3045026684}, 'B2': -1628993691}],
 'A4': {'D1': 1215437574593136588,
        'D2': {'E1': 9245554637161176509,
               'E2': 5396530370683486184,
               'E3': [-697569210,
                      -1631382031,
                      1351344195,
                      -1629483437,
                      1977261163,
                      1449989602,
                      -1060658208],
               'E4': [-956, -22231],
               'E5': -0.5140877296971487,
               'E6': 15125,
               'E7': 216},
        'D3': 102},
 'A5': 663881766,
 'A6': 26043}

(b'PXMG\x0e<dBr\xe8\xf4!\xf1gqwu\x02\x00/\x00\x00\x00v\x00f\x14\xcd'
 b'\xa4\x1f\x01I\xb0\xc0\x97mE)FclC\xf4\xc1\x82%\x1c\x1f\x00n\n\xed'
 b"\xd1'\x00\x0f,#P$\xd6\xfb\xd2r\xf3\x9cD\xe8<\xdduL\x0cA\xd4\xf3\xa8\x806f"
 b'\xa6VFB7v+G\xcb\xe0\x04_\xa8\xe8\x9a9:;~\xc2\x83i\xff\x8au%\xf2\xd0'
 b'\x9c~\xbey\xb0\xd3?_2\x88[\xffl\x7f\xd5Z\x12\xdc;\x00\xa1')

{'A1': 17375438116558627900,
 'A2': 'gqwu',
 'A3': [{'B1': {'C1': 2545987657, 'C2': 1177109869}, 'B2': -772994450},
        {'B1': {'C1': 4098059363, 'C2': 472220353}, 'B2': 1344482319}],
 'A4': {'D1': -2588906962772230309,
        'D2': {'E1': 4944094165437503012,
               'E2': -3152224741648155416,
               'E3': [914401523,
                      1180083814,
                      729167682,
                      81840967,
                      -1696028577,
                      2117810745,
                      -9862206],
               'E4': [30090, -3547],
               'E5': 0.30764621355997424,
               'E6': 12895,
               'E7': 136},
        'D3': 161},
 'A5': -1530063770,
 'A6': 287}

Вариант №26

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

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

(b'JWOWy\x004\xa6\x11\x00\ns\xef\xf9\xe9{\xe9?G?\xeb\xd1b\x92$\x80\x9e\xc8'
 b'?\xdfYv\xe5G\x19\x04\x00\x00\x00\x12\x00\x00\x00\x1b?+\xee\xa5\xbbB\xd2$'
 b'\x00\x0f\x00\x00\x00\x02\x00\x00\x00$\xac\x8b\xe6t\xfb`os\xaa@'
 b"\xfb\xc5\xb6\xcc\xc9\xb2\x9f'\xed\xf6\xa5\x8b|\xbf\xd5\xfdl\x14\xe7m"
 b'\xf0\xc1\xfb\x00\x02\x00,J0X+')

{'A1': {'B1': {'C1': 31721, 'C2': 63},
        'B2': [{'D1': 71, 'D2': 0.8693096975657857},
               {'D1': -56, 'D2': 0.48983547583010556}],
        'B3': {'E1': [-84, -117],
               'E2': [-428541088,
                      1869851200,
                      -70928692,
                      -911040729,
                      -302602869],
               'E3': 124,
               'E4': -0.34359266320617987,
               'E5': 49659,
               'E6': [0.6716101765632629, -0.0029727304354310036],
               'E7': 74,
               'E8': 48},
        'B4': 88,
        'B5': 43},
 'A2': [-23023, 10, 29679, -1559]}

(b'JWOWy\x004\x17\xc2\xc9\x7f\x8c\xc7\xa7\x7f\xd3>\xa1>\xbf\xd63\xc1\x8f'
 b'\xe1$\x80\xc2?\xcdq\xf6\x89\xe6w\x00\x00\x00\x00\x12\x00\x00\x00\x1b'
 b'>\xc3\xde\xf3?Q @\x00\x0f\x00\x00\x00\x02\x00\x00\x00$\xa5@aq\x1e.\xb1\x10Q-'
 b'\xa5\x94Q.be\xb5f\xcb\x8d;\xe7\x96?\xc2,\xcb\xa4F\xe9\xb8\xfet\x00\x02\x00,.'
 b'\xab\r\x9c')

{'A1': {'B1': {'C1': -11458, 'C2': 161},
        'B2': [{'D1': 62, 'D2': -0.3469089417527087},
               {'D1': -62, 'D2': 0.23004037602816396}],
        'B3': {'E1': [-91, 64],
               'E2': [1634803246,
                      -1324330707,
                      -1517006546,
                      1650832742,
                      -879936537],
               'E3': 150,
               'E4': 0.14199204942071986,
               'E5': 65140,
               'E6': [0.3825603425502777, 0.8168983459472656],
               'E7': 46,
               'E8': 171},
        'B4': 13,
        'B5': 156},
 'A2': [6082, -13953, -29497, -22657]}

Вариант №27

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

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

(b'XQOJ\x00\x00\x00\x92\x92\xfb\xbc#\xce\xc5>\xf0\xca\x15?\x16\x88\xf0\xbe\xd8'
 b'\xcf`\x89\xda\x92\xb6\xddZ\xbf\xe0\xfb\x19\xed\xb0\xd8\x06\x00\x03\x00\x00'
 b'\x00\x1a\x11N\x19\x8eL\x1c\x8c\xda\xbf\xe7\xae\xdcP\xc4\x93\xdc\xbb\xce'
 b'\x95L\r9\x19\xa6"t?\xd4\x1fw=\xb5~\xa4\x00\x03\x00\x00\x00BH\xb4'
 b'\x1a\xca\x0ff]\xbe\xbf\xe4\xe4\xf5y\x9e\xad~\x87\xa6\xe8\x1f8\x94'
 b'\xb3\x87\x11a?\xd3s\x8c\xa4\x1f\xde`\x00\x03\x00\x00\x00jv\xc4G\xd4\xa9N'
 b'\x8c[?\xeb\x1e\x98\xb2\xe2\x8a\x18\xa9\x7f\x06`\x03\x0c\x00\x00\x00 '
 b'\x00\x00\x00H\x00\x00\x00p\x0f\x8fD\xdf\x06\x7f\xc2T6e\x8f\xe2\xee\xd0\xf0')

{'A1': {'B1': 780,
        'B2': [{'C1': -0.5306520121000637,
                'C2': [-30246, -27978, -8870],
                'C3': 1246962245781195994,
                'C4': -0.7400952889917067,
                'C5': -1144089268},
               {'C1': 0.314420519125614,
                'C2': [3385, 6566, 8820],
                'C3': 5238841721682812350,
                'C4': -0.6529490828883551,
                'C5': -2019104737},
               {'C1': 0.30392757442266394,
                'C2': [14484, -19577, 4449],
                'C3': 8558044170609921115,
                'C4': 0.8474849218221747,
                'C5': -1451293088}],
        'B3': [261047519, 109036116, 912625634],
        'B4': {'D1': 61136, 'D2': 240}},
 'A2': 37627,
 'A3': [-0.009998028166592121,
        0.47029176354408264,
        0.5880270004272461,
        -0.42345714569091797]}

(b"XQOJ\x00\x00\x00\x92D\x08\xbfN_\x88\xbfVU\xfd\xbft\n\x1c?'\nV\xa3<p\xf5[\xb7"
 b'?\xdd\x8a\xa5\xa1,D\xa8\x00\x03\x00\x00\x00\x1a\xc0\xea\xa3\xce\xda\x83'
 b'I\xfe\xbf\xc5\xa2\xa6\x9f\x90\xf5h\x9eiKxv\xd5\xc9^\xc3\xf5\xbf\xe8Y\xed'
 b'\x00\xf3\\T\x00\x03\x00\x00\x00B\xc3\x1f\xda1m\xee\xe8\xd0?\xd35\xe4\xe1\xe1'
 b'\x1b\xc8\xf0!A0\xfc\xce\x92\x89\x9d\xe9?\xd1\xd0\xc6n0R\x94\x00\x03\x00\x00'
 b'\x00j|m\xd4\x9a\xfd\xdf\xbe\xee?\xd8\xa5{j\xca\xe2|\x16\xb38\xa7\x9f\x08'
 b'\x00\x00\x00 \x00\x00\x00H\x00\x00\x00p{\x12J\xf1B9\x99\xd2\xfb\xfc\xd0_'
 b'\xaa r')

{'A1': {'B1': 40712,
        'B2': [{'C1': 0.461587340732033,
                'C2': [-23748, 28917, 23479],
                'C3': 13901103308657084926,
                'C4': -0.1690262107021383,
                'C5': -1637266568},
               {'C1': -0.760977269989676,
                'C2': [30421, -13986, -15371],
                'C3': 14060196467506604240,
                'C4': 0.30016443308380447,
                'C5': -266256080},
               {'C1': 0.2783676219999418,
                'C2': [-818, -28023, -25111],
                'C3': 8966056195313876718,
                'C4': 0.38510022572476266,
                'C5': 380844199}],
        'B3': [2064796401, 1111071186, -67317665],
        'B4': {'D1': 43552, 'D2': 114}},
 'A2': 17416,
 'A3': [-0.806145191192627,
        -0.8372495770454407,
        -0.9532792568206787,
        0.6525014638900757]}

Вариант №28

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

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

(b'DCKV\xb9<g\x00\x00\x002e/C\xf1gB?\x1b1M\xd1.#\xb1Oi\xc5\xba\xacm\xe9'
 b'.F\xec\xbf)s\x97\xbeY\xdc\xa0\x9b\xcf\xa00({DD\xec\x8aa\xc1\xe1?=\xd6\xf7'
 b'\xd3\x88\x80\x99\x1a\xa9Q\xf0\x14\xfe\x9d\xea\x89\x00\x00\x00'
 b'\x8c\x00\x00\x00\x8f\x00\x00\x00\x92\x00\x00\x00\x95\x00\x00\x00'
 b'\x03\x00\x00\x00\x98\x00\x00\x00cma\x94\x05P@\xe4\x8f\xec\xbf\x03'
 b'\x03\x00d\x00\x00\x00\x07\xef\x10@\x00L\xc5\xcb\x0c\x122\xden?,g\x95Y/&7C'
 b')\xabu\x1e\x8c,\xa3\r\xc3\xf6h!W\xd7\x9dV\x83\xc99\x067\x89\xea\xb2')

{'A1': 60,
 'A2': {'B1': {'C1': -0.892564893351095,
               'C2': 3,
               'C3': 'cma',
               'C4': 61191,
               'C5': 1300638440647311376,
               'C6': 0.9330779314041138,
               'C7': 44,
               'C8': [38247, 12121]},
        'B2': 1127179570,
        'B3': {'D1': 0.7593985199928284,
               'D2': 5742409683861057819,
               'D3': -14999,
               'D4': -0.8835672911785857,
               'D5': -0.29580047726631165,
               'D6': -1683956647,
               'D7': -24369,
               'D8': 48},
        'B4': 31528,
        'B5': 0.5548560822809425,
        'B6': -738732483,
        'B7': 1508795661906706568},
 'A3': 254,
 'A4': -5475,
 'A5': [{'E1': 38, 'E2': 17207},
        {'E1': 41, 'E2': 30123},
        {'E1': 30, 'E2': 11404},
        {'E1': -93, 'E2': 49933},
        {'E1': -10, 'E2': 8552}],
 'A6': [1453184855, 104450435, -1293252297]}

(b'DCKV\xb9mf\x00\x00\x00\x14w\xea$*T6?\xe7\xd2\x93g"\xca\xeav1\xb1'
 b'6\x13\xdf\x86\x06\t\xe8?\x0c\xfc1\xbf\xd1&\xf9,\xeb S\xa8\xa2\xea\xd7 '
 b'\x90\r\x07\xe6?\x8dEsP^\xe4\x93pA`~\x1fUD:\x88\x00\x00\x00\x8b\x00\x00\x00'
 b'\x8e\x00\x00\x00\x91\x00\x00\x00\x94\x00\x00\x00\x05\x00\x00\x00'
 b'\x97\x00\x00\x00fc\xbc\x8b\xe4\x8fA\x9a\xe1?\xaa\x02\x00d\x00\x00'
 b'\x00"\xb3\x95kii<\\\xf4\xd7t\xeab>\x1e\x0fJ\xe6\x7f\t\x98<\xa2\xba\x11~\xdb'
 b'm\xe3Px\x89U\xda\t\xd8TA\xbc\xc2\x04\x9bh\xe5y\xd5\xde\x17\xd1\xa8(\x9bv!')

{'A1': 109,
 'A2': {'B1': {'C1': 0.5500800905614294,
               'C2': -86,
               'C3': 'fc',
               'C4': 45858,
               'C5': 15561164027008215957,
               'C6': 0.22159749269485474,
               'C7': 30,
               'C8': [18959, 32742]},
        'B2': 619345684,
        'B3': {'D1': 0.7122217416763306,
               'D2': 8568883490141229799,
               'D3': -20175,
               'D4': 0.7511017450529838,
               'D5': -0.6952521800994873,
               'D6': 754525905,
               'D7': 8427,
               'D8': 83},
        'B4': 41640,
        'B5': 0.6883609595304254,
        'B6': 1349731725,
        'B7': 2269357096419189854},
 'A3': 85,
 'A4': 14916,
 'A5': [{'E1': 9, 'E2': 15512},
        {'E1': -94, 'E2': 4538},
        {'E1': 126, 'E2': 28123},
        {'E1': -29, 'E2': 30800},
        {'E1': -119, 'E2': 55893}],
 'A6': [1096079369, -1694186820, -713431704, -1462691874, 561421096]}

Вариант №29

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

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

(b'CLY\x08\\W\xa2?\xc0u\x15\xa5\xf36q\t?z\x00\x00\x00zuD\xae\x9f:\xbb'
 b"\xc6\xa3{\x0c\r/(\x08#\x10_' \xbb7g\xbe\x05\x00\x17\x00\xac\xa8\x1d"
 b'3B\xe5\x08\xc8?\x1c\xd2t\xbf\x04\x00!\x00\x9f\xe0eHxUY\xac\xbf\x01P\xc6\x0ci'
 b'\xb7\xac\xb2*/x\x07V\xdb\xddf*\xef\xfb\xe5\xcf*\xe3\x14\xbc|\x92\xe7k\xa1k?S'
 b'\x0bql\xa4\xd5\x0e~;V\xcb\x04\x00K\x00\xf6}\x02\x00\x15\x00\x92e\x17\xfc'
 b'\x02\x00)\x00bm%\x1cb\x7f:\xb5x\xa3\xc0\xdf\xd6(\xb8$O\x00')

{'A1': 23560,
 'A2': 17556462317854499415,
 'A3': 0.5368837118148804,
 'A4': {'B1': 32246,
        'B2': 'zu',
        'B3': 26002,
        'B4': -1001,
        'B5': [{'C1': -0.22579853236675262,
                'C2': [44612, 15007, 50875, 31651, 3340],
                'C3': 172,
                'C4': 0.18777147037893127},
               {'C1': -0.9563310146331787,
                'C2': [10287, 8968, 24336, 8231],
                'C3': 159,
                'C4': -0.0553690633134456}],
        'B6': 13058890128869911906,
        'B7': 2645909684422222712,
        'B8': {'D1': [-1297303703,
                      125316906,
                      1725815638,
                      -436474070,
                      350431951,
                      -409830212,
                      1064018283,
                      1819347795],
               'D2': -92,
               'D3': 3797,
               'D4': -883541122,
               'D5': [1, 80, -58, 12]}}}

(b'CLY-\xa1c{J{\xb7\xbeo\x11\xe9\xa0p\xbe\x8e\x00\x00\x00cd\x8bP\x86v\xca'
 b'\xf1\xf9wZ\x93r\xe8\xbe\xf5\xcb\xac\x9c\xe5^>\xd9\xdd\xfa\xb1='
 b'\xbf\x03\x00\x17\x00t\xe2\x0e\x83_-\xc8\xe6\xbfw\xf5\xbf\xbe\x05\x00'
 b"\x1d\x00\xa0PI~\xb2\xdf\x07\xee\xbf$\xfeA>\x03\x00'\x00s\x88\x9a\x08\x9c"
 b'\x0b\xc5\xc8?y\xc8\xdc\x95\xf1\xc0\xf0(\x9e\xf5]jq\xe8\x85D\xde9^\xdb'
 b'\xa0\xdb\xef,\xcb\xf7\x1a\x96"[\x82X\xb0\x1c1\xd3\x91\x1dMv>\xa6\x03\x00'
 b'`\x00.\xfa\x02\x00\x15\x00\x0b\xf2Nt\x03\x00-\x00b\xb9\xb8\xfbB\xb12w'
 b'\xe8\xea \xfd\x1c\x0f8 c\x00')

{'A1': 41261,
 'A2': 1256432516316429155,
 'A3': -0.23498882353305817,
 'A4': {'B1': -1490,
        'B2': 'cd',
        'B3': -3573,
        'B4': 29774,
        'B5': [{'C1': -0.7409969568252563,
                'C2': [20619, 30342, 61898],
                'C3': 116,
                'C4': -0.7119356980769818},
               {'C1': -0.3749196231365204,
                'C2': [30713, 37722, 59506, 62910, 44235],
                'C3': 160,
                'C4': -0.9384611593434702},
               {'C1': 0.18944603204727173,
                'C2': [58780, 15966, 56793],
                'C3': 115,
                'C4': 0.1935133468516208}],
        'B6': 8589122340598102370,
        'B7': 2321622225089784552,
        'B8': {'D1': [-255790699,
                      1576377896,
                      -2048364182,
                      1580850756,
                      -270819109,
                      452447020,
                      -2107956586,
                      823963736],
               'D2': -45,
               'D3': 7569,
               'D4': -1505855923,
               'D5': [121, -56, -36]}}}

Вариант №30

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

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

(b',FAHP\xc6KE\xcf\x00\x00\x00\x8cL\xcd\xc6\xba\x10y\xedn\x93\x10bc\xde4C'
 b"\xea`@\x1f*\xd9\x06W'\x0fyp\xc7\xbd\x84\xfc\xce\xc1M\xba;\xfdW\xf3\xe8\xb0Y}"
 b"\xdfx\xb8\x8a\x84\xd1\xd4M\x85>\xf0X'D\x94z\x86\xc8oFH\x8e{\x8dr?\x11\x1a"
 b'\xc8~\xebb\xdb\xa7\xe8\xd1\x16\xc3\x18\x08\xbf\x8cS&\x00\xd9\x99e'
 b'\xb8\x00\x19\x00A\t\x1b\xd83\xdc\xe2\x041\x88\xc9u~\x7f\xe6\xed\xcc\xa2}!'
 b'\xb5\xb5=\xc0\xc5\xcf\x82\xb98\xf1\xfb>\x00\x02\x00\x00\x00i\xa2\xaf'
 b'\xd7\xbcM\x02\x00\x00\x00m)')

{'A1': -968145457,
 'A2': {'B1': [{'C1': [-2435246824584372438, -2808461492343967545],
                'C2': -0.06493531167507172,
                'C3': -16051,
                'C4': 47675,
                'C5': [-681,
                       -3096,
                       -20391,
                       32223,
                       30904,
                       -30076,
                       -11820,
                       19845]},
               {'C1': [4535221750439639686, -4003904266267030158],
                'C2': 0.5668148994445801,
                'C3': 32491,
                'C4': 25307,
                'C5': [-22552,
                       -12010,
                       -15592,
                       2239,
                       -29613,
                       9728,
                       -9831,
                       26040]}],
        'B2': 2729433020,
        'B3': 19714,
        'B4': {'D1': 152819763,
               'D2': 56546,
               'D3': [70355145, 1971224550, -305356163, 565556541],
               'D4': 3234189186,
               'D5': 3107516923,
               'D6': 62},
        'B5': 41},
 'A3': 1288554170,
 'A4': 1187241035958346339}

(b",FAHP\xaf\xf3J`\x00\x00\x00\x8c\xd8\xc1\xbd\x0cA\xc7r-'l\x02_0\xb1c"
 b'*\x90N\xd46~ \x1c\xb3\xd9\xbf\x1e\xa8\xbe\x06\xe9Z=w"\tA\xeb\xa6'
 b'G\xa9\xdb\xc2\xc6\xcf\xd3}\n\xa0\x0c(y\x9d\xca!\x81OE>[\xa1\xc1\xf7'
 b'Z\xda@\x1b?\xbd\xcd_\xcf\xa1QXl\x0e\x18\x16\xcf"\xce[\xd0\xefy\x8b'
 b"\xac\xd8\\V\x00\x00\x19\x00AE>\xa9\xd6\xaas\xf8p'G\xfcX!Z\r\x07\x0e\tJ"
 b'\x03]~\xa9\xa5\xe9\xe5\x93X\x8a\xd5J\x00\x02\x00\x00\x00i\x1b\xc8'
 b'\xe2\x8a\xfa\xdd\x00\x00\x00m\x14')

{'A1': -1343010208,
 'A2': {'B1': [{'C1': [3508694619159188534, 9088295606811565736],
                'C2': -0.13174954056739807,
                'C3': 15735,
                'C4': 8713,
                'C5': [16875,
                       -22969,
                       -22053,
                       -15674,
                       -12333,
                       32010,
                       -24564,
                       10361]},
               {'C1': [-7076807025194877349, -6790874793517245633],
                'C2': -0.10028039664030075,
                'C3': -24239,
                'C4': 22636,
                'C5': [3608, 5839, 8910, 23504, -4231, -29780, -10148, 22016]}],
        'B2': 466150026,
        'B3': 64221,
        'B4': {'D1': 1161734614,
               'D2': 43635,
               'D3': [-126867641, -61333158, 218566153, 1241734526],
               'D4': 2846222821,
               'D5': 2472053461,
               'D6': 74},
        'B5': 20},
 'A3': 3636575500,
 'A4': 4739882671091221087}

Вариант №31

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

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

(b'AAI5u\xd6#p\x08{\xf9TH\xb5?/\x00\x00\x00~\x00iB!\xa3e9\xb7P\xb3V\x81'
 b'\x89:\xfa\xb4\xbeI\xdei\x8c\xe9\xe1@I\xd4Bovdbo\xd5\xac\xb3w\xcc \\\x9f'
 b'\x11\xa7\x15\xf2\xf06W\x8c\xf0\x9b(\x06-\x85\x9bn\xebR\xe6H)\x9e\x0ft'
 b'\xf4\xe9\x86\xa7\xf0\x83g\xe3\x19M\xd5\x8a#nMXi\x82\xb5$\xde\xb1)aV1t\x90'
 b'\xa0`J\xe1\xaa\xc6\xbf\x7f\x89\x116/\x1a\xac\xce\x8e\xac\nKy\xe3?6\x00'
 b'H\x00Z\x00l\x002\xb2\xe8\xd8:')

{'A1': 601257269,
 'A2': 0.08313494768938923,
 'A3': {'B1': 'ovdbo', 'B2': 44245},
 'A4': {'C1': 0.6085562904813402,
        'C2': [{'D1': [550270899, 2802949980],
                'D2': -7210108697208360427,
                'D3': 1576},
               {'D1': [1855685933, 1223054059],
                'D2': -6375150986367885783,
                'D3': 33776},
               {'D1': [1293542247, 1847823061],
                'D2': -5630022122170918835,
                'D3': 24873},
               {'D1': [2423533910, 3779748000],
                'D2': 3401925850776454826,
                'D3': 44058}],
        'C3': [50, 178, 232, 216, 58]},
 'A5': 5816180552463630953,
 'A6': {'E1': -1988012365,
        'E2': 58,
        'E3': -19206,
        'E4': 18878,
        'E5': -34,
        'E6': 3790179433},
 'A7': 1121208640}

(b'AAI\xe9\x96\n\xddX\xdf@\x93r1\xcc\xbf/\x00\x00\x00~\x00R\xd2O\t1\xc2\xb6'
 b'w\xff-27I\xd2\xb2d\x10\xedj##\xf1\xe5\xd5Z\x8cpitdb\x85\xd2Cl\xc0W.\xa8(b$S'
 b'\xaf#T\x81y\x91A\x10\xb5.\x9d\xdfj\xef\x87\x1c\xceVQ\x7f\xb2\x8a\xb6\xef'
 b'\xc6\xff\xf3\xf2O9\xf9\x00\x96\x18\xb0\xa4\xc4\xb8\xcf\xad|}\x10M+K|\xba'
 b'\x10~\x9ea\xdbO\xcf\xfa\x96\x7f0\xea(\xe8\xa8Uqkx\xba\xee?6\x00H\x00Z\x00'
 b'l\x00\xb4-\xc9\x1f\x83')

{'A1': 3708458729,
 'A2': -0.2202590197573453,
 'A3': {'B1': 'pitdb', 'B2': 53893},
 'A4': {'C1': 0.960262498711633,
        'C2': [{'D1': [1472228419, 1646831662],
                'D2': -7964192267652082908,
                'D3': 4161},
               {'D1': [3751620277, 478670698],
                'D2': -1173598153638586674,
                'D3': 65478},
               {'D1': [961540851, 412483833],
                'D2': 9042293259522843824,
                'D3': 19728},
               {'D1': [3128707883, 1637776912],
                'D2': -1571615983522590757,
                'D3': 59432}],
        'C3': [180, 45, 201, 31, 131]},
 'A5': 8626295652140175954,
 'A6': {'E1': 926035455,
        'E2': 73,
        'E3': -19758,
        'E4': 4196,
        'E5': -19,
        'E6': 4045611882},
 'A7': 2354763237}

Вариант №32

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

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

(b'iUBH\x12\xb2gc~\x06\xf9mP\x00X\x00`\x00\xe2Z\xb0\x9c\xd2\xd4xshe'
 b'\xa2K\x99\x0c\x8e\x88\x97\x1b\xf9\xads-0\xd2\t3\n\x03XKZ.iY\x15?\xf1\xed'
 b'\x84%\x1f\xe4\xb4TA\x8b\x16k#\xf1\xbft?\x80\x1b2{K\x01\xed\xbf0{\xca\xe6\xca'
 b'FQ\x81\xfaXT\x06G\x08\x06\xb1\n\xcd\x105\xebM:\xd2m')

{'A1': 7924372159238484498,
 'A2': [{'B1': -890844549, 'B2': 4202778950},
        {'B1': 1191597144, 'B2': 179373576},
        {'B1': -348843827, 'B2': 1842494029}],
 'A3': {'C1': 23266,
        'C2': 3570572464,
        'C3': 'xshe',
        'C4': 162,
        'C5': 2383190347,
        'C6': {'D1': -115632248, 'D2': [173, 115]},
        'C7': {'E1': 164769837,
               'E2': [1476594227,
                      1764645451,
                      -247524007,
                      522552557,
                      1096070372,
                      594220683],
               'E3': 0.9560537934303284,
               'E4': -0.9064080625692981,
               'E5': 48}}}

(b'iUBH\xf3\xf3\x90\xf9\xeb\xa7\xde\xa1P\x00X\x00`\x00\xddj\xde\x9f\xe8\xf5evhg'
 b'P\x90\xf5\xcf\xed\n\xd8#T\x13\xfel\xb8\xf3<\xed\x88y\xd8\xf3\xab\xf1\xbc\xb3'
 b'c\xb4\x0c\x8f\x8ep\xc7\xf9_\xaeE\xc2\xa6\xb3\x92\x19(2\xbf\xa0J\x900\x8b'
 b"\xf5\xca\xbf&\x10\xdfFoF\x05\xe9\n\xfc\x16\x8f\x80'\xff\xe6\xf0"
 b"\xb3\xe2\xcb\xd4X\x837'")

{'A1': -6782799356827208717,
 'A2': [{'B1': 1866915600, 'B2': 183043398},
        {'B1': -2138106116, 'B2': 4041670439},
        {'B1': -724835661, 'B2': 657949528}],
 'A3': {'C1': 27357,
        'C2': 4125663198,
        'C3': 'evhg',
        'C4': 80,
        'C5': 3989829008,
        'C6': {'D1': 1411635210, 'D2': [19, 254]},
        'C7': {'E1': 1022605420,
               'E2': [-663123731,
                      -1125012493,
                      213148595,
                      -948924785,
                      1169055737,
                      -1833720126],
               'E3': -0.6959243416786194,
               'E4': -0.21061839934607907,
               'E5': 38}}}

Вариант №33

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

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

(b'WMDU}\x97\x03\x82i\xbb\xd6\xa3U\x06\x98I\xea\xf0\x9aA\xe6\xbf\xb6\xf5'
 b'\xb6A\x99\xec\xddi\xaf\x820\x08/Z\xbeV\xc8?\xc2\xfel\x00\x00\x00/\xe2'
 b'\xc0\xdb\x8b\x9a\\?\x11\xa4\xdcn\xfb\x03\xad>\x12W\xbce\x00#>\xbf\xbf*'
 b'\x89f\xb6\xa7n>.\x006\x00>\x00F\x00nzbm\xf2.?\xd7\nI\xbe\x7fb\x97'
 b'\x13\xcce\x03\x90\x90*\xa7\x04\x00\x00\x00N\x00\x03\x00\x00\x00V\x00'
 b'\x00\x00\xd4\x97W\xf2/\xd5\xe6\xbfd\x82d\xc6\xf6\xa7\xd6?\xcc\xdb'
 b'\xbb0\x9a\xf6\x11\xeel\xec\xb7ag\x92\xa2\xc4\xe7\t6\xfex6&P\xce\xc8'
 b'~\xad\x87W\x85\xc1\xbf$\x83f)\x99\xe3\xe5\x0b2\x00\t\x96\xc4\x04\xde\xd0\r'
 b'Y\x00g\x00')

{'A1': -105,
 'A2': {'B1': 456451079910556163, 'B2': -0.6955084519743648, 'B3': -2634},
 'A3': 9416861747733152182,
 'A4': 0.19014720347883118,
 'A5': 65218,
 'A6': {'C1': [{'D1': 47, 'D2': 226, 'D3': -9280, 'D4': 0.8617331385612488},
               {'D1': 17, 'D2': 164, 'D3': 28380, 'D4': 0.33792099356651306},
               {'D1': 18, 'D2': 87, 'D3': 26044, 'D4': -0.7427215576171875},
               {'D1': 191, 'D2': 42, 'D3': 26249, 'D4': 0.23306164145469666}],
        'C2': 'nzb',
        'C3': {'E1': -0.7135238393063852,
               'E2': 0.3540017068317296,
               'E3': [-52, -37],
               'E4': 12475,
               'E5': 154,
               'E6': [4598, 27886, 47084, 26465, 41618, 59332, 13833, 30974],
               'E7': 3461359158},
        'C4': -0.1368817722786757,
        'C5': [857341551048033060, 15050472247096049714],
        'C6': 13,
        'C7': {'F1': 0.6833866238594055,
               'F2': -0.19633041322231293,
               'F3': 328688255,
               'F4': 26060},
        'C8': {'G1': 3, 'G2': 2804584592}}}

(b'WMDU}\xe3S\xc8\xd4\x8a\x11\xc2\x18\x9d,\x9c\xeb\x04\xff\xd3\xdf?l\xeb'
 b'\xcc\x8fn7o\xc9\x02\xb7\x9aF\x16I\xf0\xae\xea?JIb\x00\x00\x00^\r'
 b'\xa3\x05\xb9\xc3\x04?\x8d\x05I\x1eK\x11\x80>@u\x1b5\xc6\xbfE?.\x006\x00>\x00'
 b'ktv\x85\x94O?\x18[\xc5>mlNk\xd4r?jWJ\x15\x03\x00\x00\x00F\x00'
 b'\x03\x00\x00\x00L\x00\x00\x00\n\xdfz\xc1\xa0-\xe7\xbf\xc8\xe4b\x9b'
 b'\x06+\xe5\xbf\xb7\xde&\xd8\xd5[K\xe2\xba\xd5\xbc\x8b\xf8\x9d\x87\xc9LP\r\xae'
 b'\xa0MH\xa2%\x88\x9a\xa4\x8e\xcfR\xd8\xbf\x0e\x92N;1\x83`\xa9\xc4b\xd9'
 b'\x08\x0f\xb6\x0b\xc2\xdaO\x00]\x00')

{'A1': -29,
 'A2': {'B1': -7126733029714376621, 'B2': 0.49731421928885555, 'B3': -5268},
 'A3': 13187324138402779084,
 'A4': 0.8338548114281423,
 'A5': 18762,
 'A6': {'C1': [{'D1': 94, 'D2': 13, 'D3': 1443, 'D4': 0.518611490726471},
               {'D1': 141, 'D2': 5, 'D3': 7753, 'D4': 0.2501319348812103},
               {'D1': 64, 'D2': 117, 'D3': 13595, 'D4': 0.772457480430603}],
        'C2': 'ktv',
        'C3': {'E1': -0.7243198183923323,
               'E2': -0.6615021738899935,
               'E3': [-73, -34],
               'E4': 55334,
               'E5': 213,
               'E6': [19291, 47842, 48341, 63627, 34717, 19657, 3408, 41134],
               'E7': 631392333},
        'C4': -0.38005436830500416,
        'C5': [12204899237645685262, 13982469643791065796],
        'C6': -38,
        'C7': {'F1': 0.8108599781990051,
               'F2': 0.38546061515808105,
               'F3': 1800301677,
               'F4': 29396},
        'C8': {'G1': 63, 'G2': 357193578}}}

Вариант №34

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

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

(b'\x08VQZ\xb4L\xbfM\x8f\xba\x0c\xb6\x1ccgbn\x8dH\x02\x002\x00\x00\x00!2o'
 b'\n\x8e)\xd7xh\x00m\x00\x00\x00^\x1d<\xae G\n\x88\x98\xb4\xeevsp\x81.\xe2'
 b'\x86=lfJ=#\xf1\xdd\x1c\xfa3o\x80\xf3\x04\x00+\x00\x00\x00\x15\xc4\xd0P>\xe8A'
 b"\xbe3\x0f\xb9\x89\xe8\xda\xb5~\xc9\xd0'I\x00\x03\x00/\x00\x00\x00\t\x91\x83:"
 b']6\xd2\xc1G')

{'A1': -76,
 'A2': 2068855074231009100,
 'A3': 'cgbn',
 'A4': 18573,
 'A5': {'B1': [{'C1': 29558,
                'C2': 33136,
                'C3': 0.06586109101772308,
                'C4': 108,
                'C5': -424220237131593114,
                'C6': 4085280563,
                'C7': [32, 71, 10, 136]},
               {'C1': -15339,
                'C2': 20688,
                'C3': -0.18936249613761902,
                'C4': 51,
                'C5': -3927501873211655921,
                'C6': 4794320,
                'C7': [152, 180, 238]}],
        'B2': [33, 50, 111, 10, 142, 41],
        'B3': 30935,
        'B4': {'D1': 981700873, 'D2': 93}},
 'A6': {'E1': 54, 'E2': -15918, 'E3': 71},
 'A7': 2923175262}

(b'\x08VQZ}\xf3\xd5a$\x04u\xf16myzktL\x03\x003\x00\x00\x00T\xbc\xe2'
 b'\x05.\xf0\xb8\x9e\x84\x00\x89\x00\x00\x00I\xa5\xdb\xb3\x83\xa6\x9e\xe1\x8c'
 b'\xa9\xc8\xed\xe4z\xb2j\xad\x90_?^\xd49\xdd;\x11\x89&\x91d\x12\x85\x89'
 b'\x02\x00+\x00\x00\x00\xa8\xe9<o\x7f\xa5\xd2>>Ke\n\x8d*\xea+\x94\xa7'
 b"\x86\xd2'\x03\x00-\x00\x00\x00\xeeu\xc5\xee\x81\xc6;?\xd1\x17 (\xed\xc8'"
 b'\xbe2J\x8e \xba\x03\x000\x00\x00\x00P\x9d\xbc\x05\xef\xb1\x1a&\x9f')

{'A1': 125,
 'A2': 3959074208086087155,
 'A3': 'myzk',
 'A4': 19572,
 'A5': {'B1': [{'C1': 31460,
                'C2': 27314,
                'C3': 0.8733013272285461,
                'C4': 94,
                'C5': -7987546181983192620,
                'C6': 2307199588,
                'C7': [131, 166]},
               {'C1': -5720,
                'C2': 28476,
                'C3': 0.4114188849925995,
                'C4': 62,
                'C5': -7769859263621864117,
                'C6': 668108455,
                'C7': [158, 225, 140]},
               {'C1': 30190,
                'C2': 61125,
                'C3': 0.733497679233551,
                'C4': 209,
                'C5': 3656403691397193751,
                'C6': 3122695754,
                'C7': [169, 200, 237]}],
        'B2': [84, 188, 226, 5, 46, 240],
        'B3': -24904,
        'B4': {'D1': 96247120, 'D2': -17}},
 'A6': {'E1': -79, 'E2': 9754, 'E3': -97},
 'A7': 3017516361}

Вариант №35

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

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

(b'SYQ\x00d\x02w\xd5\xb7)>\x1e\xe6\xbf\xe5\xad\x02O\xfdI`\x18C\x978\xa5&\xa5'
 b'>\xef\x0b\x1b\x00\x02\x00\x83\xd2\xd0\xb8-\xfa@9\xfc\xc7\xdf[""+\x12w'
 b'\xb0D\x83\xe3\xf7\xa9\x8bMF\xbb:\x85\x83\xb3\xf6\xf6?0\x85V\xbd(\x7f\x91'
 b'?c&\x93=\x8a<\xde\xbeF\xc3\xce?~cQ\xbeY\x82C>)\xe9 \xf1\x9d\x08J'
 b"\xccf\xb2\x9erzz\x05\xfd\x8e\x06\xd3\x87Lt\xbf\xe7\x91!'5\x17\xc63"
 b'\xcf\xa7\xf6e\xdeyi')

{'A1': {'B1': [{'C1': 61853, 'C2': 2122}, {'C1': 52326, 'C2': -19810}],
        'B2': 'rzz',
        'B3': 431657299267243124,
        'B4': -0.736466003968183,
        'B5': 869246966},
 'A2': 177845692952092390,
 'A3': -0.6773692667286859,
 'A4': 6211,
 'A5': {'D1': 2537071910,
        'D2': 165,
        'D3': 0.4668816030025482,
        'D4': [26078, 31081],
        'D5': [3536893997,
               4198513148,
               3353303842,
               573248119,
               2957280227,
               4155083597,
               1186675333],
        'D6': -2085357834,
        'D7': 0.6895345449447632},
 'A6': [-0.04113728180527687,
        0.887307345867157,
        0.06749890744686127,
        -0.1941063106060028,
        0.9937029480934143,
        -0.21241097152233124,
        0.16592836380004883]}

(b'SYQ\x00d,\xf0\xfc\\\x96D\x02\x0b?\xdc\xf7\x9a\xee\xaa\xb9\xec\x97mD'
 b'\xd4W\xebS\xbf\r\xbe\xec\x00\x02\x00\x83\x9ao\x06oT\x98\xd1tB\xf7\xf6\x0f'
 b'\x1a\xdc\x9c?uB\x92F\xd0\r\xbd\x1d\x90.;|j\xe2\x88\x8e\xbe\xb7\xf9\xeb'
 b'>\xf9\xb1\x96>\x0bG\x06\xbe\xa1I\xd4>\x87z\xe3>4\x1aN>\x84,\x00\xbf7\x1c\xfe'
 b'^\xdcpk+\x82\\EuijSU\xeb\xba\x11\xf4\x93K?\xbe>\xf3\xba\x85k\xe0\xc2'
 b'\xe7V\xbb\xef\xad\x11\x9e')

{'A1': {'B1': [{'C1': 24284, 'C2': 28779}, {'C1': 11138, 'C2': 23621}],
        'B2': 'uij',
        'B3': 6004964862566110027,
        'B4': 0.11814807227840118,
        'B5': -1025026373},
 'A2': 3238365606667616779,
 'A3': 0.4526126223308029,
 'A4': -26771,
 'A5': {'D1': 1154766827,
        'D2': 83,
        'D3': -0.553694486618042,
        'D4': [61357, 4510],
        'D5': [2590967407,
               1419301236,
               1123546639,
               450665535,
               1967297094,
               3490561309,
               2418948988],
        'D6': 1793230990,
        'D7': -0.35932859778404236},
 'A6': [0.4876829981803894,
        0.13601312041282654,
        -0.31501638889312744,
        0.2646094262599945,
        0.17588159441947937,
        0.258148193359375,
        -0.715286135673523]}

Вариант №36

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

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

(b'UKVA1\xbf\xe5\x9f@)R\xfd\x12\x00\x00\x00\x04\x00%\x00K\xcaPZ\xd7\xe8<s'
 b'\xce\xbf\xe9\xf1\x01G\x089(\xcd\xc9\x1f\x8c\xc6\xff>\xae\xce\xee\xad'
 b'U\x9b\xc3\xd4\xe8\x8e\xa4sx?S\xdcZ\xfe\xcf\x86\xea\xd8\xf6)\xdb\xe9\x1d\xdc'
 b'5\xcd\xba/\x00\x00\x00\x02\x00\x00\x00)\xff\x7f\xd7y\xd3\x10?q\xffh>\x96'
 b'_\xd7=\ts\x13\xbfFT\x9f>yX\x87>\xce\xd8\xaa>\xe2\xe6X\xbf\x14\x8d\x87\x81`'
 b'\xea\x13\xc9]\xbeE\xdd\xf5?~\x01\x17\xccR\xa0\x8e\x00\x00\x00\x06'
 b'\x00\x00\x00E\xb8#\x16\\\xf5\x01\xf8\xc3')

{'A1': -0.6756897742378973,
 'A2': [205, 201, 31, 140],
 'A3': {'B1': 47,
        'B2': [{'C1': -14593,
                'C2': 0.34142249822616577,
                'C3': -5956683666734674268},
               {'C1': 29560,
                'C2': 0.8275810480117798,
                'C3': -85701524676269605}],
        'B3': -1,
        'B4': 2144827859,
        'B5': 16,
        'B6': {'D1': [0.9453034400939941,
                      0.2936999499797821,
                      0.03355700895190239,
                      -0.7747287154197693,
                      0.24350176751613617,
                      0.4039967656135559,
                      0.4431636333465576,
                      -0.5802845358848572],
               'D2': 33120,
               'D3': -367802019,
               'D4': -0.19322951138019562,
               'D5': 0.9922041296958923,
               'D6': 3427967118},
        'B7': [-23, 29, -36, 53, -51, -70],
        'B8': 13268473515666962627},
 'A4': -3868492196550511666,
 'A5': -0.8106695544572959}

(b'UKVA1\xbf\xa0\xbe\xc1[\x99)\xe0\x00\x00\x00\x04\x00%\x00L\xb2\x8dX'
 b'\xd1\x98\xfe\xd0\xda\xbf\xe6\xe6\xb3\xcc!\xc5r\xff q\xe2\x95\xd9?'
 b'b\xae\xd3\xd7\xd9j\xe2\x9d^\xc6G\xf1\x18>\xd0t\xc9U\xd1\xdc\x9e\x87\rw'
 b'\x85\xd3\xf6\x1ei&\x9d\x8a\x1e\x00\x00\x00\x02\x00\x00\x00)\x16\xe1\xb0'
 b'\xae\xb8\xb3>\x85\x82@\xbfj\x06i\xbe%\xceZ\xbe\xa6yE\xbe\xf7E\xe3\xbe\xfb#%?'
 b'K\xc8\x16>\x92\x8d\x9d\xf5\xb2\x87\xc2\xad\x98\xbf%\xd5b>.\xda'
 b'\x9f\xc8\xcc\x8cd\x00\x00\x00\x07\x00\x00\x00E\xcf8\x02\xee\xddTBz')

{'A1': -0.03270534747260334,
 'A2': [255, 32, 113, 226],
 'A3': {'B1': 30,
        'B2': [{'C1': -27175,
                'C2': 0.8854801058769226,
                'C3': -2893163764073445817},
               {'C1': -3816,
                'C2': 0.4071410000324249,
                'C3': 6183966336785151877}],
        'B3': 22,
        'B4': 3786452664,
        'B5': 179,
        'B6': {'D1': [0.2607593536376953,
                      -0.9141603112220764,
                      -0.1619199812412262,
                      -0.325143963098526,
                      -0.48295506834983826,
                      -0.4905025064945221,
                      0.7960218191146851,
                      0.2862366735935211],
               'D2': 62898,
               'D3': -2017284712,
               'D4': -0.6477872133255005,
               'D5': 0.17075584828853607,
               'D6': 3368848484},
        'B7': [-45, -10, 30, 105, 38, -99, -118],
        'B8': 14931687789485638266},
 'A4': -5580706706003930918,
 'A5': -0.7156619059516471}

Вариант №37

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

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

(b"MPCJ\xfb-q\nH'\xf7|egso\xf7c\x00\x02\x00X?\xccm\xfeG\xee\x19\x88\xe5'"
 b'3\xdc\xd5\x11GT\x00nCt\x00\x8c\xc9\x0eQ\xd7\xbe\xd3\xa5 \xbc\x03\xb4\x1d'
 b"6\ro5(\xeb\x96\x94\xcb-t\xee\xe2\xb0\xa5\t\xab\xaelFe\x14\xa2\x01j'x0"
 b'G_\xc7\x8c\xe9K\x9a\x9f\xc3\x00\x07\x00\x00\x00,\x9b5\x1cx\xd4'
 b'\x00\x04\x00\x00\x00H\x14\x99\x8c\xe2\xbf\xe6\xa1\xfdZ\x1c\xd0r\xfe\xca'
 b'\x84\xab[\x01xi:\xe4\xe7\xb5L\xdd\x81^\xa2\x9a\xf9\x85/P\xee\xd69a\xf7\x9e><'
 b'\xf1L')

{'A1': 18099246766446081916,
 'A2': {'B1': 'egso',
        'B2': 63331,
        'B3': [{'C1': 233,
                'C2': 1268424643,
                'C3': [3373158871,
                       3201541408,
                       3154359325,
                       906850101,
                       686528148,
                       3408753902,
                       3803227401]},
               {'C1': 155,
                'C2': 891058388,
                'C3': [2880334918, 1695851009, 1780971568, 1197459340]}],
        'B4': 0.22210672867022319,
        'B5': -1934520491371837612,
        'B6': {'D1': 345607394,
               'D2': -0.70727412796124,
               'D3': -2,
               'D4': 202,
               'D5': [-31573,
                      23297,
                      30825,
                      15076,
                      -6219,
                      19677,
                      -32418,
                      -23910]},
        'B7': 17268,
        'B8': {'E1': -108712112,
               'E2': 4007016801,
               'E3': -2146,
               'E4': 0.18451422452926636}}}

(b'MPCJ\x9a\x7fl\t\xe64>Huvrt\x0f#\x00\x02\x00D\xbf\xcf\x00\x0cT\x9b'
 b'\xd4\xc0\\\x01\x06\xbe\x05\x89m\x1c\x00Z\xfee\x00x[\xe7\xff\xc6'
 b'\xdc\xd0\xf9\xb5\xb1\x12\x8c\xfd(\xcf\xe0wg\xc9\xfe&\x9e\xb6\x8b\xe8i|n\x84'
 b'b\x00\x03\x00\x00\x00,7\xbd\x01\x03M\x00\x03\x00\x00\x008\xcd\x98'
 b'\x19\xba?\xd1\xba\xf24v\xaa\xc8\x8d\x01b\x04C[\x90\xaf\xee\x8d\xa1\x17?\xa8'
 b'a\xf2,\xafPk\xd0\xec\xbcX\xa5\xe2\xf0\x98\xbe\xb1\x95\xe5')

{'A1': 11132735593655844424,
 'A2': {'B1': 'uvrt',
        'B2': 3875,
        'B3': [{'C1': 105,
                'C2': 2087617634,
                'C3': [1541930950, 3704682933, 2970782973]},
               {'C1': 55,
                'C2': -1124007091,
                'C3': [684712055, 1741291046, 2662763496]}],
        'B4': -0.24218896991047778,
        'B5': 6629587539672526108,
        'B6': {'D1': 3449297338,
               'D2': 0.2770352852191249,
               'D3': -115,
               'D4': 1,
               'D5': [25092,
                      17243,
                      -28497,
                      -4467,
                      -24297,
                      16296,
                      25074,
                      11439]},
        'B7': -411,
        'B8': {'E1': 1349243116,
               'E2': 3159926242,
               'E3': -3944,
               'E4': -0.34684672951698303}}}

Вариант №38

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

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

(b'GAWF5\x00c\x00\x8c,(\xbf\xbaD\xea\xc9\x92\x97WT\xe1\x86q\xa4\x83\xa8+$'
 b"\x1c\xc1v\x139\xbf\xc8\x02\x00\x14\x00\r\x00\xf4\x19\x9c\xc3O\xc0\xa0'}?\x8a"
 b"z\x16\x00\x04\x00\x00\x00'\x00W[:/\x00l\xeb\xf4\x89r\xa0B\x9c:\x98\xb5?B\xa3"
 b'\x1d\x02\x00B\x00\xd5\x14\x98\xe0\n\xcc x h\x97>\x89.D\x00\x04\x00\x00'
 b'\x00U\x00\x81\x1e\t]\x00')

{'A1': [{'B1': {'C1': 113,
                'C2': 732464036,
                'C3': 14465343283896851492,
                'C4': [-31, -122]},
         'B2': [13, 6644, -15460, -16305],
         'B3': [87, 91, 58],
         'B4': {'D1': 0.9888858795166016, 'D2': 31370}},
        {'B1': {'C1': -12,
                'C2': 1117811337,
                'C3': 2135623489700772508,
                'C4': [108, -21]},
         'B2': [5333, -8040, -13302, 30752],
         'B3': [129, 30, 9],
         'B4': {'D1': 0.2957162857055664, 'D2': 11913}}],
 'A2': -0.6569297313690186,
 'A3': 6077492878868366522}

(b'GAWF:\x00j\x00\x1c\xc0l?\xa0\x8d\x94\xd6\xed4[\x89"\x1fN+/:\xc9\xce'
 b"\xf5'@\x1b\x0e\xbe\xa3'\x03\x00\x14\x00\xf9y\xbf\x92e\xe8f\xdc\x8el\xaeg"
 b'\x8dK`?\xff]\x17\x00\x06\x00\x00\x00(\x00\x1f\xb1\xdc4\x00A\x9f\x03\xe6\xf8'
 b"\x98's\xce/Y(\xdaO\x82\x02\x00G\x00\x839\x041\xbce$\x88,\xfc\x1bI\x19\xbf"
 b'bWI\x00\x05\x00\x00\x00Z\x00\x93R\xe8d\x00')

{'A1': [{'B1': {'C1': 43,
                'C2': 3469294127,
                'C3': 2856335556479035381,
                'C4': [34, 31, 78]},
         'B2': [31225, -27969, -6043, -9114, 27790, 26542],
         'B3': [31, 177, 220],
         'B4': {'D1': 0.8761528134346008, 'D2': 24063}},
        {'B1': {'C1': 3,
                'C2': 664336614,
                'C3': 9389963614920625779,
                'C4': [65, -97]},
         'B2': [14723, 12548, 26044, -30684, -980],
         'B3': [147, 82, 232],
         'B4': {'D1': -0.5987717509269714, 'D2': 22370}}],
 'A2': 0.9248063564300537,
 'A3': -8549181271520801376}

Вариант №39

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

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

(b'ZBQD[\xbf\xd7^\x8cb\xd9\xf1\xecio\xf08\x1c\x04\xac\xf3\xe8*\xd0\xda\rC\n'
 b'\xf6\x82\xc4\x9c\x00\x00\x00}\xd7Q\xff\n\xd1\x98\xa6O\x00\x00\x00\x02'
 b'\x00\x85v;\xef\\h\x98\xeaeMu.\\\xc2\x9f\xde\x002\x005\x008\x00;\x00>\xb8'
 b'\xce\xc0q\xbe\xe2>\x02\x8b\xa5\x0c\xdcI\xaadY,\x0f\xd6\xe1\xd0\xe5\x05\x8f='
 b'\xb8G\x99H\xcc\xf7\xa7\xed?\xb4\xdd{\x8a&\xd4\xed\x1a\x00\x04\x00\x00\x00K*'
 b'j\x00\x05\x00A\x00\x00\x00k*%9\x8c')

{'A1': -0.36514577535106585,
 'A2': 1768943672,
 'A3': 28,
 'A4': [1196, -3096, 10960, -9715, 17162, -2430, -15204],
 'A5': {'B1': [{'C1': 118, 'C2': 15343},
               {'C1': 92, 'C2': 26776},
               {'C1': -22, 'C2': 25933},
               {'C1': 117, 'C2': 11868},
               {'C1': -62, 'C2': 40926}],
        'B2': {'D1': -19,
               'D2': 4590537442865894637,
               'D3': 26,
               'D4': [13316792742947470850,
                      10062463082697483353,
                      3174992527680144783,
                      4447383355705325479],
               'D5': 42,
               'D6': 106}},
 'A6': {'E1': -2931281460510284209, 'E2': [10789, 14732]}}

(b'ZBQD[?\xe0\xfd{?{/\xba\x19:S\xdd\x8bJ\xf2\x93\xf5\rd\xf2\xa6\xe0\x14'
 b'!\x1f\xeb\xb8\x00\x00\x00uA\xee\xe5\x89\xb1\xd5\xe7L\x00\x00\x00\x02'
 b'\x00}\x92)\xd2\xec\xff\xeb\xf8\xb5HX\xe3\xaf\x8e\x8f+\x002\x005\x008\x00'
 b';\x00>\xbet\x9a%\xba\xbb\xfe\xd5\x07y\x87Q\xeb\xf7-\xdc\xc4L\x07\xa3\xec'
 b'\xbdS\x81\xc75\xces\\SC9\xa6\xd0\x00\x03\x00\x00\x00K\xe1\x18\x00\x05\x00'
 b'A\x00\x00\x00c\xf5buc')

{'A1': 0.5309425582759026,
 'A2': 423252957,
 'A3': -117,
 'A4': [19186, -27659, 3428, -3418, -8172, 8479, -5192],
 'A5': {'B1': [{'C1': -110, 'C2': 10706},
               {'C1': -20, 'C2': 65515},
               {'C1': -8, 'C2': 46408},
               {'C1': 88, 'C2': 58287},
               {'C1': -114, 'C2': 36651}],
        'B2': {'D1': -57,
               'D2': 3877163169583675814,
               'D3': 208,
               'D4': [13723763451342094037,
                      538610416368430556,
                      14144688930296779649],
               'D5': 225,
               'D6': 24}},
 'A6': {'E1': 4750987036479317836, 'E2': [-2718, 30051]}}

Вариант №40

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

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

(b'\x85PWPLA6\x98\x00\x00\x00R\xfbX\xf5\xd2\xd1\x80!\xc1[\xe6\x03\xef'
 b'\x98\xa7c\xaa\xc3;z\xd8~\xedw\xc2?\x1dj/?\x1e\t\x1f\xbfy\x8c^\xbe\xb0\x97j'
 b'?Y\x96$\xc8\xe1\xde\xfe?\xef\xd9]%\xfd>d\x00\x05\x00$:\x8bOY6\xbc\x00"'
 b'y\xe0@A3\xa4\xdd\xbe\x7f8\x9d@yr\x00\x02\x00\x00\x00\x0c>\xca\xd3~'
 b'\x13\x8e\x00\x00\x008')

{'A1': 1279342232,
 'A2': {'B1': {'C1': 16449, 'C2': 3721343002362813760},
        'B2': 'yr',
        'B3': [{'D1': -1192, 'D2': [62930, 53632, 8641, 23526, 1007]},
               {'D1': -26457, 'D2': [25514, 49979, 31448, 32493, 30658]}],
        'B4': 0.3961448073387146,
        'B5': 5006,
        'B6': {'E1': 3370245886,
               'E2': 0.9952836744286739,
               'E3': [0.6149014830589294,
                      0.6173266768455505,
                      -0.9747980833053589,
                      -0.34490519762039185,
                      0.8499472141265869],
               'E4': 4218552720551575586,
               'E5': 31200}}}

(b'\x85PWP/\x84;\x0f\x00\x00\x00JC\xc7W\xd8L\xed\xcd_\x93\xe0\x1d\xd86?\xffT'
 b'\x96\x1aR\xf4\xf17K&=A\x1a\xc1="f\x85\xbf,w\xb9g\xfet\xe6\xbf\xd0\xf8\xfa'
 b'"\xf7\x95\xa8\x00\x03\x00$\x18\xfcPY_\xb8\x91\xdb\x81\xa1\x80m%X\x1b\xdc'
 b'\x86{JViv\x00\x02\x00\x00\x00\x0c?\x1e\x94*\xc7\xab\x00\x00\x000')

{'A1': 797195023,
 'A2': {'B1': {'C1': 32877, 'C2': 2690931411316853334},
        'B2': 'iv',
        'B3': [{'D1': 17351, 'D2': [22488, 19693, 52575, 37856, 7640]},
               {'D1': 13887, 'D2': [65364, 38426, 21236, 61751, 19238]}],
        'B4': 0.6194483041763306,
        'B5': -14421,
        'B6': {'E1': 1744729318,
               'E2': -0.26519635596045044,
               'E3': [0.047144655138254166,
                      0.03964855149388313,
                      -0.673701822757721],
               'E4': 1800402295829598683,
               'E5': -32351}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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