ИНБО-08-22

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

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

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

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

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

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

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

(b'IDR\xfb\x00\x00\x00\x02\x00\x00\x00\x95\x00\x02\x00\x00\x00\x99\x00\x00'
 b'\x00\x9bgM[\x94B%\xe1\x01\x8cds-Zp\xcdB\xc5\xfa\x06\x97\xf2\xee\xb3HjY'
 b'\xc2\n\x8f\x88\x93\xa5\x97\x00\x00\x00\x07\x00\x00\x00&\x00\x00\x00-0'
 b'\xd9\x7f\x1d\x8d\x0c\xb3\xaa$w5\x89t\xab/\xc0\x00?\x10\xa8x\x85\x94\xe8\xc5'
 b'\x99\xa6\xf1\xf7\xb7\x14\xda\xb4\xe9U\xb4\x1c\x1b/\xfc\x88\xc3\xe7/\x00'
 b'\x00\x00\x08\x00\x00\x00]\x00\x00\x00e\xd6N|2\xa6k\r\x8a\xad\x7f\n_\xb0'
 b'\xb8\x1aB\x00w]V\xbf\xb3t\xb23\xb1\x00K\x00\x83zv\x8a8s\x90\x11\xeauZ\xaa'
 b'\xacr\x98]\xd2zBt\xf2\xc4\x86\xcd\xe3\xf7\xa0\x04\xde')

{'A1': [{'B1': 2627627772078141376,
         'B2': {'C1': {'D1': 1214929346,
                       'D2': 10,
                       'D3': 143,
                       'D4': 34963,
                       'D5': -23145,
                       'D6': [-59, -6, 6, -105, -14, -18, -77]},
                'C2': 12505,
                'C3': 32541,
                'C4': -1928547414},
         'B3': 1200341815818503577},
        {'B1': 12501722496706812482,
         'B2': {'C1': {'D1': 1437867035,
                       'D2': 47,
                       'D3': 252,
                       'D4': 35011,
                       'D5': -6353,
                       'D6': [-90, -15, -9, -73, 20, -38, -76, -23]},
                'C2': -10674,
                'C3': 31794,
                'C4': -1502933622},
         'B3': 6725773871002301361}],
 'A2': 'zv',
 'A3': {'E1': 138,
        'E2': [947097617,
               3933559466,
               2893191261,
               3531227764,
               4072965837,
               3824656388],
        'E3': 222},
 'A4': [7443706451436364033, 10116337301609041218]}

(b'IDR\xfb\x00\x00\x00\x02\x00\x00\x00\x90\x00\x02\x00\x00\x00\x94\x00\x00'
 b'\x00\x969\xa4"\x90\xf5\xed\x14[?_(\x12\xa37\xf1d\xd9~\x03!\x99\r'
 b'\xd8\x89n\x1a\xed\xbf\x8d\x1b7!\x00\x00\x00\x06\x00\x00\x00&\x00\x00'
 b'\x00,\x0bL\xf3\xfcSs\xfe\xd8\xf4\xea\xb0D\xbbr\x89\xc6\x00>\xc4^\xc4\x80'
 b"<\xac\xf7:D\xc9Cn\x08\xe8\xb1\xd5\t'\xed\xdb\xb4\x8d\x00\x00\x00\x04\x00\x00"
 b'\x00\\\x00\x00\x00`,\xdc8\xb1O<Y\x96K\x0f\xc9\x12\x042\x8d1\x00r'
 b'v\xfe\xad\xee\xe0Y\xd2\xbb\x00J\x00~ew\xc3dZ\x8dS\x10Y!`\xdd|\xdda\x02'
 b'\xe2%~\x12S\xae5"oI\x1c>')

{'A1': [{'B1': 17648111899053820358,
         'B2': {'C1': {'D1': 3632885274,
                       'D2': 237,
                       'D3': 191,
                       'D4': 36123,
                       'D5': 14113,
                       'D6': [-39, 126, 3, 33, -103, 13]},
                'C2': 2892,
                'C3': 62460,
                'C4': 1400110808},
         'B3': -4296780939412048070},
        {'B1': 5408762756712271153,
         'B2': {'C1': {'D1': 149467605,
                       'D2': 9,
                       'D3': 39,
                       'D4': 60891,
                       'D5': -19315,
                       'D6': [68, -55, 67, 110]},
                'C2': 11484,
                'C3': 14513,
                'C4': 1329355158},
         'B3': 8574481982037807803}],
 'A2': 'ew',
 'A3': {'E1': 195,
        'E2': [1683656019,
               274276704,
               3715947873,
               48375166,
               307473973,
               577718556],
        'E3': 62},
 'A4': [4153482762339030107, 4566412607689847140]}

Вариант №2

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

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

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

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

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

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

(b'JUW\xd2udurqkiv\xee\xd5\xcb\xd7co\x99\x0e\xae4am\xb7\x116\xc8v)\x0c2'
 b'\xf6\xbe\xf2\xc48\xb7Mwv|{u\x96`\xac.9\x9dUe\xe1?lE\x1d\xaaj\rC\xd1\x02\x00'
 b'\x00\x00\x87\x00\x00\x00\xc2\rap\x99\x8e\x10\xb15Fi\x1fD\x86\xb7Uq\x9b'
 b'X\xdex\xea\xf3\xaf \x1b\xc4xk\xd1\xe7?\x89\x8a\xd5c\tPL\xed\x02\x00'
 b'\x00\x00\x8b\x00\x00\x00\xb9}\xdeWL\x15\xdeb\xb0\x13\xea7\x8f\x00'
 b'\x00\x00\x98\xf0\xbcs\xe3\xe1\xa1z(\x96\xeb\xceB\x90\x82M3\xa1r}\xa9\xdd'
 b'\xec\x00\xf0\x8bo')

{'A1': 'udurqkiv',
 'A2': 3620460014,
 'A3': 28515,
 'A4': 1276609283645902489,
 'A5': -4686503334415775690,
 'A6': [{'B1': -15118,
         'B2': {'C1': 8465496772822546232,
                'C2': 24726,
                'C3': 0.5436199255722918,
                'C4': 15078910729138292076,
                'C5': [-17168, -7309]},
         'B3': -62,
         'B4': 2574278925,
         'B5': 900796558,
         'B6': 26950,
         'B7': 31},
        {'B1': -31164,
         'B2': {'C1': 16895498474226800055,
                'C2': -20493,
                'C3': 0.7443139418327043,
                'C4': 17099129886478797449,
                'C5': [-24095, 10362]},
         'B3': -71,
         'B4': 1280827005,
         'B5': 2959269397,
         'B6': 59923,
         'B7': 55}],
 'A7': {'D1': 3696754425248803734,
        'D2': 2843570849,
        'D3': -35,
        'D4': [236, 35824],
        'D5': 111},
 'A8': -104}

(b'JUW\xd2pwycnbcw=\xef\x12vK\xebkjF\xcc\x02\xa9\xf6\xe5\ts\xa1\xe2\x83m~4e\x19'
 b"')MG\x84\xdf\x9f\xc9\xbd\xbf\xa4j\xc9\x01\xdc\xa2\xed?\x88\x8c\xfb?\x8a2"
 b'k\x91\x02\x00\x00\x00\x87\x00\x00\x00#\xa9k\xac,7\x19\xc2\xfd\xbd'
 b'\x1f\xf2\xb9X\xb9\x15x\x13\xe1\xc8\xf7U\xb3\xe2\xb0\x99\xc2\xfe\xd1\xdc'
 b'\xdc\xbfi\x97\x86\xd9%\x1fM\xf3\x02\x00\x00\x00\x8b\x00\x00\x00H\xcf'
 b'\xb9\x07m\xd9\xc2\x13-/\xa3F\x8f\x00\x00\x00\xab\x05\x17dq\xbe\nbJS'
 b'f\xb8\xfc\x12\xd1\xe7\x85o\x84\xf8\x1a\xb2s\x05\xb8\xe7\xaf')

{'A1': 'pwycnbcw',
 'A2': 1980952381,
 'A3': 60235,
 'A4': -1876126365271037333,
 'A5': 3782581150248170249,
 'A6': [{'B1': 6501,
         'B2': {'C1': 14528576682145425703,
                'C2': -16451,
                'C3': 0.9261302981279482,
                'C4': 10478524527367916680,
                'C5': [5893, 29028]},
         'B3': 35,
         'B4': 749497257,
         'B5': 4257356087,
         'B6': 8125,
         'B7': 242},
        {'B1': 22713,
         'B2': {'C1': 6194640681491240377,
                'C2': -7501,
                'C3': -0.4509778011219181,
                'C4': 17531703171846936425,
                'C5': [2750, 19042]},
         'B3': 72,
         'B4': 1829222863,
         'B5': 756269785,
         'B6': 41775,
         'B7': 70}],
 'A7': {'D1': 9648910606144136787,
        'D2': 452494447,
        'D3': -78,
        'D4': [1395, 59320],
        'D5': 175},
 'A8': -85}

Вариант №3

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

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

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

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

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

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

(b'GHP\xb5\x83\xf1G\xe6\xfc\x1b\x84T=\x87\xc1\xe9o\xcc\x89\x00\x00\x00K\xb4'
 b'\x15\xa0<\xbf\xd5\x84\xfa\xb6\xc5.\x08\xdd\xc8\xd4\xf9cB[WzY\\G\xfa'
 b'\xb6\xd6M\xfa{`4\ra<\x1c\x80\xdc\x1ay\x19\xb1G\xbb\xde\xd4\xc5F\xaf'
 b'\xb3~\x00mhcf\xe8\xea\xdf\x8d)en\xbdVb@+q\xf9\xd8\xd8R\x88\xb3\xfb\x9f'
 b'd\xe0\xf8\xe5\xfe\x91\x99\xca\xaa?\xf0"r\x1d\xcf\x93\xb3\x0f\xce\xa9'
 b'\x1f\n3\x19\xe5\x9c7\xca\xf4\x00\nTS\xbd\x93\xd6\xfe\xcc\x01r\x9bCH\xe7'
 b'C\xe8\x00\x00\x00\x02\x00C')

{'A1': 131,
 'A2': {'B1': 4048021244, 'B2': 27},
 'A3': -124,
 'A4': 6070157139680152713,
 'A5': {'C1': 'mhcf',
        'C2': [{'D1': 232, 'D2': 234, 'D3': 223, 'D4': -8274971314019212736},
               {'D1': 43, 'D2': 113, 'D3': 249, 'D4': -2821414419458973852},
               {'D1': 224, 'D2': 248, 'D3': 229, 'D4': -103132220734050270},
               {'D1': 114, 'D2': 29, 'D3': 207, 'D4': -7803876349027874253},
               {'D1': 25, 'D2': 229, 'D3': 156, 'D4': 4020293898392064957},
               {'D1': 147, 'D2': 214, 'D3': 254, 'D4': -3746587403821193405}],
        'C3': -24,
        'C4': [-556481210, -1347191296]},
 'A6': -1273651140,
 'A7': -0.33624141548781994,
 'A8': [3720926457,
        1665293143,
        2052676679,
        4206286413,
        4202389556,
        224476188,
        2161908345,
        431048635]}

(b'GHP\xb53\xcf\x9fy\x00\x93\x836H\xe6\x84\xa6\xa7\xe6\x9d\x00\x00\x00O\xb5'
 b'\xfa\x81\xdc?\xc55n\xf8\x9d\xe7\x90aj{\x8b\xdc\xa5\x83\xe1\x9d'
 b'\x86\xb5\x1a\xcd\xae#\x02\xe9\xba\x9b\x15\xedy\xa1z\xbb\xa7*\x97\xed'
 b'\xd0\xe2\x9e\xe1\xee\xf5v\xc4\xc0\xd0s\xa3\x1a\x99\xcchlgr+~\xa1\xba\xef'
 b'O\xc1\xb2V\x07\xbb$n\x19\xf9m6u\xfe\x85\x1a\xfe\xa4\xa7\x1f\\\x8eh\xc9'
 b'\x00\xcb8\xd7q~\xb2\x16\n\x92\x89zd$\xabU,\xc3\x1b\xb4\xb7\xb7\xf3\xb8'
 b'\xc4\xa1\x1a\xccH\x964\x957q\xe1UtU\x00\x00\x00\x03\x00C')

{'A1': 51,
 'A2': {'B1': 3483334912, 'B2': 147},
 'A3': -125,
 'A4': 3911629733777368733,
 'A5': {'C1': 'hlgr',
        'C2': [{'D1': 43, 'D2': 126, 'D3': 161, 'D4': -4976671369881843781},
               {'D1': 36, 'D2': 110, 'D3': 25, 'D4': -473662505394824450},
               {'D1': 164, 'D2': 167, 'D3': 31, 'D4': 6669383310693316823},
               {'D1': 113, 'D2': 126, 'D3': 178, 'D4': 1588242937763079339},
               {'D1': 85, 'D2': 44, 'D3': 195, 'D4': 1996422535527842977},
               {'D1': 26, 'D2': 204, 'D3': 72, 'D4': -7623304203865074316}],
        'C3': 85,
        'C4': [-504433290, -993996685, -1558537780]},
 'A6': -1241873956,
 'A7': 0.16569316043370153,
 'A8': [1634368395,
        3701834721,
        2642851098,
        3450741506,
        3921320725,
        3984171386,
        3148294807,
        3989889694]}

Вариант №4

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

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

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

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

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

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

(b'\xe0MCX\x16\x00\x00\x00b\x00\x03\x00\x00\x00q\x00\xb7r\x8b>\x8e\x14\xc5\x0f'
 b'\x819\xe2\xb6\xa2\xe3\xe9HW\xd8)\xc8R\x7fU+\xc8\xa7+\xfc\x0c\xf1\x9d\xea'
 b'@1\xf5_\xa4{L\xd4\x18\x9e-\x89\xd1xkz\x1c\x80\x1d\x08r\x8eb\x91'
 b'\xd1\xcb\xd3\x16\xfdz\xbe+\x82\x8e\x16\xbe\xc6Mm\x01\x81S,M\xcd\x19>\x8d'
 b'G\x00u\xf6\x03\x00\x00\x00J\x00\xb0\xd65\x9c\x9c\xe6#!@\xcf')

{'A1': {'B1': 4037,
        'B2': 14721,
        'B3': [{'C1': -30,
                'C2': [-74, -94, -29, -23, 72, 87, -40],
                'C3': -14295},
               {'C1': 82, 'C2': [127, 85, 43, -56, -89, 43, -4], 'C3': -3828},
               {'C1': -99,
                'C2': [-22, 64, 49, -11, 95, -92, 123],
                'C3': -11188},
               {'C1': 24,
                'C2': [-98, 45, -119, -47, 120, 107, 122],
                'C3': -32740}],
        'B4': 14686679712314558493},
 'A2': {'D1': 63093,
        'D2': [10268818197465339603, 6017092146111626774, 20140021206830380],
        'D3': -80,
        'D4': 2627483094,
        'D5': 9190},
 'A3': [33, 64, -49],
 'A4': 0.27235957980155945,
 'A5': 5262}

(b'\xe0MCX\x16\x00\x00\x00b\x00\x03\x00\x00\x00q\x00\xfbk_?f\xfc\xfe\xe3'
 b'\x9a\xfa\x10#\xc7\xdd\xfeM\x1b\xa5/\xf2/H\x07\xefl&=\xf9\xbf\xaa\xfe\xc7'
 b'\xe3>\x19\xff\xf5\xc4y\xc1\x91\xbeU\xdf\xdc\xf2\xb1\xb7\x8e\xfb\xbe\xd9'
 b'\x9a\x1aZ\xc6\xd7l\xd7\xb3x\xd8\xdf\xc8j\x08\xb2\rZ(\xd9Q>K1\x9dyR\xca\xe4'
 b'j$\xa7<\x03\x00\x00\x00J\x00\xfdh\xec\xee\x9c\xb3\xdbw\x0c\x0b')

{'A1': {'B1': 58366,
        'B2': -1382,
        'B3': [{'C1': 16, 'C2': [35, -57, -35, -2, 77, 27, -91], 'C3': -3537},
               {'C1': 47, 'C2': [72, 7, -17, 108, 38, 61, -7], 'C3': -21825},
               {'C1': -2, 'C2': [-57, -29, 62, 25, -1, -11, -60], 'C3': -16007},
               {'C1': -111,
                'C2': [-66, 85, -33, -36, -14, -79, -73],
                'C3': -1138}],
        'B4': 7842955366384720318},
 'A2': {'D1': 15527,
        'D2': [606517963569804247, 5421860994527399346, 2624161290514963761],
        'D3': -3,
        'D4': 2632903784,
        'D5': 56243},
 'A3': [119, 12, 11],
 'A4': 0.8727414011955261,
 'A5': 64614}

Вариант №5

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

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

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

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

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

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

(b'LIXL\xdf\x00\x00\x00\x03\x00;\x98\x04|\xe0\xca\r\x98[zloq\x00\x00\x00I\xd1'
 b'\x1f\xdbK\xab0\x88\xbf\x00\x00\x00\x03\x00S\x96[\x10\xcf\xe8\xef\xd3'
 b'\x84\x176\xc5\xd1A\xa6\x92\x9c\x87q\x00\x00\x002\x00\x00\x005\x00\x00\x008l'
 b'k\xbd\xfc\x7f\xf0\x13\x97\x00\x02\x00G\xbf\x13\x04\xd4\xbf1\xfc\x0b\xbe'
 b'\xd5s\xdf')

{'A1': [{'B1': 14021, 'B2': -47},
        {'B1': 16806, 'B2': -110},
        {'B1': 40071, 'B2': 113}],
 'A2': 2550430944,
 'A3': -905078693,
 'A4': 'zloq',
 'A5': {'C1': {'D1': -1107525648, 'D2': 5015, 'D3': [108, 107]},
        'C2': 3508525899,
        'C3': 2872084671,
        'C4': [-0.5742924213409424, -0.6952521204948425, -0.4168996512889862]},
 'A6': 10834271813722166148,
 'A7': 23}

(b'LIXL\xdf\x00\x00\x00\x02\x008\xff\x1b\xfdcN\x9a\xf2\xaazvpq\x00\x00\x00GG'
 b'\xc52J\xfc\xaeSa\x00\x00\x00\x02\x00Q\xf6\xbd\x02?\xe7\xdap\xa6Ot$'
 b'\x85\x11\xc0\\\x00\x00\x002\x00\x00\x005\xa0\x82-\x07\x8c\xe1\x8a|F\xddF\xfc'
 b'\xe5\x00\x07\x00@>\xa5s0\xbfVH4')

{'A1': [{'B1': 29732, 'B2': -123}, {'B1': 4544, 'B2': 92}],
 'A2': 4280024419,
 'A3': 1318777514,
 'A4': 'zvpq',
 'A5': {'C1': {'D1': 2085018950,
               'D2': 64741,
               'D3': [160, 130, 45, 7, 140, 225, 138]},
        'C2': 1204105802,
        'C3': 4239283041,
        'C4': [0.32314443588256836, -0.8370392322540283]},
 'A6': 17779369377424634022,
 'A7': 79}

Вариант №6

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

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

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

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

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

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

