ИКБО-22-22

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

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

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

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

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

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

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

(b'QKZR\x07\x00\x00\x00O\x00\x00\x00V\x00\x00\x00_\x00\x00\x00h\x00\x00\x00'
 b'q\x00\x00\x00z\x00\x00\x00\x83\x00\x00\x00\x8c\x00\x00\x00\x95\x00\x00\x00'
 b'f,)\x80\xd0\xeeD3\xc0\x0b\xbc?p~\xd8x\xb6;\xaf\xbd\xb0_\x9e\x00'
 b'\x05\x00\x00\x00\xa5\x00\x00\x006:\xafckejqxb\xea\x9d\x81\x8do;\xed?\x7f\x10'
 b'\xdd+\x08\xfdT\xbf\xbf\xdcZ\x95\x9c\xfe\x06\t\xef?e\xaeb\x1a/\xb6\xbc\xea'
 b'?\xa6\x80\xc5w\x1a\xd0\\\xef?\x93\xf0\xd5\x89\xaa\x8bq\xb5?\xba'
 b'\x10\x15\xea\x08\x96=\xc6\xbf\x15j\xafI\xbd\xa1\xa8\xe0\xbfv\x10\x8e\x0cLdf'
 b'X\xd5\xf8\xe0n\xa5')

{'A1': 'ckejqxb',
 'A2': [{'B1': 0.9135053409381133, 'B2': 127},
        {'B1': -0.12239057015891697, 'B2': -36},
        {'B1': 0.9698519680866113, 'B2': 101},
        {'B1': 0.8355360908490945, 'B2': -90},
        {'B1': 0.9800797001791324, 'B2': -109},
        {'B1': 0.08376381791625653, 'B2': -70},
        {'B1': -0.1737544578101411, 'B2': 21},
        {'B1': -0.5205849358585344, 'B2': 118}],
 'A3': 2150181990,
 'A4': {'C1': 0.10955430270854127, 'C2': 32368},
 'A5': 1001814232,
 'A6': {'D1': 1605418415,
        'D2': {'E1': [36368, 19468, 26212], 'E2': 88},
        'D3': [-43, -8, -32, 110, -91]},
 'A7': 14902,
 'A8': 175}

(b'QKZR\x04\x00\x00\x00O\x00\x00\x00S\x00\x00\x00\\\x00\x00\x00e\x00\x00\x00'
 b'n\x00\x00\x00w\x00\x00\x00\x80\x00\x00\x00\x89\x00\x00\x00\x92\x00\x00\x00'
 b"\xbd\xd1\x04\xc9\\\xb6\xa0u\xd4\x16\xe4\xbf\xcc\xaa'\xaeJb\xbc:8\x0f\x9b\x00"
 b'\x02\x00\x00\x00\xa2\x00\x00\x00}+\xd3tpwyJ\xbc\xb0\xf9\xe1Z\xef?H'
 b'\x0c\xe1\x9fl\x99\x06\xed?$ljY\x8d;w\xdb\xbf\n\n\xd5\x81\x06\xb73'
 b'\xe9\xbf\xe3$x\xd1\xab\x07\xfe\xd2\xbf1\xf6\x0cx\x18=\x10\xe5?\x82\xca;\x91'
 b'V\xea\xaa\xe8?:H\x87(\xe7\x84\x9e\xdb\xbf\x1a\xf3\x18\r\xe6Rp\xf8*\x1d')

{'A1': 'tpwy',
 'A2': [{'B1': 0.9798440815701579, 'B2': 72},
        {'B1': 0.9070555802891547, 'B2': 36},
        {'B1': -0.4291523819316925, 'B2': 10},
        {'B1': -0.7875628592579755, 'B2': -29},
        {'B1': -0.29675475863575884, 'B2': 49},
        {'B1': 0.6582322576436173, 'B2': -126},
        {'B1': 0.7708636942642155, 'B2': 58},
        {'B1': -0.43155024122289776, 'B2': 26}],
 'A3': 3372536253,
 'A4': {'C1': -0.6277868554513577, 'C2': 43724},
 'A5': 1649061415,
 'A6': {'D1': 255343292,
        'D2': {'E1': [6387, 58893, 28754], 'E2': 248},
        'D3': [42, 29]},
 'A7': 11133,
 'A8': 211}

Вариант №2

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

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

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

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

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

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

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

(b'\x87YSXo\xdd\x16\x00`\x96\xf6\x9d#uW2a\xfd\x1b\xe8\x00Z\xcdO{%\x00\x00'
 b'\x00i\x00\x00\x00}\x00\x00\x00\x85\x00\x00\x00\x8d\x90\xca\xe9Q\x0fy'
 b'\x9b\x8e=\x91\xaf\xbe?r\x8e\x93>\x93\x0f\x9b?<8\x92>\xdc\xd9\xfb>\x1e'
 b'\xdde\xbf \xfe\r\xbfb\xd1\xd6\xbf\t\xe49\xbdy\xacP\xdd(\xebuu~Bk}v\x0f\xcep7'
 b'^\xe9\x84\x0c\x96\x87L\x93}1\xeaqqoeiw\x1f\xcb\x1a\xd3\xbf|]\xd6\xac\xffN'
 b'\xf5>\xa9I\x1c\xdd\xdd\x95">\xaa\xc4\xac\x8e\xc7\x8d\x0e')

{'A1': {'B1': 111,
        'B2': -2515822926990238429,
        'B3': 117,
        'B4': 22322,
        'B5': 1643977704,
        'B6': {'C1': -8920,
               'C2': -21,
               'C3': 'uu',
               'C4': 32322,
               'C5': 7745476744407168862}},
 'A2': -850429147,
 'A3': {'D1': 59780,
        'D2': 907061137923453418,
        'D3': 'qqoeiw',
        'D4': 8139,
        'D5': 6867},
 'A4': [{'E1': -0.9858068227767944, 'E2': 2902413045},
        {'E1': 0.3306359052658081, 'E2': 3722286370},
        {'E1': 0.3335317373275757, 'E2': 2395442446}],
 'A5': -8013336052591125618,
 'A6': 0.0711359828710556,
 'A7': [0.947488009929657,
        0.28722843527793884,
        0.7352381944656372,
        0.43135055899620056,
        0.1551414281129837,
        -0.6288765072822571,
        -0.8860143423080444,
        -0.5386386513710022],
 'A8': -1116099504}

(b'\x87YSX\x01m\xc5\x1e\xc5^\x0e\xa2\xf2E[;\x15:\x98\x13\x00Z\xcf2'
 b'\xc8\xd3\x00\x00\x00i\x00\x00\x00}\x00\x00\x00\x85\x00\x00\x00\x8d\x8e\xc6'
 b'r\xd7\r2\xfff\xbd \xf5\xe4\xbf\x1f\x08\xee\xbe\x8b9\x8a\xbe\xd27\x1d>\xa7'
 b'H\x97?e\xa6R\xbe\xd1\xf6\xf6?G\xab\xeb\xbf_|\xec]\xaaj\xde\x89\xa3\xa4im\xda'
 b"\xb2\xf4I6\x19'\x94^<\xdd\x8fv\xc3}*\xffO\xad\xcenqaqqe&\x92\x1b\x80>\xe77"
 b'\xe4\xfft=\x85?jO\xaf0\x8c\x17W?Mys#I\xcf\x0c')

{'A1': {'B1': 1,
        'B2': 7909762153581552370,
        'B3': 69,
        'B4': 23355,
        'B5': 356161555,
        'B6': {'C1': -30301,
               'C2': -92,
               'C3': 'im',
               'C4': 55986,
               'C5': 17602660100220411452}},
 'A2': -818755373,
 'A3': {'D1': 56719,
        'D2': 8557821340559584718,
        'D3': 'nqaqqe',
        'D4': 9874,
        'D5': 7040},
 'A4': [{'E1': 0.45159828662872314, 'E2': 4285808005},
        {'E1': 0.9152783751487732, 'E2': 814487383},
        {'E1': 0.8026344180107117, 'E2': 592039692}],
 'A5': -8158707406970093722,
 'A6': -0.03929699957370758,
 'A7': [-0.6212300062179565,
        -0.27192336320877075,
        -0.410576730966568,
        0.32672569155693054,
        0.8970690965652466,
        -0.4100872874259949,
        0.7799670100212097,
        -0.872999906539917],
 'A8': 1571449566}

Вариант №3

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

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

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

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

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

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

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

(b'ZGKQt{\xbd\xfc\x1b\xeb\xb5\xb8&%\xa3\x85\x8e\x80\xab\xf0\x06\xdcD\xf9AaL`'
 b'\x97\xa9\xc3\xa9\xf8\xfc`\xc3\x83\x98\x8e\xd7?\x03\x00\x00\x00b\x00?'
 b'\xf43\x9d\xeb\x05\x00\x00\x00n\x00\x00\x00Z\xb4\xf5\xa6p\xfa\xd7\xeb'
 b'\xe09J\xf6\x87\x03\x00\x00\x00x\x00\x00\x00\x80\x00\xe3-9\xe2\xe4\xbf\ni%'
 b'\x9f\xbc\xce\x80\xf1EY\x00\x00\x00\\\x00\x00\x00_\x00\x00\x00\x8a\x9a'
 b'\r^\xf6q\x93\x05&ib\x9b\xf2')

{'A1': 2790179990547512699,
 'A2': 500088127273411365,
 'A3': -7538941795615816484,
 'A4': {'B1': {'C1': 4171875241,
               'C2': 0.3680783545255648,
               'C3': [{'D1': 10, 'D2': [105, 37]},
                      {'D1': -97, 'D2': [-68, -50]},
                      {'D1': -128, 'D2': [-15, 69]}],
               'C4': 62527,
               'C5': 51},
        'B2': 60317,
        'B3': {'E1': [-25974, 24077, 29174, 1427, 26918],
               'E2': -1452416993059294118,
               'E3': 224}},
 'A5': 2281065017,
 'A6': [98, -101, -14],
 'A7': -0.6526151558137059}

(b'ZGKQt\xb1\x1e\x9f\xd4Q~\xae\xcd\xd4\xac\x17\xe8\xbe-P\x97\xadm\x1b'
 b'\x13\xcfk\xfb\x9eh\xac5d\x90\x1c\x8cN\xa0\xa2\xdf\xbf\x04\x00\x00'
 b"\x00e\x00\xc1B\xf0\x9e\xda\x05\x00\x00\x00u\x00\x00\x00\xbe' \xf4\x0f|N\x8b"
 b'\xd0\xb7\x1a\x1e<\x05\x00\x00\x00\x7f\x00\x00\x00\x14\xd8\x1b'
 b'\xbe\x87\xd4\xe3\xbfT\xce\xd6\x16\x1d\xcf:\x80\xb9v?\xa1Y\x00\x00'
 b'\x00\\\x00\x00\x00_\x00\x00\x00b\x00\x00\x00Q2\x9f\xdc\\\x9e,YDl\xcd'
 b'\xbec\x01\xac')

{'A1': 14820922313647529649,
 'A2': 10903264995824872660,
 'A3': -6990875459439596115,
 'A4': {'B1': {'C1': 1681239144,
               'C2': -0.49430091543804,
               'C3': [{'D1': 84, 'D2': [-50, -42]},
                      {'D1': 22, 'D2': [29, -49]},
                      {'D1': 58, 'D2': [-128, -71]},
                      {'D1': 118, 'D2': [63, -95]}],
               'C4': 17089,
               'C5': 240},
        'B2': 55966,
        'B3': {'E1': [12881, -9057, -24996, 22828, 27716],
               'E2': -8408647046292035650,
               'E3': 208}},
 'A5': 1008605879,
 'A6': [-51, -66, 99, 1, -84],
 'A7': -0.6196936333715279}

Вариант №4

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

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

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

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

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

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

(b'ZGSH-\xe0\xa6]\x8b<6/\x00\x99]\x00.\x84M\x1c\xe2/\xe6?r\n\x9fb'
 b'\xbf\x86\xad\x9b\x86\xeb-K\xbf\xb8#!\xf2\\\x82\xc4\xbf\xac\xdf\\\xcc[\n\xb5'
 b'\r\xe7\xbf\x0c\xb5ha\xaec\xd3?\x04V\xc59\xef\x00\xdf\xbf>YU?\x02'
 b'\x00\x00\x00-\x00\x00\x00\xeb2(\x18\xe5GV,\xb7{2g\xac2}\xbb\xe4\xbf\xce\x98o'
 b'e\x86H\xe5\xbfd\x1fE\xaf\x18\x96\xe3\xbfW\x94\xf3\xbe\x02\x00\x00'
 b'\x00[\x00\x00\x00(h\xccd:P\xf1\x87')

{'A1': -8147,
 'A2': 23974,
 'A3': 15499,
 'A4': [{'B1': 54,
         'B2': {'C1': [-0.7204232408825066,
                       0.30295905602072604,
                       -0.4844320358436962],
                'C2': 0.8333929777145386,
                'C3': [-84, -33],
                'C4': 3194820034944316139}},
        {'B1': 153,
         'B2': {'C1': [-0.6478868474689305,
                       -0.6651031476183336,
                       -0.6120723174326312],
                'C2': -0.47574111819267273,
                'C3': [-73, 123],
                'C4': -8651045197472569304}}],
 'A5': {'D1': 0.6933451226033236,
        'D2': 114,
        'D3': -0.8852392435073853,
        'D4': -122,
        'D5': [-83, -101, -122],
        'D6': -0.7936694025993347},
 'A6': -0.16022836516120065}

(b'ZGSH\xbd\xa7\xd6Z\x05i.3\x00\xeeb\x00\xe4:\xc0\xc4\x8cM\xd1\xbfakH`'
 b'\xbe\xff7F\xac\xa1\xe70>\xc0\x87\x93\x81"\xb6\xe5\xbf&\xb8\xc5\x8a}\x88F'
 b'\xdf\xe13A\xe9\xec?P\xb9\xd4\x08\x14p\xc8\xbf\x00\xfc\xcd\xe9\xa1\xb4]?\n'
 b'\x19\xeb>\x06\x00\x00\x00-\x00\x00\x00\xae\xff\xba8\xafS\x06\xc7\x80'
 b'\x90|\x84\x1e\xbe\xdbf\x93\xd9?v\xf1\xeeL\x92;\xef?@\nI\xa5\x94\x07'
 b'\xd4?\x80\x9c\xea\xbe\x03\x00\x00\x00_\x00\x00\x00\x12\x8e\x90M(P\xeal')

{'A1': -22595,
 'A2': 23254,
 'A3': 26885,
 'A4': [{'B1': 46,
         'B2': {'C1': [0.9034734738661221,
                       -0.1909203570480238,
                       0.0018130856689990704],
                'C2': 0.4591754078865051,
                'C3': [38, -72, -59, -118, 125, -120],
                'C4': -4105501998265466962}},
        {'B1': 238,
         'B2': {'C1': [0.3996216913151118,
                       0.9760219099621696,
                       0.31296268597739996],
                'C2': -0.4582252502441406,
                'C3': [-128, -112, 124],
                'C4': 7848173434676743698}}],
 'A5': {'D1': -0.27035826887087766,
        'D2': 97,
        'D3': -0.21902625262737274,
        'D4': -1,
        'D5': [55, 70, -84],
        'D6': 0.17275859415531158},
 'A6': -0.6784832506930272}

Вариант №5

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

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

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

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

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

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

(b'PWJ\xbf\xca\xd1\xe7t\xdd\xee\x05,bf\xafT\xd55\xa0\x17=\x17o\xd8\xcb\t\x061'
 b'i\xeb\x05\x16\x99\xa3\x9bO2\xc3\xde\xaf>z\x00\x91\xb2\xe5\xa1\xc6\x88m]M'
 b'z1\xbe\x03\xbe\xb3\xac3\xc4\x18\xab\xcd\x84\x02\xb1\xd8?\x83\xc3\x19'
 b'\xb8\xfd\x10\x1d\x98\xd7t{\xf8\x846@\xae\x12]u\x01\x04\xa5o\x03\xd3E\xe4'
 b'h\x00\x00\x00v\x00\x00\x00\x0229\xdd\x96x\xe1\xaa=\xc0\x93f\x81\x18M\xe2'
 b'\x1e\xfb\x93\xd8\xc1\xaex1\xbb\xa2\x8e\x14sB\x8b>')

{'A1': 3172204147468915146,
 'A2': 'bf',
 'A3': 903173295,
 'A4': 705895738256463776,
 'A5': [{'B1': [11788477714299171078, 8808671292475723675],
         'B2': -28416,
         'B3': [-6734, -14687, 28040],
         'B4': 12951793693772893533,
         'B5': 13228},
        {'B1': [15614264152479701188, 2094452793875333951],
         'B2': -10344,
         'B3': [31604, -31496, 16438],
         'B4': 8044840713677771438,
         'B5': 54019}],
 'A6': 58437,
 'A7': {'C1': -6133488628149964286, 'C2': [61, -64, -109, 102, -127, 24]},
 'A8': {'D1': 4213105229,
        'D2': -1363027821,
        'D3': 2730176888,
        'D4': 5262,
        'D5': 0.2719913423061371}}

(b'PWJ\xbf?\n\x17Q\xc1\xfb\tmpx\x9c\xfcQ\x83J\xcbY_\xba\xc6\xb7\xbb\xd3S'
 b'\xca\xd3\x87[\x12;\xd8\xa20\xbe\x1a\xd1O|\xb2\x18\x8c\xd2P\x1b\x91]8x'
 b"\xe1\xef\xa3\x8e\x1ai#}~\x11\x8d\x08V\x86g%gx\xc9{rMT\xe5\x81M#>N\xb11'"
 b'Wu\xfc_o\x83571\x9c\x81\xa7h\x00\x00\x00v\x00\x00\x00\xdd\xb8A\x1bB\xda)\x93'
 b'QY\xf68\xf2\xaf\xfdo\xb4_\xcd\x96\x9a\x91\xcf\xa4\xfc\xd9m\x85\x15\xb1|\xbd')