(b'\x03NQN\x00\x03\x00\x00\x00#\x00\x00\x00\x02\x00\x9e\x81\xad~v\xb5{\xb0\xba'
 b'\x00\x00\x00\x03\x00\xa6\x1b\x00\x00\x00\xacsra\xb3|\xeb\xe3f\xf1'
 b'\xb1\xb9=\x01\xcaM\xce+\xc5\xe7\xf1Ksq\xbf\xbc\xfc\x12<\x11$0?\xb2'
 b'l\x1d\xe2\x9a\xd6\x00\x02\x19\xbe\x83\x00\x00\x00\x05\x00&B\xe6\xa4\x8f'
 b'\xa3\xab\x92\xe6\xeeB\x91\xf8S\xb9\xe7L@\xd1\xd9\x9cVk\xa8\x9e\xe8\xc6w\xe8'
 b'Ym\x9aI\xaf4\x94-\xbf\xe3\xee)\x8dy\\\x16?\xe0\x12\x9e\x94\x84W\x8a'
 b'?\xf6\x89\xc5\x00\x00\x00\x06\x00`\xf2d\xd3\xa6=\xc7\x0c\x97;+iC\x00\x00'
 b'\x00:\x00\x00\x00x{\xf6h_\x8a\xe9?\xe9E\xc8\xc6\x8cp\x12\xc6S\x89\xca'
 b'\x18\xb15d\x17')

{'A1': {'B1': 'sra',
        'B2': [{'C1': -0.11322130171278455,
                'C2': 0.07196223051399642,
                'C3': 35241603,
                'C4': [-1283658781,
                       1727115705,
                       1023527501,
                       -835992089,
                       -246713487],
                'C5': 4820721387979903718,
                'C6': 3997340152},
               {'C1': -0.6228225482144605,
                'C2': 0.5022728825303926,
                'C3': 1073121733,
                'C4': [1404692300,
                       1087494556,
                       1449896094,
                       -389646360,
                       1500355145,
                       -1355508691],
                'C5': 17466317965804113047,
                'C6': 992700739}],
        'B3': 9344263850179670202},
 'A2': [31734, 26719, 35561],
 'A3': 27,
 'A4': {'D1': 0.7897685888196995, 'D2': -58, 'D3': 6019564584358470679}}

(b'\x03NQN\x00\x05\x00\x00\x00#\x00\x00\x00\x02\x00\x8c\xe5\x1b\xf0\xfb'
 b's1\xa0\x86\x00\x00\x00\x02\x00\x94\xcf\x00\x00\x00\x98kiatwk=\xe9\xd1'
 b'/\xf9\xbb\xeb$P\x03z?\xee\x9f<\xe5\x9eN\xc6?\xe6\xc6)k\xfb>\n\xc8\x12/9'
 b'\x00\x00\x00\x03\x00(e;\\\x12\xe3\xeb\xef\xb8\x1bG1\xcenN\x9cz\xee\xa2'
 b'3\xc0\xf8\x8f\xb9Q\xbf\xdf\x10v\x86\xaeY\xc0?\xe5\xb2\x891\xdc\xadB=\xbc'
 b'\xebp\x00\x00\x00\x03\x00Z\xc1\x8c\xe6\x99z\xb7\xb8\x93o\x01\xb5:'
 b'\x00\x00\x004\x00\x00\x00f\n&\x9e\xc3\xbf\xcdD<\xf7"T\xd0\x17\xd4\xd9R'
 b'\xd0~0\xa7\xdd')

{'A1': {'B1': 'kiatw',
        'B2': [{'C1': 0.9569382176145715,
                'C2': 0.7116896733295459,
                'C3': 3356634937,
                'C4': [1799219665, 804895723, 609223546],
                'C5': 7294525257659707320,
                'C6': 457650638},
               {'C1': -0.4853798213238427,
                'C2': 0.6780439351909211,
                'C3': 1035791216,
                'C4': [1850645626, -291359808, -124798639],
                'C5': 13946775692922828947,
                'C6': 1862382906}],
        'B3': 16509053821816774790},
 'A2': [2598, 40643],
 'A3': -49,
 'A4': {'D1': -0.22864496295065928, 'D2': 23, 'D3': 15337381061410727901}}

Вариант №7

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

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

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

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

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

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

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

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

(b'DMPPbmp\xcdS\x00\x00\x00\n\t\x11?\xffOq\xdc\xe6p_l\xff\x02\x00t\x00\xdc\xb6='
 b'\xc73\xa2\xd1?N\xebAU\xd7r\xcc\xf2X\x91\xad\xaa\xd4\x02\x00\x84\x00\xc0\xff'
 b'\xae\xc4L\xc1\xda\xbf\xc1\xa3\r\xbe\x8d\xcd\xd4\xdcJ!O\x81\xc5\xb1\x07\x1bB,'
 b'\xd3\xf6\xe6J\x00\x00\x00\xadv0I\x1b\xf8o&,\x90\x9dybs.A\xac\x16\xb7R:'
 b'\x02\x00\x00\x00Q\x00\x00\x00\x88\t\x16w\xebH\xe2\xbf^`\xacy\r\x03\xe7\xbf'
 b"\xa0\x1cPb[e\xd0?&VS'\x01X\xe2?")

{'A1': 'bmp',
 'A2': {'B1': -51,
        'B2': {'C1': {'D1': -59, 'D2': 177, 'D3': 742529799, 'D4': 211},
               'C2': {'E1': 2769705091931862701,
                      'E2': 44,
                      'E3': -25200,
                      'E4': 25209,
                      'E5': 4202622710297210483,
                      'E6': [-10, -26]}},
        'B3': 0.5665441751480103},
 'A3': 7809084415726931967,
 'A4': [{'F1': -1,
         'F2': [-0.5714013410472925, -0.7191226364548233],
         'F3': 0.2755250402177418,
         'F4': 17495484921601452878,
         'F5': -1431465640},
        {'F1': -44,
         'F2': [0.25618633843300564, 0.573242737586672],
         'F3': -0.4180480881441291,
         'F4': 15912569392069452737,
         'F5': -2125520566}]}

(b'DMPPwkq`S\x00\x00\x00\x1a\xcfa\xbfK\xb18\x91@\xa6H\xad\xff\x02\x00t\x00R(m'
 b'\xe5\xbc\x12\xe9\xbfp\xd4>1\xbb\xccpB\xda\x1bN\x07t\x02\x00\x84\x00\xe8\x11'
 b't\xba\x94Z\xe2?\x9a3?\x9bB/\xff\xd8z\xe6\xe6h\xc5\xc9$W\x96\xb33\xba\xa0J'
 b'\x00\x00\x00\xffj7:Y\x08\x1b\x96\xa8O^\x15/[\x1b\x80V\xa2\xb3)$'
 b'\x02\x00\x00\x00Q\x00\x00\x00\xa0\xabG\xe9\x8c\x9b\xec?\\\xd6/\xb6'
 b'\xebK\xd9\xbf\x98\x83\x0e;\xc9>\xd4\xbff\x8eq\xa0\xbe\xe2\xe4?')

{'A1': 'wkq',
 'A2': {'B1': 96,
        'B2': {'C1': {'D1': -59, 'D2': 201, 'D3': 3012974372, 'D4': 51},
               'C2': {'E1': -7630495964327351553,
                      'E2': 168,
                      'E3': 24143,
                      'E4': 12053,
                      'E5': 2605811369227852635,
                      'E6': [-70, -96]}},
        'B3': -0.8820663690567017},
 'A3': -5960331310580321973,
 'A4': [{'F1': -1,
         'F2': [0.8939880901574391, -0.3952588347595787],
         'F3': -0.7835373383507067,
         'F4': 4787551508251989104,
         'F5': 122559450},
        {'F1': 116,
         'F2': [-0.3163321568227331, 0.6526787885345129],
         'F3': 0.5735572473209318,
         'F4': 15636268394372608922,
         'F5': 1759962746}]}

Вариант №8

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

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

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

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

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

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

(b'VJK\xdd\xdb\xea\x93\xf4Pm\x1a\x03\x00c\x00\x00\x00\xf0\x04\xb8W^\xc0\xd0'
 b'\xbf\x02\x00\x00\x00f\x00\x89\xd2\x03\x00h\x00\x00\x00\x9a\xe1\x02?n'
 b'~\xcb>\x94\xe0\x03?\x89\x83\x9f\xbe\x10\xeam\xa3\x15u\xce?\x04\x00t\x00\x00'
 b'\x00\xf5\x86(?3\x03t\xbf\xfc\xf6@\xbf\xfdfe\xbf\x04n\xd1M\x0e\xd0\xde'
 b'\xbf\xb8Z\x9f"\x86\xb4tmfjo\x7fM\x05\xbfL.\xd4\xbe\xbdD+?Z\xe2?<'
 b'\xf3\xde\x19\xbf\xe9\x9bF>\x83K\x99=')

{'A1': {'B1': -1813324835,
        'B2': 443371764,
        'B3': 'tmf',
        'B4': -0.2617412430409578},
 'A2': 'jo',
 'A3': -11639,
 'A4': [{'C1': [-0.520713746547699, -0.41441571712493896, 0.6690176129341125],
         'C2': [0.5112549066543579,
                0.39744895696640015,
                0.5151455402374268,
                -0.31155040860176086],
         'C3': 0.23794813613842836},
        {'C1': [0.011711681261658669,
                -0.6010581851005554,
                0.19395412504673004,
                0.07485105842351913],
         'C2': [0.658309280872345,
                -0.953173816204071,
                -0.7537686824798584,
                -0.8961027264595032],
         'C3': -0.48144872283384665}],
 'A5': 184,
 'A6': {'D1': 90, 'D2': 8863},
 'A7': 46214}

(b'VJK} oj\x93\x9c\x9d\xbc\x03\x00c\x00\x00\x00N+\xb9]\xcd0\xea?\x02\x00\x00'
 b'\x00f\x00\x0b\x05\x03\x00h\x00\x00\x00\x92D\x1e?\x7f\x1a\xfe\xbeP\x85v\xbfk'
 b'\x9c+?0\x96]\x8e\xb2d\xe3\xbf\x02\x00t\x00\x00\x00\xf1\x89\xdb\xbe,\xa9\xc4'
 b'>V7\x94\xbe\xf9\x8b3\xbe\x84n\x10\x85(y\xe4\xbf\xd6\xff\xf7a4\xa7dwsys'
 b'\xb1\xc0:?c\x93\xb8\xbc\xc8&a?F\x11\x9b:`;9?')

{'A1': {'B1': 1785667709,
        'B2': -1130521453,
        'B3': 'dws',
        'B4': 0.8184573011907135},
 'A2': 'ys',
 'A3': 1291,
 'A4': [{'C1': [0.7295027375221252, -0.022531216964125633, 0.8794980049133301],
         'C2': [0.6182337999343872,
                -0.49629589915275574,
                -0.9629716873168945,
                0.670355498790741],
         'C3': -0.606042173440704},
        {'C1': [0.0011830709408968687, 0.7235622406005859],
         'C2': [-0.4287867844104767,
                0.3841031789779663,
                -0.2894846796989441,
                -0.17533864080905914],
         'C3': -0.6397898291501893}],
 'A5': 214,
 'A6': {'D1': 255, 'D2': 25079},
 'A7': 42804}

Вариант №9

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

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

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

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

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

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

(b'TBUR\x003vntql\x00\x00\x00S\x15\xefV\xe6\xe1\xdb/@\x85A=o\xf1\xcf\x06Fw'
 b"\xbf'ei<\xa1*\xbc\x9f\xa1r\xbe'\x0e\x9c\xbfb7WYx\x00\x00\x00\x02\x00\x1d\x86"
 b'FJ\xe8\x02t\xb9D\xfb4\xf7\xe3\xeeA\xa7\xe1\xa4\xbe\xd3\xeb\x8a3\xcf\xa4\xde'
 b'\x1f!*\xd9\xbf(W\xd8\x00\x00\x00\x06\x00;\xc0\xdd\xee\x84')

{'A1': {'B1': 22904,
        'B2': [{'C1': [6, 70, 119],
                'C2': -0.6538911461830139,
                'C3': 0.019673697650432587},
               {'C1': [-97, -95, 114],
                'C2': -0.163141667842865,
                'C3': -0.883656919002533}]},
 'A2': 'vntql',
 'A3': {'D1': 3726582058,
        'D2': 217,
        'D3': -0.657590389251709,
        'D4': [2252753640,
               41204036,
               4214552547,
               3997280225,
               2763969515,
               2318651300],
        'D5': 3235769988},
 'A4': 5615,
 'A5': 6261940663412098369,
 'A6': 0.05858021602034569}

(b'TBUR\x003aprbk\x00\x00\x00K\x90\xe4t\x97t\xd8\xff\xc4 V\xbd\xcaCj\xc4\xf5G'
 b'\xbf`\x87\xdf>\xe8;3\x00\x08\xb0\xbf\x02\xffU\xbf\x10\xf5\xbc/'
 b'\x1b\x00\x00\x00\x02\x00\x1dAm)}#0zs\xf6\xf7:\x10\xa1\x11\xeb\xf4\x11'
 b"\xed\xa7\x83\xdf>\xdbo\x95\x00\x00\x00\x04\x00;'sy1")

{'A1': {'B1': 12059,
        'B2': [{'C1': [-60, -11, 71],
                'C2': -0.8770732283592224,
                'C3': 0.4535766541957855},
               {'C1': [0, 8, -80],
                'C2': -0.5117085576057434,
                'C3': -0.5662496089935303}]},
 'A2': 'aprbk',
 'A3': {'D1': 300787587,
        'D2': 223,
        'D3': 0.4285856783390045,
        'D4': [1097673085, 590379635, 4143397392, 2702306292],
        'D5': 661879089},
 'A4': -28444,
 'A5': 8401312105235750998,
 'A6': -0.09876139461994171}

Вариант №10

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

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

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

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

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

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

(b'YORA\x00\x04\x00\x8bX\xde=o7\xe72\xef\xc7\xbf~\xcd\x87?\xc3\xc7\xb7\x93G\xb3'
 b'\x90\x18\xdf[\xd8\xb6\n\x8d\x1b*\x86?:\x9b\xa1\xb9\xd3\x946\xc8q\xcf\xfc\x0f'
 b'dy~s\x883w\xf4\x0b\xc5ral\xbf}\xe6!\xf8\x94\xd19Mb\xdc\xeb\x07?\x12[\x17cc'
 b'>\x07d\xf4\xf4\x1e\xf2"\xd89Ma\xf7\xbe\xfe\xc1xbg>\x83\x96Z\xc33\xcf"+'
 b'#\xad!\xe6\xbe\xa1\xe7\xf3xe\xbe\x80R\x00\xa1F\x01\x89+\x92\xd7f\x19\xbc'
 b'\xf4+>\x00?\x00R\x00e\x00x')

{'A1': [{'B1': 'al',
         'B2': -0.9917927384376526,
         'B3': -8,
         'B4': -7723328881429779705,
         'B5': 0.5717024207115173},
        {'B1': 'cc',
         'B2': 0.1322210431098938,
         'B3': -12,
         'B4': 2229883077571469815,
         'B5': -0.4975697994232178},
        {'B1': 'bg',
         'B2': 0.2570064663887024,
         'B3': -61,
         'B4': 3733240184790917606,
         'B5': -0.31622275710105896},
        {'B1': 'xe',
         'B2': -0.2506256103515625,
         'B3': -95,
         'B4': 5044463877871855129,
         'B5': -0.029805775731801987}],
 'A2': 22750,
 'A3': 61,
 'A4': {'C1': {'D1': 28471,
               'D2': -6350,
               'D3': 61383,
               'D4': -0.9953235983848572,
               'D5': 0.15453238192949614,
               'D6': 24,
               'D7': [-8357, -10058, 2701, 6954, -31169, 15003]},
        'C2': 161,
        'C3': 3117650998,
        'C4': 51313,
        'C5': [53244, 3940, 31102, 29576, 13175, 62475, 50546]}}

(b'YORA\x00\x04\x00\x8b\xc7B\x89\xc2\xaa \x05\xf1#?l\x88Z?\xe4\x90'
 b'\xa2\x19\xe5\xea\xba\x0b\x8f\x00\x1f\x80\xeb\xc1\x12z\x9d\xd5'
 b'\xc6\x01\xf6\xfa\xb7\xaf \x0c\xc9\xfc,\x19\xffg\xf7\x8b\xcc\xfd\xad\x13'
 b'\x07[-nc\xbe\xe0\xd0\xb1\xde\nB\x9d\xb0\xdb\nn\xf4\xbe\xc0\xba\xa3bt'
 b'\xbdGT\x89XG\xaa$\xe9m\xe9\xe5\x8c?Cw\x90cl>\xb6h\xa3#\x06]\xdfN'
 b'\x97q\x89\x80>X\x95\xaftv>\xfcb\xfa\xad\x82\x02 \xdc\xc3\x1b\xcf\x9b?'
 b'\x1e\x9b\x0c\x00?\x00R\x00e\x00x')

{'A1': [{'B1': 'nc',
         'B2': -0.4390921890735626,
         'B3': -34,
         'B4': 739326671756881652,
         'B5': -0.3764239251613617},
        {'B1': 'bt',
         'B2': -0.048664603382349014,
         'B3': 88,
         'B4': 5163980507723720076,
         'B5': 0.7635431289672852},
        {'B1': 'cl',
         'B2': 0.3562670648097992,
         'B3': 35,
         'B4': 458768265702902144,
         'B5': 0.21150849759578705},
        {'B1': 'tv',
         'B2': 0.4929426312446594,
         'B3': -83,
         'B4': -9078657766287224933,
         'B5': 0.6195533275604248}],
 'A2': -14526,
 'A3': 137,
 'A4': {'C1': {'D1': -15702,
               'D2': 8197,
               'D3': 61731,
               'D4': 0.9239555597305298,
               'D5': 0.6426554208586233,
               'D6': 11,
               'D7': [-28928, 8064, -5183, 4730, -25131, -14847]},
        'C2': 246,
        'C3': 4206341920,
        'C4': 3273,
        'C5': [64556, 6655, 26615, 35788, 64941, 4871, 23341]}}

Вариант №11

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

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

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

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

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

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

(b'\xd2SWC\xea\xd1I\xdb\xfd?%\x1c(?\xe8\x80\xc7\xf8\x8bv2mrfmkj]>W%>'
 b'\x00\x00\x00\x02\x00>\x00V\xd4\xbf)>\xe2\x00\x00\x00\x02\x00v\x00'
 b'\x8e\x9a\xbf\xf2\xd2\x8a\xe0:@\xf7\xf1\xa3/\x89[\xb6m\x89x\xd6S8\x9e\xd3'
 b'\xba\xb8>\xf4\xce\xe9\xbd\xc5\x81\xe7\x0bi\x85\xdd\xbf\x05>?\x90\xdf'
 b'\xbfS\x01\xd8?\xd5\xa6{\xe1I\xdd\xa0\x00\x00\x00\x02\x00\x00\x00N'
 b'\x16w\xf8\xfbH\xb2J\x00GK\xa3\xb7\xac,\xb5\x1b=\xa1?r\xdf\x17\xber'
 b'\x8c&\xd3\xf2\x8e\xc6>p\xb4ok\xd2?2\xa2y\xbf\xd94D7wr\xb8\x00\x00\x00\x02'
 b'\x00\x00\x00\x86.\xa0')

{'A1': {'B1': 60113, 'B2': 73},
 'A2': 56317,
 'A3': 0.644960880279541,
 'A4': 0.7657203535451969,
 'A5': 'mrfmkj',
 'A6': [{'C1': 93,
         'C2': 0.21010300517082214,
         'C3': [17411812851340176777, 8707238432215382712],
         'C4': {'D1': 191464925,
                'D2': -0.5204810500144958,
                'D3': -28449,
                'D4': -0.824246883392334,
                'D5': 0.3382863712390307,
                'D6': [0.47814109921455383, -0.0964391753077507],
                'D7': 5751}},
        {'C1': 212,
         'C2': -0.6611157655715942,
         'C3': [17941013471143413579, 11797087056937303457],
         'C4': {'D1': 3555888838,
                'D2': 0.23506329953670502,
                'D3': 27602,
                'D4': 0.6977916359901428,
                'D5': -0.39381509224567024,
                'D6': [0.9487165808677673, -0.23686274886131287],
                'D7': 11936}}],
 'A7': 154,
 'A8': [3220361866, 3761914103]}

(b'\xd2SWC\xe1\xc6-\x9f\xc4?\x02\x80\xea\xbf\xe1 \xd7\xa8U;\xb8vdgrkk\x11'
 b'>\x98\xb8n\x00\x00\x00\x02\x00>\x00V\xd0?F!\xc6\x00\x00\x00\x02\x00v\x00'
 b'\x8e.V\xeb\x99\xd8\xc6l\n@ |jX?J\x93i\xad6\xdc\x87\xe3\xb4\xe4\xc1\xbe\xe1'
 b'\x1e\x17\xbfRY\xe7l\xde\x97\x94?}\xa4VH\xa5\xbe\xac\x04{\xbf\xef\xb76'
 b'\x81&1\x8c\x00\x00\x00\x02\x00\x00\x00Nq\x96\xc8\x03{:>\xd3\x96[\x90W'
 b'\xe1\x92 \x91I\xa2>\xc4$\x17\xbe\xd2\xe7\xa0\x8c%\x8d\xac\xbf Q{\x9f\xea'
 b'>\x02\xe9\x9b?\xd2i\xd0\xa0\xc5] \x00\x00\x00\x02\x00\x00\x00\x86E6')

{'A1': {'B1': 57798, 'B2': 45},
 'A2': 40900,
 'A3': 0.5097795724868774,
 'A4': -0.5352590835335524,
 'A5': 'vdgrkk',
 'A6': [{'C1': 17,
         'C2': 0.29828208684921265,
         'C3': [2340862833577333609, 12481405893502887105],
         'C4': {'D1': 1826527124,
                'D2': 0.9907888174057007,
                'D3': 18597,
                'D4': -0.3359716832637787,
                'D5': -0.9911148569531618,
                'D6': [-0.4396826922893524, -0.8216843008995056],
                'D7': 29078}},
        {'C1': 208,
         'C2': 0.773952841758728,
         'C3': [14412498722608092763, 10401029882163317154],
         'C4': {'D1': 2351271340,
                'D2': -0.6262432932853699,
                'D3': -24598,
                'D4': 0.12784425914287567,
                'D5': 0.2877084322003203,
                'D6': [0.3830878436565399, -0.4119234085083008],
                'D7': 17718}}],
 'A7': 46,
 'A8': [1458280920, 3328969280]}

Вариант №12

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

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

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

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

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

(b'QTS\xb2\x02\x00\x00\x00B\x00\x00\x00\x06\x00\x86\x00\x00\x00\xac\xe3#\x82\rC'
 b'\x9a%\xc5,\x98\x94U\x9a\xee\xf5\x1c\x06\x05\x87\x19\x82\xd2L\xe4g\x86V\xcc\n'
 b"\xdbX\x06\xb2\xc4%'\xc9\xf6y\xd3\xb7\xfb\r\x00\xd2e\x92\r+\xcdr\x14\x89"
 b'\xcf\x1fn\x94!\xd3\xf9\x91\x93\xe8\xdeA\xcf\x02\x00>\x00\x00\x00q'
 b'\xa5\xce\xf3\x9b\x9c\x1c\x93\xf4j\xe7\xbe\x95\x0f\xb2\xe1;\x19(\xc8a'
 b'\xc3\xae\x0c6\xeer\xf9\x02\x00@\x00\x00\x00\x15\xbc`\xcf\xdb\xafTW\x01hznhue')

{'A1': [{'B1': 13,
         'B2': 7935289256110640427,
         'B3': 8596,
         'B4': {'C1': 63955,
                'C2': -555183215,
                'C3': 65,
                'C4': -49,
                'C5': [0, -46],
                'C6': -23183},
         'B5': {'D1': -50, 'D2': 480025587, 'D3': -2925}},
        {'B1': 106,
         'B2': 1818295029456027367,
         'B3': -14296,
         'B4': {'C1': 50017,
                'C2': -298447698,
                'C3': 114,
                'C4': -7,
                'C5': [101, -110],
                'C6': -17387},
         'B5': {'D1': 96, 'D2': 1420811215, 'D3': 343}}],
 'A2': 'hznhue',
 'A3': [2709551851113800620,
        -725472797604172603,
        5535629938142807580,
        6402723167978547172,
        8788432892834656774],
 'A4': 234600403}

(b'QTS\xb2\x02\x00\x00\x00B\x00\x00\x00\x05\x00\x86\x00\x00\x00\xc4\xbc'
 b'\x8a\xce\x10]u\xbe\xbc\xc5?V*\x074\x87\xc5\xb5q\xdc\xec\xb3\x11\xfd\xb0.'
 b'\x9d\x84\x86\x86W\x816\x96t;\x17\xbc\xc1\x8e\x99\x9f\xf4\x07u\xccKhE\xd1'
 b'\xed\xd6\xe0\xa3j8pPm\xfaF\\\x8e\xb9\x80\xb7\xa1\x02\x00>\x00\x00\x003'
 b'\x8b\xf2\xebz7\xe4\xf7\xb6ZT\xb5\xca\x19Q"\xdd\xa1\x19\x91\x7f\xc3\'\x95\xea'
 b'\x9d\xe8`\x02\x00@\x00\x00\x00\xe6!\x9a\\\xfc\xddg\xfa9bibva')

{'A1': [{'B1': 69,
         'B2': 8086330383028121041,
         'B3': 27984,
         'B4': {'C1': 18170,
                'C2': -2135323044,
                'C3': 183,
                'C4': -95,
                'C5': [117, -52],
                'C6': -29901},
         'B5': {'D1': -14, 'D2': -466126101, 'D3': -18697}},
        {'B1': 90,
         'B2': -6783227732029688492,
         'B3': -28391,
         'B4': {'C1': 50047,
                'C2': -1645570777,
                'C3': 232,
                'C4': 96,
                'C5': [75, 104],
                'C6': 8678},
         'B5': {'D1': -102, 'D2': 1742601308, 'D3': 14842}}],
 'A2': 'bibva',
 'A3': [-4722766307462038332,
        -8704324301383285316,
        -211189877617609275,
        -9126678207534387536,
        -8160034241850862026],
 'A4': 133472153}

Вариант №13

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

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

(b'\xd5MDVZ\x0f^\xae@?\x17\x18E\xe9^\xff\x82)\x1fL\xf9>\xbaZ\x128\xd7B\x0b9Mg'
 b'\x9dv^+\xeb\xed\xfe\xa0\xf7\xbe6\x9a\xaaa\xf1\xeeS\x13\xcc\x90\xb2\xde\xb6V'
 b'j\xe66\xe1G?r>R\x00\x00\x00\x05\x00^)\xb5\x00\x86\x00\x00\x00\x02\x00'
 b'\x94?\x10\x14a\xd7\x00\x00\x00\x02\x00\x00\x00\x96?\xe5\x015\xd9`'
 b'\x9d\x1e\xbfA\xd8\x85\x82S\xf0\x00?\xe0A\xea\x8e\xa8\x97\xd2?\xa5\xb9 \xb0s'
 b'\xef\x80?\xe2\xbcw\r\xb9\x0fx\xf9\xb32a\x00\x82T\x17J\xa0\xde\xf6\xf5\x8e'
 b'_Yy\x02\x8a#')

{'A1': [{'B1': 1107514149339338821,
         'B2': 16816158993148759289,
         'B3': 0.3639684319496155},
        {'B1': 4095815002090203037,
         'B2': 8529303036596494583,
         'B3': -0.1783243715763092},
        {'B1': 7057684131648147634,
         'B2': 16048109339310219591,
         'B3': 0.9462634325027466}],
 'A2': [0.6563977475788396,
        -0.000544610204684215,
        0.5080464159298066,
        0.04242803720441568,
        0.5855059879327049],
 'A3': 10677,
 'A4': {'C1': {'D1': -105696671, 'D2': 36684205985423094, 'D3': -2674},
        'C2': [95, 89],
        'C3': 1058018401,
        'C4': 215,
        'C5': [30978, -30173]}}

(b'\xd5MDVZd\xc0\x14\x7f+\xb4\xa0\t?oA\x93q\xbdN\xd6?!\x08\xa0\x94\xcb+'
 b"\xba\xd2>\xcf>k3R\x0e'n\xf3F>Pn\xe4\xb1\xa6\x8cP\xa4\xb7\x95\xf0<\xc8\xbf"
 b'\x97[\xb9\x98\xd4\xbf:\n#\x00\x00\x00\x02\x00^\x17P\x00n\x00\x00\x00\x02\x00'
 b'|Ws\x04\x17\xe9\x00\x00\x00\x04\x00\x00\x00~\xbf\xe2.\xe6\xb4D'
 b'\x9c\xe2\xbf\xac\x04R\xd79N\xa0;\x1b\xa1\xfb\xb2\xf7E\xe4\xef\xbe'
 b'\x15\xa1\xea\xc4\xachN\xa0\xd9\xc6\x12\x88\x0ew')

{'A1': [{'B1': 7259825135747899401,
         'B2': 4570944248328572630,
         'B3': 0.6290378570556641},
        {'B1': -7725032654432710850,
         'B2': 7724608006615135046,
         'B3': 0.20354801416397095},
        {'B1': -5645670804873570832,
         'B2': 4379961294417664212,
         'B3': -0.7267171740531921}],
 'A2': [-0.5682252426967376, -0.05472048642391525],
 'A3': 5968,
 'A4': {'C1': {'D1': 991666683, 'D2': -5550891166133774943, 'D3': -5436},
        'C2': [-84, 104],
        'C3': 1467155479,
        'C4': 233,
        'C5': [20128, -9786, 4744, 3703]}}

Вариант №14

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

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

(b'\x90XJS\x00\x00\x00-\x1f\x9c\x00\x00\x00\x02\x00[\x00\x02\x00\x00'
 b'\x00c\x00\x04\x00g\x15\x8c\xca\x7fP\xd9\x83}\xdd\xd8\xf3\xae\xe5{\xc9c\xc8<'
 b'\x88\x00\x1a\x89C\x01\xb6*\xe7&ddd\xb4\xc2\xea\xf8\xd7\xad\x17\x0f38\xa5'
 b'yE\xbd\x8d\xda\x8bz\xd00\x11l\xf2\x1e>\xaf\xc3\xbb/>|.\xd6\xe0\x00'
 b'\x00\x00Q\x00\x00\x00V\x02\xeda\xbe\x93:vz')

{'A1': {'B1': {'C1': {'D1': {'E1': 21, 'E2': 36042},
                      'D2': 9174071599729334515,
                      'D3': -5844128836550640504},
               'C2': 137,
               'C3': 17153,
               'C4': 3056264998,
               'C5': 'ddd',
               'C6': [-5421512646909421809,
                      3690881834909797850,
                      -8396169650409508322]},
        'B2': 8092},
 'A2': [{'F1': 0.34329017996788025, 'F2': 47},
        {'F1': 0.24627241492271423, 'F2': 224}],
 'A3': [749, 25022],
 'A4': [-109, 58, 118, 122]}

(b'\x90XJS\x00\x00\x00-\xde\xaa\x00\x00\x00\x03\x00`\x00\x04\x00\x00'
 b'\x00l\x00\x03\x00t\x82*=\x1fS\x8eVuFR\xfe\xef\xb2\x1fe4\xfd%\xd5\x00\x1a\xf1'
 b'\xdb\xc1\x85\x9b;Putm\x85E\x8czb\xd9\xa3p\xb0"2e\xf91Cu\xa2\x97!g\r.\x94'
 b'\xc3\xbf2F\x7fa?a\x12\xb5O?x\x9a\xe8\xaa\x00\x00\x00Q\x00\x00\x00V'
 b"\x00\x00\x00[\xf1\xca\x17\xda\x03'\xd8\xeb\x1dG\x92")

{'A1': {'B1': {'C1': {'D1': {'E1': 130, 'E2': 10813},
                      'D2': 2257304340228625150,
                      'D3': -1174842033249114667},
               'C2': 241,
               'C3': 56257,
               'C4': 2241542992,
               'C5': 'utm',
               'C6': [-8843507835999771792,
                      -5754981960272231563,
                      -6730874391595412285]},
        'B2': 57002},
 'A2': [{'F1': -0.6963881850242615, 'F2': 97},
        {'F1': 0.8791916966438293, 'F2': 79},
        {'F1': 0.9711136817932129, 'F2': 170}],
 'A3': [-3638, 6106, 807, -10005],
 'A4': [29, 71, -110]}

Вариант №15

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

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

(b'OPPOb\xe0\x98\xac3*\xb0]1\xd6\xb2\x86mi\x8f\xe6\x92[J\x00\x05\x00\x00\x00'
 b'T?\xd3\xec\x89\xcc\x93\xb9\x90\xcd"\xf8\xbc\xca\xc0\xce\xb6\xee\x00\x00'
 b'\x00h\r;3\xa0+\xcd\xf0\x05\xac\x00\xa2\x89w\xcf\xe9{[\xa7\xf9\xb2B\xca'
 b'\x88/\x9d\x1cZ4\xec \x0e\r\x05\xe5\x00\x00\x00@\x00\x00\x00D\x00\x00\x00H'
 b'\x00\x00\x00L\x00\x00\x00P\xfd\xe0\x9c9\x85\xbe\x8e\x92\x87\xf1\xde X-\xd1n'
 b'ZP\xc4x\x83\xffJ\xec\x9a\x13\x83\x93\xaa\x015+\xfd\xcan\xc7\xd0\x95\xe9\xed'
 b'e\xe2\xc4\xcc')

{'A1': {'B1': 57496,
        'B2': 172,
        'B3': [51, 42, -80, 93, 49, -42, -78],
        'B4': 9686514440313396042,
        'B5': [{'C1': 59771, 'C2': [91, 167]},
               {'C1': 63922, 'C2': [66, 202]},
               {'C1': 34863, 'C2': [157, 28]},
               {'C1': 23092, 'C2': [236, 32]},
               {'C1': 3597, 'C2': [5, 229]}],
        'B6': 0.311312150747562,
        'B7': -51},
 'A2': 2519971570517980910,
 'A3': {'D1': 4259355705,
        'D2': [-2051109230, -2014192096, 1479397742],
        'D3': 6507917483440032492,
        'D4': 39443,
        'D5': 9481108562708790730,
        'D6': 28359,
        'D7': -3416567536464771892},
 'A4': 3387,
 'A5': 866134989,
 'A6': 61445,
 'A7': [44032, 41609, 30671]}

(b'OPPObt\x92\xd6\x9e\xfa\x91\xff<\t?=\xb1\xc6%Unj\xb3\x00\x02\x00\x00\x00'
 b'H?\xcamMl\x8e-\x00g\xa2\xc3p\xa0\x93J\xc5n\x00\x00\x00Pd~\xf0\xd1u\x08'
 b'\xe4\x94\\\xa5\x8c\x19\xa7\x99)\x19@\x13i\xa05;\x00\x00\x00@\x00\x00\x00D'
 b'\xebs"\xb9\x97\xf0N\xa2\\\xc3,9\x9b\xe3\x8a\xec\x1e\x01\xf4N\xe2\xd5fC'
 b'\xfd\x12\xe4-W3/\xb6+Rj\xbd\xa1\xfa\xf0n^\xd1\x7f{')

{'A1': {'B1': 29842,
        'B2': 214,
        'B3': [-98, -6, -111, -1, 60, 9, 63],
        'B4': 4445552170840779443,
        'B5': [{'C1': 10521, 'C2': [64, 19]}, {'C1': 27040, 'C2': [53, 59]}],
        'B6': 0.20646064568095568,
        'B7': 103},
 'A2': -6718402384138418834,
 'A3': {'D1': 3950191289,
        'D2': [-1745858910, 1556294713, -1679586580],
        'D3': 2162277915764811331,
        'D4': 64786,
        'D5': 16441893691954965330,
        'D6': 27325,
        'D7': -6774838332597633157},
 'A4': 25726,
 'A5': 4040258824,
 'A6': 58516,
 'A7': [23717, 35865, 42905]}

Вариант №16

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

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

(b'LLH\xd1\x90\xf4\xe7I\xa1\x95F\\\x00\x03\x00(\xbfL\x86\x12\x00\x02\x00\x00'
 b'\x00\x97>\xf9\xa5\x9f$\xed\x97\xf3\xf1\xb1\xfc\xb6\xd1\xc1\xbf\xb0$\xe3'
 b'\x06\x1a\xe0\xe0\xbf\xd4;\xa3\r|\xe0\x1c\xbf\xdd\x92\xd4\xf6t2(\xe5\x17\xa8]'
 b'\xea\xcc\xde)\xa5\x0ew6\xcc\xa8\x90\x96M\x8dKB\x16?Gv_\xe0s\x00'
 b'\x00\x00\x05\x00\x00\x00@\xbc\x00\x00\x00E>\xe4\xeb\xcfj-5i\xd3a\x16x'
 b'\xf9\\;\xb6\xba\x11\xdf\xa6\x9f\x91\x15\xd1>\xa6\xd7\x96\xd3\xe3\x00\x00'
 b'\x00\x04\x00\x00\x00l\xba\x00\x00\x00p={=\x89\x00d\x00\x8f')

{'A1': 209,
 'A2': -8001516334500985252,
 'A3': [-0.06306284808204365, -0.3161399490086312, -0.4620869070793412],
 'A4': -0.798920750617981,
 'A5': [{'B1': {'C1': 3437111717,
                'C2': 1042362091388835405,
                'C3': -1924447722,
                'C4': 0.7791499495506287,
                'C5': -8077,
                'C6': [229, 23, 168, 93, 234],
                'C7': -68},
         'B2': 0.447111576795578},
        {'B1': {'C1': 3546355320,
                'C2': -478441804416295002,
                'C3': -1617881647,
                'C4': 0.3258635401725769,
                'C5': -11293,
                'C6': [106, 45, 53, 105],
                'C7': -70},
         'B2': 0.06133798137307167}],
 'A6': {'D1': 0.4875917136669159, 'D2': 619550707},
 'A7': -15,
 'A8': [-79, -4, -74, -47, -63]}