{'A1': 7857087832632265279,
 'A2': 'px',
 'A3': 2203188380,
 'A4': 13526498509596511050,
 'A5': [{'B1': [4256565236750504915, 8957608096653419224],
         'B2': 6322,
         'B3': [-11636, 6992, 23953],
         'B4': 7573522558132254776,
         'B5': 32035},
        {'B1': [2695270606073303422, 16524918086827604071],
         'B2': 19841,
         'B3': [15907, -20146, 10033],
         'B4': 3978230360226690391,
         'B5': 39985}],
 'A6': 42881,
 'A7': {'C1': -7842497298629019427, 'C2': [81, 89, -10, 56, -14, -81]},
 'A8': {'D1': 1605660669,
        'D2': -1852139827,
        'D3': 3657213135,
        'D4': 34157,
        'D5': -0.061692316085100174}}

Вариант №6

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

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

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

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

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

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

(b'YXZJ\xc9=\xf0\xc8Yiz?F+)\x81]\xc8\xf8\x83E?\xdaE\xd5R\x86\x8c\xc4\xa1.=S?ul'
 b'\xfajv\xdd\xa9xp\xcci\xbe\xaa\x11\x1b\xbf\xec\xc3\xfb_\xaf\xf5\xf0u\x06\xa7'
 b"\xfa\x00k\xbf\xd8\xfa'.\xe16\xd4\xad\xb4m\x94W\xf5\xb8\xe1\xab\xcaU\xeb\x0b"
 b'\xc0-\xa8\x1f0L96\xc1\x19Vl\x8e\x83\xd9\x1b\xc7\xe2*\xef\x08\xf8\x06`'
 b'\xfc2\xc2\xdf}0\xcaB\x81\xec8')

{'A1': [{'B1': 0.11756963282823563,
         'B2': 'iz',
         'B3': [16198, 11049, 33117, 51448, 33605],
         'B4': 0.4105122857965393,
         'B5': 2704162131},
        {'B1': 0.9586941003799438,
         'B2': 'jv',
         'B3': [56745, 30832, 52329, 48810, 4379],
         'B4': -0.8989235752957807,
         'B5': 1963370490}],
 'A2': {'C1': 6988516534326735050, 'C2': 1115810872},
 'A3': -0.3902681310472478,
 'A4': [-21068, 28052, 22517, -18207, -21558, 21995],
 'A5': {'D1': 197143976,
        'D2': 2247380022673348950,
        'D3': [27790, 33753, 7111, 57898, 61192, 63494]}}

(b'YXZJ\xc9?\x1f;=fk\x86\xc8\xf0Y\xfc4\xda\x9fmF?\xdf\x97\xd7n\xcc\x81'
 b'\x84\x9f\x8cs\x90\xbd\xcaS\x1ajie\xcf\xa2Q3\x10\x9fz\xe9\xc9\xbf\xc1\xa1'
 b'T\xeaGNx\xbbn\xb8u\x00k?\xe1\xe2\x02\x08B\x12Z\x85\x9cF\xb4%\xb5@\xd8\xfc'
 b'?\xaep\xfb\x0c\xdb\x19\x94\xf6\x96{\xe7_\xde\x8d\xea\xfb\xf4\xb5X'
 b'\x87\xa5\xff\xb9h\xc91\xbf\xdei\x8b\x9c\xfa\x08\xf71,\x9f\x0b')

{'A1': [{'B1': 0.6219976544380188,
         'B2': 'fk',
         'B3': [34504, 61529, 64564, 55967, 27974],
         'B4': 0.49364267177772825,
         'B5': 2676781968},
        {'B1': -0.09879131615161896,
         'B2': 'ji',
         'B3': [26063, 41553, 13072, 40826, 59849],
         'B4': -0.1377359527528943,
         'B5': 3144595573}],
 'A2': {'C1': 13825603954429004023, 'C2': 825007883},
 'A3': 0.5588388596812124,
 'A4': [-31332, 18100, 9653, 16600, -961, -20880],
 'A5': {'D1': 4211923737,
        'D2': 10733932220791119501,
        'D3': [60155, 62645, 22663, 42495, 47464, 51505]}}

Вариант №7

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

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

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

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

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

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

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

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

(b'IWVOv\x86\x02M\xbd}\xefQ\xd4\x82\x97\xab=7\xd7PG\xc0\xcc"7\x08t\xb4'
 b'?q\x80\x10\xb8\x12\xdc\xf9.Q\xfa\xda\x06\x00\x00\x00_\x00\xe2\x1a'
 b'q\x91\x02\xeerfylce@m\xc5\xe2\xdd\xf3\xf7\x0cZ$\xc2>\x02\x00e\x00\x9f\xc0'
 b'YL\xcd\xea_\xd3\xf4x\xe1s\x82\x1b\x80\x04\xb9\x00\x81pJtbitysi\x9a\xb9'
 b'r\xd2|f#9\xaf\x01@\x06\xab\x00\xba\xe8O')

{'A1': {'B1': 1292011126,
        'B2': 12364495150388313533,
        'B3': {'C1': 1356281661,
               'C2': 71,
               'C3': 0.07989550920574384,
               'C4': 3384978567901249649,
               'C5': -1455,
               'C6': -38,
               'C7': 'tbitys'}},
 'A2': -1854858526,
 'A3': 2,
 'A4': 238,
 'A5': {'D1': 'rfylce', 'D2': 934483582020578624, 'D3': 1052910682},
 'A6': [{'E1': 105, 'E2': [47514, 53874], 'E3': 958621308},
        {'E1': -81, 'E2': [16385, 43782], 'E3': 1340652032}],
 'A7': {'F1': -97, 'F2': -850634304, 'F3': -9046639316837376022},
 'A8': 5363928996302323739}

(b'IWVO\xf1\xa5\xa5+\xe1\x96\xbf\x81K\xb6\xb2C\xe5\xcd\x19\x8a\xe1h\xb7{'
 b'+\xac\xbd\xeb?Q@\x10\x0c\x99a<|D\xa5\xfa\x05\x00\x00\x00_\x00@\xf7_\x08{c'
 b'rrufzc9)\xd3\xfc{W\x94\x90\x83\xf8g\xc8\x02\x00d\x00\xca\t\xb2\x04\x12\xf1'
 b'\xb2\xc3\xba,\xa48$\xbfK\x8e\x1e\xcf\xb8p\x88xkhbf\x8eo\x84W\xe7\x8f\xbe\xf2'
 b'\xb8*\x0b6\x83\xf9\xda\x1d$\xe0')

{'A1': {'B1': 732276209,
        'B2': 4878161781811287777,
        'B3': {'C1': -1978020379,
               'C2': -31,
               'C3': 0.8669033860476079,
               'C4': 8952137469265985617,
               'C5': -23228,
               'C6': -6,
               'C7': 'xkhbf'}},
 'A2': 140506944,
 'A3': 123,
 'A4': 99,
 'A5': {'D1': 'rrufzc', 'D2': 10418048028049090873, 'D3': -932710269},
 'A6': [{'E1': -114, 'E2': [33903, 59223], 'E3': -1192051057},
        {'E1': 42, 'E2': [13835, 63875], 'E3': -534503974}],
 'A7': {'F1': -54, 'F2': 302297609, 'F3': 2610016496080106225},
 'A8': 9831561186260175807}

Вариант №8

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

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

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

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

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

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

(b'\x8dQAYBK6\x1a?_\xcd\xc8\x1c\x004\x00P\x00g\x00x\x00\x87\x00\x9a\x00iw'
 b'\x10\xc8i\xd8\x02\x00\x00\x00\x1a\x00U\x88Q\xbd\xa4\x8dU\x1a\xfcv'
 b'\xe6\xbe\xf9D\xd7\x1d\r\xbf}\xf9K\xb5zwgww\xd3o\xc2\xbb\xbb\xb1\x9d'
 b'\xbc0\x01\xea\xd7\xce\xddN\xfb\x07\x00\x00\x00B\x00\x00\x00\xc9;\xd8'
 b'\xb4b\x12\x81\xdb\xd7[\x84KIhs\x07\x00\x00\x00Y\x00\x00\x00\xd7-0\xff'
 b'\xae\x91g\x8cT\x04\x00\x00\x00p\x00\x00\x00*\x0e\xfc\xb0\x7f\x00\x8d'
 b'\x03\x00\x00\x00\x81\x00\x00\x00\xad\x08\xfa\x96\xacO\x1e\xbe'
 b'\x82\x9f\xda\x05\x00\x00\x00\x90\x00\x00\x00')

{'A1': 0.6023909449577332,
 'A2': -12961,
 'A3': -56,
 'A4': {'B1': -14320,
        'B2': -10135,
        'B3': 'iw',
        'B4': 1897578556696922197,
        'B5': -0.4501265287399292,
        'B6': 17657},
 'A5': {'C1': -0.5512365698814392, 'C2': 3041655165, 'C3': 'zwgww', 'C4': -45},
 'A6': [{'D1': 251,
         'D2': [-15761, -17477, -25167, 12476, -5631, -12585, 20189]},
        {'D1': 115, 'D2': [15305, -19240, 4706, -9343, 23511, 19332, 26697]},
        {'D1': 84, 'D2': [11735, -208, -28242, -29593]},
        {'D1': 141, 'D2': [3626, -20228, 127]},
        {'D1': 218, 'D2': [2221, -26886, 20396, -16866, -24702]}]}

(b'\x8dQAYB\xa2Qk\xbfs\xc7\x12\x1c\x004\x00J\x00Y\x00j\x00{\x00\x92\x00cu'
 b'\x81\x1366\x02\x00\x00\x00\x1a\x00\xf87\xb5\x14\x80\x85\xf3\x07\x9eh'
 b')?\x83\xfe.\xa6v?3\x06\xe1\xfbghrzc\xc8\xec\xf1"\xde\'\xe6\x99\xdc\xb4\x04'
 b'\x00\x00\x00B\x00\x00\x00\xedm:\x8c\xce\x95\xdc\x03\x00\x00\x00S\x00'
 b'\x00\x00\xb0\x88\xf6I\x92\xe39Y\xac\x04\x00\x00\x00b\x00\x00\x00\x0c'
 b'\xe2\xdfx\xa5\xf6\x1es\xa2\x04\x00\x00\x00s\x00\x00\x00\xf9\xbf\xff@'
 b'\xc3\xa3\x9dmKS#o\xfbN\xd5\x07\x00\x00\x00\x84\x00\x00\x00')

{'A1': -0.9192143678665161,
 'A2': -14477,
 'A3': 18,
 'A4': {'B1': 4993,
        'B2': 13878,
        'B3': 'cu',
        'B4': 572948362755913720,
        'B5': 0.6617525815963745,
        'B6': 65155},
 'A5': {'C1': 0.9634732007980347, 'C2': 4225828403, 'C3': 'ghrzc', 'C4': -56},
 'A6': [{'D1': 180, 'D2': [-3604, -8670, -6617, -9063]},
        {'D1': 220, 'D2': [28141, -29638, -27186]},
        {'D1': 172, 'D2': [-30544, 18934, -7278, 22841]},
        {'D1': 162, 'D2': [-7668, 30943, -2395, 29470]},
        {'D1': 213, 'D2': [-16391, 16639, -23613, 28061, 21323, 28451, 20219]}]}

Вариант №9

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

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

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

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

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

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

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

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

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

(b'OWFA\xc0\x02\x83\x87\x04X\xdd\xbf\x1c\x00\xec\xb6\x10\xe53\x86'
 b'\xdb\xab\xbf\x01\xc1~\xeb\xbbj\x8c\xce\x98;\xdc\xc5\x19\xadp\n\xa8\xe3Ur2'
 b"=\xe0\x12\x11wRZ\x8c:\\\xef'\xbe\x90\xc9\x03\x00\x00\x00\x16\x00\x18;\x9a"
 b"G\xc7'\xe5\xc1\xee\xbf\xd4+~l\xa9\x93f\xea\xf8!\x01\x060\x03\x00\x00\x00"
 b'\x19\x00\xe45\xb0\xc7B\xc0\x03#\xd5?n\x87>\x93\x93\x1e\xbb?m\xdaA\xa1'
 b'\x0b\xb9\xde\x1ex\xf1u\xcf\x94\xcc\xe0?H\xf9\xbex\xdd\x92\xd68\x82\xe9\xbf\\'
 b"9'\xe8\x16\x8b\xd1\xbf)\x91\x19H\xb7\xa5t\xe8\x81pAl")

{'A1': -0.4584971736294783,
 'A2': {'B1': {'C1': {'D1': 106, 'D2': -116, 'D3': -50, 'D4': 15256},
               'C2': {'E1': -1390819876,
                      'E2': 4409712698366364272,
                      'E3': 4218846261170737888,
                      'E4': -0.1639990210533142},
               'C3': [{'F1': -112,
                       'F2': 201,
                       'F3': [-65, 1, -63],
                       'F4': 15128,
                       'F5': -0.9611688401148399,
                       'F6': [212, 43],
                       'F7': 126,
                       'F8': 81619953896368492},
                      {'F1': 6,
                       'F2': 48,
                       'F3': [126, -21, -69],
                       'F4': 13796,
                       'F5': 0.33026212478136596,
                       'F6': [110, 135],
                       'F7': 62,
                       'F8': 4745225277877949331}]},
        'B2': -558298207,
        'B3': 1978759198,
        'B4': 38095,
        'B5': 57548,
        'B6': {'G1': -0.4868793189525604,
               'G2': [-0.7971462431805056, -0.27411434813702384]},
        'B7': [1209635113, 3899958711, 1816227969]},
 'A3': 12383639157829842668}

(b'OWFA\xd8\xe29K\xb1\x87\xc5\xbf\x1b\x00R\x96\x9e\xf8\xa6\xeb\x10NJ}'
 b'\xf5\x1cK\xdc\xeb\x14\x90w\xabb\xc4\x05\x13-\xb6m\xc3`U\xf2\xbc-\x10G'
 b'\xac\xd9\xf77{\x1a\xcd\xba9\x94\x03\x00\x00\x00\x16\x00q\xf7`IH\x98k\x82'
 b'\xde\xbf\x93\xfc\x88\xf6\x93\x80>i\xa4c73\xbd\x02\x00\x00\x00\x19'
 b'\x00\r\xa7\xe0\xcd\xc3E\x94\xfd\xc0\xbf\xca=\xd8\x11\xcd\x02A\x17\xed'
 b"\xcd\x17g\xecV\x89\xecK\xed\t\x8e\x99'\xaa\x00\r\x1b\xbf\x9cj\xd9\x8d\x03/"
 b'\xdc\xbf\x00\x02\xcb\xe5\x95H\xd1\xbf\x90\xde\xfd\x07>F\xbc\xd1\xce\xca'
 b'G\xae')

{'A1': -0.16820350812101625,
 'A2': {'B1': {'C1': {'D1': 220, 'D2': -21, 'D3': 20, 'D4': 30608},
               'C2': {'E1': 96756395,
                      'E2': -984774551035040493,
                      'E3': 4032931325283413436,
                      'E4': -0.0015648150583729148},
               'C3': [{'F1': 57,
                       'F2': 148,
                       'F3': [74, 125, -11],
                       'F4': 63345,
                       'F5': -0.4767102229244724,
                       'F6': [147, 252],
                       'F7': 136,
                       'F8': 3991214466707526646},
                      {'F1': 51,
                       'F2': 189,
                       'F3': [28, 75],
                       'F4': 42765,
                       'F5': -0.1327386227272731,
                       'F6': [202, 61],
                       'F7': 216,
                       'F8': 1715287717228760337}]},
        'B2': -1990792089,
        'B3': 166546412,
        'B4': 39310,
        'B5': 43559,
        'B6': {'G1': -0.6056671142578125,
               'G2': [-0.44036949970692674, -0.27005526962969384]},
        'B7': [134078096, 3518776894, 2923940558]},
 'A3': 5625255036953990738}

Вариант №10

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

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

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

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

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

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

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

(b'YIRP\x91=T\xbe\x1e\x00\x80)_\x0f\xcc\x86\xc2\xbf\x89\x00\xc4\xa4M\x8c\x03^cL'
 b'\\\xf6\x0c\xfe\xb4\xf6t_\xb8D\x87\xa7N\x12\x8c-?.\xa21i\xf4\xb2\xcf'
 b"t\xc2\xd6\xef~&\xf2z\xe4x/\x13l_9'\xe5\xc6\xad\x9e\x15\xda[+\x06\xefX\xe6"
 b' \x1doJ\x01<r\xbb\x9a\xa9&\xe3\xc8\xbf\xf3;d\xa37%\x02s\xf3uM\xaa\x04\xc3'
 b'Fy\xaf\xf9%F\xe1\xf0O\xaa\xfa\xb1M\xd8Y`\x0c\xc7\x16t\x1e\xa9\xbe\xa9.\xb0Bc'
 b'\x8a:F\x1b\x18\x00\x16R\x10\xad\x0f\x02\x00\x00\x00(\x00>\x00\x00\x00')

{'A1': -0.20726610720157623,
 'A2': {'B1': 65036, 'B2': -6375051188853475660},
 'A3': -0.14473868132183654,
 'A4': {'C1': 17978,
        'C2': 1129577026282330139,
        'C3': [{'D1': 764154446, 'D2': [63, 46, 162, 49, 105, 244], 'D3': -78},
               {'D1': 3603068111,
                'D2': [239, 126, 38, 242, 122, 228],
                'D3': 120}],
        'C4': {'E1': 14331904516544009007,
               'E2': [-24915, -9707, 11099, -4346, -6568, 7456, 19055, 15361],
               'E3': 114,
               'E4': [-882766124009547077,
                      -904376741300837317,
                      -5802528841479336587,
                      -384406922196539911,
                      1641294197163576753],
               'E5': 7796,
               'E6': -8474856749316587863}},
 'A5': 5504346538908689604,
 'A6': -2468}

(b'YIRP\xbd\x81M\xbf\x1e\x00X\xae\xb6V\x7f\xa0\xe5\xbf\x89\x00\x03n\x17k\xce^x}'
 b'\xa5\x961\x9c\xc8\x04\xbe\x0c\x7f\xf6\xc9\xcdi\x7f(\xb7\x92\xc70\x1c'
 b'\x1e\xb3]\xf7\xc6{k:\xfb\xe0\xad\x93\xffX\x19\x03\xdb\xf5PZ\xf8\xbd\x91\x11'
 b'\x84p8P\x08|\xd2\r\xa0\xf6tk\xdd-\xab\\\x0c@\xe3D\x02\xb3u\xd6\xa7\xc7Z\x1f'
 b'\xda\xa4\xc6\xe2\xa0\x85W\xc2\x1cK\x04\xac?\x8av\x98\x96\xd8P\xf4'
 b"\xd5\xed\x1dw\x0f\x93\xf1'J\x8a\xf4\xafM4\x01O\x95\x9c\xa9\xcb\xe8\\\xfd%"
 b'E\xa7\x17\x02\x00\x00\x00(\x00>\x00\x00\x00')