(b'LLH^Z\xe4U\n\xb46\xaa\xab\x00\x02\x00(\xbf`\x12F\x00\x02\x00\x00\x00\x8e?1'
 b'r\x8aP\x11o\xdd!\xf0\r6\xcd\x1b?\xd3\xdc\x91\x00\x15_\xf4\xbf\xc3h\x8c'
 b't\x9c}P\xfcAA$\xd0*!<\xf3\xf9}\x083\x80\x89\xb2\xf9>\xef\xa8\xe1?y\xb1'
 b'\xc3U\xf7\x00\x00\x00\x05\x00\x00\x008O\x00\x00\x00=\xbf\x10\x9b\x03\x9f=?3'
 b'\x10\xbf\x1f"\xd4\xa3\xde\xc3R\x9e\x19;\xc7q\xba\xbf-)M\x8a\xc6\x00\x00\x00'
 b'\x03\x00\x00\x00d\xd9\x00\x00\x00g\xbfH\xc6E\x00\\\x00\x86')

{'A1': 94,
 'A2': 6549453262565059243,
 'A3': [0.31033730514673086, -0.15162807172689918],
 'A4': -0.8752788305282593,
 'A5': [{'B1': {'C1': 706821363,
                'C2': -469209768883801351,
                'C3': 1055893729,
                'C4': 0.9753686785697937,
                'C5': 22007,
                'C6': [252, 65, 65, 36, 208],
                'C7': 79},
         'B2': -0.5648652911186218},
        {'B1': {'C1': 856735519,
                'C2': 2509811069507247641,
                'C3': 1002926522,
                'C4': -0.6764114499092102,
                'C5': -30010,
                'C6': [159, 61, 63],
                'C7': -39},
         'B2': -0.7842753529548645}],
 'A6': {'D1': 0.693153977394104, 'D2': 1343320029},
 'A7': 33,
 'A8': [-16, 13, 54, -51, 27]}

Вариант №17

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

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

(b'IYIZ\x02\xd2\xb8\x00\x00\x00z\x00\x8b/h\xc8\xea\x1a\xc1\xc1\x97\xf0\xed?'
 b'\xce\x1f\xeb\x9e\r\xe6\xd8\njm}\xe0v\x9f:*\x07?E\xd9\xb6?aok>\xc7\x87F>9\xbe'
 b'\x1b?\x07\\\x8a>\x126ApiZ\r\x19\\\xc7\x9d\xfc\x97p\xb7\x8d\xf59"\xd0\x89\xeb'
 b'\xc9\x1e\xf8\xbb5$\x83\xbe\x8d\xe9\x00P\x9e\r\x8dI;\xed>\xbeA\x12\xe3\xa0'
 b'\xd9\x18\xe810-8/\x1d\x96\x81>\xc7,\x00\x02\x00\x00\x00A\x00C\x00N\x00Y\x00d'
 b'\x00o\xe6\xfd\x02\xff\xbfg=t?(\xfb4\xc9A\x896')

{'A1': 210,
 'A2': -72,
 'A3': {'B1': 'pi',
        'B2': [{'C1': 23053, 'C2': 25, 'C3': 6685485880052856717},
               {'C1': -2759, 'C2': 34, 'C3': 15026800880738941749},
               {'C1': 9347, 'C2': -66, 'C3': 10225704775170493769},
               {'C1': 15341, 'C2': 62, 'C3': 13709259509557958888},
               {'C1': 12592, 'C2': 45, 'C3': 4048487122280040236}],
        'B3': -26},
 'A4': {'D1': [-3, 2, -1],
        'D2': -0.9032814502716064,
        'D3': 0.6600830554962158,
        'D4': 3376515382},
 'A5': 12136,
 'A6': 14477413371614851309,
 'A7': 0.23534913270468993,
 'A8': {'E1': 2666,
        'E2': 7889708922305128967,
        'E3': [0.7728532552719116,
               0.8806063532829285,
               0.3897039294242859,
               0.18138925731182098,
               0.528755784034729],
        'E4': 0.14278508722782135}}

(b'IYIZ\x02dQ\x00\x00\x00z\x00\x8b\xeb\xc1\xe7z4L\xca\xb5_\x17?\xd6o\xe6\xe1'
 b'\xc9q\xac\x9d\xaa\xe9\x12\x99\x81\x91Q_\x8e?-<\x96\xbe\xe7\x91h\xbe\xd1\x05'
 b'\x92\xbf|C%\xbfs\xa6\xfc>;\t\xc7ac\t\xe0\x87\xde\x0ew\xee\xcfi\xfb/\xf4\xd0'
 b'n\x9f""\x85R\x05\x90\xa6\xed\xc3\x99#+G\xc7!\xf8(M\xf0\\\xe1\xc9'
 b'\x13\xc2\x15\xf0\xd6\x1b\x0b\x01\x83A\x14\xd6 |\xe1\x93B\xb3\x00\x02'
 b'\x00\x00\x00A\x00C\x00N\x00Y\x00d\x00o\xb4\x02\x1c\x0f\xbeb\xcb\xeb??'
 b'\x1d\x03,\xe3\xfe\xc2')

{'A1': 100,
 'A2': 81,
 'A3': {'B1': 'ac',
        'B2': [{'C1': 2528, 'C2': -121, 'C3': 16000858393659702063},
               {'C1': -2864, 'C2': 110, 'C3': 11466765557240795302},
               {'C1': -4669, 'C2': -103, 'C3': 2534198135920011341},
               {'C1': -4004, 'C2': -31, 'C3': 14489137825671682827},
               {'C1': 387, 'C2': 65, 'C3': 1501423246507197107}],
        'B3': -76},
 'A4': {'D1': [2, 28, 15],
        'D2': -0.22148101031780243,
        'D3': 0.7465364336967468,
        'D4': 753139394},
 'A5': -5183,
 'A6': 16679701674343096087,
 'A7': 0.35057994889737176,
 'A8': {'E1': -25174,
        'E2': 16794654742185861006,
        'E3': [0.6767057180404663,
               -0.45228123664855957,
               -0.40824562311172485,
               -0.9853995442390442,
               -0.9517667293548584],
        'E4': 0.1826544851064682}}

Вариант №18

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

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

(b'HWK\xffB\xed\xf3g\x02\x00\x00\x00\x18\x00psxo\xa2\xe2Cm\x82\x00hojjpemm'
 b'W<\xae\xc26\xc9\xc9\x92\xd0\x1fa\xff\xd8yxm\x9d\xb02\xa3ZH\x88\xcf'
 b'\xba\xeeU\xef\xbf}\xf2\x02Hh}\x9e\xbf3\xa1\xbbj\xdb\xd4S\xa0dfwcahl'
 b'\xb4t\x89;5\x83\x10GwS\x9d\xd8/\xf3\xd0\xc9\xddRdeB\xae0P\x86\x9dBc'
 b'\xe8\xbf\x83\x89\xf5\xb8r\xcau\xfe+b\\-\xe7\xcc\xd6r\xf1B\x19\xaf\xbd\xac'
 b'\xdek\xc6\xd0\x88]\xdd\x10I\x1a\xb5\xd0K\xc1>_G#\xe3\xe5\xcb\xee\xf0\xbb'
 b'\to|\x94\x9e[>')

{'A1': 4092412671,
 'A2': 103,
 'A3': [{'B1': 'hojjpem',
         'B2': 2923190125,
         'B3': 3385407170,
         'B4': 146,
         'B5': {'C1': 4284555216,
                'C2': -6687088306498799144,
                'C3': 90,
                'C4': -0.9792398117681467,
                'C5': -4639132679306808707},
         'B6': -6893932565720489677},
        {'B1': 'dfwcahl',
         'B2': 998864052,
         'B3': 1192264501,
         'B4': 119,
         'B5': {'C1': 802725203,
                'C2': 4784340486222106867,
                'C3': -82,
                'C4': -0.7621167256024872,
                'C5': -110960021722527357},
         'B6': 8275026658610405931}],
 'A4': 'psxo',
 'A5': 1833165474,
 'A6': {'D1': [241, 66, 25, 175],
        'D2': -67,
        'D3': 15951055885479698092,
        'D4': -1256568560,
        'D5': 0.3775315284729004,
        'D6': 17361037801778530143,
        'D7': 4493359413812201915}}

(b"HWK\x18Q\x12\xa6\xa3\x02\x00\x00\x00\x18\x00hjcx\xc1\x85\xda'\x82\x00yefg"
 b'alw\xb1\xd02\xe4\t\x95\xb3\x13\xf5\xa7Y\x12PM\xeb\xbf\x88\x01\xa4\xc3\xa1'
 b'\xbcn\x8cb7"\x18\xe8?\'\x9e\x1b\x1dU@TRq\xd6WtW\xbep\tvgyypaf\xc5\x16\xea%'
 b'I5\x03\xb9\xbaP\xf3\x91u@\x97\xf5\x05w\xf8\xecx\x87\x88\x1f\x13\xb3\xbaB'
 b'\xe9?\xad\x9f\xb1\xd5ex\x17\xc8\xd5C\xffI\x1a\x02\x0f\xc8N\xbbu\xc4\x1a\x87'
 b' :\x17\xe5\xf5\x9e\xee\x07\x96\xb8\xb5\xed\xd8\x80\xbc\xe1\xa5\x92\xe9['
 b'\xc1\xfc\x1d\x04C\xd1\x88v\tn\xdc')

{'A1': 2786218264,
 'A2': 163,
 'A3': [{'B1': 'yefgalw',
         'B2': 3828535473,
         'B3': 330536201,
         'B4': 245,
         'B5': {'C1': 1343379879,
                'C2': -6790403486648374451,
                'C3': -68,
                'C4': 0.7529460031258972,
                'C5': 5932437343458532903},
         'B6': 680252826556290673},
        {'B1': 'vgyypaf',
         'B2': 636098245,
         'B3': 3103995209,
         'B4': 186,
         'B5': {'C1': 1972499280,
                'C2': 8713612569139844928,
                'C3': -121,
                'C4': 0.7893956658890469,
                'C5': -4028618962887401555},
         'B6': -4031000829539433515}],
 'A4': 'hjcx',
 'A5': 668632513,
 'A6': {'D1': [78, 187, 117, 196],
        'D2': 26,
        'D3': 17194450791633133703,
        'D4': -1246194169,
        'D5': -0.015728438273072243,
        'D6': 2160814521735882209,
        'D7': 15883643340488524548}}

Вариант №19

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

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

(b"INF2\xf4\xa9\xa0\xc4\x8e\xaa\x0e\x0f\x13\xbf-\xc5\xe8'\xda\xbf2W]b"
 b'\x0f\xc9\xec\xbf8B~:\xde\\\xcdU\x97 >\xb1\xda\xbdw\xa0u\x97\xa1\xa5'
 b'(\xcb2\xc9\xd4\xddW\xbe\xef52XH\xb6\xd3\xfd\xb6t\xe4xZ-\xcfW\x0bV$\xc3'
 b'h\x93\x00\x02\x00\x00\x00b\xbf\xef\xa4\xee]\r\xc0\x8c\x00\x00\x00~\xab\xf4zq'
 b'\xe1\xb1uN\xeb\x97\xc5\xff\xef\x13\xdc\xc4\x94\xe1\xae\x9e\x0b\xfe\xd6\x0b'
 b'jD\xfa\xc8\x89\xf9\xbf\x18\xfe\x9d6\xac\x1b\xa1N\x00dW&OAQ\x1c\x94'
 b'\xe9\xfa]\xed+tQ\x8e\xe4\x10WuT\xcb\xe5#X\xee')

{'A1': {'B1': [{'C1': 3671746104171342350,
                'C2': 3859,
                'C3': -0.6788010597229004},
               {'C1': 2871817935337120271,
                'C2': 51692,
                'C3': -0.7197645902633667},
               {'C1': 4241929936003604542,
                'C2': 45530,
                'C3': -0.06045575812458992},
               {'C1': -7520548308105639468,
                'C2': 56663,
                'C3': -0.46720272302627563}],
        'B2': 6361535495271773412,
        'B3': 2019175887,
        'B4': 1460360740},
 'A2': -15512,
 'A3': 147,
 'A4': 'zq',
 'A5': -0.9888831918197112,
 'A6': {'D1': -0.5976350903511047,
        'D2': 917248929,
        'D3': 78,
        'D4': {'E1': [16262908711232062975,
                      17227355736491798174,
                      864363523017603784],
               'E2': -30215},
        'D5': 6279793872367031529,
        'D6': {'F1': 250,
               'F2': [93, -19, 43, 116, 81],
               'F3': -8150371457817064475,
               'F4': 9048},
        'D7': -18},
 'A7': -21516}

(b'INF\x0fV\xaa\xf7\xa1\x02\xe0\xe2\xfb\xcb\xbf\n1S(\xbd\x18\xb1\xf9/\x1e'
 b'\xe7\xd0C>r.\x0f\x90\xde(")\x7f\x98%t\xf2>\xe5\x15-\xd9\x91\xc1'
 b'\xb9\xc1\x90\x91m\x87\xf1\xbf\x03\xc4\xf93\xa8;\xc2lR\x9b\xd0Z'
 b'\xf0\xa5\x82\x08\xfb\xb8\xc6\xa7\xd0\x81\x00\x02\x00\x00\x00b?\xc0R\xfa'
 b'\x18E9 \x00\x00\x00~?-cn\xcd\xf5\xbc\x15q~z\xa7V\x08\xa35c~b\xc3\xd19\x19O'
 b'\x90\xd4=\x18i\x8d\xbf>?*A^\xa3\x17\x96\x00d\x07\x9f\xa7qi\xcd6\thj8e\xf7ut'
 b'\x04\x1b\xc2\x0fo;e\xe1\xef\xb0')

{'A1': {'B1': [{'C1': 1105258739100999906,
                'C2': 64459,
                'C3': -0.5398151278495789},
               {'C1': 2935529684784324327,
                'C2': 53315,
                'C3': 0.23650382459163666},
               {'C1': -8007918960227936219,
                'C2': 29938,
                'C3': 0.4474271833896637},
               {'C1': -2769219292295556755,
                'C2': 34801,
                'C3': -0.5147243142127991}],
        'B2': 3722290798248762320,
        'B3': 1525720450,
        'B4': 150714566},
 'A2': -22576,
 'A3': 129,
 'A4': 'cn',
 'A5': 0.12753225503042476,
 'A6': {'D1': -0.7431513071060181,
        'D2': 1096721175,
        'D3': -106,
        'D4': {'E1': [14840974947353787047,
                      6199384336773309123,
                      15076109057122385176],
               'E2': 27021},
        'D5': 549341785110689289,
        'D6': {'F1': 104,
               'F2': [106, 56, 101, -9, 117],
               'F3': 8359837328603036517,
               'F4': -7697},
        'D7': -80},
 'A7': 16173}

Вариант №20

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

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

(b'MRBIo\\\xf9/\x00c\x00f\x00i\x00l\x00o\x00r\x8a\x9a\xbe\x81\x00\x7fu\x93'
 b'N\xd9\x93Q\x10\x97\xd0I\xcf\r\xbe\xdb\xcc\xcf\xbfU\xb2\xd2\xbfjy;\xbf+'
 b'\xee\xf7\xbem\xa5\xe1\xbd~\r\xc2\xbf\x0e\xc9\xd8\xbeWm7?\x10\x92$1\x00'
 b'\x00\x00\x03\x00\x00\x00\xa5\x18\xb5\xe5\x9a\xd65\x89d\xa0\x05P\xe0s'
 b'\xb8\xfe\xc7\xfa\xd1e\rL\xbf\xbd$+\xf1lW\xc4\xfa\x01\x90\x13\x97Z\x89\xd6'
 b'\xcb\x87\xca5x\x06\x0b\xf3]g\xac!\xefw\xc5D\xbe\xf2=\xfd\xdc\x91\xbe\xe4'
 b'\xbf\xc2&Y\x03~\x05\xd8\x00\x05\x00\x00\x00u\x05k\xf1\x98\xbf\xf3\xb1HQ\xd3')

{'A1': 28508,
 'A2': 63791,
 'A3': [{'B1': 250, 'B2': 53605},
        {'B1': 13, 'B2': 19647},
        {'B1': 189, 'B2': 9259},
        {'B1': 241, 'B2': 27735},
        {'B1': 196, 'B2': 64001},
        {'B1': 144, 'B2': 5015}],
 'A4': -1969570175,
 'A5': {'C1': 17536286513051957189,
        'C2': {'D1': 68,
               'D2': {'E1': -0.47312918305397034,
                      'E2': 3700539108,
                      'E3': -0.14179527922173807,
                      'E4': [23177, -10549, -30774, 13688, 1547]}},
        'C3': 5,
        'C4': 27633,
        'C5': -26433,
        'C6': -3151},
 'A6': 1972588249,
 'A7': {'F1': {'G1': -7831460032799977715,
               'G2': [-0.42929694056510925,
                      -0.8347598314285278,
                      -0.9159123301506042,
                      -0.6716150641441345,
                      -0.23207809031009674,
                      -0.06202483922243118,
                      -0.557767391204834,
                      -0.2103775590658188],
               'G3': 0.5647299289703369,
               'G4': 49,
               'G5': [72, 81, 211],
               'G6': 1780581680876456292,
               'G7': -1610264352},
        'F2': {'H1': 29624, 'H2': 254},
        'F3': 199}}

(b'MRBI\xdc\xc3\x9b\xb9\x00c\x00f\x00i\x00l\x00o\x00r\xf25\xdb\xec\x00\x81\xf4p'
 b'J\xd2\xd7B;\x88Y\xb5\x85\xf3\xbf<\x8ef\xbe\xf5!\x06<\xb9\xa1\xba\xbe\xbe'
 b'#\x9b\xbe\xac\x1a\xaa\xbf-\x03$>\xdd\x1c\x0b>h{2\xbfY,W\xd8\x00'
 b'\x00\x00\x03\x00\x00\x00\xa7\x93|To\x0e:K\xb4\n\xd1i#C\xd9\x96\xc8\xda'
 b'\xed\xa3\xdeOMW\xcd\x8bdw\x85\x88\xc3)\xc0 \x0f\xcf\xdd0G\xbf )'
 b'\xc6\xdd\xc7\x94b\xa9\xbb\xfa\xa56v\x87\xfa#\xbf5\xe6\x81m\xa2\xea\x8e?\xd0'
 b'+\xd8\x9e\xb0\xfa\xe0\x00\x06\x00\x00\x00ul\x8fi^\xdc\xad>c\xc9\x9f')

{'A1': 56515,
 'A2': 39865,
 'A3': [{'B1': 218, 'B2': 60835},
        {'B1': 222, 'B2': 20301},
        {'B1': 87, 'B2': 52619},
        {'B1': 100, 'B2': 30597},
        {'B1': 136, 'B2': 49961},
        {'B1': 192, 'B2': 8207}],
 'A4': -231351316,
 'A5': {'C1': 12230644800544999418,
        'C2': {'D1': 35,
               'D2': {'E1': -0.710548460483551,
                      'E2': 1839393422,
                      'E3': 0.25267615792465214,
                      'E4': [-12323, 12359, -16608, 10694, -8761, -27550]}},
        'C3': 108,
        'C4': 36713,
        'C5': 24284,
        'C6': -21186},
 'A6': -193967406,
 'A7': {'F1': {'G1': -2935718550285482509,
               'G2': [-0.7365478277206421,
                      -0.4787675738334656,
                      0.02266012504696846,
                      -0.37136539816856384,
                      -0.3361409306526184,
                      -0.6758291721343994,
                      0.43185457587242126,
                      0.22703245282173157],
               'G3': -0.8483328223228455,
               'G4': -40,
               'G5': [99, 201, 159],
               'G6': -7819282017065219148,
               'G7': 181496099},
        'F2': {'H1': 17369, 'H2': 150},
        'F3': 200}}