{'A1': -0.802760899066925,
 'A2': {'B1': 39985, 'B2': -3618089800080423736},
 'A3': -0.6758419698357541,
 'A4': {'C1': 43420,
        'C2': 1704407013449853131,
        'C3': [{'D1': 3072884585, 'D2': [146, 199, 48, 28, 30, 179], 'D3': 93},
               {'D1': 1803273975,
                'D2': [58, 251, 224, 173, 147, 255],
                'D3': 88}],
        'C4': {'E1': 13688790371161277209,
               'E2': [4497, 28804, 20536, 31752, 3538, -2400, 27508, 11741],
               'E3': -85,
               'E4': [8481125018162433116,
                      -4132938729817397290,
                      309372620422619362,
                      5825571699571703724,
                      -1039470084714801676],
               'E5': 18983,
               'E6': -7687924714744843126}},
 'A5': 9041080492599242243,
 'A6': -26971}

Вариант №11

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

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

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

(b'pGVPI\x03\x00\x00\x00\x1d\x00|\xe4\x1b\xd1\xb0\x86\x0b\xf4\xacJ\xbd\xd7\x83'
 b'\xecJ\xdf`\x00arq\xa5\xa0%\xb9y\\\\\xf6\xcb\x9f\xc7\xe3\xe2?3\x90'
 b'\xd2\xf7\xfc\xb2b=.I\xdb:\xe7\xbf\xc1\xfa\x8e\xdb\xdae\xd8\x90F\xfe\r\xf2'
 b'\xd5?5\xaezjJX\xd2\xdd#\xe0M\xb3\xe4? \x00.\x00<\x00J\x00\x04\x00X\x00'
 b'O\xd2\xd0\xfd\x13\xbc\x04\x81\x15\xd8$n\xc3\xee2\x10&?-\xf0Zh\x1a\xac'
 b'X\x89\x87\xe2\x1a\xa6ob')

{'A1': 'arq',
 'A2': 17585297263978865788,
 'A3': -2356811403970655572,
 'A4': {'B1': [{'C1': -1188716379, 'C2': 23673, 'C3': 0.5903051491765825},
               {'C1': -137195469, 'C2': -19716, 'C3': -0.725934641772181},
               {'C1': -611386687, 'C2': 26074, 'C3': 0.34289884406667914},
               {'C1': 1786424885, 'C2': 22602, 'C3': 0.6468877198921581}],
        'B2': {'D1': [-11697, -560],
               'D2': 48147,
               'D3': [17204716106008592644,
                      7519586604972118066,
                      11969128031443266586],
               'D4': 25199}}}

(b'pGVPI\x04\x00\x00\x00\x1d\x00|\x99!\xa7\x11\xf3\xc3\xc3\x12\xf3\x15\xd3\xa3'
 b'\xf7\xe5\xd7\x81\x00swaf\xec\xbfb\x16u\x05\xb0\xb4\xdd\x1fR\xc9\xe6?9'
 b'G\xd4f\xfd\xf9\x18n\x9d\xc3\xefl\xe8\xbf\xbc\xd5.\x9aa( \xfcc\x1db'
 b'\xa3\xe3?\xaa\xbe(\xa5m \x80\\[xG\xd2\xc9\xbf\x96\x9c\xf0\xc4\xe1\xaa\xa8'
 b'\x8e\xdf\x9e8\xe2\xda?\x06\xde\xa3_\xb0\x8b\xc8\xb0\xf6\xf9\xa5)\xed'
 b'\xbf!\x00/\x00=\x00K\x00Y\x00g\x00\x06\x00u\x00\xa8\x08.\xcc#\x9a\xfe'
 b'\xd5\xb5w\x81\x1f\xc5\x06Z^\x04\xe9\xcc\xc0\x85\\\x1d7-\x0b\xf2\xf23)\xc7Y')

{'A1': 'swaf',
 'A2': 14106385714998516092,
 'A3': -2889631302895144174,
 'A4': {'B1': [{'C1': 375570412, 'C2': 1397, 'C3': 0.7120752928145944},
               {'C1': 1725187897, 'C2': -1539, 'C3': -0.763297922192069},
               {'C1': -1708206660, 'C2': 10337, 'C3': 0.6136942457231989},
               {'C1': -1524056406, 'C2': 8301, 'C3': -0.20172971131134787},
               {'C1': -990864234, 'C2': -21791, 'C3': 0.420057444715193},
               {'C1': 1604574726, 'C2': -29776, 'C3': -0.9113340265371557}],
        'B2': {'D1': [2216, -13266],
               'D2': 39459,
               'D3': [487830775559214590,
                      6666946809707126362,
                      2968983700750808861],
               'D4': 22983}}}

Вариант №12

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

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

(b"\x9fAUPX\x80\xccC\x00\x00\x00\x02\x00\x00\x00\x82\x00\x00\x00PJ'sqL\xeb?\xdd"
 b'B\x17.\xb3Qf?\x126\x93x\xea\t\xeb?0X\xfa\xf2\x0f\xd2\x85\xe2a\xa5\xf9n\x8c'
 b'\x88O\x19\x86\xf1v\xc2\xb6\x05X\xb1\xd3\xf4\x94\x1b\x10\x19g\x0f\xb2'
 b'\xb2\xd1\xbf\xf4\xc5\x7f4\xd7\xf9\xde?rneexu\x93\x03\x00\x00\x00+\x00'
 b'\x00\x00H\xf6\x90\xca\xa6NR\x9eQ\xac\x0b\x05?\x8bR\xd7\xfe\xed\x07\xb0\x8aC'
 b"\xda\x13\xc6'\xcf\x92n\x00x\x00")

{'A1': -13184,
 'A2': {'B1': 462746835,
        'B2': -0.2765317106644867,
        'B3': {'C1': 0.4839990627943671,
               'C2': 'rneexu',
               'C3': -109,
               'C4': [-2124060683292485584,
                      1823826510846993761,
                      -5667773848541007482]},
        'B4': 11408267284352923208},
 'A3': [{'D1': -21423, 'D2': 11, 'D3': [5, 63, -117, 82, -41, -2, -19]},
        {'D1': -20473, 'D2': -118, 'D3': [67, -38, 19, -58, 39, -49, -110]}],
 'A4': 0.8530814408389435,
 'A5': 773276381,
 'A6': 0.8996841311454773,
 'A7': 0.84496043729604}

(b'\x9fAUPX\xfe3;\x00\x00\x00\x02\x00\x00\x00z\x00\x00\x00j\xfbAp\xf9^\xe2?l'
 b'9\x10\xc8\x80\x0e\r\xbe\xce \xe9\x97z\x10\xe3?400\xa9\x95I\xb3\x96a'
 b'\xb02D\xd0}X\xef\xdf\x1a\xac*\x98E\xf2\xa3\x02\xd9\xc6?\xac\xc8\x17\x93\xe6'
 b'\x19\xdc\xbfnzcgcpV\x02\x00\x00\x00+\x00\x00\x00v\x0c\xe2\x8e\x00\x04\xf7EIS'
 b'\x0bk0S\x01\x1d\x16&\x84\xa9W\x8d\xa4,.\xa8"\x19f\x00p\x00')

{'A1': 13310,
 'A2': {'B1': 715922143,
        'B2': 0.17849762921518386,
        'B3': {'C1': -0.43908085217038706,
               'C2': 'nzcgcp',
               'C3': 86,
               'C4': [-7587640040051691468, -1200070967243394975]},
        'B4': 5041502708308249718},
 'A3': [{'D1': 21321, 'D2': 11, 'D3': [107, 48, 83, 1, 29, 22, 38]},
        {'D1': -22140, 'D2': 87, 'D3': [-115, -92, 44, 46, -88, 34, 25]}],
 'A4': 0.5740935509237322,
 'A5': 3356506476,
 'A6': -0.13775062561035156,
 'A7': 0.5957615820889488}

Вариант №13

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

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

(b'RXQ\x85G\x00zjbyo\x02\x00\x00\x00P\x00\\\x00\x00\x00\xe7\xa5\x01'
 b"\x95\x95\x1c'V\xea\xd8\x14\x11\xd7d\x0e\xd8\xc6\xe6\\P\x7f`\xa7C{\xccr"
 b'\xd3\xd0\xb0)\x7fN\xc7\x8d\xbe\x1f\x8b\x02\x00\x00\x00n\x00ecusce\x08'
 b'\x06\x00A\x00\x00\x00\xbbZ\xbd\xe0\xb8\x9c\x1a?Q\xcde\xebx?\xb6[7d'
 b'\x19:\xe0\xbfL~\x1c\x92]\xe6?U"\xd4U\x8f')

{'A1': {'B1': 8, 'B2': 'ecusce', 'B3': 23227},
 'A2': 'zjbyo',
 'A3': [{'C1': -8003, 'C2': 0.6039538383483887},
        {'C1': -12975, 'C2': 0.9723418354988098}],
 'A4': {'D1': -0.5070921857212543, 'D2': 6142881706314333772, 'D3': 54306},
 'A5': [6207962040129136103,
        15568491836733708522,
        4874971221577230022,
        9163049327809186939],
 'A6': -0.276911199092865,
 'A7': 35615,
 'A8': [85, -113]}

(b'RXQ\x85H\x00hmhit\x02\x00\x00\x00Q\x00]\x00\x00\x00\xe4\x84\x8bQ\xf5\\\xb4'
 b',\xb7\xdf\xdf\x95Yq\xca\xbc\x0b\xc8\x9fm\x91\xa4\x0f,\x99\xfb\xe1'
 b'\x98\x8e\xd6\xe2\x9bV;\xb5\xbe6\xb5\x02\x00\x00\x00o\x00itmqxxvp\x07\x00A'
 b'\x00\x00\x00\xf2E\xc6\x12\xa9\xdd\x0c>m\xb9\xed\xd5i\xbf\xe0F\xb8'
 b'\xd7\xe4\xb2\xb7?\xaa\xd1\x1c,\xa3\xaf\x19\xab\x937\x01\xd9')

{'A1': {'B1': 112, 'B2': 'itmqxxv', 'B3': 17906},
 'A2': 'hmhit',
 'A3': [{'C1': 4806, 'C2': 0.13756431639194489},
        {'C1': -18067, 'C2': -0.9134204983711243}],
 'A4': {'D1': 0.092573454538321, 'D2': -6117665503451491926, 'D3': 14227},
 'A5': [3221301842181588196,
        13603810254006509495,
        3174937206835890187,
        11232776328554085273],
 'A6': -0.3539683222770691,
 'A7': 46390,
 'A8': [1, -39]}

Вариант №14

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

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

(b'\xddTDU\x89>f,@z\xca\xdan\xd3\xd1g\xe2\xc0\x85\xb1\x00>\x12\xd6\x8c\xea\xfd,'
 b'\xa2\xd2\x80\xdf\x12\xfb`&}?\xc8k\x98"\xc6Lm\xf0\x90|\xe3\xa0\x02\x00'
 b'\x00\x00>\x00\x00\x00m\x00\x00\x00bq5ze\x86\xab\x157\x05\x9a\xd5_\xc4'
 b'\n\x02\x00@\x00|\x93\x98\x80\xadr\xe7{\xda\xce\x81K\xc5\xcb\x1fjA\xf9&'
 b'\x1d)N\xd9.b\xec|}H\x00\x00\x00\x03\xb9\xb6\xef\xba\xfb\x1e\xf6Rf\x82'
 b'\xc7\x05\x00Y\x00\x00\x009bv\x08\x81y\xa6\x03')

{'A1': 137,
 'A2': 62,
 'A3': {'B1': 2051026022,
        'B2': 3547257546,
        'B3': [{'C1': 26577, 'C2': 49378, 'C3': 45445},
               {'C1': 15872, 'C2': 54802, 'C3': 60044},
               {'C1': 11517, 'C2': 53922, 'C3': 57216},
               {'C1': -1262, 'C2': 9824, 'C3': 16253},
               {'C1': 27592, 'C2': 8856, 'C3': 19654},
               {'C1': -3987, 'C2': 31888, 'C3': 41187}],
        'B4': 'bq'},
 'A4': {'D1': {'E1': -1000352358,
               'E2': 10,
               'E3': [2254797365, 87496107],
               'E4': 8928230875797689212},
        'D2': {'F1': -711854910773741309,
               'F2': 3347211858,
               'F3': [1266798298,
                      1780468677,
                      489093441,
                      785993257,
                      2105338978]},
        'D3': 263031223347470905}}

(b'\xddTDU[\xde\x9c\xac\x8c[\x0c\xa7\xf01\xaa"\r\t\x89\xe3V\x89\xab\x19'
 b'J\x82\xad\x04\x04\xf2\xa9\x17\xd1\xf3\x9b\xba\x02\xdd\x8c\x8fR\x9d\xcdk'
 b'\xef;\x16j\nM\x03\x00\x00\x00>\x00\x00\x00j\x00\x00\x00psb\xd1\x1e6'
 b'\xb4\xfb\xddm\xc4P\xb2\x08Pr\x02\x00A\x00a\x87\xd3\xfe\x15\x7fe\xb4m$'
 b'\x97\x85\x89\xb7\x13\xe4\x06\xabk\xbe\x94\xb1\x10\xcdI\x00\x00\x00\xc1\xb2'
 b'\xaf>\xef\xbf\xeb\xf2\x14)@\xb8\x04\x00Z\x00\x00\x00\xb5c\x86\xf5\xab~2\xc2')

{'A1': 91,
 'A2': -34,
 'A3': {'B1': 1535945884,
        'B2': 837854988,
        'B3': [{'C1': 8874, 'C2': 2317, 'C3': 58249},
               {'C1': -30378, 'C2': 6571, 'C3': 33354},
               {'C1': 1197, 'C2': 61956, 'C3': 6057},
               {'C1': -3119, 'C2': 47771, 'C3': 56578},
               {'C1': -28788, 'C2': 40274, 'C3': 27597},
               {'C1': 15343, 'C2': 27158, 'C3': 19722}],
        'B4': 'psb'},
 'A4': {'D1': {'E1': 1342747216,
               'E2': 114,
               'E3': [3023445713, 3295534587],
               'E4': 12998935631921121121},
        'D2': {'F1': -942448662734196031,
               'F2': 3091212564,
               'F3': [2241274989, 3826497417, 3194727174, 3440423316]},
        'D3': 13993386269217285045}}

Вариант №15

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

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

(b'DIUV\xb9\x1f\xc9@q\x00.E\x89\xc2b\n\xcb\x1b \xc9\x83\x97\xef\xfbj\x0b]\x14'
 b'=O2\xf3Z\xac\x18-a\xac>\xf8w\x8f\xbe\x7f\xa4\x04\xbfu\xfa\xe7\x83\xb3'
 b'\x91\xca\xcd\xdb\x1aGqwpycfcv8\x7f\xda\xf1\xf83\xbd7v\xea\x00\x02\x00\x1e'
 b'\x1b\xa9\x93R!\x95\xcd\xf7X\xa9\x17\x02V({\xdfa\x01\x00\x02\x00"\x87\xa1'
 b"\xb4'\xad\xe7\xc0]M7\xd7\x95\xed\x9e\x00\x00\x00\x02\x00\x00\x00&")

{'A1': 533282929,
 'A2': {'B1': -0.9608597159385681,
        'B2': -8956654933686674873,
        'B3': 'qwpycfcv',
        'B4': [{'C1': 4071213320952331575,
                'C2': 30442,
                'C3': [13043, 23212],
                'C4': 1993286291048222199},
               {'C1': 6388662845204626399,
                'C2': 24833,
                'C3': [6189, 25004],
                'C4': -8673453324824493987}],
        'B5': 1295505301,
        'B6': -4706,
        'B7': [0.4852871596813202, -0.24964910745620728]},
 'A3': {'D1': 5010749786770053920,
        'D2': -55,
        'D3': [33687, 61435, 27147, 23828, 15695]}}

(b'DIUV\xb9\x0575\xd6\x000 )M\xe9P\xa9\x10y\xfd\xb6\xec\xc0\x80\x9f\xb5\xadi'
 b'^\xff\xa3\xc7\xc1`\xf7\xd1\xc7\xdd\xe4\xd0\xbfw\x02\xe6\xbf!\x01\x1b'
 b'\xbfW\xde\xd8Y\x00!ei\x82h%cpaqtoxk\xdb*\xcaP\xf9\xde\xc95W\xa5\x00\x02'
 b'\x00\x1e\x846\xe5\x06\x08\xf3\xbd\x98\x9ff\xa4\xd4~\x80\x96fAD\x00\x03\x00"'
 b'\xb6thw\x9dDdY"i\xa9\x9d\x88\xe2\x00\x00\x00\x02\x00\x00\x00(')

{'A1': 87504342,
 'A2': {'B1': -0.8432440757751465,
        'B2': 6413162588821153829,
        'B3': 'cpaqtoxk',
        'B4': [{'C1': 15792657492466387253,
                'C2': 22437,
                'C3': [-23609, -16032],
                'C4': -8919690197877932648},
               {'C1': 11486049132217407078,
                'C2': 16708,
                'C3': [-2095, -14371, -6960],
                'C4': -5299495998559329191}],
        'B5': 577350045,
        'B6': -30494,
        'B7': [-0.9648879766464233, -0.6289231181144714]},
 'A3': {'D1': 2317469147734806649,
        'D2': -3,
        'D3': [46828, 49280, 40885, 44393, 24319]}}

Вариант №16

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

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