Вариант №21

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

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

(b'\xcbDBEZ\xa2A\x1d\xe7\xd8kZ\x8e7vx\xfbgqYmgxxy\xa9\xbe\xe52OY\xd6'
 b'\xd6\xe4\xbf\xd4\xbb\x17\xec\x8f\xb5 \x00\x00\x002\x00\x00\x00X>DoH\x81\xe0'
 b'\x88\x19\xfe\x91W\xd62\xeb?\xd2.\x8dF\x7f\x9a\x00?\x88m\x92\xfd\x8e\x87\x00'
 b'\xbf\xdd4\xf9\xf7Z\x95\xf0?\xe0\x80\xd6\x17x\xd0\xec\x12cH1\x00\x02\x00>'
 b'\xbf\xda\xe0J\xfbD|\xd8?\xef\x84V[x~\xfe\xbf\xe7\xd8\xda8\xbf\xe6\xea'
 b'\xbf\xa4x\xc4\xc2\xa2.\x80\xbf\xe8\x1d\xcb\xd0/<B\x00\x03\x00@8]`\xcb')

{'A1': -6755085084473468274,
 'A2': [{'B1': 55, 'B2': 'vx'},
        {'B1': -5, 'B2': 'gq'},
        {'B1': 89, 'B2': 'mg'},
        {'B1': 120, 'B2': 'xy'}],
 'A3': -87,
 'A4': -4691288120445446428,
 'A5': -0.32391927816100186,
 'A6': {'C1': 0.19183075428009033, 'C2': 9358629670902388694},
 'A7': {'D1': 0.5157270868717467,
        'D2': 308496433,
        'D3': {'E1': [50, -21],
               'E2': [-0.41993975198597644,
                      0.9849044596230383,
                      -0.7452212437048875,
                      -0.039983891257262094,
                      -0.7536372247794889]},
        'D4': [0.2840912998639453, 0.011927746165216302, -0.45635842471742105],
        'D5': 14429,
        'D6': 24779}}

(b'\xcbDBEZR\xf6\xcf\xa1fR\x0e\xefZwb\xf2sq\xbebp\xb4cd\xf5S:\xdd\x9a&3'
 b'\xf8/?\xef\xd2m\xdd\x18\xfb\x92\x00\x00\x002\x00\x00\x00X>\x16\xb2\n R'
 b'Hj\xb9\xfe7?L3\xbf\xe7\xb9\xc29\xc39\x00\xbf\xea\xe8\x83\\\xa2\xcaV'
 b'\xbf\xef\x80\xe5\xfa\xb9\xc5\x88\xbf\xda2\x8c\x7f\xf0\xcex\x13\x9e\x15d'
 b'\x00\x02\x00>\xbf\xe3\xb7*\t\xb7=\xf8?\x82\xb5\xcd\xeb\xcf\xc5\x80'
 b'\xbf\xed\x1fQ\xd0\xce\x956?\xe1@1"\xfcMH?\xd1\x97\xe0\xd6\xcf\x97\xb8'
 b'\x00\x03\x00@^\x86\xc5\x85')

{'A1': 5978193847494250223,
 'A2': [{'B1': 90, 'B2': 'wb'},
        {'B1': -14, 'B2': 'sq'},
        {'B1': -66, 'B2': 'bp'},
        {'B1': -76, 'B2': 'cd'}],
 'A3': -11,
 'A4': 5997349507932878895,
 'A5': 0.9944371527015952,
 'A6': {'C1': 0.1471635401248932, 'C2': 2329003580528146239},
 'A7': {'D1': -0.4093352555675902,
        'D2': 329127268,
        'D3': {'E1': [76, 51],
               'E2': [-0.6161089124452124,
                      0.009135826834582472,
                      -0.9100731924305936,
                      0.5390859301864248,
                      0.2748949144137174]},
        'D4': [-0.7414256218123967, -0.8408829507155342, -0.9844846627221822],
        'D5': 24198,
        'D6': -14971}}

Вариант №22

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

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

(b'GHCC\x98\x00\xa5\xbeF?\xa5\x84\xdf\x98\xccG\x03\xa2\x9e\x81Td\x88\xc9v)%\xdb'
 b'\x9a\xde\x89\xb6\x85\x9b>\x05\x00\x9f\x03\x00\x00\x00\n\x00\x05\x00\x10\x00'
 b'\x19\x0c\x8e\xdd\xc6\xff\x93\x9b\x86\x17H\xe2\xa6p\x84\xea\xc5\x18z\xb2'
 b'\x02\x00\x00\x000\x00\x02\x004\x00i.\xa9\x8a\x18\xec\x99\x08i2\xc50\xa2\xe7'
 b'S\xe9\xd4\x13C9-\x04-]c\xa6\x03\x00\x00\x00N\x00\x04\x00T\x00\xa1\xdd'
 b'\x0e\xba\xc0\xc2HPR\xe5\xdfE\xf5O\xaf`\x08M\x18\x1c\x9b\xce\xf2\xd6VC'
 b'\x1b\xd8\x03\x00\x00\x00r\x00\x05\x00x\x00\xa0\x14\xe8\xb8\xd8\x8f\xa4?'
 b'*\x1a\x00\x00\x008\x00\x00\x00\\\x00\x00\x00\x82\x00\x00\x002\x9e+Bf\x99\xe9'
 b'?')

{'A1': {'B1': 0.04015996224556173,
        'B2': 42,
        'B3': {'C1': [{'D1': [37, 219, 154, 222, 137, 182, 133, 155],
                       'D2': -1627388610,
                       'D3': [-31579, -26401, 18380],
                       'D4': [41475, 33182, 25684, 51592, 10614]},
                      {'D1': [134, 23, 72, 226, 166, 112, 132, 234],
                       'D2': -1300621115,
                       'D3': [3097, -8818],
                       'D4': [65478, 39827]},
                      {'D1': [83, 233, 212, 19, 67, 57, 45, 4],
                       'D2': -1503437523,
                       'D3': [11881, -30039, -5096],
                       'D4': [2201, 12905, 12485, 59298]},
                      {'D1': [8, 77, 24, 28, 155, 206, 242, 214],
                       'D2': -669301930,
                       'D3': [-8799, -17906, -15680],
                       'D4': [20552, 58706, 17887, 20469, 24751]}],
               'C2': 0.7999755184545789}},
 'A2': 0.7763465046882629}

(b'GHCC\x94\x00\xae\x864?\xf7!~\xe1\xa0\xf8\x9c\x12\x17\xf3\xef\x15\xa7\x1b'
 b'\x9c\xe3\x04A\xd2\xbf<\xcb}\x07\xc6\xbep\xec\x03\x00\x00\x00\n\x00'
 b'\x05\x00\x10\x00\x0cA\xc8z\xe3\xd9G\xe8c\xe3\xdd\xa7r\xb5\xebC\x98Ff\x96'
 b'\x02\x00\x00\x000\x00\x02\x004\x00\x1b4\xa7\x0b\x9d\xe9%O\xe8Lp-\x84y'
 b'p\xac[\xd1\xea\xa6U\x17\xf71\x02\x00\x00\x00N\x00\x04\x00R\x009\xf3\x8eP'
 b'\x8b\x16G\xba\x02S\xc5T\x91\x10\x8b\x9e\x82\x03\x07\xe0F:\x0f\xd8'
 b'\xbbV\x03\x00\x00\x00p\x00\x04\x00v\x00\x84\x84\xb0;\xa6\xe1\xeb\xbf'
 b'\xce\x1a\x00\x00\x008\x00\x00\x00Z\x00\x00\x00~\x00\x00\x00\xd8\xbc\\'
 b'Q\x00\x15\xec?')

{'A1': {'B1': -0.8712950864611604,
        'B2': -50,
        'B3': {'C1': [{'D1': [4, 65, 210, 191, 60, 203, 125, 7],
                       'D2': -328155450,
                       'D3': [8695, -7810, -1888],
                       'D4': [4764, 62231, 5615, 7079, 58268]},
                      {'D1': [99, 227, 221, 167, 114, 181, 235, 67],
                       'D2': -1771682152,
                       'D3': [16652, 31432],
                       'D4': [55779, 59463]},
                      {'D1': [132, 121, 112, 172, 91, 209, 234, 166],
                       'D2': 838276949,
                       'D3': [13339, 2983],
                       'D4': [59805, 20261, 19688, 11632]},
                      {'D1': [139, 158, 130, 3, 7, 224, 70, 58],
                       'D2': 1455151119,
                       'D3': [-3271, 20622, 5771],
                       'D4': [47687, 21250, 21701, 4241]}],
               'C2': 0.8775636281115125}},
 'A2': 0.7051800489425659}

Вариант №23

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

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

(b'RMKCk}\xe7\x07\x1d\x00\x00\x00 \x00\x00\x00\x07\x00\x00\x00#\x00LFS\x00\xeea'
 b'\x00\xc0\x17q5\xcern>;\x14\x11\x83\x82m\xd7\xcfm\xd6Y\xc1\xff\xb3\xaf'
 b'Q\xc5\xa0\xf0\x19\xe5\x9f\xac\xed\x19\xd0\xf8N;?Ps1\xbf;\xeb\x1b?d'
 b'\xa72\xbf\xa8\xa3|\xbfX%\x05\x00?\x00\x00\x00$p\xac\x13y\xbf\xfe#\xcd'
 b'\xd7-\x8a\x14Cv\xca\x8b\xcf\xdb\xbc\xea\xc60B\xfa!')

{'A1': 132611435,
 'A2': [{'B1': 192, 'B2': 28951}, {'B1': 53, 'B2': 29390}],
 'A3': [{'C1': 110, 'C2': [62, 59, 20]},
        {'C1': 17, 'C2': [-125, -126, 109]},
        {'C1': -41, 'C2': [-49, 109, -42]},
        {'C1': 89, 'C2': [-63, -1, -77]},
        {'C1': -81, 'C2': [81, -59, -96]},
        {'C1': -16, 'C2': [25, -27, -97]},
        {'C1': -84, 'C2': [-19, 25, -48]}],
 'A4': 17996,
 'A5': {'D1': 9560,
        'D2': [0.7316737174987793,
               -0.6931657791137695,
               0.6090580821037292,
               -0.697866678237915,
               -0.9868721961975098],
        'D3': [36, 112],
        'D4': -0.9729564189910889},
 'A6': 238,
 'A7': {'E1': 254,
        'E2': -13021,
        'E3': 344600023,
        'E4': 67,
        'E5': 14333476416325929590,
        'E6': 570049072}}

(b'RMKC9Y\xb6t\x1d\x00\x00\x00 \x00\x00\x00\x05\x00\x00\x00#\x00\x8fVK\x00\x1aY'
 b'\x00{\xe9Z\xa4\xfe\x1fB\xdf\x98\x84d\xf3\x8co\xb5\xdc\x9fWK\x86@\xca\xedgX=2'
 b'\x8ak\xbf\xabz\x17?\x8aY\\\xbf\xd4N:\xbf\x92\xc6\xee>\xa9Q\x05\x007'
 b'\x00\x00\x007\xa7T\xf9\x1c>$\xfd\xb1;\xcd\xa9\xd0O\x8f\xc3U:B\xc4K'
 b'\xcc\x12\t\xe8\xa6')

{'A1': 1958107449,
 'A2': [{'B1': 123, 'B2': 23273}, {'B1': 164, 'B2': 8190}],
 'A3': [{'C1': 66, 'C2': [-33, -104, -124]},
        {'C1': 100, 'C2': [-13, -116, 111]},
        {'C1': -75, 'C2': [-36, -97, 87]},
        {'C1': 75, 'C2': [-122, 64, -54]},
        {'C1': -19, 'C2': [103, 88, 61]}],
 'A4': 22159,
 'A5': {'D1': 20905,
        'D2': [-0.9200774431228638,
               0.5917155146598816,
               -0.8607412576675415,
               -0.7277653217315674,
               0.4663587212562561],
        'D3': [55, 167],
        'D4': 0.1532948613166809},
 'A6': 26,
 'A7': {'E1': 36,
        'E2': -19971,
        'E3': 3500789051,
        'E4': 79,
        'E5': 14721075595716182927,
        'E6': -1494742766}}

Вариант №24

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

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

(b'NGW\x86z\x94\xa4\xe1O\xde#\x88\xf4A\x92`\x81\xac\x89\x90si\xcc;\n\x16\x0b2'
 b'\xda\xbf\xe8\x8d\x89\x08 \r|?!({\x0c)\x91\x02\x00\x94\x00\x00\x00\xe2\xf1'
 b'\xc5\xefNh\x8c\xb1\xfe\x9b\xe4\xb2\n\xe6\xe6?\x02\x00\x96\x00\x00\x00'
 b'9\xfe\xe5\xbd\x16\xb8\x8c\xb1I.\x03\x00\x9a\x00\x00\x00n\x86(\xf8'
 b'\x03\x02\x92Q0\x9aAQ]#\xc6?\x02\x00\x9d\x00\x00\x00G\xac\x12?T6\x80\x18h|'
 b'\x04\x00\xa1\x00\x00\x00\xf7(Y8K\x93\xbc\x11\xf2eQd\xed\x00\xe8\xbf\x02\x00'
 b'\xa5\x00\x00\x00\x9c]\xa2YFg(?\xb4\xc2e\x03V\x06\xfc-\xc4S\xeb?Q')

{'A1': -8636815225697037190,
 'A2': 10415045284941939188,
 'A3': 'si',
 'A4': -0.4093044009431963,
 'A5': 143232488,
 'A6': [{'B1': 0.9845752716064453,
         'B2': {'C1': 10273, 'C2': -1859580805, 'C3': [-100, 93]},
         'B3': {'D1': -5653028744017350174,
                'D2': 0.7155812734607705,
                'D3': [22946, 26438]}},
        {'B1': -0.1123012974858284,
         'B2': {'C1': 47126, 'C2': 776581516, 'C3': [40, 63, -76]},
         'B3': {'D1': 5877762679743481454,
                'D2': 0.17295423953619737,
                'D3': [26050, 22019]}},
        {'B1': 0.572941243648529,
         'B2': {'C1': 13908, 'C2': 2087196800, 'C3': [6, -4, 45, -60]},
         'B3': {'D1': 1278058345543575799,
                'D2': -0.7501131972632591,
                'D3': [-5293, 20799]}}]}

(b'NGW\x86\x82\xde\x11\x06|z\x13\x89\xd5\x83C\x06\x13\xaaV\xa2af\x88\x14'
 b'\xd3}\xd6\x8f\xd4?\x05\xf0\x96P\xc1\x1b\xd8>w\x19z-$\xc1\x02\x00\x94\x00'
 b'\x00\x00\xfd\xed\x8eb\xbfL\xbfB\xd8\xf7\xc1(\x98b\xe7\xbf\x02\x00'
 b'\x96\x00\x00\x00\xc2\xf36<\x85\xdf\x9f\xfa\xdb\xeb\x03\x00\x9a\x00\x00\x00'
 b'\xe2e\x03*\xf6Ie\xbf\xc0\xbd\xf6\xc5\xc2\xf8\xa0\xbf\x02\x00\x9d\x00'
 b'\x00\x00\x1f\xd6|>@9wA\x1f\x9f\x04\x00\xa1\x00\x00\x00\x8e\xeb~\xb1\x0f\xe2'
 b'N\xcb`\x8e25\xf8\t\xcd?\x02\x00\xa5\x00\x00\x00T5:\x90\x0b\x0el\xdf'
 b'\xe9\x9b\xa7@\xb0\x08~\xdf}\xc0P\xc4\x1f')

{'A1': -8569370992859554174,
 'A2': 11697724080827630549,
 'A3': 'af',
 'A4': 0.32127916610290486,
 'A5': 1352069125,
 'A6': [{'B1': 0.4220867455005646,
         'B2': {'C1': 6519, 'C2': -1054593670, 'C3': [84, 53]},
         'B3': {'D1': 4809647311930977789,
                'D2': -0.7307854457901568,
                'D3': [-28614, 3595]}},
        {'B1': 0.011166514828801155,
         'B2': {'C1': 57221, 'C2': -337904993, 'C3': [108, -33, -23]},
         'B3': {'D1': -4655233318201891358,
                'D2': -0.033147894540316525,
                'D3': [-22629, -20416]}},
        {'B1': 0.24691055715084076,
         'B2': {'C1': 14656, 'C2': -1625341577, 'C3': [8, 126, -33, 125]},
         'B3': {'D1': -3796848878796477554,
                'D2': 0.22686674687894293,
                'D3': [20672, 8132]}}]}

Вариант №25

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

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

(b'KQJG\xdc\xd7\x99K\x0c\xdb\x05\xec7\xbfb\xff\xf2\xef\x9e\x0c\x83&O\xd6'
 b'\x95\x0cy)\xd3\\\xc8\xf0\xa6\xa5\xab\xfd\r\x02\xe3l{A\x0chF\xc4@ImT\x84\x1b'
 b'\xa70_\x8c\x08\x98\x8f\xf4\xfc\x00\x00\x00\x03\x00\x00\x00~,v?\x91|D\xcd'
 b'\xdd\x98\x9e\xb6\xfd\x07\xbfZ3e\xfbHf=4Q\xdc?%OF\xbc\x10\xb5\xb2\xf1rL'
 b'Un\x9cf\x00\x00\x00\x02\x00\x00\x00\x84\xdb\xf0\xb7\xec\x82\xee2\x15'
 b'\x12\xf0\xce+Y\x84\x08\x0e\x01\xfa\xe6\xce\xaapr\xa1')

{'A1': -36,
 'A2': 15535530908177525815,
 'A3': -0.8867179155349731,
 'A4': 61342,
 'A5': {'B1': {'C1': [{'D1': 901606474748595321, 'D2': 10707},
                      {'D1': 6685858245366250765, 'D2': 739},
                      {'D1': 7816913099776508992, 'D2': 18797},
                      {'D1': 6090023000996809736, 'D2': -26481}],
               'C2': -2820,
               'C3': [-12757, 22916, 2062],
               'C4': {'E1': [745947025,
                             2084883933,
                             2560538365,
                             129980979,
                             1710966886],
                      'E2': 0.04402337968349457,
                      'E3': 0.6457408666610718}},
        'B2': -0.008832382038235664,
        'B3': -244167595,
        'B4': 28316,
        'B5': 102,
        'B6': [33220302, 2859496097],
        'B7': 3689986028,
        'B8': 33518},
 'A6': 840241904}

(b'KQJGS\xec\xad\xa25c\x9e\r;\xbe\xf6\xf6\xcc\xc3*.\x88\xd9\x0e\xf1'
 b'\xf9j\x15\x1a\xf3\xd2\xcc\xf1\xa4)\xaa?\x8c\x89\xae9\xe1<\xc4a\xc5]\r\xe7'
 b'\xc6?\xac{\xf5\xec\xba\xb1\x98\x03@\xe89\x00\x00\x00\x04\x00\x00\x00'
 b'~\xd2\xcf[\xaf\x0c"9\xe0q\xf0\x8f\xf5}\nk\xf9\xb47\x9b)\xbf\x12\xb9'
 b'o\xbf\x1b\xc4\xcb?tR\xed2\x0b\xaeC\x9d\xee\xae\x00\x00\x00\x04'
 b'\x00\x00\x00\x86\xd4\xc0\xf26?\x13\xe8.\xed%\x1bcY\xbe\xfb\xebHV\x18\x87'
 b'\xb6E\x8a\x0c\xe0;\xea\xac\xbeCW\xf70\xfa')

{'A1': 83,
 'A2': 17054465714110205243,
 'A3': -0.4823516607284546,
 'A4': 49962,
 'A5': {'B1': {'C1': [{'D1': 3353168580789758485, 'D2': 6899},
                      {'D1': 15189781330589794188, 'D2': -30290},
                      {'D1': 4170681544073370893, 'D2': -6202},
                      {'D1': 4588178416552554904, 'D2': 832}],
               'C2': -6087,
               'C3': [7011, 22974, -1045, 18518],
               'C4': {'E1': [3536804783,
                             203569632,
                             1911590901,
                             2097835001,
                             3023543081],
                      'E2': -0.5731419920921326,
                      'E3': -0.6084715723991394}},
        'B2': 0.9543903470039368,
        'B3': 839626307,
        'B4': 40430,
        'B5': 174,
        'B6': [411547205, 2316099643, 3937189443, 1475817722],
        'B7': 3569414710,
        'B8': 16147},
 'A6': 3895389477}

Вариант №26

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

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

(b'ASKIDn\xc7sjyy\xe6\xd6g\xc6\xd9\xd6\xfe\x01l\xb3\xdf\xce\x97Me\xbe\xcf'
 b'Y\x14=S\xf0A\x0e)\t-\x92\xb1\x86f\x08\x05\xf5N\x92v\xde\x9e\xf7;(]z\xc3'
 b'\xcc/\xcf\xec\x1ee\x8a\xa2\x0f\xac7\x8b_\x9a\xfdjoxfi$\x10+\x89'
 b'\xb8\x8a\xa1\xab\xa5\x1b\xd4\x01\x00Z\xf0?HB\x97,\x0cA\xac%\xbe\xe1q')

{'A1': {'B1': 28359,
        'B2': 'sjyy',
        'B3': {'C1': 59094, 'C2': 1741085142, 'C3': 4261506227}},
 'A2': -8242,
 'A3': [{'D1': 10902482143130752061, 'D2': 21488},
        {'D1': 4687729381535297926, 'D2': 26120},
        {'D1': 429335730450243319, 'D2': 15144},
        {'D1': 6735911474428898334, 'D2': 25994}],
 'A4': -6769002360353088771,
 'A5': 'joxfi',
 'A6': [605039497, 3096093099, 2770064385],
 'A7': {'E1': -16, 'E2': 0.7822660803794861, 'E3': [11276, 16812, 9662, -7823]}}

(b'ASKID\xf6Bfpsw2(N\xf1\x84\xac\xc8\x95\xa78\xffa\xfc\xec\xeeK\xe8'
 b'\xfc\xe0U\x9c\xb9\xfb\xcf\xba\x99$S\x85TLIUI\x1b\x189\xfaC"#\xe3Q\xd1B'
 b'\x8f\xa9\xc7\x88~\xba\x87G\xf0\xd2\x82~\xa8\xeeBvwyjnD\xd5\xf0\xb9"m(\x07'
 b'M\x8f\x04\xee\x00ZR<\xcd\x88\xc3|w\xf2\xde\x0c{_\x00')

{'A1': {'B1': 63042,
        'B2': 'fpsw',
        'B3': {'C1': 12840, 'C2': 1324450988, 'C3': 3365250872}},
 'A2': -159,
 'A3': [{'D1': 18225203801860399189, 'D2': 40121},
        {'D1': 18144926590601233748, 'D2': 19529},
        {'D1': 6145472957389620002, 'D2': 9187},
        {'D1': 5895566572000872574, 'D2': 47751}],
 'A4': 5183874629016022594,
 'A5': 'vwyjn',
 'A6': [1154871481, 577579015, 1301218542],
 'A7': {'E1': 82,
        'E2': 0.025089627131819725,
        'E3': [31863, -3362, 3195, 24320]}}

Вариант №27

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

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

(b'ZOWYF\x00\x00\x00\xbeo>\xbc\xd1\xd9\x1a\x89\x07\x00\x00\x00X\x00\x00\x00(+~?'
 b'l\x00\x00\x00\xa1]s\xbfT\x10\xa7\xd8UP7\xc87\xfe\xbf\xc0/\xd4UO*\x1a\xeb{'
 b'ha_\x15\xda\xa7\xa0T`\xee\xe7\t]\x0f\x04\x00\x00\x00&\x00x\x8a\xbd\x19'
 b'\xcc3\xc9\xffkucw\xecam\x1bf\xdf\x1dD\xcf\xff\xa4gh\xed\xa0K\x19\xec\x87\x13'
 b'\x8clF?\x03\x00f\x00\x00\x00\xb6\xc4\xdf\xbd\x9d\x93u>\x14\x9a\x08\xbf,#'
 b'B\xbe\xa2\x1aX\xbf\x03')

{'A1': {'B1': [{'C1': 55463, 'C2': 20565, 'C3': -29898697},
               {'C1': 49343, 'C2': 54319, 'C3': 438980437},
               {'C1': 31723, 'C2': 24936, 'C3': -1478879905},
               {'C1': 21664, 'C2': 61024, 'C3': 257755623}],
        'B2': -15424172020888968,
        'B3': 'kucw'},
 'A2': 3158208446,
 'A3': 2300238289,
 'A4': [25068, 7021, -8346, 17437, -49, 26532, -4760],
 'A5': 0.9928460121154785,
 'A6': {'D1': 0.7750937938690186,
        'D2': [19360, -5095, 4999],
        'D3': [-0.10926191508769989,
               0.2398209124803543,
               -0.5336010456085205,
               -0.1895872950553894,
               -0.8441563844680786],
        'D4': 3},
 'A7': -0.9506474137306213,
 'A8': 4180}

(b'ZOWY6\x00\x00\x00\xda\xd5\x0e\xe2W\xb4\xccv\x02\x00\x00\x00H\x00\x00\x00'
 b'\x9e\x14\x84>R\x00\x00\x00\xa77j\xbf\x05\x89\x99\x91\x1fF\x05\xb7'
 b'\xef\x83\x8f\xaa\xb0\xfc\xd9\x1d\xe5\xd8\x02\x00\x00\x00&\x00GT\xc7w'
 b'\xc0\xa6\x84\xc8lqrw\xf7\xc6\xf7]\xf6^\x07\xff^\xe7\xa4h\x86>\x03\x00'
 b'L\x00\x00\x00\xc9\xda(\xbe\xd6\x16M>\xe9\xc9|?\xe3\x14~?\x82\xd3\x8c\xbe7')

{'A1': {'B1': [{'C1': 37273, 'C2': 17951, 'C3': -2081442043},
               {'C1': 43663, 'C2': 64688, 'C3': -656073255}],
        'B2': -3997887223624674233,
        'B3': 'lqrw'},
 'A2': 3792623066,
 'A3': 1993126999,
 'A4': [-14601, 24055],
 'A5': 0.25796979665756226,
 'A6': {'D1': 0.2625170946121216,
        'D2': [24310, -249, -6306],
        'D3': [-0.1648970991373062,
               0.20028242468833923,
               0.9874559044837952,
               0.992506206035614,
               -0.27505117654800415],
        'D4': 55},
 'A7': -0.914911687374115,
 'A8': -30459}

Вариант №28

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

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

(b'\x9bJSU\x00&\xea\xe1>4\xe3\x88{k*\xbe\x94\xf8\xd4\xc8\xdam\x99\xca'
 b'\x1a\xe2\xc4e"\x0f1bt\xbaNm)?\x8f1Cp\xfb\x00\x02\x00\x1f\x9d\x82\xbb?\xd5'
 b'(\xaaA\xee.\xec\xee\x99u\xbf\xe5\x8b_\x9e\xe1\xa0\x08\x96\xac\xd4'
 b'?\xdb\xe0\x8a6\x81M\x94\x0f\xb1\xcc\x15"\x12\x0b\x0c\\\x00!')

{'A1': {'B1': -113,
        'B2': 826503419,
        'B3': 'bt',
        'B4': [{'C1': [157, 130, 187], 'C2': 0.33060699881092037},
               {'C1': [238, 153, 117], 'C2': -0.6732633689071017},
               {'C1': [150, 172, 212], 'C2': 0.43557982752573676}],
        'B5': 1130909372584692492,
        'B6': 92,
        'B7': {'D1': -17842, 'D2': [109, 41, 63]}},
 'A2': 16924877271511628651,
 'A3': 717133048,
 'A4': -3113998978060248350,
 'A5': 3294962191,
 'A6': 49}

(b'\x9bJSU\x00&d\xe1\xfd\x1c)Y\xc17E\xd2\x81\x97g\xb0.`\xd7\x0eM\xd97\xcc'
 b'u)\xa1xj\xf7v\x80\x90\x13\xde\xe5r\x14\x96\x00\x02\x00\x1f\xd9i\xd9\xbf\xea'
 b'\xad\xa1#\xa6\x0bb\xfa\\\x91\xbf\xac\x0c.\x15jK\x80\xc2b\xc1\xbf\xe8\xd6\xff'
 b'\xeb\xe2\xce"\x9bd}\xbbg"\xfc+\x03\x00!')

{'A1': {'B1': -34,
        'B2': -445508458,
        'B3': 'xj',
        'B4': [{'C1': [217, 105, 217], 'C2': -0.8336950012456834},
               {'C1': [250, 92, 145], 'C2': -0.054780426134263926},
               {'C1': [194, 98, 193], 'C2': -0.7762450797221769}],
        'B5': 11197212817392598059,
        'B6': 3,
        'B7': {'D1': -2186, 'D2': [128, 144, 19]}},
 'A2': 7269369570947350839,
 'A3': 1171423639,
 'A4': 7471522775267429849,
 'A5': 936146217,
 'A6': 161}

Вариант №29

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

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

(b'TNA\xdaobozpai\x85\x9b\xe3\xe8\x87/\x10h\x1am\x0b1[h\x9c\xffm\ne~ '
 b"\x1c8\xdc\xc4l\xf6h\xd0[\xc4\xb2C\xf3'\x9b\x93rl\xf4\xf5\xad0\xc4\xf2"
 b'\xff\x11\x1fU\x00\x00\x00\xae\xed\x82A8\x01-\x80\x98\xe3\x1d\xab\x96'
 b'\x99\xaa|\xb2\xad\r2\xb9Z?\x00\xee#\x03\x00I\x00\x00\x00\xbc9\xef\x19\xcb'
 b'Ps\x80^\xa6\xd1e\x9d\x9a\x95*\xfcK\xc8\r')

{'A1': 'obozpai',
 'A2': [{'B1': -25723,
         'B2': 59619,
         'B3': 1745891207,
         'B4': -28032756796920550,
         'B5': 2669},
        {'B1': 32357,
         'B2': 7200,
         'B3': 1824840760,
         'B4': -917693342629730058,
         'B5': 39719}],
 'A3': 4100747923,
 'A4': 2238851907918540277,
 'A5': {'C1': {'D1': 1099099566, 'D2': [56, 1, 45, -128, -104, -29]},
        'C2': 9198,
        'C3': [2576788253, 2914155690, 1522086413],
        'C4': [435108284, -2139926325, 1708238430, 714447517, 231230460]}}

(b'TNA\xdaweogwed7\n\xbc\xc3T\x1a;;4\x9e\x0f\xbe\x8e\xdeJU\xca\xb5j\x840'
 b'\xdb&9\xb4\xc0\x8f\xa2\x17\x87\xdd@o\x12\xcf\x1e\xb1\x96\xa9t\x14r\xf7\xf6Q'
 b'\xe9\xfc\xd9Y\x00\x00\x00\xa5\xc6\x0e`\xdf\x15\xaa\xda\x1b\x1c{\xf7\x0b'
 b'\x13y\xcae\x1b\xc6\xa5\xdf\x8b\xe3\xdc!\x80?\x00\xba\x19\x04\x00I'
 b'\x00\x00\x00>\x9e\xad\xf6\xbc\x91#\x81\xaa\xb6g\xf7"f)\x84!\xaaCY')

{'A1': 'weogwed',
 'A2': [{'B1': 2615,
         'B2': 50108,
         'B3': 993729108,
         'B4': 6145969346155879988,
         'B5': 46538},
        {'B1': -31638,
         'B2': 56112,
         'B3': -1061930714,
         'B4': 1328351735296008847,
         'B5': 7887}],
 'A3': 1957271217,
 'A4': -2739057935103069676,
 'A5': {'C1': {'D1': 1611581093, 'D2': [-33, 21, -86, -38, 27, 28]},
        'C2': 6586,
        'C3': [319551355, 459655801, 2346689990, 2149702883],
        'C4': [-156393922, -2128375364, -144197974, -2077661662, 1497606689]}}

Вариант №30

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

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

(b'\xa7WSRBe\x00\x00\x00v\x00\x00\x00\x9a\xf5\xc0&\xe5=C\xc2\x18\x91\xfc'
 b'\x86\xb3\xe6\xcd(k.7\x98%\xdb?F\xc0/\x02\x00\x00\x00\x14\x00\x00\x00\xcc'
 b'\xf6\xdf;\xbf9:\x14v\x85R\xba\xba\xf9\xe5\xbf\xab\xb2,\x02\x00\x00\x00/\x00'
 b"\x00\x00v\xc7!\x9f\xe7\xc3'\xceNS{\xdc\xd12\xe4?\x93X\x19\x02\x00\x00"
 b"\x00J\x00\x00\x00\xc6\xfeW?nycoqy\xbf\x18\x003\x00N\x00\xb6'qp)\xb1"
 b'\xa6\xb9\xb5O\xe4\x00\x1a\x96;\xa8\x85\xf8\x10\xa7\x83\xe8\xb0$pr\xab\xc7o^'
 b'\xc2?\x02\xf5\xbct\x8c\xcb>v\xdd4\xbf\xc6\xbbU\xbf=\xed\xb1>')

{'A1': {'B1': 0.8437312841415405,
        'B2': 'nycoqy',
        'B3': 191,
        'B4': [{'C1': 3454448518,
                'C2': 0.42416959179688485,
                'C3': -16314,
                'C4': 47,
                'C5': [6338, -879]},
               {'C1': 339360191,
                'C2': -0.6867345465763453,
                'C3': -19797,
                'C4': 44,
                'C5': [-2356, 15327]},
               {'C1': 3458712551,
                'C2': 0.6312035852703077,
                'C3': 22675,
                'C4': 25,
                'C5': [-14474, -24799]}]},
 'A2': {'D1': 1886463926,
        'D2': [3114709289, 14962613, 2822477338],
        'D3': 2643868633407748229,
        'D4': 0.14350697755334663,
        'D5': 2,
        'D6': -17163,
        'D7': [0.397555947303772,
               -0.706504225730896,
               -0.834896445274353,
               0.3475131094455719]},
 'A3': -2662,
 'A4': 0.11189031600952148,
 'A5': 67}

(b'\xa7WSRBe\x00\x00\x00v\x00\x00\x00\x88~\xa2\x87\x93;\x8c\xd1\xbb8\xb2'
 b'\x1a\xfe\xd6\x12P\x86\xdbX\xb5.\xd8?\xb1bt\x02\x00\x00\x00\x14'
 b'\x00\x00\x00\xfc./i\xce\x9d\xe0=\xce?/\xf5\x9cF\xe3?\xf0\xd0\xf0\x02\x00'
 b'\x00\x00/\x00\x00\x00\xe0(\x15\xf4\x9b\x81~\xf8\x00\xfa\xa6\x1eaY'
 b'\x8c\xbf\xf4\xbb\x03\x02\x00\x00\x00J\x00\x00\x00\x98\x84\xe4>wfiwtg#'
 b'\x18\x003\x00N\x00\xfe6\xf3\xc0\xe4_8\x94\x96\xdc\xf1\x195n\xbf\xa7t:\xf6.WL'
 b'\x8d\xdb\x02\xf3)\xa8\xed\\\xe6\xbf\n\xf9\xc5\x99\xd6z?Z\x99\xa8'
 b'\xbe\x7f\x92@?<Z\xc4\xbe')

{'A1': {'B1': 0.44632411003112793,
        'B2': 'wfiwtg',
        'B3': 35,
        'B4': [{'C1': 316079642,
                'C2': 0.37785085370533,
                'C3': 25265,
                'C4': 116,
                'C5': [-17455, -19912]},
               {'C1': 1038130638,
                'C2': 0.6023697651635247,
                'C3': -12048,
                'C4': 240,
                'C5': [12028, 26927]},
               {'C1': 4169040283,
                'C2': -0.013842352626736165,
                'C3': -17420,
                'C4': 3,
                'C5': [10464, -3051]}]},
 'A2': {'D1': 3237164798,
        'D2': [2486722532, 435281046, 2814340661],
        'D3': -2626359070353376652,
        'D4': -0.6988437923861002,
        'D5': 10,
        'D6': -14855,
        'D7': [0.9798370003700256,
               -0.32929497957229614,
               0.7522353529930115,
               -0.38350093364715576]},
 'A3': 32392,
 'A4': 0.004502252675592899,
 'A5': -116}

Вариант №31

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

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

(b'\xf2HEE\x06\x00\x00\x00\x10\x00\x00\x00\xad\x00\x00\x00afaozt\xc0$'
 b'\x00\xe4\x88\xe3X\xe8\xa7GuA\xd1y\xa4\n8\x07\xa1k\xfeU\xd4W\xc9i'
 b'\xc8\xc9\xa1m\xd5\x00\xa0\x06\xa7\xe3\xd2.\xec\xb1{\x97\x05\x00\x00\x00'
 b'\x16\x00\x00\x00\x02\x00\x00\x00>\x00\x00\x00T\x8ce\x06~\xff\xb2\xcd'
 b"$\x04\xa8\xf3w=\xec\xecR\x08\xcd\xa1?\xe5\xf3\xf3\x0b\xfc\xd6u\x1e\x13\xe3'"
 b'w\xd1\xaa_\x11\x89\x9f\x99\xd4:\xba\x13\x8b;x\xc1\xa5\xcc\xaf\xa7'
 b'\xd4\x1c\xf7\xa9YY\x07\x00\x00\x00P\x00\x00\x00\x02\x00\x00\x00\x88\x00'
 b'\x00\x00\x89\xb1<\xbf\x9d\xecq\xf7\xb3\xbf\x85\x1f(=?\xfc[\xa2>@\x00\x00'
 b'\x00\x8a\x00\x00\x00\x80q-P\x94\xeb\xbb?\x9a\x00')