(b'\x9eNASB\xe8(\xe0\na}\xab\xea_m\x02\x00\x00\x004\x00\x97&8\x00o\x00\x02'
 b'\x00\x82\x00\x00\x00\x1b\x10[\x14\xb7\xa7xC\xcf\xbd\xd5\x874\x04\xb4'
 b'T\xa4,\xbc"\x00+\x00\x8b\x03\xe8\xb5i\xe8\xac3o\xd3\xe1\x8d \xa1\x0f;'
 b"\xbb\xc3_%\x9fc\xfd\xd7t\xbf\xd2\xffZ\xbf-d\xf6>\xf5\xbbs>\xa5H\xd8>\xb0'"
 b'}\x85\xbes\x04n?\xad\x0f\xf2>\xb5\x06\xc8\xa27\x0eD\xa6\xf7[\xe7\xd8h'
 b'L[\xf2\x07\xd2?<C&\n53\xd1?PE&\xbbhG\xc5?')

{'A1': -1536996992069130008,
 'A2': {'B1': {'C1': 27999,
               'C2': [{'D1': 16, 'D2': -1481173925, 'D3': -0.10120290517807007},
                      {'D1': -43,
                       'D2': -1274792825,
                       'D3': -0.010537225753068924}],
               'C3': 9879,
               'C4': {'E1': 3051881355,
                      'E2': 105,
                      'E3': 2345779279149903080,
                      'E4': -95,
                      'E5': 7178497424287808271,
                      'E6': [-0.9564207196235657,
                             -0.8554660081863403,
                             0.48123303055763245,
                             0.23802168667316437,
                             0.42242923378944397],
                      'E7': -80,
                      'E8': [-0.26072046160697937,
                             0.9297553896903992,
                             0.4727758467197418]},
               'C5': {'F1': 1717,
                      'F2': 200,
                      'F3': 1141782434,
                      'F4': 3881564070,
                      'F5': 0.2817350284182232}},
        'B2': [0.2687504386058668, 0.1662417329612631],
        'B3': 27}}

(b"\x9eNASB\x14\xd4C\xf6=\xdbH]'\xf8\x03\x00\x00\x00=\x00\xba\x11C\x00z\x00\x04"
 b'\x00\x8d\x00\x00\x00?\xe3\xd4\xa2\x7f\x1a\x92\x10@=\xcd("\x9d\xa3'
 b'\xf2O\xd3\xbd\xa8\x10C\xc5[\xe7\x02\x9b\xbe"\x00+\x004\x00.,4\x1e\x0c'
 b'\xe5\x05\x92\xa3\xc1E\x0b\x9f\x951\xb7\x9d\x81\x84\xf13HC\x08\x9a>R.\xa1'
 b';\xf7\x98c\xbf|cm\xbf\xd6\xd9\xac\xbe\x87\xeb\r\xfd>\xfe~f?\x0f\xf3'
 b"\xee>\xa3'\xa98\x8fG=\xb7\x86\xa3\x13\xf8\x91\x0el]B\xe9\xbfT\xfe\xbe"
 b'\xb1\xc7\xc6\xea?\xde|\xbdM\xce~\xe4?\x14\xcdL,\xcdC\xea\xbf^L\x15'
 b'\x11\x83\x82\xe8\xbf')

{'A1': 6721863503021593620,
 'A2': {'B1': {'C1': 63527,
               'C2': [{'D1': -29, 'D2': 444572372, 'D3': 0.046890802681446075},
                      {'D1': -51,
                       'D2': -1549983192,
                       'D3': -0.10317982733249664},
                      {'D1': -88,
                       'D2': 1539654416,
                       'D3': -0.30275651812553406}],
               'C3': 4538,
               'C4': {'E1': 506735662,
                      'E2': 12,
                      'E3': -6986413698959931931,
                      'E4': -107,
                      'E5': 5202767545955628849,
                      'E6': [0.30084428191185,
                             0.004918851889669895,
                             -0.8890528082847595,
                             -0.9272992610931396,
                             -0.3375994563102722],
                      'E7': -121,
                      'E8': [0.49424681067466736,
                             0.900375247001648,
                             0.46669813990592957]},
               'C5': {'F1': 10147,
                      'F2': 169,
                      'F3': 1028099896,
                      'F4': 329483959,
                      'F5': -0.7893511877524011}},
        'B2': [0.8367651435473342,
               0.6404792326319713,
               -0.8207765450701197,
               -0.7659316381126577],
        'B3': 63}}

Вариант №17

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

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

(b'FYFI\xcd&\x00\x00\x00\x02\x00\x00\x00\x1e\x00:M\x0b\x00\x00\x00J\x00l'
 b'\xb2\x9a\x00\x00\x00|pkJ\xa0\xe9\x8aITn\x85R\xdb+\x87n\xd8$I\xd8Z\xad\x04'
 b'3\xd1\xe1YN\x06-r9\xb5\x00\x00\x00\x02\x00 \x00\x00\x00\x03\x00"\xabe'
 b'\x04\xbf\x94\x8c\xd8\xd4\xa9ex\xf2J\x06\t3%\xab\x1e\x0eH\x051\xa4b\x89'
 b'i\x13\x9d&\x16.\xb3\xdb&\xa9Y}\x00\x00\x00\x02\x00Z\x00\x00\x00\x02\x00\\'
 b'\xae\xdf\xfc,\xa9\xb80\xb4\x93\x0c\xbf\x1b\x949mu')

{'A1': -13018,
 'A2': 'pk',
 'A3': [{'B1': {'C1': [45, 114, 57, -75],
                'C2': [74, 160],
                'C3': [16828343584603591387,
                       3136597540087650394,
                       12467146644990283270]},
         'B2': 19723,
         'B3': {'D1': 12350282774010976468,
                'D2': -1452967694,
                'D3': 18950,
                'D4': 2355}},
        {'B1': {'C1': [38, -87, 89, 125],
                'C2': [37, 171],
                'C3': [2165747657956680329, 7571568185446413275]},
         'B2': 45722,
         'B3': {'D1': 12601067551162118324,
                'D2': -1827881189,
                'D3': -27591,
                'D4': 28021}}]}

(b'FYFI)\x94\x00\x00\x00\x02\x00\x00\x00\x1e\x00B]\xa4\x00\x00\x00R\x00\x8c'
 b'\xff\xcb\x00\x00\x00\x9cwv\xb4T\x01\xfc%\x9cJ\x84\x1a\x11\xc0\x1a'
 b'\xfd\xba\xde\xbe\xcc\xfa\xbf\xe8\x0eZ\xc0=\xdb\x84\xfbE\xea\xae\r\xf9@-C\xfb'
 b'\x01!\x00\x00\x00\x02\x00 \x00\x00\x00\x04\x00"X\x18\xacU\x00\x94\xf6pX)'
 b"&mi\xc8\x11\x99\xd8\xd2\x93'\xfd3\xd8j\x90k\x7f\x93\x93\xdbt\xd0\x05:"
 b'\xf8\x02YH/\xf0\xa0\xea??L\xfe&\x8a\xcbo2\x1c\xa5\x1937}\xedY\xd6_\x91'
 b"\x00\x00\x00\x02\x00b\x00\x00\x00\x05\x00dk\x17\xd6\xca$4\xdfp'\xc0L\x9c"
 b'1w\xde\x0b')

{'A1': 10644,
 'A2': 'wv',
 'A3': [{'B1': {'C1': [67, -5, 1, 33],
                'C2': [180, 84],
                'C3': [143030641364310545,
                       13842655383719431418,
                       13828318438776232836,
                       18106135910192594989]},
         'B2': 23972,
         'B3': {'D1': 6348013155860674160,
                'D2': 1479091821,
                'D3': 27080,
                'D4': 4505}},
        {'B1': {'C1': [89, -42, 95, -111],
                'C2': [216, 210],
                'C3': [10603722246783144043,
                       9192853835160225082,
                       17870944437936365802,
                       4557446002374265711,
                       3610942528896335341]},
         'B2': 65483,
         'B3': {'D1': 7716872650201816944,
                'D2': 666913948,
                'D3': 12663,
                'D4': 56843}}]}

Вариант №18

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

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

(b';QCC\x02\x00\x00\x00=\x00fthklpr;R\xc1c\x0bG\xca\x0eLI\x91\x1e._4\x15\xeb>B'
 b'\xfd\xe2\xdcU\xb1"\r_\x12\xa2\x84D\xad\x03\xc5r\x83=j\xb19\xf0\xf8m'
 b'D\xd4\xd9\xef\xad\xfdR\x86\xd8\xdc.ccik\x16\xf2#{\x04\xa1\xd1\x03\xf0'
 b'\xfd\xd2?\x01\x01P3\xae\xb6\x19d\xe3J-cX\x8fB\xdd\x19{\xca\x9b&g\x11`\xe5'
 b'\xbf')

{'A1': [{'B1': -44,
         'B2': 217,
         'B3': {'C1': [1392356847, 786225286],
                'C2': 8873201868955280227,
                'C3': 0.29674911854682784}},
        {'B1': 1,
         'B2': 1,
         'B3': {'C1': [3064869712, 1256416281],
                'C2': 8870364219025417005,
                'C3': -0.667977048365054}}],
 'A2': 'fthklp',
 'A3': 15218,
 'A4': {'D1': [191086930,
               1276037703,
               773755209,
               -350931873,
               -486718914,
               582047196,
               -1575854323],
        'D2': 61686916,
        'D3': -59,
        'D4': 1782416242,
        'D5': 177,
        'D6': [57, 240, 248, 109, 68]}}

(b';QCC\x02\x00\x00\x00=\x00pdyvwec\x90\x0c\xec\x02\x01\xabYI\x98\xa2='
 b'_\xe1\x1fkJ\x9f`&\xe9\xf9\xbb\x16V\x8b\x01gP=\xa0\xb8\xb9\x11q\xee'
 b'+\xe3\x02\xb3\xc1\xf8\xcf\nr\xbe\x94xQ=\xe2\xc8\xc65\xe6\x84\x0e\x8b(\xac'
 b'\xa3(O`S\x9c\xf06l\xc1\xbf\x8c\xce\xce\xb9z\xe7N\x84m\xe8\xe3\x8c1l\xa4to'
 b'X\x08#\xd9\x02\xc2\xa3\xc2\xbf')

{'A1': [{'B1': -66,
         'B2': 148,
         'B3': {'C1': [3795669368, 3862283976],
                'C2': 5703988887874637444,
                'C3': -0.13611494778219946}},
        {'B1': -116,
         'B2': 206,
         'B3': {'C1': [3883579854, 3899491406],
                'C2': 6372440247291186403,
                'C3': -0.14562249316284004}}],
 'A2': 'pdyvwe',
 'A3': 36963,
 'A4': {'D1': [16968716,
               -1740023381,
               -513851998,
               -1622512865,
               -102160800,
               -1957292357,
               1028679425],
        'D2': 297384096,
        'D3': 113,
        'D4': 48442350,
        'D5': 179,
        'D6': [193, 248, 207, 10, 114]}}

Вариант №19

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

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

(b'ISK\xb1\x00\x18t\xf7\x9e]f\xf1\xce\xc2\x00\x00\x00=H\xd8\x9a%\xca\x9d'
 b')\xdc@\xbf\xee\xea.o\xa5\xd3:\x00\x00\x00\x03\x00\x12Z\x00\x00'
 b'\x00\x03\x00\x15\x83\xa0(gi#|\xf6<\xe1\x15M\x10\xbf\xe3\x98>u\xd2\xe5'
 b'X\xb0\xc9H@\xfe\xea\xd4>y\x91\xcay~\n\r\xd4\x8b\xa4\xf2V\xf3\x9c\xb0'
 b'\xfb%j\xbe\xe4\xb0\xb2\xcc\xb5\xcd\xbc\x12\x05\xccs\xe5\xbc\x8f\xea\xe2'
 b'\x8e\xb5\xb3{S\x12G$\x99')

{'A1': {'B1': {'C1': 41,
               'C2': 56384,
               'C3': -0.9660865955944253,
               'C4': [{'D1': [72, -40, -102], 'D2': 90},
                      {'D1': [37, -54, -99], 'D2': -125}]},
        'B2': -6906156327308036548,
        'B3': -518697712},
 'A2': 8428379351643442882,
 'A3': {'E1': -0.6123344708677605,
        'E2': 2965981248,
        'E3': 65258,
        'E4': -44,
        'E5': 0.24372020363807678,
        'E6': {'F1': 8754445780171597042,
               'F2': [1458805936, -81433922, -458181940],
               'F3': [-18995, -17390, 1484, 29669],
               'F4': -0.017568055540323257},
        'E7': 10283322666426451748,
        'E8': -103}}

(b'ISK\xb1\x00\x16~?\xb1\xa3W\xb9\x14\xf3\x00\x00\x00;<\xd0j\xfcKBg?\xe03'
 b'\x13\xb2K)\x1a\x00\x00\x00\x02\x00\x12!\x00\x00\x00\x02\x00\x14\xb9A'
 b'\x95\xfb\xd0\xccl#\xa1\xdcQ\x0e\xd5?\xd1\xcbQ\xe3Nk,\xac\xbfz\x16\xc1'
 b'\x88\xc3\xbe\xf0\x92\xa3\x04F\xf4\xcc\x0c\xbf\xa4\xb2F\x1d\xd0g\x8e\x88'
 b';\x93m\xbe\x1d\xbcA\xdf\x9d\x8cq\xb8\x07\xa5\xbf`\xd2\xc6\xcd\x13'
 b'\x1a&\x00\x9b}\x7fu')

{'A1': {'B1': {'C1': 75,
               'C2': 16999,
               'C3': 0.5062349779412074,
               'C4': [{'D1': [60, -48], 'D2': 33},
                      {'D1': [106, -4], 'D2': -71}]},
        'B2': 4725960258196612001,
        'B3': -598667563},
 'A2': 9097185087421224179,
 'A3': {'E1': 0.278034660319167,
        'E2': 2898229782,
        'E3': 49544,
        'E4': -61,
        'E5': -0.4698687493801117,
        'E6': {'F1': 308202781745849522,
               'F2': [1176359015, -1903674477, 1841175996],
               'F3': [16863, -25204, 29112, 1957],
               'F4': -0.8782161474227905},
        'E7': 14777183552853998975,
        'E8': 117}}

Вариант №20

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

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

(b'DSJa\x1c\x13\xbfX\x00\x00\x00+\xd0\x03\x00p\x00\x84B\xd3\x03\xa1g\x91N&\xfcB'
 b'\xe20\xed\x96\xe2ialgbib\xd2FH\xeeD\xf9\xf0"\xf7\xa0\x86\xa0\xba\x94\xd0\xa8'
 b'\xd3\xfe\xdf\x1e\xb3\xd0\xa9\x08"\n[\xb5\x08\xd2O\x04N\xf3\'\xe9tp\xa8"'
 b'8\xed\xe1\xf2\x83p\x83B\x07\x00\x00\x00!\x00(\x008\x00H\x003E\xcf>'
 b'\xb7G\x0e\xee:\xaf\x98w\xe7-\xda\x8a\x83\x82')

{'A1': -0.5746517777442932,
 'A2': {'B1': 'ialgbib',
        'B2': [{'C1': 3997714130,
                'C2': 11567109676251281732,
                'C3': -1462725446},
               {'C1': 517996243, 'C2': 13068049885036138675, 'C3': 72339976},
               {'C1': 3911709518,
                'C2': 17501530452293873780,
                'C3': 1115910275}],
        'B3': 0.404824823141098,
        'B4': 8617830554610321335},
 'A3': 53291,
 'A4': {'D1': [11751, -29990, -32125],
        'D2': 5661420147832996484,
        'D3': [3796040742, 3801541936]}}

(b'DSJ\t]\x13?S\x00\x00\x00\x17\xa4\x03\x00k\x00_\x8d\x91\xe6Izo\x10ti0'
 b"\x8b\x1f\x9f\x88Her\t'F\xa6\xa3e4\xb2\x9a\xb1\x97\xdd\xb2\x0b\xf6\x90S"
 b'\xe5\xe9\xc9\xc9\xdb\xb91h\xd1\xe3o~\xc1F\xaa\x83\xad\x1c\xf4\xbc\xdcx\xf7,'
 b'f\xb8(\x19jK%\x02\x00\x00\x00!\x00#\x003\x00C\x00\x07\x05i\xbe#'
 b'\xf2\xe7\xd1\xa4F\x1b\xa1L\xf9\xda\xd6HP')

{'A1': 0.5756383538246155,
 'A2': {'B1': 'er',
        'B2': [{'C1': 2789615369,
                'C2': 15967426281838241187,
                'C3': -1862923342},
               {'C1': 3387549011, 'C2': 8062518003364387785, 'C3': -1438203522},
               {'C1': 4095520131, 'C2': 2934207500548365500, 'C3': 625699353}],
        'B3': -0.22755824029445648,
        'B4': 11608950138187805219},
 'A3': 42007,
 'A4': {'D1': [-1716, -10534, 20552],
        'D2': 1184299684841229663,
        'D3': [2335205748, 1216913183]}}

Вариант №21

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

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

(b'WSKB`\x1b\xcdV\t|\xc7\xb4\xfdE\xa7\xd8\xbf\x13y@U\x80\x98\xb4\xbe\x03\x00.'
 b'\x00\x02\x00S\x00\x00\x00\xf8\xefi\xbfpykpq[\x00ypg\xf2I\x1b9Y\xcf\x1c'
 b'S\x82\x96\xd0C\x10\xcb\xe6r\xbd\x19\xc3\x8e\x8b\x0f\xe1I\x96\x03\xd8'
 b'\xef^\xd4j\xbb]\xb31\x00\x00\x00B\x00\x00\x00\x1a|\xc5\xb4!\xdc\xca\x9b\x12'
 b'\xff\xad\xdaU@\xb1mvN\xbfy\xc3\xc2Y')

{'A1': {'B1': 156683547,
        'B2': -0.3852095582579904,
        'B3': 1430288659,
        'B4': -0.3527259826660156,
        'B5': 'ypg',
        'B6': [{'C1': 242,
                'C2': -9055862748831212727,
                'C3': 272879766,
                'C4': 3178424011},
               {'C1': 25,
                'C2': 258475259597655747,
                'C3': 3562991576,
                'C4': 3009264490}]},
 'A2': -0.9138178825378418,
 'A3': 'pykpq',
 'A4': {'D1': 3032841242,
        'D2': 33,
        'D3': 6186448349187263196,
        'D4': 1986900288,
        'D5': [-16562, -15495, 22978]}}