{'A1': 'afaozt',
 'A2': {'B1': [{'C1': [-1704362281879460672,
                       766871776213157799,
                       6328777927578158904,
                       60074711681886665,
                       -5626070351195208032],
                'C2': [123, -105]},
               {'C1': [-3624553833341547436,
                       -1374656200856566748,
                       -868098241692104622,
                       2874162008739478539,
                       -7377026956897103497,
                       -4505785958666716460,
                       -6199454662380237659],
                'C2': [89, 89]}],
        'B2': 0.10906340558489624,
        'B3': {'D1': -0.7370839715003967,
               'D2': 157,
               'D3': 2891176544199733740,
               'D4': 16189,
               'D5': 0.31710803508758545}}}

(b'\xf2HEE\x03\x00\x00\x00\x10\x00\x00\x00\x9a\x00\x00\x00gbmS\x19\xdd\xc8q'
 b'\x98\x9a=n"t\xcb\xa3\xd0\xd1{K\xa2\x0e\xffu\x14\xaa#[\x04m,\x9c'
 b'\x9c\xdf\xa3\xa4\xff\x04\x00\x00\x00\x13\x00\x00\x00\x02\x00\x00'
 b'\x003\x00\x00\x00^a\x13h3\x1a[\xf5w\xfbQK_\xadx#\xe6G/\x03:*\xc5\xfd\xa8vT'
 b'1\xcc\xfe\xf2\xafJ\x06\\1L\x97\xd6[\xa2\xe0p\xf6\x9b\xd7\xf9\xf2D\x91\x06'
 b'\x00\x00\x00E\x00\x00\x00\x02\x00\x00\x00u\x00\x00\x00\xff\x85\x0c>\xc5'
 b'L\xf9?\x1e$H\xbc\xb2\xb4\x93\x02D\x19?5\x00\x00\x00w\x00\x00\x00\x90i'
 b'\xf9\x18#\xa6\xc6?\x87\x00')

{'A1': 'gbm',
 'A2': {'B1': [{'C1': [4439027997195704659,
                       8922141738709295726,
                       2569889034391167563,
                       -6638415131146648485],
                'C2': [-92, -1]},
               {'C1': [-766990503444782754,
                       2555983413329918839,
                       -160675783051884570,
                       -5768268019753781592,
                       6617643055968945738,
                       -938481982475542366],
                'C2': [68, -111]}],
        'B2': 0.1769451019234336,
        'B3': {'D1': 0.13722990453243256,
               'D2': 197,
               'D3': -5567495719373244084,
               'D4': 37812,
               'D5': 0.5986939668655396}}}

Вариант №32

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

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

(b'JKY\xbf\xd9\xc0D;\xdel\xe4\xbf\xc2dlIh\x06 \x00\x00\x00\x03\x00r\x00\x00\x00'
 b'\x80\x00\x00\x00\x8fV\xaf\xfeM\x9f\xf4\xa0\x86\xb7\x07x\xf8\x81\xf9\x9a'
 b'P\xb4\xbf\xac\x16\xa7\x012\xb6\xbe\x18RI\x02\xfe\x0e\xf8{\x84\xac'
 b"\xe2\x19u\x92\xb9'\x17\x9fXi\x11\xa5\x08\xcd\xe3\xad\xb6\x07L\xf6"
 b"\xec\x99\x08?#ad?\x0f'l\xe0\xcd\xd0Q\x82UN\x916\x0b\x18\xa4!\xf3}\x00c"
 b'\x00h\x00m\xaf\x83\xf5S\x1e\x1d\xb8\xf6\x00\x00\x00\x02\x00xx\xd7'
 b'\x97\xa9\xf1\x80=\xb87\xde\xea\x8c>\xb4!\xbd\x00\xc9\x96\r4\xee\x06\xe5b\xab')

{'A1': -0.40236001822058953,
 'A2': {'B1': {'C1': -0.14368966659826388,
               'C2': [{'D1': -32, 'D2': 3452981634},
                      {'D1': 85, 'D2': 1318139403},
                      {'D1': 24, 'D2': 2753688445}],
               'C3': {'E1': [2944660819, 505264374],
                      'E2': 120,
                      'E3': 15535072294341556279}},
        'B2': {'F1': 3739913278,
               'F2': [46113, 48384, 51606, 3380, 60934, 58722],
               'F3': -85},
        'B3': 86,
        'B4': [-5765085123588356425,
               538453392592883892,
               -4635305009935632706,
               1752543482201700475,
               -8886479365734221529,
               1702176392460175565,
               -2040774913656689511]},
 'A3': 8,
 'A4': [0.63820481300354, 0.5591952800750732]}

(b'JKY?\xeb7J\xe1\x0fi\x98?\xee(\xceQm\x9e\xf2\x00\x00\x00\x02\x00m\x00\x00\x00'
 b'y\x00\x00\x00\x88\x9f\xf4\x8fw,h\xa1N)\xc1\xb7\x11lh\xd6\xb4\x83\xa7\x01'
 b'y\xec|\x91\n\xb5\xa6\xce\xf4\x9eJ0\xdbk\x98\x96\xdd\x03\x811\x11\x10\xb6\xc9'
 b'\x80z\xbe\x9c\xa5\xf8AQ[_\xef!]\xe0\xfd?=\n\x83\xbfd\x95B\x05v\xc0l\x8a'
 b"\xba'\xe4\x02\xf9\x00c\x00hD\x1e\x0e\xbb\x10\x7f]P\x00\x00\x00\x02\x00q\xf6"
 b'FA\xe9\xb2|\x82\xc7\x138\x9cH\xee\xc7%\r\x9fxo\xbc,*\x8a\xe8\x15\xb2')

{'A1': 0.8504995723445061,
 'A2': {'B1': {'C1': 0.9424811926264438,
               'C2': [{'D1': 5, 'D2': 1992322186},
                      {'D1': -70, 'D2': 669254393}],
               'C3': {'E1': [1142820539, 276782416],
                      'E2': 246,
                      'E3': 5062584408943544083}},
        'B2': {'F1': 949766382,
               'F2': [50981, 3487, 30831, 48172, 10890, 59413],
               'F3': -78},
        'B3': 159,
        'B4': [-824309174167843287,
               -4488099346338368381,
               -6412710337789752651,
               -6426930657524393109,
               -7451525526315790064,
               -5275544223815522824,
               4706643553170841056]},
 'A3': -3,
 'A4': [0.7384416460990906, -0.8929024934768677]}

Вариант №33

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

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

(b'VUKV2)\x8e\xa5\xda\x94\x8c\xe0P\xc47\xd2\xa6\xd4+H\x19\xf3\xc3\xc6\\\x11$w'
 b'\xaf\x0b\x02\x00\x00\x00(\x00\x00\x00B\x00\xdccpn\x85\xad\xfb\xaf\x00x%\xd2'
 b'\xe6\xafnsb\xc2Y\xa8\x17W\xdd\xfb=V\xce2yyI\x18<\xac\xc9\xa4\x00\xed\x89\xd0'
 b'A\xde\x9d\xfc\xbb\x91\x07r{H?\xa5Yd\xf1(3C\xe3\x88\x00\x8bN\x14'
 b'\x86\xad\xb2\xbe\xe25@1\xdcE\xb6X\x16\x9cC\x1c\xd2\xb2\xe4')

{'A1': 5827812488768753193,
 'A2': -60,
 'A3': 17517111578722751031,
 'A4': 842022652135392963,
 'A5': [{'B1': -36, 'B2': 'cpn', 'B3': -123, 'B4': -1814346502539052115},
        {'B1': -81, 'B2': 'nsb', 'B3': -62, 'B4': 6214399988908664921}],
 'A6': {'C1': -50,
        'C2': {'D1': [31026, 18809, 15384, -13908, 164, -30227, 16848],
               'D2': -0.007709248922765255,
               'D3': 1937,
               'D4': 0.7831336259841919,
               'D5': -91,
               'D6': 9863801495880819801,
               'D7': [340691712, -1095586426]},
        'C3': 826291682,
        'C4': 2036643076293150172,
        'C5': 45778,
        'C6': -28}}

(b'VUKV2^[\xb43\x19\xfcRK\x1f\xaf\xff\xac\xca}$\xd5\x86\xdd\x9b\xe4\x11Y\x02'
 b'\x1f\x87\x02\x00\x00\x00(\x00\x00\x00B\x00\x17rix\x86\xb7\xf4\xc86R\xc2\x12'
 b'O\xabbgc\x8e)\xb66\xc0@\x9cc\x97\xcf\xac\xa1Nt\x0e[\xdc\xba\xb6T\xeb\xbe\xd4'
 b'\xe6\x7f\xf7\x99\xbe/\xc3\xdd\xc4x?FW\x1c\xff|9\xa6\xbe9S\x9c\xd7%\x99\xfb4y'
 b'\xbd\x0c\x948\x9d?3\xe7\xddJ\x8f\x11\x03|\x88')

{'A1': 5427677686106708830,
 'A2': 31,
 'A3': 9715711893811560367,
 'A4': -8710240572735710243,
 'A5': [{'B1': 23, 'B2': 'rix', 'B3': -122, 'B4': 5697830136939345079},
        {'B1': -85, 'B2': 'bgc', 'B3': -114, 'B4': -7538009549371427287}],
 'A6': {'C1': -49,
        'C2': {'D1': [-24148, 29774, 23310, -17700, 21686, -16661, -6444],
               'D2': -0.300716370344162,
               'D3': -15569,
               'D4': 0.9717538952827454,
               'D5': 70,
               'D6': 4160945871577357399,
               'D7': [634887251, 2033515417]},
        'C3': 949226685,
        'C4': 1265312337241522077,
        'C5': 31747,
        'C6': -120}}

Вариант №34

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

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

(b'LXNDT\x04\x00a\x00\x00\x00\xae\x1e\xf8(\xb2\x7f\xa8\xab\x03\x00q\x00\x00'
 b'\x00\x8c\x00\x00\x00\x98\x00\x00\x00XH9\xbd\x02\x00\x00\x00\xa4\x00\x00'
 b'\x00\xdbK\x00?\x8c\x89\x04!\x11\xaf]\xefQ??Q\xecI5\xc2>\xe5\x83\x8c\xf1E\xa6'
 b'\xc8_\x12^Z\xd03\xda\xd8\xb0\x003\xe6\x9aa=\x12\xa1\xe3{a\xb9++\xfa1\x00\x00'
 b'\x00=\x00\x00\x00I\x00\x00\x00U\x00\x00\x00T\x90D\xfff\x06\xb7\x0fNPrJ!M\x8f'
 b'\x84\xd9\xe3Kb\x9f.r\x88~@\xd4xO\xb4\xb3W\xde\x96\xf5\x0b_`\xbf\xfeO<Q'
 b'\xdc\xb6\xe8\xaf\x18\x9dD={]')

{'A1': [{'B1': 35212, 'B2': 2937135364, 'B3': 1062334301, 'B4': 20799},
        {'B1': 18924, 'B2': 3846095413, 'B3': 1173458051, 'B4': 51366},
        {'B1': 4703, 'B2': 869292638, 'B3': 11589850, 'B4': 58931},
        {'B1': 24986, 'B2': 3818983997, 'B3': 733569403, 'B4': 64043}],
 'A2': 12369276779741322926,
 'A3': [{'C1': 1132380870746083412, 'C2': 78},
        {'C1': -2772933909119602096, 'C2': -29},
        {'C1': 4647301889482777163, 'C2': -44}],
 'A4': [{'D1': 17696576254057402232, 'D2': -0.87645024061203},
        {'D1': 12675582208606228478, 'D2': 0.048001378774642944}],
 'A5': -0.045235008001327515,
 'A6': [123, 93],
 'A7': 0.5011574625968933}

(b'LXNDT\x02\x00I\x00\x00\x00"\x07\xac-6\xd8\xab\xfe\x04\x00Q\x00\x00'
 b'\x00u\x00\x00\x00\x81\x00\x00\x00T\xb9\n>\x02\x00\x00\x00\x8d\x00\x00\x00[_.'
 b'\xbc\xa8\xed\xb4\xdd\xd5\x03Oz#\x1c\x1b\xa1\xe3I-@-\t\xb9\xae\xb6+G'
 b'\x151\x00\x00\x00=\x00\x00\x00\x1c<\xf8l4h\xa6o\xc0c\xae\xdd\xba\xa1\xd2'
 b'L\xe9j\xbeN\xd6\x1b\x1c\xd7F\x80)\xcc\xe9\xf9\xba\xf8\xc0\x82\xfe\xaf\x12UH'
 b'H\x97P!g\xa4\x07\x18?\x0b\xd4\x1cZ\x9d~\xff\xaa\xea\x8e\xd5\xbe\x88\x94')

{'A1': [{'B1': 60840, 'B2': 64347572, 'B3': 472087119, 'B4': 41243},
        {'B1': 18915, 'B2': 153960493, 'B3': 733392569, 'B4': 5447}],
 'A2': 18350998833857300258,
 'A3': [{'C1': 8045232358719765532, 'C2': -64},
        {'C1': -1635700972575674781, 'C2': 106},
        {'C1': -9203432272758944066, 'C2': 41},
        {'C1': -107311266582107700, 'C2': -81}],
 'A4': [{'D1': 7431309470821012754, 'D2': 0.5938665866851807},
        {'D1': 12321706319795770379, 'D2': -0.4171059727668762}],
 'A5': 0.1354725956916809,
 'A6': [-120, -108],
 'A7': -0.010642851702868938}

Вариант №35

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

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

(b'EBV\x00\x02\x00\x00\x00hM\x03w8\x00\x02\x00\x00\x00j5Bm^\x00\x03\x00\x00\x00'
 b"lG\xa2G\xb6\x00\x02\x00\x00\x00o\xbd[;\x15\x00\x04\x00\x00\x00q'\x9e\xf1"
 b'q\xb6\x8b\x05\x92Z_\xebY\xdd@\x14\xfe\x9e:[\xce\xbd?\xba\x00\x00\x00}?0.\xfa'
 b'\xbe\xfe\xfa^?\\\xb2\xb4\xbd\x1a\xad\xb9\xbf\x06\x9c\xeb=\xfe\xccN>\xd8\xd13'
 b'seisaihrphsrt\xff\x8e\x98\xa5\xf1\xcd\xf7\xffR\r\x00\x02\x00u\xb6\xa01?\xd6'
 b'O\x95\x1a\xfbM\x14\x182\x19\xd1\xe0\x0f\nv\x9d\xdf')

{'A1': [{'B1': 'se', 'B2': 1292072760},
        {'B1': 'is', 'B2': 893545822},
        {'B1': 'aih', 'B2': 1201817526},
        {'B1': 'rp', 'B2': 3176872725},
        {'B1': 'hsrt', 'B2': 664727921}],
 'A2': 182,
 'A3': 2332398170,
 'A4': 1609259485,
 'A5': 4617595473498984125,
 'A6': {'C1': 16314,
        'C2': {'D1': 21005,
               'D2': [-7432027, -238159873],
               'D3': -74,
               'D4': -24527,
               'D5': 0.3486073268406511,
               'D6': 1743484394943744630,
               'D7': [157, 223]}},
 'A7': [0.6882168054580688,
        -0.49800390005111694,
        0.8621017932891846,
        -0.0377633310854435,
        -0.5258318781852722,
        0.12441311776638031,
        0.423471063375473]}

(b'EBV\x00\x03\x00\x00\x00h{V\nJ\x00\x04\x00\x00\x00k\xd3\xc8\x06\xbc\x00'
 b'\x04\x00\x00\x00o\x10\xe0f\xcf\x00\x03\x00\x00\x00s\xc3\xa2U\xcd\x00'
 b'\x02\x00\x00\x00vxO\x83\xb6\x99\x15\x14W\xf7\x1c\xf5\xe2\xcb\x00\xcb'
 b'\xf8c\xa3\xf6\xdc\xc2\xc1q\x00\x00\x00\x80\xbf.\x82\xc4\xbe\xbfW\x16'
 b'\xbfHe\x13\xbed^\x11?yk\xb5>\xebF\xdb=\xd0\x0b&bpjllgxlptqvcurp'
 b'\xee\x06\xf4\xfa\nF\xff\x16=\xe1\x00\x02\x00x\xab\xc0\x07\xbf\xe6N'
 b'\xac\xfa\x1cH\xca\xc3\xde\xc5\xd9\xfb \xe6D\xf4\x1a')

{'A1': [{'B1': 'bpj', 'B2': 2069236298},
        {'B1': 'llgx', 'B2': 3553101500},
        {'B1': 'lptq', 'B2': 283141839},
        {'B1': 'vcu', 'B2': 3282195917},
        {'B1': 'rp', 'B2': 2018476982}],
 'A2': 153,
 'A3': 353654775,
 'A4': 485876427,
 'A5': 57412527108578498,
 'A6': {'C1': -16015,
        'C2': {'D1': 15841,
               'D2': [-301533958, 172424982],
               'D3': -85,
               'D4': -16377,
               'D5': -0.6971039662332938,
               'D6': -4332808251472026044,
               'D7': [244, 26]}},
 'A7': [-0.681682825088501,
        -0.3737112879753113,
        -0.7827922701835632,
        -0.22301508486270905,
        0.9742997288703918,
        0.4595249593257904,
        0.10158376395702362]}

Вариант №36

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

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

(b'RWT\x00\x00\x00\x02\x00\x00\x00)\x00\x00\x008dvspwn\xbf\xe2\xd1\xd9HZm'
 b'\xc2\x00\x03\x00W\xe5\xd9r3\x00\x00\x00]Nx!\x93\xc8\xe9\x98rJ\xbenhori'
 b'L\xec\x81\x82\xb2\xa1\x8e\xebW\x86\x8f$\x00\x00\x00\x05\x003C\xd7(\xd4H1'
 b'C\xfb\xcf\xeck7\xbc\xa0\xf1\xc18\x1b\x1e\xff\xe4\xf7`\x9a\xb1\x1d$\xf4\xd1+'
 b'0.\xbf\xc8:>x>\x95_s0\x89?\x13j\x1f\xdd\x13\xbc_\xba\xdc\xc4\x83')

{'A1': [{'B1': 20088, 'B2': 8595, 'B3': -56},
        {'B1': 59800, 'B2': 29258, 'B3': -66}],
 'A2': {'C1': 5542947639728901867,
        'C2': 1468436260,
        'C3': 'nhori',
        'C4': 1138174164,
        'C5': 5202013793393863479,
        'C6': 188},
 'A3': 'dvspwn',
 'A4': -0.5881163037442365,
 'A5': [-24335, -16072, 6942],
 'A6': -438734285,
 'A7': {'D1': 18439134768645872932,
        'D2': 62673,
        'D3': 3112038743745904248,
        'D4': 0.29174384474754333,
        'D5': 12425,
        'D6': 0.575838029384613,
        'D7': [3709058143, 3135030403]}}