(b'WSKB`\xd3^s\xb8d\xd1v\x0b\xbbo\xea?\xe7\xc6\xc8\xa5\xcc\xd2n\xbf\x05\x00.'
 b'\x00\x02\x00U\x00\x00\x00\x95\x16\xbb\xbehbwrf]\x00ektnt\xe5\xab\xfb\xea\xd3'
 b'\x10c|0\xa4\x13X\xac\xbc\x16\x18\xaf\x94%\x03p3\xaan\xf0\xb5\x92"\xaf'
 b';\xd9\xc8\x96\x913\x00\x00\x00D\x00\x00\x00\xa1H:\xbf\x91Td\xba"B\x0f'
 b'O@\xf5\xd3\x14\r\xd1\xcbm?\xa6m')

{'A1': {'B1': -1200398637,
        'B2': 0.8261389945896949,
        'B3': 2781398759,
        'B4': -0.9329040050506592,
        'B5': 'ektnt',
        'B6': [{'C1': 229,
                'C2': 3493776334858681259,
                'C3': 2891453348,
                'C4': 2937591484},
               {'C1': 148,
                'C2': -5336643881147563227,
                'C3': 1001333394,
                'C4': 2442578137}]},
 'A2': -0.36540666222572327,
 'A3': 'hbwrf',
 'A4': {'D1': 3208267937,
        'D2': 145,
        'D3': 4633939318312428628,
        'D4': 219468789,
        'D5': [-13359, 16237, 28070]}}

Вариант №22

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

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

(b'GWVRXO\x00\x00\x00_\x00\x00\x00o\x00\x00\x00}\x00i6y\xc302C\xea\xef'
 b'\xb3\x87r,\xf2p\x9c\xd1\x17\xf6\xcf\xc6\xbfG\xa7<\xd5\xc0\xb5\xba'
 b'\xaf\xd0\xb6\x95Jq\xff\xb0?\xaa/\xc0m"&\xd8d\xca?\x02\x00\x00\x00\x96'
 b'\x00\x00\x00\xd3\xe2iz\xb3\x7fq\xef2I\xfa\xf8\x02\x00\x00\x00M\x00te\x08'
 b'\xff\xce\xd1\xaea\x94\xea\x02\x00\x00\x00]\x00gqaT\xef3V\xe5A\xc2\x02'
 b'\x00\x00\x00m\x00cE6\xcd"\xf3\xf7(n)\x0b?\xe0\x16^\x8e\xd0\xe6\xa5?\x95|;'
 b'3\x90%\x9e\xca-Z\xd6\xe3E')

{'A1': [{'B1': -506011525011374157, 'B2': 'iz'},
        {'B1': -1543501368809029880, 'B2': 'te'},
        {'B1': -4449022798464068511, 'B2': 'gq'}],
 'A2': {'C1': {'D1': 2952095411561973091,
               'D2': 0.5436009168624878,
               'D3': 0.042776601199006725,
               'D4': [-107, 124, 59, 51],
               'D5': -112},
        'C2': 13929,
        'C3': 50041,
        'C4': 12848,
        'C5': 17450448583318825539,
        'C6': -0.17822147524859444,
        'C7': [42823, 54588, 46528, 44986],
        'C8': 0.06639774390142894},
 'A3': 12202,
 'A4': 0.20620252477679735,
 'A5': [768253477, 1172559450],
 'A6': -7469}

(b'GWVRXO\x00\x00\x00_\x00\x00\x00o\x00\x00\x00}\x00\x15\xd3Rb\x987\xdc\x11\x1a'
 b'\x81\xc2?}9\xec\x16\xb4\x04\xaet\xea?\xea-\xa4\xbc\xa3A<1\xb8\x97\x13'
 b'\x07j\xb0\xc2?2&|"-\x89\x87\x9d\xd6?\x02\x00\x00\x00\x96\x00\x00\x00\xde'
 b'\xeavz\x88\xa11G\xe6=F\xfd\x02\x00\x00\x00M\x00kp\xf2\xab\xadn\x16'
 b'\x01\xd6\x19\x02\x00\x00\x00]\x00teOw\xf6F\xfc\xb6@\n\x02\x00\x00\x00m'
 b'\x002\x08@c;@b\x93\xb4\x8b\x8d\xbe\xf0d\x0c\x95\x0f\xa6\xc6?\x99\xa7\xbe'
 b'\xec)\xad2\x7f\xe9\x01\xb4\xfd\xd8')

{'A1': [{'B1': -196401474497830520, 'B2': 'vz'},
        {'B1': 1861676691822062578, 'B2': 'kp'},
        {'B1': 738791533527332687, 'B2': 'te'}],
 'A2': {'C1': {'D1': 10620121495105439794,
               'D2': -0.27645647525787354,
               'D3': 0.17694277551417015,
               'D4': [-103, -89, -66, -20],
               'D5': 41},
        'C2': -11499,
        'C3': 25170,
        'C4': 14232,
        'C5': 4142537336872899036,
        'C6': 0.8267431346764318,
        'C7': [11754, 48292, 16803, 12604],
        'C8': 0.14600873322996022},
 'A3': 9778,
 'A4': 0.35336483379482053,
 'A5': [3917427373, 3640505345],
 'A6': -5410}

Вариант №23

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

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

(b'\xf5YNQX\x8b\x00H\xb6\xe6\x89\xfeua?\xb0\xd0v\x18\x8e\x90\xd0\x00\x00'
 b'\x00\x02\x00\x0cs\x96\x98\r>\x0fO\x0fZ\xe9G\x89?N\xda\xbdU:\x08\x9e'
 b'\xbe\xcc\xe5\xdc\x00\x1c\x00$\x00,*s_\x10\xa5s\x93[\x89Tez=F\x00\x00\x00\x0e'
 b'\xe9\x00\x03\x004\x1c\x96\xea\x08\x0b\x9f\x88\x14\xf9\x91\xa9\xf4[\xff\xe1'
 b'o\xa8\xed\xb6\xfd\x0f\x00\x00\x00\x07\x00\x00\x00:\xbf\xe2\xee\xe6~\xfb'
 b'5\x04>D\t\xce\xb7(\xca=n\xf6\x9b')

{'A1': -117,
 'A2': {'B1': {'C1': 0.06568086719068167, 'C2': 'ua'},
        'B2': 233,
        'B3': [{'D1': 29590, 'D2': -104, 'D3': 13, 'D4': 0.13995002210140228},
               {'D1': 23273, 'D2': 71, 'D3': -119, 'D4': 0.8080251812934875},
               {'D1': 21818, 'D2': 8, 'D3': -98, 'D4': -0.40019118785858154}],
        'B4': 7318,
        'B5': -368571489,
        'B6': -8641007381000201217,
        'B7': {'E1': [225, 111, 168, 237, 182, 253, 15],
               'E2': [10867, 24336, -23181, -27813, -30380, 25978, 15686],
               'E3': -0.5916626434424477,
               'E4': 0.19144365191459656,
               'E5': 46888,
               'E6': 202,
               'E7': 0.0583406500518322}},
 'A3': -1226405378}

(b'\xf5YNQX\x86\x00>3\xfd\xdd\xa9ap?\xc2\xda\xce\xc4\x19\x1f(\x00\x00'
 b'\x00\x02\x00\x0c=E"Q\xbc5A1\x08\xbf0q\xbf\x19k\x98\x00\x1c\x00$\x84\ro\xb7'
 b'\x92\n\x02\xe0\xcdG\x18\xa6\x02\x0b\x00\x00\x00\x0e2\x00\x02\x00,\x07'
 b'\xe3\x12Ve.?<\xfb\x975\x9bg\xf8{\x01jG\x9c6\xc1\x00\x00\x00\x07\x00\x00\x000'
 b'?\xd9p3\xaf\xc7\x18\xcc\xbe\xae\xa9r@\x97^\xbe\xe6\xf5\xa7')

{'A1': -122,
 'A2': {'B1': {'C1': 0.1473024804602059, 'C2': 'ap'},
        'B2': 50,
        'B3': [{'D1': 15685, 'D2': 34, 'D3': 81, 'D4': -0.011062906123697758},
               {'D1': 2239, 'D2': 48, 'D3': 113, 'D4': -0.5992980003356934}],
        'B4': 2019,
        'B5': 307651886,
        'B6': 4556793549850109944,
        'B7': {'E1': [123, 1, 106, 71, 156, 54, 193],
               'E2': [-31731, 28599, -28150, 736, -12985, 6310, 523],
               'E3': 0.3974732605532949,
               'E4': -0.34113651514053345,
               'E5': 16535,
               'E6': 94,
               'E7': -0.451092928647995}},
 'A3': 872275369}

Вариант №24

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

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

(b'SPAY\x00-\x00o\xae;,m\xe3\xbd?\xe9k\x98\x0b\x97\x1eR\x00\x00\x00\x06\x00\x00'
 b'\x00y\x97$S\x15\xbd\x08Y\xf6V\xca\x81\xa2\xecuu\x00\x00\x00\x02\x00+[e*\x9cF'
 b'\xd1\xc4\xf9\xa9\xff\xbfZ\xf33\xbe\\zE\xc8XQN\xf0\xdf\x87\xac\xde=\x03'
 b'i\xce*bb\xf1\xec\xd1\xc3\xa2\x9d\xd7\xfb\xf9d\x19S\x01.\x9d\xf1\xc8\x8dj'
 b'_\xde\x90\xdaz\xe6?\xbf\xe5sy\x00]\x9b\xa2\xb0k\xcf&B\xd7\xc2\x00Wcu\xe0\xce'
 b'\xbfr\xbb\x12\x9f\xc0\xabh\x00@\x98\xfb\xd3')

{'A1': {'B1': 'uu',
        'B2': 23397,
        'B3': {'C1': 3070406912726641151,
               'C2': -0.855273425579071,
               'C3': -0.21531017124652863},
        'B4': [{'D1': -56,
                'D2': 22609,
                'D3': [20208, -8313],
                'D4': [2900245763, 1775118946, 1660021969],
                'D5': 50082},
               {'D1': -99,
                'D2': 55291,
                'D3': [-1692, 6483],
                'D4': [19832305, 3364711007, 3734035066],
                'D5': 58943}]},
 'A2': {'E1': -0.67034578391473, 'E2': 45163},
 'A3': 44603,
 'A4': 745399229,
 'A5': 0.7943840242741749,
 'A6': {'F1': [3475391191,
               3254802275,
               1977667263,
               1924862623,
               3232458752,
               1083767763],
        'F2': -1759227115},
 'A7': -4825508086174547550,
 'A8': 236}

(b'SPAY\x00-\x00oX\xa6g\xd9\x0b\x0f\xbf\xd4\xc8~\xc0\t\xd7\x00\x00\x00'
 b'\x00\x05\x00\x00\x00y\xa9.\xe23\xfb\x90;=6\x1b\xd5\xfePdi\x00\x00\x00'
 b'\x02\x00+\xd3\xdb~qL1D\x92\xb5#\xbf\x0e\x063?aC\xf3+B1\xfa\xbbD\\'
 b'\x8f\x17\x08\x8a\x0f!\xcfd\xdd\xbd\x8a\xef\x08\xc9\xd8}>\xdc0\xca'
 b'\xac\xee\x85\x84\xbf\r\x81q\x90\x8bV4\x07%d\xbf\xa0B\xa2\xeaU\xc0\x00t'
 b'q\x14s\x9bXQi\x16\xec\xcbe&\x7f0\x99\xa8\x88DgL\x99')

{'A1': {'B1': 'di',
        'B2': -11301,
        'B3': {'C1': 9111147295634797859,
               'C2': -0.5547820925712585,
               'C3': 0.8799430727958679},
        'B4': [{'D1': 43,
                'D2': 16945,
                'D3': [-1349, 17500],
                'D4': [2400651402, 253874020, 3720186607],
                'D5': 2249},
               {'D1': -40,
                'D2': 32062,
                'D3': [-9168, -13652],
                'D4': [4001727679, 226587024, 2337682439],
                'D5': 9572}]},
 'A2': {'E1': -0.0317583952954692, 'E2': 29809},
 'A3': 22694,
 'A4': 1742277391,
 'A5': -0.32473725084069827,
 'A6': {'F1': [343120728, 1365841644, 3412403839, 815376520, 1147620505],
        'F2': -1456545229},
 'A7': -319690439456467458,
 'A8': 80}

Вариант №25

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

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

(b'SNCA<\x00\x00\x00I;A\xbf\x04\x00\x91\x00F\x8a\xc1d"$\r\xeb.\x0b\x04\xfb*/EX'
 b'Z%\xfaX?\xbd(\xf4\xbe\xa1\xdb\xb5>MGU\x8f\x9afpk`=&=^\xf2\x0fC\xcf\xbc=wsxs'
 b'krj\x80\xc0\x85K\xda\xbf\xaf\xbfR\r\xaa\x90\xcd\xa9e\x0c\x7f\x9b\x03\x00\x00'
 b'\x00\x18\x00\x00\x00\x89Q)\x89\xd1\x85\xb3\xaa\x85\x97RA\x91{\xfa'
 b' \x99\x0b\x1b\x04\x00\x00\x00\x1b\x00\x00\x00\xc8\xfb\x0b\xbf\x18\xdc\x1cN'
 b'k\xe3\x8f\xe0\xec\xcf\\\xb0\xcb\xf8 \x1f\x00=\x14=`')

{'A1': {'B1': 53059,
        'B2': 15804,
        'B3': 'wsxskrj',
        'B4': -0.06201059505372175,
        'B5': 3410,
        'B6': 11204688028701135018,
        'B7': [{'C1': [46, 11, 4],
                'C2': 20873,
                'C3': 2245101865,
                'C4': 2542119603,
                'C5': 2073117010,
                'C6': 194584826,
                'C7': 27},
               {'C1': [251, 42, 47, 69],
                'C2': -1080,
                'C3': 3692609291,
                'C4': 3815460380,
                'C5': -806559601,
                'C6': 4174098524,
                'C7': 32}],
        'B8': {'D1': 23128,
               'D2': [0.8475669026374817,
                      -0.4768733084201813,
                      0.35519126057624817],
               'D3': 2404730701,
               'D4': 154,
               'D5': 28774,
               'D6': 1149084471660470379}},
 'A2': {'E1': -0.7548108696937561,
        'E2': [61, 20, 61, 96],
        'E3': 1690405446,
        'E4': -351460318}}

(b'SNCA=\x00\x00\x00\xbb\xb9\x04\xbf\x06\x00\x92\x00\xf0\x85\xfc\xb74\x145\xb5'
 b'H>U\xa6\x97\x0e%\x1e\x11Mp\x8c\x12?\x0c\xf1T\xbf\xcf\xe3\x19?\xa9\xe4'
 b'\xfa|\x9d\x84\xe9l:b\x9cdk\xba\x14\xcf\xe6\x14\xf1wdumdig\xd8\x07h\x89'
 b'\x99\x90\xc9\xbf\xc1\xfb\xa1\xcd\x19\xa7\xb0\x00\x85)\x04\x00'
 b'\x00\x00\x18\x00\x00\x00\xc62\x8a;\xe73u\xdd\xdf\x9bC8\xb0\x0fcP\xe1\n'
 b'\xb9\x04\x00\x00\x00\x1c\x00\x00\x00\xeb_0\xd7\x17c\xd0H\xc1a\t'
 b'\x97\xd1\xd5\x0c\x8c\x1a\x02* \x005\xb5t^T:')

{'A1': {'B1': 59087,
        'B2': 61716,
        'B3': 'wdumdig',
        'B4': -0.19972533425612826,
        'B5': -1087,
        'B6': 2991798286175292833,
        'B7': [{'C1': [72, 62, 85, 166],
                'C2': 12998,
                'C3': 870792074,
                'C4': 2615139701,
                'C5': 263206979,
                'C6': 182538339,
                'C7': 185},
               {'C1': [151, 14, 37, 30],
                'C2': 24555,
                'C3': 1662506800,
                'C4': 1640057040,
                'C5': -707684599,
                'C6': 35294220,
                'C7': 42}],
        'B8': {'D1': 19729,
               'D2': [0.5724554061889648,
                      -0.8318030834197998,
                      0.601132333278656],
               'D3': 2096817321,
               'D4': 157,
               'D5': -5756,
               'D6': 1493624306291325548}},
 'A2': {'E1': -0.5184590220451355,
        'E2': [53, 181, 116, 94, 84, 58],
        'E3': -1208187408,
        'E4': -1254812620}}

Вариант №26

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

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

(b'LOL*\xe5\x89\x91\xd7\xe2:\xed\xe0\xcb\x84V-\x00\x00\xa1\x94c\x1a\xf1\xd8'
 b'\xbf\x03\x00\x00\x00J\x00x\x8e\xefu\x8b\x00\x06\x00\x00\x00\xa1\x00\x00'
 b'\x00&\x04^\x90W\x89\x1bK\xe4\xef3[-\x96\xe2 b\xbf\x90\xa0Px\xfa\xb4\xf7W\xda'
 b'\x07\xd0\x91\xe1C>\xbcL\xcf\x86G\x08\xda\xbf*\x7fH\xbf\x80\x17\x18\x9b\xa7V'
 b'\xb0\xbf\xb3K\xd7>\x04t\xaa?\x90\xec\xdf?\xeb\x0b\x7f\xbf\xb3\xac\xe4>\xe1m'
 b'\xd9\xbeI1\x14\xbf\xc8@K\xbf\x05\x00n\x00\xfb\x0e\x8aV\xc4\xed^e\x92\xe0'
 b'\x1f$l?\xec\x82\x00\xc0\xcf\x07&\x849\xec\xbf\xff\xde"5f\x0c\xf1\xab')

{'A1': -1853233878,
 'A2': 6234331951100781271,
 'A3': {'B1': 38,
        'B2': 4,
        'B3': -1990750114,
        'B4': 27,
        'B5': 16327287368814945355,
        'B6': -1866505696,
        'B7': -2713427893799071584,
        'B8': -12281},
 'A4': {'C1': -0.38971576428095034,
        'C2': [{'D1': 0.19129015505313873, 'D2': -0.4067553345204933},
               {'D1': -0.7831903696060181, 'D2': -0.06382224594571362},
               {'D1': 0.42049941420555115, 'D2': 0.4988136884438179}],
        'C3': 1978633848},
 'A5': {'E1': -1838850323,
        'E2': [8160, 27684, 60479],
        'E3': {'F1': [-0.9962756037712097,
                      0.4466300904750824,
                      -0.4246664345264435,
                      -0.5788770318031311,
                      -0.7939572334289551],
               'F2': [-5, 14, -118, 86, -60]},
        'E4': -0.8820210211547348,
        'E5': 57087},
 'A6': [34, 53, 102, 12, -15, -85]}