(b'RWT\x00\x00\x00\x02\x00\x00\x00)\x00\x00\x007ruzfve\xbf\xe1mnb<W'
 b'v\x00\x03\x00V\xf0\xa3\xd1O\x00\x00\x00\\\xf8\xaf\xd2\\P\x15\xf4+\xd6\x8ds'
 b"mwt_'F\xc6\x1b2\x13I\x92Y\x12\x88\x00\x00\x00\x04\x003b\xae\xe9&\xa5\x9e\x9b"
 b'\xde\x1b\xd2\x1e\xd0{\x01z\x0b\xe5R\xeer\x15\xcb\x198\xc6\x9ac\x90,k('
 b'\xcc\xcf\xcd\\\xb1\xe7\xbe\xaa\x1b\xe1\xbeN\xbf/\xfa\xf4I\xf8\xc5\xc3'
 b'J\x05\xae\x8f')

{'A1': [{'B1': 63663, 'B2': 53852, 'B3': 80},
        {'B1': 5620, 'B2': 11222, 'B3': -115}],
 'A2': {'C1': 6856526774368605001,
        'C2': 2455310984,
        'C3': 'smwt',
        'C4': 1655630118,
        'C5': -6512596632879358256,
        'C6': 123},
 'A3': 'ruzfve',
 'A4': -0.5446082991281702,
 'A5': [378, 3045, 21230],
 'A6': -257699505,
 'A7': {'D1': 8220700004021869155,
        'D2': 36908,
        'D3': 7721646754002416103,
        'D4': -0.332243949174881,
        'D5': -16818,
        'D6': -0.6874229907989502,
        'D7': [1241040323, 1241886351]}}

Вариант №37

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

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

(b'ICHR5J~\t\xa1\x0e\xf0\x00\xe0\xdc\xce\xf8\x1c9L\n)T\x00\x02\x00t\x00\xa1'
 b'i\x1e\xfaWl|\xe3\x90w\x81i\x05\x00\x94\x00\xda\x93_-\xa9\xd3\x9d\xdc\x02'
 b'\x00\x00\x00\x9e\x00^\x1co\xbeu\xd4|z\x8b\x03xQ\x88R\xb4\t\xa3}y'
 b'\xcb\x0e\x89\xbbMHe\xd0\x1bem\xb2\xfe\xa0\x9frkKj\x0b\xb8Vs\xdc7f\x10\x14'
 b':P\xb5\x90-N\xda\xbc\xf7\xfdT\xb4\xc2\xb0\x91\xfc\xde\xbbxW\xc0\xb0U\xe0'
 b'\x10\xad\xbb\xbf\x91\xc6\x92\x91;\xdbQ\x1el\x87\r\xc0\xd9v\xd5?s\x85\x8f\x8a'
 b'X\x11\x19V\x9b\x85m3\xe6\x19T3\x1d\x17')

{'A1': {'B1': 16141165010117819978,
        'B2': 486067932,
        'B3': 688540729,
        'B4': {'C1': 2993513755,
               'C2': 822552806805184766,
               'C3': 3698546360,
               'C4': 336619063,
               'C5': 13608275181661671482,
               'C6': 3025468919},
        'B5': {'D1': [{'E1': [194, 176, 145, 252, 222, 187, 120, 87],
                       'E2': -0.10810952641412808},
                      {'E1': [145, 198, 146, 145, 59, 219, 81, 30],
                       'E2': 0.33537906413231755}],
               'D2': [161, 105, 30, 250, 87, 108, 124, 227],
               'D3': {'F1': 1770092432,
                      'F2': [-31373, -30065, 4440, 22041, -31333]},
               'D4': -2549649090457660454,
               'D5': [434516845, 387789652],
               'D6': -0.23350664973258972,
               'D7': 2055001205,
               'D8': 699274587585119115},
        'B6': -93,
        'B7': 31101},
 'A2': 15016488031232790219}

(b'ICHR5O\xdb\xd4\x15\xe7%\x15%\x0f\x96)\xe2_\x06?\x8fT\x00\x02\x00t\x000'
 b'\x9b&\x9d\xbb\xa7\xf4\x82\xb5\xfe\xa6\xa0\x05\x00\x94\x00u}\x19\xd8\xd8'
 b'e\xc9]\x04\x00\x00\x00\x9e\x00\xd30\xad>Q\xfa\x1e\x9a\xd0t\xb05\x93\xe7C'
 b"i\x86\xeb\xf3\xc4<y\xa8<\xe2#\xfe\xcf\xde\x03e@Vr>9c'jf\xc5{\x8d\x8b\x06`H"
 b'\x86\x90q\xac\xf0\x1e\x08V]\x15\x16\xe2\x04/\xc4\xceOj\xeb\x93|p$\x94'
 b'!\x88\xec\xbfl\\\xc0%\xb6b\x02 \xe4\xe5\xf5q\x80\x1c\xd6?c\xad\xf8"=\xd4Hh'
 b'\xf34\x0c\xce\xa7 \xfdH\xa8@\xf2\x06%\xa18X\x08\xa6')

{'A1': {'B1': 2672083628348201807,
        'B2': -500591089,
        'B3': -1891695009,
        'B4': {'C1': 1694752463,
               'C2': 7649191589624043072,
               'C3': 2373698918,
               'C4': 1214252683,
               'C5': 6199238906109595782,
               'C6': 3793098077},
        'B5': {'D1': [{'E1': [4, 47, 196, 206, 79, 106, 235, 147],
                       'E2': -0.8916175740628343},
                      {'E1': [108, 92, 192, 37, 182, 98, 2, 32],
                       'E2': 0.3454896080871477}],
               'D2': [48, 155, 38, 157, 187, 167, 244, 130],
               'D3': {'F1': 2695298741,
                      'F2': [-21149, 8952, -11203, 26696, 13555]},
               'D4': 6758044697859030389,
               'D5': [547868172, 1084770557, 2703558386, 2785564728],
               'D6': 0.3382631242275238,
               'D7': 2585721425,
               'D8': 7585160816869012688},
        'B6': -122,
        'B7': -3093},
 'A2': 18312729259971001540}

Вариант №38

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

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

(b'NAHL/\xf3^*?\x8a\x1a\x0bF\x93\x00\xf3\xbd4m\x03\xf2a\xbf\x0f:\xec+\xc7'
 b'>\xa6\xe8\xb4\xbe\xc2\x1d\x1d>\xd3\xf3\xe7>\x0f \x17?AD\xc9>_\xa3n>_\x15K'
 b'\x90\xba\xa1\xeeV\x05\x00\x00\x00\x1d\x00\x9f\x82\xf9\x1e\x8ckZ\xb1\xa4'
 b'n\x0fJ\xe7\xe8\xfc@\xbf\xa7\xab\xc7>:\xc0`\xbfn\xb1\x81\xbeb\xea\xb3\xbe'
 b"o:f\xbe\xd4=b\xbfE\xf8X\xbf\xe3\x9b\xe5\xbe_\x95'm\xa2\xbe\x9bE"
 b'\x08\x00\x00\x00P\x00\xae\xf7\x8c\xfcC\xef\x9b\xbaY<\x94\x1eh\x97*9\xc81'
 b'\x00\x00\x00p\x00\x00\x00\xb5\x8e\x17\xbc\t\xbf\x02\x00\x8f\x00l')

{'A1': 47,
 'A2': 0.6655113101005554,
 'A3': 1175132810,
 'A4': {'B1': [{'C1': 0.2330450862646103,
                'C2': {'D1': -1874127521,
                       'D2': 1458479546,
                       'D3': [-0.35333746671676636,
                              0.15343382954597473,
                              0.45303210616111755,
                              0.5903329253196716,
                              0.3930988609790802]},
                'C3': 519668383,
                'C4': 140,
                'C5': [23147, 42161],
                'C6': 110,
                'C7': 18959,
                'C8': -25},
               {'C1': -0.44845494627952576,
                'C2': {'D1': 1831310687,
                       'D2': 1167834786,
                       'D3': [-0.7538590431213379,
                              0.3899814784526825,
                              -0.877933144569397,
                              -0.2533068060874939,
                              -0.3513975739479065,
                              -0.22483228147029877,
                              -0.8837559223175049,
                              -0.8475382924079895]},
                'C3': -57870418,
                'C4': 67,
                'C5': [39919, 22970],
                'C6': 60,
                'C7': 7828,
                'C8': 104}],
        'B2': -29003,
        'B3': -0.5380262732505798,
        'B4': [10903, -14279],
        'B5': 108},
 'A5': 1832173043,
 'A6': -0.8825990557670593,
 'A7': 14863,
 'A8': 0.38900697231292725}

(b'NAHL\x80\x08\xbe\x12>g\x81SF\x91\x00\xc0\xda8\xffX\xb4H\xbf^\x03\x9b\xcf\x0c'
 b"\xbfw\xb6\xad\xbdy\x94'?\x12\x0eJ\xbf\x00\xff\xd6\xbe5\xac\x9e\xbe\xdf.@"
 b"\xbe}\xd6U?\xe7\x00\x1f?\xc5\x9aG?^X f'\n-A\x08\x00\x00\x00\x1d\x00\xb7"
 b"-P\x1d\x02\xec'f\xf7\xc1\xb1\x136\x8aZB?\xbcVx\xbd\xaaT:>z>e?\x86\xbe7?"
 b's\xa7\x8dU;\xe0\xe2\x93\x04\x00\x00\x00\\\x00\x0cw\x03&f\x1a\xfe%Q\xde'
 b'Z\xb0V\x1b\xf7\xa0"\x80 =\x00\x00\x00l\x00\x00\x000\xe3\xed\xa9J\xbf\x03'
 b'\x00\x8b\x00\x8c')

{'A1': -128,
 'A2': 0.1433030366897583,
 'A3': 1179877735,
 'A4': {'B1': [{'C1': 0.7797053456306458,
                'C2': {'D1': 1713395806,
                       'D2': 1093470759,
                       'D3': [-0.08482068032026291,
                              0.6546092629432678,
                              -0.789277195930481,
                              -0.41991424560546875,
                              -0.30990758538246155,
                              -0.18767879903316498,
                              0.8353040814399719,
                              0.6211075186729431]},
                'C3': 491793847,
                'C4': 2,
                'C5': [10220, 63334],
                'C6': 193,
                'C7': 5041,
                'C8': 54},
               {'C1': 0.7177509069442749,
                'C2': {'D1': 1435346803,
                       'D2': 2481119291,
                       'D3': [0.759194016456604,
                              -0.06062959134578705,
                              0.18196359276771545,
                              0.8954845666885376]},
                'C3': 637761292,
                'C4': 102,
                'C5': [65050, 20773],
                'C6': 222,
                'C7': 45146,
                'C8': 86}],
        'B2': -7376,
        'B3': -0.7916553616523743,
        'B4': [-2277, 8864, 8320],
        'B5': 140},
 'A5': 4281916096,
 'A6': -0.7840018272399902,
 'A7': 862,
 'A8': -0.5500428080558777}

Вариант №39

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

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

(b'AVTDK\xca\xd4p\xb8\x17\x0c\xe1\x9f\xb6\x96\x15v\xefG\x05\xf9\x0e2\xf3A\x9e(z'
 b'7\xa7\xdc\xbfN:\xce\x00\x00\x00\\\x00\x00\x00h\x00\x00\x00t\x00'
 b'\x00\x00\x03\x00\x80\x16\x9a\x14cQ\xa3*\x8e\xd2\x8b\xea\x84\x00\x00\x00'
 b'\x02\x00\x00\x00\x83f\x8c\x06\xa8\xc3\x14#h\x00\x00\x00\x85\x0fB,'
 b'\xf9\xc2\xc9\xbf\xafz\xban8r\x99f\xdf\xe2\xbc\xb5\x19\xc6\x9d\x1fk\x87\xa7L'
 b'4\x0b"\xd9\x06\xd51\xddw:\x9c\xc2\x99/\xee\x1e\x82\xf2\x978x<\x97\xc5'
 b'\xb9\xf2V\xc8\x07\x11<\xef\xa0*\x19c\xce4\x82\x91\xa1\x9f4a\x8c\x127>'
 b' \xb4\x9f\xa5i4L\x8b8-\x85Xe\x8e\x1e')

{'A1': -13612,
 'A2': {'B1': 8122267272055076502,
        'B2': {'C1': 1546686610370268722,
               'C2': -918278952320522276,
               'C3': -0.8055847883224487,
               'C4': [{'D1': -5802120187357259418, 'D2': 57314, 'D3': 48309},
                      {'D1': 1857344654610507596, 'D2': 13323, 'D3': 8921},
                      {'D1': 492354561524800706, 'D2': 39215, 'D3': 60958}],
               'C5': {'E1': [-126, -14, -105],
                      'E2': 1628636632051821198,
                      'E3': 3532384900,
                      'E4': [56, 120],
                      'E5': 1720452776,
                      'E6': -1022090392},
               'C6': {'F1': 0.018526898697018623,
                      'F2': 242,
                      'F3': 1455949585,
                      'F4': [1022337066,
                             425971252,
                             -2104385121,
                             878808082,
                             926818484,
                             -1616549580,
                             1284192301],
                      'F5': 2237162894,
                      'F6': 30},
               'C7': [15, 66, 44, 249, 194, 201, 191]}}}

(b'AVTDK]\x1dh\x94,nX\x0b\xd4v\x83G\xee/\x8a\x11\x17;A7\xa6d\x90w\x941\xbe'
 b'O0E\x00\x00\x00\\\x00\x00\x00h\x00\x00\x00t\x00\x00\x00\x03\x00'
 b'\x80\xf6\xb7\xa4\x99\xd1\xb8 -\xc04\x896\x00\x00\x00\x02\x00\x00\x00\x83E$E'
 b'\x04\xe5N\x84\x88\x00\x00\x00\x85d_\xbb\xb8\xfa"Gy\xce\xb1p\xd4\x80\xd0\xb9'
 b'\xc2\x9e\x7f\x85\xb97\xdc\x15\x99D\x16[>X\x18\x86@\x92\x91^\xc4L\xca\xaa'
 b'\x92\xe5\xdd\x9e\xfej\x18\x9d\r\xbfS\x1ao\xcf\xe1\xfa\x9f\xae\xac\x8e'
 b'\xdf\x1a\xcf\x93\xca\xe3\xcd\x95$\xd8\xbc\x0c\xed1\xc2\xf8\x99\xe2\xf4t'
 b'\x04\xf8\x11\xa1\r\xe7E\xa4U4X')

{'A1': 23837,
 'A2': {'B1': 7535696928932877430,
        'B2': {'C1': -8986952643447285957,
               'C2': 4699407687035098161,
               'C3': -0.20233257114887238,
               'C4': [{'D1': 8777147821951340729, 'D2': 49822, 'D3': 32645},
                      {'D1': -5100366067649997221, 'D2': 15960, 'D3': 6278},
                      {'D1': 4652941201233463978, 'D2': 37605, 'D3': 56734}],
               'C5': {'E1': [-2, 106, 24],
                      'E2': -668885039085772755,
                      'E3': 3224668470,
                      'E4': [-99, 13],
                      'E5': 1160004868,
                      'E6': -447839096},
               'C6': {'F1': -0.8246220946311951,
                      'F2': 207,
                      'F3': 3791298478,
                      'F4': [-1399922918,
                             -812397853,
                             -845863720,
                             -1140003535,
                             -1023895070,
                             -193723144,
                             295767527],
                      'F5': 1168397620,
                      'F6': 88},
               'C7': [100, 95, 187, 184, 250, 34, 71]}}}

Вариант №40

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

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

(b'HIH\x85\xca\xe8N*\xe8\xc6\xdcf\x00\x00\x00S\x00s\x00\x00\x00\x8b\xbf\x13'
 b"'#\xbf\xcd(,\xf3\x93\xeaX\xc7\x1dj\x02Y\xe8\x0b\xd0\x91\x90\xf4\\\x90\x00"
 b'\x02\x00\x00\x00\x90\x01!\x04\xc7f\xfc\xdaCV?x\xd8\xbfQ~\xb9`\xdf\xc1'
 b'7\x05X\xdb\xe3?\n\xe2\xe1vh>\xb2\x9d4U\xe2\x009\x00E\xec\x97\x88'
 b'B\x00\x02\x00\x00\x00Q\xd3Y\xc9\x18\xbe\xb2\x1c@\xbe\xd7\x18P\xca'
 b'\x99\xe1\xbf\xa0\xad\x18\xd9\x00\x00\x00\x02\x00k>3\xf9U\x08\x9d\xb7'
 b'MO\xd5\xbf;k,\x05\x7fCN\x93')

{'A1': -3825721937250296730,
 'A2': {'B1': {'C1': 0.3488556146621704,
               'C2': 85,
               'C3': -30,
               'C4': [{'D1': 7421046268744399064, 'D2': -0.8183398842811584},
                      {'D1': 6980510389504629731, 'D2': 0.5425243973731995}],
               'C5': -325613502,
               'C6': [118, 104],
               'C7': -749090536},
        'B2': {'E1': 14598947880248875225,
               'E2': [-0.3478717803955078, -0.420107364654541],
               'E3': 0.1757558137178421,
               'E4': 144553805,
               'E5': 20437},
        'B3': {'F1': -0.7321040630340576, 'F2': 5},
        'B4': -0.5748159289360046},
 'A3': -0.2277885617584896,
 'A4': -954373630,
 'A5': 6478441054395757660,
 'A6': -112,
 'A7': [32579, 20115],
 'A8': 18941127}

(b'HIH\x85\x05\xd8\xa7<\xca\xaa\x87\xb5\x00\x00\x00U\x00u\x00\x00\x00\x8d\xbfL'
 b'\x8c\xab?\xe0\xe5\x14]\x1e\xc6\xfa\xa7y\xfe\xd8\xc7*/\x97a\t\x1a2@\x00'
 b"\x02\x00\x00\x00\x92\xdd\xde\x0f\x16\xe2\xd1|\xe1\xb5\xe1\x0f'\xbf\x17\xa0"
 b'\x95\x9b\x00\x847w\xdb\x10\x08>-\xc9\xfe\x1d\xb1s?\xbe\x13n\x1d\x1e\x82\x00'
 b'9\x00Eo\xf4l\x19\x00\x04\x00\x00\x00Q\x9b\x9e1\x1d\xbe\x9a\x9e\x17\xbe#\x81'
 b'J\xe8<\xafI\xd25\x89z\x00\x00\x00\x02\x00m>\xf0\x8cq,p,\xe5U6\xbe\xb7\xb2'
 b'\xf2_H\x80\x8eh')

{'A1': 421270444699191221,
 'A2': {'B1': {'C1': -0.14397473633289337,
               'C2': 30,
               'C3': -126,
               'C4': [{'D1': -2102762242144399577, 'D2': -0.5922940373420715},
                      {'D1': -7277671624061808632, 'D2': 0.16971585154533386}],
               'C5': 1878289433,
               'C6': [29, -79, 115, 63],
               'C7': -1684131555},
        'B2': {'E1': 16734443046996117882,
               'E2': [-0.3019873797893524, -0.15967288613319397],
               'E3': 0.4698214828968048,
               'E4': 745549029,
               'E5': 21814},
        'B3': {'F1': -0.3587871193885803, 'F2': 95},
        'B4': -0.7990214228630066},
 'A3': 0.5279638117555969,
 'A4': -1485177128,
 'A5': 14351335489784060466,
 'A6': 64,
 'A7': [18560, 36456],
 'A8': 3722317590}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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