(b'LOLE&\x9a\xb1\xfe\xb5>\x8e\x1f\xce\x986-\x00x=\x0b\xd4\xaeh\xc4'
 b'\xbf\x02\x00\x00\x00J\x00\x9cI\x80\xbb{\x00\x03\x00\x00\x00\x91\x00\x00'
 b'\x00\xea\xf6BvK\xcdu\xdaS5Q\xed\xafx\xe0 \xa4\xba\x01\xae\xda\x8d1'
 b'\xae\xca(\x87\xd3\xa6\xf55#? (\xc7\x91\x19{\xbb?\xca\x801\xbf _\xd2\xaa\x832'
 b'\xe8?\xd9kB\xbe\xf8\xdcW\xbf\xc0n\x1e\xbf\xe3\x1c\x1d?\x04\x00b\x00\x9d\xe2'
 b'v\xf3\xfbL\x10\xbbQc\x0cw\xb2*gr\x000\x86\xfb\xdb\x1f?\xd4?\xd8'
 b'\xd4\x88\x8b\x1f')

{'A1': -1315297723,
 'A2': 3934120909433910782,
 'A3': {'B1': 234,
        'B2': 246,
        'B3': -850692542,
        'B4': 117,
        'B5': 16174871495505695706,
        'B6': 29008928,
        'B7': -8707487030016353618,
        'B8': -22829},
 'A4': {'C1': -0.1594446692820204,
        'C2': [{'D1': 0.6375420689582825, 'D2': 0.10734710511238221},
               {'D1': -0.6933714151382446, 'D2': 0.7561662994730547}],
        'C3': 3145746844},
 'A5': {'E1': 1371213900,
        'E2': [3171, 45687, 26410],
        'E3': {'F1': [-0.18986453115940094,
                      -0.8432154655456543,
                      -0.6188774108886719,
                      0.613722026348114],
               'F2': [-99, -30, 118, -13, -5]},
        'E4': 0.3163528106943856,
        'E5': 54488},
 'A6': [-120, -117, 31]}

Вариант №27

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

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

(b'DPLA\x9eU\xa9&\xd2\xad\xdc\x96\xf5\x85\x844O\xc4\x96\x02\x00\x00\x00R'
 b'\x00\x00\x00|\xc2\xee\x04\x00T\x00\xca\x03\x00X\x00\xa6\x02\x00[\x00'
 b'\xbd\x08\x00]\x00z\x04\x00e\x00-\x02\x00i\x00q\x08\x00k\x00\x16\x03\x00s'
 b'\x00DYW\xf2\xa3\x1c\x02\xe33@Zx\x00kc\x82t\xb0\xa1~\xfb\x960\xfb\xde\x03"'
 b'\x8e\x9bWB\x8f\xf4\x9b\x84\x05p\xe0`y@\xd7\xbcPf\xc8u1hrd\x852\x02\x00v\x00')

{'A1': 10870754718668903838,
 'A2': {'B1': -31243,
        'B2': 13444,
        'B3': 79,
        'B4': -26940,
        'B5': {'C1': 'kc', 'C2': 124, 'C3': -62},
        'B6': 238,
        'B7': [{'D1': [-126, 116, -80, -95], 'D2': 202},
               {'D1': [126, -5, -106], 'D2': 166},
               {'D1': [48, -5], 'D2': 189},
               {'D1': [-34, 3, 34, -114, -101, 87, 66, -113], 'D2': 122},
               {'D1': [-12, -101, -124, 5], 'D2': 45},
               {'D1': [112, -32], 'D2': 113},
               {'D1': [96, 121, 64, -41, -68, 80, 102, -56], 'D2': 22},
               {'D1': [117, 49, 104], 'D2': 68}]},
 'A3': 3738834437680551769,
 'A4': 23104,
 'A5': {'E1': 12933, 'E2': [114, 100]}}

(b'DPLA\xf4\x7f\xf9,\xf028\t\x01\xcc5\xc0M\xb9\xf0\x02\x00\x00\x00R'
 b'\x00\x00\x00\xe7\x82\xfa\x07\x00T\x00\x99\x05\x00[\x00o\x08\x00`\x00'
 b'\xa6\x08\x00h\x00Z\x06\x00p\x00\xaa\x06\x00v\x00@\x05\x00|\x00'
 b'\xd7\x03\x00\x81\x00!)\xc6\x94\x1a\xa0\x1c\x14}\x84\xc7\x86\x00nw'
 b'\xa4\xaf\xe1\x05\x93\xec\xa3\xbe\x95\x88\x933\xbc\x03\x8c\xe7'
 b'\x83\x9e\x87\x87\xca?\x14\xac\xb6[\x82U\xe0\x92\x00\xb7\xb3\xeb\r2'
 b'M\xbb\xfd\x8br\x97\x89\xd0iM\xe8\xf0hI\x00\xa8\x02\x00\x84\x00')

{'A1': 664336952165236724,
 'A2': {'B1': -13311,
        'B2': -16331,
        'B3': 77,
        'B4': -3911,
        'B5': {'C1': 'nw', 'C2': -25, 'C3': -126},
        'B6': 250,
        'B7': [{'D1': [-92, -81, -31, 5, -109, -20, -93], 'D2': 153},
               {'D1': [-66, -107, -120, -109, 51], 'D2': 111},
               {'D1': [-68, 3, -116, -25, -125, -98, -121, -121], 'D2': 166},
               {'D1': [-54, 63, 20, -84, -74, 91, -126, 85], 'D2': 90},
               {'D1': [-32, -110, 0, -73, -77, -21], 'D2': 170},
               {'D1': [13, 50, 77, -69, -3, -117], 'D2': 64},
               {'D1': [114, -105, -119, -48, 105], 'D2': 215},
               {'D1': [77, -24, -16], 'D2': 33}]},
 'A3': 9012860228241507881,
 'A4': 51076,
 'A5': {'E1': 43008, 'E2': [104, 73]}}

Вариант №28

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

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

(b"SVSLKeao\x92h\x00>?*^'\x1ca\xf22\xd0\xb15o\xab\xaa\xba\xcd{\xab\xeb\xec"
 b'aY\x00\x00\x00\x03\x00^\xbf\xa7\xd2\xed\xb8\x8ef`\x00\x05\x00\x00\x00jM*'
 b'\x81\xaa\x00\x00\x00xB\x82\xe1e\xd9\xe8N\x87\xbd\xeecQ\x18N\xce@\x1an'
 b'\xb7"\x96\xdf\xbb6\x10\x8fklV\x92\xb4\xe3\x00\x00\x00C\x00\x00\x00L\x00\x00'
 b'\x00U\xac\x08\xe9\xda\x9d\xa6\xbdZ\xaa\xf3{q\x17\xdap\xf5\xa4\xd0'
 b'?\xd3\xb1\x82\xd1\x1f\xb4\xd0\xfb\xd9\xfcvf\xe7\xbex\x8d2\x8e\xba'
 b'\x15<\xb6\xd2\x00\x00\x00\x04\x00t')

{'A1': 'eao',
 'A2': 37480,
 'A3': {'B1': 1115873637, 'B2': 217},
 'A4': 0.6654991507530212,
 'A5': 28,
 'A6': {'C1': 97,
        'C2': 17452240965538393002,
        'C3': 13460550839608041817,
        'C4': [{'D1': 232, 'D2': 5658700288380442702},
               {'D1': 206, 'D2': 4619126100660248507},
               {'D1': 54, 'D2': 1193290539329565923}],
        'C5': -0.04653113248714358,
        'C6': [44040, 59866, 40358, 48474, 43763],
        'C7': 19754},
 'A7': 33194,
 'A8': {'E1': 1895146704,
        'E2': 0.30770941183329814,
        'E3': 4225367158,
        'E4': 26343,
        'E5': 3195571506,
        'E6': 2394559804,
        'E7': 46802,
        'E8': [123, 113, 23, 218]}}

(b'SVSLKloflW\x00>?r&\x80M\x80\x16\xa7g\xa2V\xf67\x8e\xb7\x0fC\x8c@\xac'
 b's[\x00\x00\x00\x02\x00U\xbf\xce\xa4\x8aF\xb6\xf6\xd0\x00\x03\x00\x00'
 b'\x00]\x8at\xd0k\x00\x00\x00gXp#\xfe\xbf\x9d\xa0\x95\x8c\xd9\x17\xf3\xb3&'
 b'_\x9cH\xb3aa\x96\xa45\x00\x00\x00C\x00\x00\x00LhA-s\x00\xef\xcd\xb5\x14b\xa6'
 b'\x04\xdc\x1a?\xcb\xa9\xaf*\xde\xd5\xa8\xe56\xfb\xa7\x80\x03\xef\xf1\x00'
 b'\xee\xddb\xa0\x98\xfeJ\x00\x00\x00\x04\x00c')

{'A1': 'lof',
 'A2': 27735,
 'A3': {'B1': 1483744254, 'B2': 191},
 'A4': 0.9458999633789062,
 'A5': 77,
 'A6': {'C1': 128,
        'C2': 1632387336886433678,
        'C3': 13190836103250998107,
        'C4': [{'D1': 157, 'D2': -6875434392073555162},
               {'D1': 95, 'D2': -7185295974639164363}],
        'C5': -0.2393963666235579,
        'C6': [26689, 11635, 239],
        'C7': -30092},
 'A7': 53355,
 'A8': {'E1': -1509630950,
        'E2': 0.21611585229190422,
        'E3': 3845585831,
        'E4': 32771,
        'E5': 4025549038,
        'E6': 3714228376,
        'E7': 65098,
        'E8': [205, 181, 20, 98]}}

Вариант №29

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

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

(b'OTK\x92\xacEum\x00\x02\x00t\x00gB\x88\xb8\xa9\xd8\xc1\xc4j\xa37\xdaK?\x7f'
 b'\xc0E?)\xb2">\xe7\x11>\xbf\xc6\xe22\xbf\x1a\x959\xbf \xd20>4gy\x00\x07'
 b'\x00\x80\x00\xcd\xab\xfb\x95\x83\x84\x06\xa3\x92\xedF\xf8?>\x01\x8f@'
 b"\xbf\x9e\x99\xc3>\n'\xcf\xbe4tQ\xbf\x10\xa0~>\xcd=\xa7\xbd\xe6C\x85"
 b')\x04\xa4i\xd7\xa5\x1co\xe3U\x02\x00\x00\x00k\x00\xf3\x1e\xb6\xda'
 b'\xe6\xb5\x03\x00\x00\x00v\x00\x19S\xf4l\x97\xa3\xdb')

{'A1': {'B1': 1967500434,
        'B2': [{'C1': {'D1': 85, 'D2': [111, -29]},
                'C2': [-13, 30],
                'C3': 16999,
                'C4': 11775440512556316808,
                'C5': [0.7962984442710876,
                       0.7724685072898865,
                       0.1588827520608902,
                       -0.7424606680870056,
                       -0.6987727880477905,
                       -0.7249313592910767,
                       0.17267656326293945],
                'C6': 26420},
               {'C1': {'D1': -75, 'D2': [-74, -38, -26]},
                'C2': [25, 83, -12, 108, -105, -93, -37],
                'C3': 43981,
                'C4': 17118924381977023995,
                'C5': [0.18747052550315857,
                       -0.7521820664405823,
                       0.3820313811302185,
                       -0.4045947194099426,
                       -0.8181793689727783,
                       0.2486574649810791,
                       -0.08166084438562393],
                'C6': 17382}]},
 'A2': 2064292852942514565}

(b'OTK\xb1\xfc\xdeqo\x00\x05\x00v\x00\x15\xf2\x18\xd1vRO\xc1\xe7\x96a'
 b'\x1cA\xbf\x11\xff:\xbf\xa2\x1e\xfc=!\xfe\xae\xbe\x1fK\xb0>\xad\xc3\xdc>X'
 b'P\xd7<][\x7f\x00\x04\x00\x86\x00\xde\xad\xc4Q\x0e\x06n-q\xa9C\xa0l?s\x01\xc6'
 b"=)\x10d\xbf'\xb2\x1d?%\xf7\xd5\xbeHI_?\xda\xf8\x02>\xc9\xef\x83\x80@_\x9b"
 b'\xd5k\xb8\xd2\x1e{\x9bS\x04\x00\x00\x00k\x00L\x8c!K|\x0cm\xa4\xe9,'
 b'\x04\x00\x00\x00{\x00x^\x07\x17')

{'A1': {'B1': 1910439089,
        'B2': [{'C1': {'D1': 83, 'D2': [-46, 30, 123, -101]},
                'C2': [76, -116, 33, 75, 124],
                'C3': 61973,
                'C4': 10873872371739447576,
                'C5': [-0.7543392777442932,
                       -0.7304545044898987,
                       0.12310530245304108,
                       -0.3417825996875763,
                       0.34432312846183777,
                       0.4311803877353668,
                       0.026283428072929382],
                'C6': 23389},
               {'C1': {'D1': 44, 'D2': [12, 109, -92, -23]},
                'C2': [120, 94, 7, 23],
                'C3': 44510,
                'C4': 12209590015349379524,
                'C5': [0.9243203997612,
                       0.09668245166540146,
                       -0.8908715844154358,
                       0.6159996390342712,
                       -0.4179011881351471,
                       0.8722119331359863,
                       0.12790241837501526],
                'C6': 61385}]},
 'A2': 13288949988781490307}

Вариант №30

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

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

(b'QMXT\x00\x02\x00\x00\x00^?\xdd\x0f\x82+\xcd\xff\xe4\xff\xe8\x00\x02\x00\x00'
 b'\x00fG\xebE5\xab\xdb\xac\xdc\x00\x03\x00nbn `\xff\xb6X\xfc\x05\xd2'
 b'\x9f\x13\xfb\xf8\xb00\x84\x0e\xc6c"\x82\xacI\xfe\x83\x83\x8a_\xac\xaf\xf5//'
 b'\xaea\xae\xc0ZD\x8e\xf0\xb4\x1f\xe6\xba\x02+VL\x9bi\xdf\x98\xda\xd2\x00\x00'
 b"\x00&\x00\x00\x00B?'\xa0\x154R\\\x0c\x82\x02,")

{'A1': {'B1': {'C1': [{'D1': [7092642064134199548,
                              419572623479451696,
                              -8930982881946063799],
                       'D2': 4270031754},
                      {'D1': [6894078597190889057,
                              -5854580265079229409,
                              -1821140714163233943],
                       'D2': 3751336658}],
               'C2': 0.454071562555326,
               'C3': -1,
               'C4': -24,
               'C5': [1059561493, 877812748]},
        'B2': 5182311893038771420},
 'A2': [130, 2, 44]}

(b'QMXT\x00\x03\x00\x00\x00z\xbf\xe0\x92}R\xf4\xf9\xf2F\xa8\x00\x02\x00\x00'
 b'\x00\x86\x9c\x1f\xa2\xc0\x92\x033i\x00\x03\x00\x8em(x6\xd3\xde\xd0"~\x12'
 b'm\x85\xc7\x95\xad\xda\x81\xe5\xa4T\x85a\xb4;s\xf8F_G\xce\x91G\x97fi\xd5\x80b'
 b'0&\xf34,\xb9\xbd\x02k\xd2Cii\xd3\xb9\xca\xc4\x86c\xbc\xdb\xf3\x8f\x1b'
 b'\r\xafx\x98\xe3t\xfcpEI`\xf1\xd5v\xa2\xbcF\xe0\x11z\x0e.\x00\x00'
 b'\x00&\x00\x00\x00B\x00\x00\x00^[\xce8\n\xe9\xd3\x9a\xa8\xde\x94\xef')

{'A1': {'B1': {'C1': [{'D1': [7865668926080733218,
                              9084443819706265050,
                              -9086675990228126661],
                       'D2': 1945650783},
                      {'D1': [5174232758564055509,
                              -9195734545289958215,
                              -4827177299769464365],
                       'D2': 3117073542},
                      {'D1': [7186860944500919727,
                              8689945572602299721,
                              6985599202541455072],
                       'D2': 293211694}],
               'C2': -0.5178820247891152,
               'C3': 70,
               'C4': -88,
               'C5': [1540241418, 3922959016]},
        'B2': 11249889342161892201},
 'A2': [222, 148, 239]}

Вариант №31

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

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

(b"CBR\xbf\xc4`O'\x15K\xc0\x00?\xa2\xad\x00\x00\x00\x02\x00\x00\x00\r#"
 b' L\x00\x00\x00\x02\x00\x00\x00\x18\x85\xfbC\x00\x00\x00\x02\x00\x00\x00'
 b'#\xc3\x8dt\x9b\x15\x00\x00\x00\x04\x00\x00\x00.\xa5\x851\x07\x8fJ'
 b'\xc4\x83\x7f\x00\x0f3\xff\xf8\xeaf\xf5\x00\x1aP1{\xdd\x1c\x9e\x00% \xfb\x1b'
 b'\xad^O\x002\xe2t\x14_\x83\xe7\\\xd3Gq\xa9W\xc6\x1a\x9c\xa8;o\x08\xcc\xc7yl'
 b'\xd0\x9e\xfd\xd2U\xd2\xc9\xcd=\x00\xd1v\x13\xbee\xce\xf3\x83\x00\xa6'
 b'\x03a\xac\xe1\xbe\x84\xd0r\xbe\xa8\xc8\xd9\xbf\x1at\xfb>\xb7$\xdb'
 b'\x00\x02\x00\x00\x00;')

{'A1': -0.15918912323340173,
 'A2': {'B1': [{'C1': 1254392703,
                'C2': {'D1': [162, 173], 'D2': 35},
                'C3': 13311},
               {'C1': -118855947,
                'C2': {'D1': [32, 76], 'D2': 133},
                'C3': 20529},
               {'C1': 2078088350,
                'C2': {'D1': [251, 67], 'D2': 195},
                'C3': 8443},
               {'C1': 464346703,
                'C2': {'D1': [141, 116, 155, 21], 'D2': 165},
                'C3': -7564}],
        'B2': 341804007,
        'B3': 92,
        'B4': [-3222482036224288100,
               -6324339168125683348,
               -3414012387675420211,
               4395743541381195214,
               -899874787522663199],
        'B5': [-0.2594028115272522,
               -0.32965734601020813,
               -0.6033474802970886,
               0.3577030599117279],
        'B6': [-31439, 1935]}}

(b'CBR?\xd6~\xa0\xe7[\x03T\x00B\xaf\xd8\xccx\x00\x00\x00\x04\x00\x00\x00'
 b'\r\xf4A\x82\x7f\x00\x00\x00\x03\x00\x00\x00\x1a{\xf7\xc0\x00\x00\x00\x02'
 b'\x00\x00\x00&\xc7\xfb\x01\xd1\x9a\x00\x00\x00\x04\x00\x00\x001\xc2\x97\x10'
 b'gT\xd4`}\x8c\x00\x11\xdc\xdc\x1bK\x08\xc8\x00\x1d)v\xff\x18\xadt\x00(\xc7)%/'
 b'\x8d\xd1\x005\x951F\x95R\xeb\xd3\xc2\xc6\x19\xe5\x07RQ\xda\xed\x86\xe2\n.'
 b'PsrWyI\xc6\xa1\x96\xc5\x08\x8dmx3\x96f\x02\xac\xdee\x99&O\xd6Zu\xbe'
 b'S\xf9\xb7>\xf0\x9e\\>a\x04">\x01\'\x05\x00\x02\x00\x00\x00>')

{'A1': 0.35147879212677435,
 'A2': {'B1': [{'C1': -731873908,
                'C2': {'D1': [175, 216, 204, 120], 'D2': 244},
                'C3': -8996},
               {'C1': 457902280,
                'C2': {'D1': [65, 130, 127], 'D2': 123},
                'C3': 10614},
               {'C1': -15159948,
                'C2': {'D1': [247, 192], 'D2': 199},
                'C3': -14551},
               {'C1': 623873489,
                'C2': {'D1': [251, 1, 209, 154], 'D2': 194},
                'C3': -27343}],
        'B2': 1184191211,
        'B3': -45,
        'B4': [-4411810313501781542,
               -1331128106486828174,
               6303150270945084680,
               -8255810378938318164,
               -2421360834814518667],
        'B5': [-0.2070072740316391,
               0.46995818614959717,
               0.2197423279285431,
               0.12612541019916534],
        'B6': [-26864, 26452]}}

Вариант №32

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

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

(b'PYEY\x14\xa6\xe9&\x818[\x00\x00\x00HP\x9b\xa5\xdd\xa9i\x00>\xb3Dl\xe7\xb5'
 b"\xe4\xe3\x8b\xd2\x1a\x1f\xb3\x18\xe8v-`A>\xe3zmkir\xd9|'f\xf6is]"
 b'\xb7\x16-\x18\xd56$\xe2\x85\x1c\xa1\x8a=\xd1qh\x00\x00\x00\x04\x00\x00\x00,'
 b'h\x15\xbd.\x8e\xe9\xac\xed\x99<\x89\x8c\n\xad\x14L1\x00\x00\x00\x02\x000\xb5'
 b'z\xbd\xf8\x99B\xff \xbd*\x92\x1c\xc9F\xbaC\x00\x00\x00\x02\x004\x86S='
 b'\xae\xf5y\xb84\x83\xb0m&*p\xd5r\x00\x00\x00\x05\x008\xaf3>\x81F\xafX\x1e\xa8'
 b'\n\xd7\xfc=\xa2\x8b\xd8\x00\x00\x00\x03\x00B\x80\x8c> \xae\x9b>')

{'A1': 2800297601,
 'A2': 14427,
 'A3': {'B1': 'mkir',
        'B2': {'C1': 26645, 'C2': -17106, 'C3': -1897288467},
        'B3': [{'D1': 153,
                'D2': 4362171691566386225,
                'D3': [55676, 10086],
                'D4': -19078,
                'D5': -0.12138606607913971,
                'D6': -1},
               {'D1': 32,
                'D2': -4815876199185728957,
                'D3': [63081, 29533],
                'D4': -31149,
                'D5': 0.08542913943529129,
                'D6': -72},
               {'D1': 52,
                'D2': -8957539648151693966,
                'D3': [46870, 11544, 54582, 9442, 34076],
                'D4': -20685,
                'D5': 0.25249239802360535,
                'D6': 88},
               {'D1': 30,
                'D2': -6338016047204758568,
                'D3': [41354, 15825, 29032],
                'D4': -32628,
                'D5': 0.1569160670042038,
                'D6': 62}]},
 'A4': [20635, 42461, 43369, 62],
 'A5': 3007605991,
 'A6': -5339893068489678925,
 'A7': 24,
 'A8': -1696118318223662214}

(b'PYEY\x14\x89\x84\x043\x13\xa2\x00\x00\x00IN\x97mf\x92Ms\xfe\xc2I\xa5\x94;'
 b'\xd8\x07\xc5\xabn\x1c\x8f\xddW\xdf\xc3hD\x8dm\xdamlgil]U\x98\x1a\xe4~a'
 b'6c@\xd8\xb16\xdf\xdd\xc5\x12\xca~;\xc9\xbbD\xc7\x00\x00\x00\x05\x00\x00\x00'
 b',vl\x7f1\x82\xce\xcaR\x80\t\x12\x95\xa2\xbd\xe7).\x00\x00\x00\x04\x001'
 b'X\x9c=\xab\xf3X\x94\x99\xf1sFe\x96\x16\x19\x8d\x00\x00\x00\x02\x009\xecb'
 b'\xbe<+b\x14\xd9\xa0\x84>D\x91\xa2\x8aj\x00\x00\x00\x04\x00=\x1f\xda\xbe\xf7'
 b'9+\xeb\xeb\xe1\x82P+Pc\xc5\x1b\x00\x00\x00\x02\x00E\x11+\xbe \xe8\xe0D')

{'A1': 2307130419,
 'A2': 5026,
 'A3': {'B1': 'mlgil',
        'B2': {'C1': 30316, 'C2': 32561, 'C3': -2100377006},
        'B3': [{'D1': 128,
                'D2': 653749422125426990,
                'D3': [23893, 38938, 58494, 24886],
                'D4': 22684,
                'D5': 0.08396023511886597,
                'D6': -108},
               {'D1': 153,
                'D2': -1048416886123521651,
                'D3': [25408, 55473],
                'D4': -5022,
                'D5': -0.18375924229621887,
                'D6': 20},
               {'D1': 217,
                'D2': -6880305866493228438,
                'D3': [14047, 56773, 4810, 32315],
                'D4': 8154,
                'D5': -0.4828580319881439,
                'D6': -21},
               {'D1': 235,
                'D2': -2197105521240849125,
                'D3': [51643, 17607],
                'D4': 4395,
                'D5': -0.15713834762573242,
                'D6': 68}]},
 'A4': [20119, 28006, 37453, 29694],
 'A5': 3259606420,
 'A6': 4312205188773321871,
 'A7': 221,
 'A8': 6331994453700341210}

Вариант №33

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

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

(b'NPQ\x00P>\x98\xf9Phjud?\xe5\xd5n\x0c&c\x98\xc6i\xb8\xdbQ\x1a\x16'
 b'\xe8\x07\x1d\\\xd0W\x92\xc0\x12N\xf2}\x8d\xac^\x81no`\xaaL\x9c\x0b\xed'
 b't\xaf \x15\xaf\t3\xacQ\n\r\x87#\xfc\xa4tCn\xcfSq)\x1c\\_t\xa5\xa2'
 b'\x00\x04\x00\x00\x00\t\x00\x02\x00\rP\xf8Z0q\x99j\xbb\x00\x00\x007^?'
 b'-M\xcd\x8br\x16R\xd6\x87\x0b')

{'A1': {'B1': 'hjud',
        'B2': [{'C1': 63,
                'C2': -438997492,
                'C3': 644061382,
                'C4': 105,
                'C5': -1193586406,
                'C6': 5864,
                'C7': 1821,
                'C8': [92, -48, 87]},
               {'C1': 146,
                'C2': -1072541966,
                'C3': 2106436702,
                'C4': -127,
                'C5': 1852793002,
                'C6': 19612,
                'C7': 3053,
                'C8': [116, -81, 32]}],
        'B3': 5834512481369287355,
        'B4': {'D1': 363792691,
               'D2': [44113, 2573, 34595, 64676, 29763, 28367, 21361],
               'D3': 689724511,
               'D4': 116,
               'D5': 42402},
        'B5': 6791196575282197014,
        'B6': 1389790987},
 'A2': 0.29877710342407227}

(b'NPQ\x00N\xbe\xf7:\x9ctf\x19\xfe\xace0\xd3\xab\xaa\x9d\x9f\xc1Ot'
 b'\x88\x01\x99\xdf\x1bu\xa8\xd3(\xb7z\\\xc4\x07\xc2M\xc4\xcc\xf6\x87K\x1c}\x06'
 b'Cx\x94^\x03V}+\x9e.\x08Ng\xf8\xc9\x08\xfd\x8e\x85]\xac\xf5\x8a\xf1\xe3<\x94i'
 b'\x8f\x9e\x00\x02\x00\x00\x00\t\x00\x02\x00\x0bCS\x8d\xc5\x19\xaa\xfd\xe4'
 b'\x00\x00\x005\xc5\x1fj#1\xebJ\xb4q+\xdd\xcd')

{'A1': {'B1': 'tf',
        'B2': [{'C1': 25,
                'C2': -22256336,
                'C3': -743724387,
                'C4': -97,
                'C5': -1051757432,
                'C6': 409,
                'C7': 57115,
                'C8': [117, -88, -45]},
               {'C1': 40,
                'C2': -1216717628,
                'C3': 130174404,
                'C4': -52,
                'C5': -158905572,
                'C6': 32006,
                'C7': 17272,
                'C8': [-108, 94, 3]}],
        'B3': 4851377101286866404,
        'B4': {'D1': 1451043742,
               'D2': [11784, 20071, 63689, 2301, 36485, 23980, 62858],
               'D3': 4058201236,
               'D4': 105,
               'D5': 36766},
        'B5': -4242555624565814604,
        'B6': 1898700237},
 'A2': -0.482869029045105}

Вариант №34

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

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

(b'IZX\x10\x00\x04\x004\x008\x00T\x00p\x1ee>\xea\xa6|\xbd\xf8\xb9\x82>\xfcB0'
 b'\xbf\x0c=\\>\x80\xf9\x92\xbf|\xaf\xc4\x00\x02\x00\x00\x00\x8c\xa0[bKO\x8e'
 b'hqcz\xffF\x885(\x01v\xa4P\xfd=\x12\xe4wT\x88"]\xd2\xbf\x0b\xd73\x90'
 b'm\xa8\x18\xe3\xa26\x1dn\x13t\x94\x99\xfc\xb4\xfb\x06.\x1cA>\x01\x1f\x06<'
 b'\xf5\xaa\xb2T\x13\xbd\xa5\\\xf4J\xfb\xd3\xb80`\xf9\xd6\x15\xc1\x11'
 b'|\x80\x16\xed\xd8\xbe\x83\xc9\xd8\n\x11"\xd8\xbfW\xd8\xbeU#\xbc>\xd1\x9e\x96')

{'A1': {'B1': 16,
        'B2': 'hqcz',
        'B3': [{'C1': 4282812469,
                'C2': 671184548,
                'C3': [20733, 15634, 58487, 21640, 8797, 53951],
                'C4': 853207349818038499},
               {'C1': 2721455470,
                'C2': 326407321,
                'C3': [64692, 64262, 11804, 16702, 287, 1596],
                'C4': 17702157359511348572},
               {'C1': 4098554835,
                'C2': -1204788999,
                'C3': [54805, 49425, 31872, 5869, 55486, 33737],
                'C4': 15567273903322519512}],
        'B4': 7781,
        'B5': 0.4583014249801636,
        'B6': {'D1': [-0.12144757807254791,
                      0.4926924705505371,
                      -0.5478112697601318,
                      0.25190407037734985,
                      -0.9870569705963135],
               'D2': [-0.20814412832260132, 0.40941303968429565],
               'D3': -1604623797}},
 'A2': 20366}

(b'IZX\xaf\x00\x02\x004\x006\x00R\x00n\x92\xff\xbe\xeb=\xfb\xbf\x13\x06X>2=\xa0'
 b'?b,\x9c?N\xde%=\x10\x0ff\x00\x02\x00\x00\x00\x8a\x96C\x97\xcf\x97\xad'
 b'rg\xde\x10\x80\xe1\x84\xdcg\x1b\xd3\xb7\xbd\xb9Y\xb4\x00\xea\xef\xe7\xf2\\Z('
 b'zd\xbf~\xe4\xf4+Q\x96A\xc8\xad\xb4"\xd4\xf9\xbb\xa2\xb3\x11\xf8\xd4\xfe^'
 b'@4\x9br\xb8\x0b\x0bdE\xf5\xb8Z\x0e\x16\xb2\xaf\xfc\\,\xd7\x82\x89\xbd\x02'
 b'\xcd[\t&$\xc1Mj\xc9\xe5e\x1c\x8b\xa5\xbe\\~\xc5?\x10\x18\x15')

{'A1': {'B1': -81,
        'B2': 'rg',
        'B3': [{'C1': 3725623521,
                'C2': -2065930469,
                'C3': [54199, 48569, 22964, 234, 61415, 62044],
                'C4': 6496577035610023156},
               {'C1': 726767169,
                'C2': -928140254,
                'C3': [54521, 48034, 45841, 63700, 65118, 16436],
                'C4': 11201217580799116789},
               {'C1': 3092909590,
                'C2': -1297089444,
                'C3': [11479, 33417, 48386, 52571, 2342, 9409],
                'C4': 5578493075532843941}],
        'B4': -27905,
        'B5': -0.45945724844932556,
        'B6': {'D1': [-0.5743155479431152,
                      0.17406320571899414,
                      0.883493185043335,
                      0.8080771565437317,
                      0.03517093509435654],
               'D2': [-0.21532733738422394, 0.5628674626350403],
               'D3': -1773955121}},
 'A2': -26707}

Вариант №35

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

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

(b'\xe8OWL\x04\x00\x0e\x00\x00\x00:\x00\x00\x00sgjp\x91\xdarN\x98\xce ?o8'
 b'\x03 \x9aA0\xbe\x04\x90\xe3q\xe0o\xfc\xbej\x08C=s\xa4)\xbdx\xb6J?Q\xed'
 b'\t\xbf\xea\xe1\x8f\x9a\xa9\x03\x00\x00\x00\x12\x00\x00\x00A\x9f\xc0\xd2\xf8'
 b'\x02\x00*\x00\xcd\xe1i/\xf8a?\x83S\x1f\x87\xf6\xa5\x02\x002\x00')

{'A1': 'sgjp',
 'A2': {'B1': -22,
        'B2': -1449488415,
        'B3': [{'C1': 1316149905, 'C2': 0.6281523704528809},
               {'C1': 537081967, 'C2': -0.17212525010108948},
               {'C1': 1910738948, 'C2': -0.4930410385131836}],
        'B4': 65,
        'B5': {'D1': 4174561439,
               'D2': [0.04761544615030289, -0.04141659662127495],
               'D3': [795468237, 2201969144, 4136050515],
               'D4': 165},
        'B6': [0.791846752166748, -0.5387774109840393]}}

(b'\xe8OWL\x05\x00\x0e\x00\x00\x00?\x00\x00\x00wbevbe\xf2,\xe8\x10wi>\x84'
 b'\x81\xf7E\xf2\xe5\xa4=\xe4\x82H\xce\xc8%Z\xbf0\x01\xbb\xbe\xbeh\xee>\x8d'
 b'\x14;\xbf&\x7f)\xbd\x9bJ\xea>\xc8w\x1d\xb2q\x03\x00\x00\x00\x13\x00\x00\x00'
 b'\x04\x00\xfdp\x02\x03\x00+\x00\xf90\xa8.0\xc7\xec\x87f\xbd\xd2J~\x02\x00'
 b'7\x00')

{'A1': 'wbevb',
 'A2': {'B1': -56,
        'B2': 1907498359,
        'B3': [{'C1': -399707547, 'C2': 0.22799324989318848},
               {'C1': 1173848452, 'C2': 0.08051671087741852},
               {'C1': -834108700, 'C2': -0.8521389961242676}],
        'B4': 4,
        'B5': {'D1': 40959232,
               'D2': [-0.36524343490600586,
                      0.46564286947250366,
                      -0.7307823300361633],
               'D3': [782774521, 2280441648, 1255325030],
               'D4': 126},
        'B6': [-0.041381023824214935, 0.4576004445552826]}}

Вариант №36

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

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

(b'MAIUN\x92s?\xee\xbc\xb8\x9a9[b\x05-?\xdd~<\x87^\xb7\x8c\x8e@\xbf'
 b'\xe4k\x92\xc6\xfb{PX\x16?\xe9t\xfe\x18\xbc\xd8\xd86\x1d?\xbc\xd9\x9fw'
 b'9`\xa0\xedO\xbf\xe6a\x10\x88\x88d~\x80y?\xc0\xc2(\x9ez\x1f0\xb1\xeffgafreu'
 b"\x00\x00\x00m<\xb6\xdbA\xde\xd8N',\x84\x7f\xf1#\x94\xe3\x01\x183\x04n"
 b'9\x99\x96\x00\x00\x00\x03\x00\x00\x00j^\x91')

{'A1': -28045,
 'A2': [{'B1': 0.9605372440517892, 'B2': 1325},
        {'B1': 0.46082986087537203, 'B2': -29120},
        {'B1': -0.6381315122961073, 'B2': 22550},
        {'B1': 0.7955313189657103, 'B2': 13853},
        {'B1': 0.11269566212411286, 'B2': -4785},
        {'B1': -0.6993487040191579, 'B2': -32647},
        {'B1': 0.13092525232445373, 'B2': -19985}],
 'A3': 'fgafreu',
 'A4': {'C1': 39318, 'C2': [4, 110, 57], 'C3': 24209},
 'A5': 4374925163995090471,
 'A6': {'D1': [44, 132, 127], 'D2': 61731, 'D3': -1797062376, 'D4': 51}}

(b'MAIUN\x89\xac\xbf\xef\x01\x88\x84\x0b=\x08\xfb\xe0?\xceH\x95\xcb\xf8\xed'
 b' \x11N?\xdd{\x1c?\x11? \x9e\xe9?\xa0\xfa\xf2\x90x\x02\xc0z2\xbf\xec\xe79\xe5'
 b'\xce\xe6\x84,\xb0\xbf\xeaQ\x1e+p"6%\xa0\xbf\xee\xd9\xe2\x82C\x84|\xde\x88xsd'
 b'kpdg\x00\x00\x00p2\xfb\xd3W\x87y\xf1x\x0b-\x95\xcf^\x0bA\xb7\x96x~+'
 b'\x1f!\x98Q\n\xae\x00\x00\x00\x06\x00\x00\x00j\xfc\xc4')

{'A1': -30292,
 'A2': [{'B1': -0.9689371661169455, 'B2': -1056},
        {'B1': 0.23659012279117864, 'B2': 4430},
        {'B1': 0.46063905867502974, 'B2': -24855},
        {'B1': 0.03316457761321123, 'B2': 31282},
        {'B1': -0.9032258499566557, 'B2': 11440},
        {'B1': -0.8224020813368671, 'B2': 9632},
        {'B1': -0.9640972656453779, 'B2': -8568}],
 'A3': 'xsdkpdg',
 'A4': {'C1': 2734, 'C2': [126, 43, 31, 33, 152, 81], 'C3': 64708},
 'A5': 3673762293939302776,
 'A6': {'D1': [11, 45, 149], 'D2': 53086, 'D3': 188856214, 'D4': 120}}

Вариант №37

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

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

(b'VAN\xef\x98\x00\x00\x00\xa4K^\xe8\xcd\x07\xdb\xbf=\x82\x17\x16)\xa0\x95\xe0'
 b'\xbf\x1a)\xe9j\x90+\xe8?b\x02\xd4\x98]\xedBH\xcf.\xf4\x8e\x00\n\xf51\xb5st'
 b'?o\xe3%\x9f\x089^gr\xb1\xdd\xde\x8c\xa8\x93\x97\x8cD\xef\xbf+\x00\x00'
 b"\x00.\xe9'?\xbdP\xfe\xa5\xff\xf9S.\xe0?\x92)l\xab\xdc\x1b`\x85\xc1"
 b"\xf5\x12'\x90\xd7WH\x13\x89\xb0\xbfQ\x00\x00\x00!\xb8K\xbf\x02\x00v\x02\x00"
 b'w\x00\x00\x00\x90\x8fP\x8cz\x03\xcc6\xbc\xf2\x9bR\xc6\xe54\x86\xe5P^\xd4'
 b'\x81\x07\xbdd\xd6;>\xcb\xc9b/\x93\xc3?A\x00\x00\x00g\x00\x00\x00ay\x00|\xb6F'
 b'\xf9\x98\x1d\xee?\xd6\xe9\x1f1')

{'A1': {'B1': 10605804266318609366,
        'B2': 16323,
        'B3': [{'C1': -0.9771178207859221,
                'C2': {'D1': -28940,
                       'D2': 0.004993160050903445,
                       'D3': 2670060399,
                       'D4': 16059186951191673096},
                'C3': 0.6559017896652222},
               {'C1': -0.06459160343351145,
                'C2': {'D1': 20669,
                       'D2': 0.50565527751786,
                       'D3': 2875992466,
                       'D4': 2815582928575142876},
                'C3': -0.7957783341407776}],
        'B4': 97,
        'B5': {'E1': 118,
               'E2': [2, 0],
               'E3': {'F1': -112, 'F2': -4884492430523740017, 'F3': -25614},
               'E4': 82,
               'E5': [58822, 34356, 20709, 54366, 1921, 25789]},
        'B6': 0.9411129826236926,
        'B7': 824175062},
 'A2': -0.42235133831234806,
 'A3': 61,
 'A4': [-0.5182648470370028, 0.7553178871251334],
 'A5': 5206985105445487202,
 'A6': 11983}

(b'VAN\xef\x99\x00\x00\x00<\xe8\xb2\x1a*Z\xd4\xbf\xee\xb08\xbe\xf5\xc8\xd9\xb3'
 b'\xbf\x00d\xd7\xb2{\xe0\xcf?i\xe7y\xb0\xe3\xe9\xe7\xad\xf8E\xaa\xcb6\t^'
 b'\xf9\x96\xfc\xe3?Z42`\xa9\x7f\x13\xc3\xeb\x14\xfc{p \x04\x84\xb2\xb1\xd5'
 b'\xbf+\x00\x00\x00rC\x1d?w/\x98C\xde\x18?\x9b\xeb\xbf\xffu\xbc0\xfb'
 b'\n\x1c\x92\xc8=\xb8\xd0@Z\xbc\x7f\x1b\xd6\xa4\xbfQ\x00\x00\x00\xad5\x82\xbdD'
 b'\\\xb1\x93\x03\x00w\x00\x00\x00>q\xbd\x06:\xab\xcdF\xc0\x00\xc8\x120G['
 b'\xb1\xa2\xeaIf\x9fWR<Gr\xf5\xe5f\xa2\xe1z\x95_A\x00\x00\x00g\x00\x00\x00\xc1'
 b'z\x00`}\x9d\xbc\xe0\xc0\xe2?}\xbe\xda"')

{'A1': {'B1': 8854536905215537735,
        'B2': 24469,
        'B3': [{'C1': -0.3389707841129228,
                'C2': {'D1': -13398,
                       'D2': 0.6245837088065744,
                       'D3': 1613902938,
                       'D4': 8934038763618926505},
                'C3': 0.6143103837966919},
               {'C1': -0.04069600996279066,
                'C2': {'D1': 12151,
                       'D2': -0.8627009854991341,
                       'D3': 817657343,
                       'D4': 15039838887257836283},
                'C3': -0.06357894092798233}],
        'B4': -63,
        'B5': {'E1': -109,
               'E2': [68, 92, -79],
               'E3': {'F1': 62, 'F2': -4591756634761020047, 'F3': -14336},
               'E4': 18,
               'E5': [18224, 45403, 60066, 26185, 22431, 15442]},
        'B6': 0.5860446628466143,
        'B7': 584760957},
 'A2': -0.3180032025080697,
 'A3': 238,
 'A4': [-0.07754188537203066, 0.24903818352211715],
 'A5': 12531241652309321577,
 'A6': 17912}

Вариант №38

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

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

(b'\xd9PXM8\x00D\x00P\x00\xad\x1c\xe1\xd1\x0ez\xf7Z\x94\xcf\x1a\xe6d\x006.\xb5='
 b'1\xb4\xc0J\xc3\x03]?\x08\x92\x9f\xbe\xe4\xd2\xd7>\xda\xde\x8e\xbe'
 b'\x9e\xd4\xc7\xbc\xd4\xafY?\x06\x00\x00\x00 \x00\x00\x00\xf4 \x0c\xf9'
 b'\x88K\xff\xdc\x16\x8cd\x92e\xd4\xeb?a\x9eB\xdcL\x0f\xc4c\xff\x9c\xeb?'
 b'&\xb7\xdd\xb92\xaeU{\x8d\x05\xd2Y\xec4\x0f\xb4j\x19\xc9\xcf\xdc\xb91\x13'
 b'\t\xdd\x8f\xe6{\xbfA\xf6\xdc\r^I\xbf\xd7_\x913\x96$\xa8\xe0B\xd9\x1c'
 b'k[\xae\x89\xcd\xb3P+\xf6\xc7\x87\x05O\xe2Ux\xdc\x14\xad\xc3\xc0\x02\x00\\'
 b'\x00\x00\x00/d\xf1\xc6\xe14\x8d&\x01\xfd\x8d\x8c\xf9')

{'A1': {'B1': {'C1': [0.8633386492729187,
                      -0.3116610050201416,
                      0.4215308427810669,
                      -0.279043972492218,
                      -0.02439337596297264,
                      0.8503391742706299],
               'C2': {'D1': -12, 'D2': 32, 'D3': 63756}},
        'B2': [{'E1': 19336, 'E2': -8961, 'E3': 0.8696773394807475},
               {'E1': -24991, 'E2': -9150, 'E3': 0.862914748053734}],
        'B3': -773776211,
        'B4': -1865950859503371762},
 'A2': {'F1': [1506936205, 3020895468, 3486062954, 322025948],
        'F2': 9,
        'F3': -2524758250421317667,
        'F4': {'G1': -0.7865913510322571,
               'G2': -2258514985597444137,
               'G3': [1797052738, 3448352347, 4130033843, 1325762503],
               'G4': 13890135980850566626,
               'G5': [-1176651994, 2069212722],
               'G6': 2777934689467458607},
        'F5': 1,
        'F6': 4186738173},
 'A3': 5386503277916794422}

(b'\xd9PXM0\x00<\x00H\x00Uq\x8a\xde|\xa50\x93\x1f\xdf\xd9\x9d\\\x00'
 b'\x8c\xde\xf9[!\xaf\xcf\xdd\xd7v\x9d\xbeP\xb80?e\x8ez?\xbdoL\xbf'
 b'\x04\x00\x00\x00 \x00\x00\x00r\x82\xa8\xc5\xf4\x9c\x02\x81\xee\x99\xf4\xd7'
 b'\xa8\xe6\xe2?\x11\xda\x03z\xc2\xaf\xf7\x1e\xac"\xe8\xbf\x14\x1eu\xca'
 b'2Q\xb6\xden\xfd2\xa7\xa4(\xd0\x19^\xd5+K\x9f\x83\xe3\xde\xe8\x07:\x87\xf2*Vm'
 b'k\xd75\x84>\x8d\x1c\xeeu\r\xe9M\x7f\x82\xdb\xdc\x01\x8cX\xab\xfc>!\x95`_|.'
 b'\xf7~\x1e\xcf\xbc\x1d \n\xff\x02\x00T\x00\x00\x00D\x94\x05\xe3Scg\\\xf5'
 b'R\xda\x00\xca')

{'A1': {'B1': {'C1': [-0.30754730105400085,
                      0.690312385559082,
                      0.9787352681159973,
                      -0.7985799908638],
               'C2': {'D1': 114, 'D2': -126, 'D3': 50600}},
        'B2': [{'E1': -25356, 'E2': -32510, 'E3': 0.5906566827659938},
               {'E1': -9711, 'E2': 31235, 'E3': -0.7542324642977223}],
        'B3': -561352363,
        'B4': -7072376413102234244},
 'A2': {'F1': [2805136750, 433072292, 1261163870, 3739452319],
        'F2': 232,
        'F3': 7740938076977314311,
        'F4': {'G1': 0.2582232654094696,
               'G2': 9173244260045954189,
               'G3': [31251330, 4239087756, 1620386110, 4147018847],
               'G4': 18377536541532561022,
               'G5': [-898294252, -558477006],
               'G6': 6658399786032796740},
        'F5': 245,
        'F6': 3389053522},
 'A3': 15983186160373063308}

Вариант №39

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

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

(b'BWDC\xf9C\x00\x00\x00\x03\x00\x00\x00k\xac]\x94\xd4\xbf\x9f\\Qe?'
 b'\x9a\xc0\x03\x80\xc4s)0\xbb7\x0c\x00\x02\x00\x00\x00n\xbf\xde3zY\xf24'
 b'\x84\x9aC@\x12\xca8i?\xeb\x00\x02\x00\x00\x00v\xbf\xe4\xce\xad6\x95\xf6\x1c'
 b'/7\x19\x19\xf0}\xf7\xebu\x00\x02\x00\x00\x00~\x00\x00\x00\x8d\xd7'
 b"\x03\xa9\xd3\xcbd<\x1f\xbf\xef\x8b5d\x88\xabPdzr\xc5\x129d'\x13\x19}\xe4~"
 b'\x16rq\xa9\xda\xce\xf6\r\x9b\xae\x15\xf6\xcc\xcdX\x7f\xd0\xedvUZ\xbe\x84\xfa'
 b'a\xde\x18\x95\x16\x17\xb6n\xa0\x00\x07\x00\x86\x94\x05\xe1\xd5\x9a\xe2\x11'
 b'CJ\xa9%\xda\x15\xfb\x1c')

{'A1': 67,
 'A2': 'dzr',
 'A3': 2891814100,
 'A4': [{'B1': -0.03062560253592994,
         'B2': {'C1': 252417578024090423,
                'C2': 12,
                'C3': [3306305892, 655563133]}},
        {'B1': -0.4718919638042467,
         'B2': {'C1': -7330945318982751937,
                'C2': -21,
                'C3': [3833468530, 1906957006]}},
        {'B1': -0.6502290788773197,
         'B2': {'C1': 3402215642701363179,
                'C2': 117,
                'C3': [4128086958, 368495821]}}],
 'A5': {'D1': -0.2597227394580841,
        'D2': 16003705197980708512,
        'D3': [88, 127, -48, -19, 118, 85, 90],
        'D4': -7780564473669873341,
        'D5': [74, 169, 37, 218, 21],
        'D6': -1252},
 'A6': 15493413870200175647,
 'A7': -0.9857432330657989}

(b'BWDC\xf9=\x00\x00\x00\x04\x00\x00\x00k\xc0\xa4\xb7\xfd?\xe3/\xd9\xd2\x1e'
 b'\x90\xbc\x9e\xd1\x82\xf0\xday"g\x87\x00\x02\x00\x00\x00o?\xd3\xec'
 b'\x17b\xcb\xf8\xec\xaf@\x8f\xd0\x15\x9e0\xb2[\x00\x02\x00\x00\x00w'
 b'\xbf\xd9\xc1TA\x95\x10,\x11[\x89$\xd8\xe293\x18\x00\x02\x00\x00\x00\x7f\x00'
 b'\x00\x00\x8ag/\xb6H8\xd9\xd2\xf2\xbf\xc7\x9b\x9d\xc0h@\xe0jspp\xd5'
 b'\xea\x0b\xa9.\xce\x97\x12\xe8R\x10\x18\xaee8b\x9b\xe2\x1by\x9c\x9f\x95E\x82'
 b'\x1dF=h\xd2\x1a\xfd\x1a\x0e(\xd5d\x0eB\x00\x03\x00\x87\xf6\xdf\\\\\x8f\x13'
 b'h\xc8\xa2\xc3`\\\xed;5')

{'A1': 61,
 'A2': 'jspp',
 'A3': 3232020477,
 'A4': [{'B1': 0.5995911697287037,
         'B2': {'C1': -7002671974615276953,
                'C2': -121,
                'C3': [3588885417, 785291026]}},
        {'B1': 0.31128487251397874,
         'B2': {'C1': -5818492594684022606,
                'C2': 91,
                'C3': [3897692184, 2925869154]}},
        {'B1': -0.40242487339515054,
         'B2': {'C1': 1250744112875977011,
                'C2': 24,
                'C3': [2615286649, 2627704133]}}],
 'A5': {'D1': 0.05684099346399307,
        'D2': 18237905209531829826,
        'D3': [-126, 29, 70],
        'D4': -657705467965642552,
        'D5': [162, 195, 96, 92, 237],
        'D6': 15157},
 'A6': 7435361931119678194,
 'A7': -0.1844365300644375}

Вариант №40

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

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

(b'XINT\x8dU\x00D\x15]\x8e\xf1\x1d\xdf\xa4\tEK\x80P-\x8c\xf3\xc9\xea\xbf\xdd,'
 b'\xe4\x82\xcf\xb0\xcc\xf48VZ\xach$\xdc\x1f\x8f\xc4-\xa4\x99\xd1\xc9\xa3L9'
 b'\xfd\xa5\xbe-\r\x18c:\xc2\x1d\xd0\xbf\xa2\x91\x02\x00\x00\x00"\x00'
 b'\x00\x00\xfa\xcdf\xbc\x03{&\xad\xb4\xd0)B\x00\x00\x00\x03\x00\x00'
 b'\x00R\x00\x7fO}')

{'A1': {'B1': {'C1': [{'D1': 2295749942038910520,
                       'D2': 143,
                       'D3': 196,
                       'D4': 42029,
                       'D5': [-103, -47, -55, -93]},
                      {'D1': 1733091728459381068,
                       'D2': 99,
                       'D3': 58,
                       'D4': 7618,
                       'D5': [-48, -65, -94, -111]}],
               'C2': -5969949000057041414},
        'B2': [-76, -48, 41],
        'B3': 20351,
        'B4': 125},
 'A2': 68,
 'A3': 23829,
 'A4': [142, 241, 29, 223, 164, 9, 69, 75],
 'A5': -0.8371522653419703,
 'A6': 17639668245804100829}

(b'XINT\x8dU\x00-\xd5o\xa0"\xbb\x8edk\\Ll\xfc\x7f\xf8H#\xeb?\x16AS\xc9\xb0\xf0'
 b'\xab\xdb\xa5k\xd4k\xba}\x82\xe6C\xaa4\xa6\x92nr\x86\xc0\x94}\xaf:0B\x89\n7'
 b'\x9b\xc1Vai\xb2\x02\x00\x00\x00"\x00\x00\x00jG\x1dO\xe1+}X\xf2\xc9'
 b'\x98B\x00\x00\x00\x03\x00\x00\x00R\x009\xafU')

{'A1': {'B1': {'C1': [{'D1': -1836767458387268699,
                       'D2': 67,
                       'D3': 170,
                       'D4': 42548,
                       'D5': [-110, 110, 114, -122]},
                      {'D1': -8556223313440041792,
                       'D2': 10,
                       'D3': 55,
                       'D4': 49563,
                       'D5': [86, 97, 105, -78]}],
               'C2': 6376300894121445226},
        'B2': [-14, -55, -104],
        'B3': 44857,
        'B4': 85},
 'A2': 45,
 'A3': 28629,
 'A4': [160, 34, 187, 142, 100, 107, 92, 76],
 'A5': 0.8480572560801085,
 'A6': 15829009957406327062}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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