ИКБО-37-22

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

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

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

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

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

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

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

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

(b'ODY\xb0\xa6\xa2.\x8e\xb9d_\x0fd\xb0\xb1\xbc\xa0N\x00\x00\x00p\xac\xc7'
 b'\x16x\x00\x00\x00\xb5\x9b\xf7\x1c;\xda\xe4o\x02\x15\xe5\xef\xae\xf6\x17'
 b'Dx\x94\xd1){o\x18\x1f\xab\x90\x9f\xd3Zg\xd8Zv#\xa3\x06|I\xf8\xad\x92\x121'
 b'\x8b\xc7\x89\xbf*}m(\n?\x12\xb6$\xe5\xad>\xa8\x0bR\xbf\x8e\xcfD\xc5'
 b'\r=\xec\xbf\x07\x00#\x00\x00\x00\x02\x00\x00\x00F\x00\x10d\xb4!\x86\x11-\x8a'
 b'd\xc1vDK\t*\xed\x00o\x00V\xefR\x8f\xbf\xa3\xe1\xdb\x0e\x82\xc6\xaf\\rY%\x83'
 b'\xc2\xa1\xfa66\x0cWn:\xbec\x00gH-\xd8fi\x0e\xcf\x8cT')

{'A1': 2385420966,
 'A2': 13596842693809366201,
 'A3': {'B1': 160,
        'B2': {'C1': {'D1': 0.5396793484687805,
                      'D2': -18926,
                      'D3': 0.3396388292312622,
                      'D4': -0.8204903602600098},
               'C2': -0.8824528553873152,
               'C3': [{'E1': 352481252, 'E2': -27},
                      {'E1': 402042607, 'E2': 68},
                      {'E1': 701600888, 'E2': 123},
                      {'E1': 2870941807, 'E2': -112},
                      {'E1': 1734005663, 'E2': -40},
                      {'E1': 2737010266, 'E2': 6},
                      {'E1': 2918730108, 'E2': -110}],
               'C4': [-947179246, 2099953545],
               'C5': 565470224,
               'C6': 4486,
               'C7': -30163},
        'B3': 382184560,
        'B4': {'F1': [100, -63, 118, 68, 75, 9, 42, -19],
               'F2': -0.015294904529632003,
               'F3': [57763, 3803, 50818, 23727, 22898],
               'F4': 879951227281113893,
               'F5': -0.18206153810024261,
               'F6': 1214709859,
               'F7': 1768347693,
               'F8': 1418514190},
        'B5': [-75, -101, -9, 28, 59, -38]}}

(b'ODY\xb0G\x86\x82c\x06aQ_\x9e\x8d\x86o\x16D\x00\x00\x00\x8c\xfcQZn\x00\x00'
 b'\x00\xc0\xe2\xb4\x15\xc1\r\xa9\xb7\xaf\x8a\xb7\x96\xe6\xe4\xa5\xd1%\x15U'
 b'\x06BE\\z\xb40fw\xc9F\x8a6j\xbeQ\x92\xa0^\xb23i\x15?Ur\x0b[\xa3\xbd\xf8\xef'
 b'\xb8>\x82D&\xfc\xa3\xfd\xec\xbf\x05\x00#\x00\x00\x00\x02\x00\x00\x00<\x00z\r'
 b'\xac\xd0s>\xd3\xa4\xb1d1\xed\x1cp\xa2S\x1e\xff\xb3\x92\xdd\xeb\xe2?\xdc\x07'
 b'|\x17\xa2\xe8\x97\x03\x15\xb5\xd5\x06\x86\x1cSAh\xf5\xb1\x99p?\x0f\x7f\xc8#'
 b'd\xf2\x82_\xcc\x8c\xdc\x08')

{'A1': 1669498439,
 'A2': 8036266296432746758,
 'A3': {'B1': 22,
        'B2': {'C1': {'D1': 0.583636462688446,
                      'D2': 29269,
                      'D3': -0.0797634944319725,
                      'D4': 0.3612058162689209},
               'C2': -0.9059619831842982,
               'C3': [{'E1': 2326771625, 'E2': -73},
                      {'E1': 2783241878, 'E2': -47},
                      {'E1': 106239269, 'E2': 66},
                      {'E1': 3027917893, 'E2': 48},
                      {'E1': 1187608422, 'E2': -118}],
               'C4': [1371433526, -1302421358],
               'C5': -794030726,
               'C6': 15987,
               'C7': -23341},
        'B3': 1515322508,
        'B4': {'F1': [-79, 100, 49, -19, 28, 112, -94, 83],
               'F2': 0.591292177705302,
               'F3': [2012, 6012, 59554, 919, 46357],
               'F4': 17683455762086889173,
               'F5': 0.9398451447486877,
               'F6': 600342287,
               'F7': 1602417252,
               'F8': 148671692},
        'B5': [-64, -30, -76, 21, -63, 13]}}

Вариант №2

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

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

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

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

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

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

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

(b'JMOXDw\xd1\xe0\x88i\xa5`\x00\x00\x00i\x00\x00\x00r\x00\x00\x00{'
 b'\x00\x00\x00\xd3E\x0bm`\xaf\x04y/L&>\xad\xca\xaa`\xaaQ+\xba\xef'
 b'\xc4\xbf\xe9\x95vYI)\xe2\xc4\xf6\x08\x90\xd8\x92\xd0\xea?\x02\x00'
 b'\x80\x00\x00\x00`\xdf\x03\xcb\x94?\xf9\xbe\x1e\xfb(\xd2\x04\xab\x03\x00'
 b'\x00\x00\x84\x00!+\xaeS\x02\x00\\\x00\xe3\x17\xc1\x84\xff\x02\x00e'
 b'\x00%\xe9\xdbE\xdf\x02\x00n\x00\x0c\xdc/\x1b\xf0\x02\x00w\x00R\x8f[\x9d\xdd'
 b'\xf8\xaf\x87\x17\xa6p\xda?\x90$R\xb4+\x1b\xc0\xbf*\xdb\xde\xe3\xfc\xc2\xe0?')

{'A1': {'B1': 2296435063,
        'B2': {'C1': -23191,
               'C2': [{'D1': [11041, 21422], 'D2': 227},
                      {'D1': [49431, 65412], 'D2': 37},
                      {'D1': [56297, 57157], 'D2': 12},
                      {'D1': [12252, 61467], 'D2': 82}],
               'C3': [17875, 27915, -20640, 30980, 19503, 15910, -13651],
               'C4': {'E1': -86, 'E2': -0.16356589427171553},
               'C5': 38377},
        'B3': 692672886,
        'B4': 50402},
 'A2': 0.8379606466044425,
 'A3': [23439, -8803],
 'A4': 3406028640,
 'A5': -0.48681318759918213,
 'A6': -1250,
 'A7': -1425747416,
 'A8': [0.4131255368981779, -0.12582918457727432, 0.5238022280308077]}

(b'JMOXDe\x8e\xda\xf51\xe1`\x00\x00\x00i\x00\x00\x00r\x00\x00\x00{\x00\x00\x00p'
 b'\xa4\x91\xe2Kl2\xa4\xa7\x1d\xbax\x0b\xf6\x8e\xf2`\x13\xaf=[\xee\xbf\x13\xaf'
 b'\x8d\x0b\x96X\xe8\xf3\x9c\xf3\xdd\x98\xea\xb4\xd8\xbf\x02\x00'
 b'\x80\x00\x00\x00\r\xd1\x0b\xcf\xf0\xc4\xf6\xbe\x05udV\xec\xc9\x04\x00'
 b'\x00\x00\x84\x00\x1ev\xc2\x01\x02\x00\\\x00$\x1a\xd3\xc5\xf4\x02\x00e'
 b'\x00\x15,n\x15\xe4\x02\x00n\x00S\xf3\xc9\x1a\xac\x02\x00w\x00\x92\n\xcd\nF'
 b"FP$\xa2c\x19\xe4?\x90=\x9d\x9c\xa1U\xba\xbf\x8c\x07'\x00/\x9c\xd3\xbf$\x0eyV"
 b'\xf7$\xdf\xbf')

{'A1': {'B1': 4124741221,
        'B2': {'C1': -7887,
               'C2': [{'D1': [30238, 450], 'D2': 36},
                      {'D1': [54042, 62661], 'D2': 21},
                      {'D1': [28204, 58389], 'D2': 83},
                      {'D1': [51699, 44058], 'D2': 146}],
               'C3': [-23440, -7535, 27723, -23502, 7591, 30906, -2549],
               'C4': {'E1': -114, 'E2': -0.94863781160805},
               'C5': 44819},
        'B3': 1486228365,
        'B4': 62440},
 'A2': -0.3860422604409963,
 'A3': [-13046, 17930],
 'A4': 3473658125,
 'A5': -0.48197126388549805,
 'A6': 29957,
 'A7': -907258268,
 'A8': [0.6280992667038923,
        -0.10286912988271113,
        -0.3064076901902062,
        -0.4866312355481759]}

Вариант №3

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

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

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

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

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

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

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

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

(b'CCF,AjA0C\x00\x1c\xaf\xbe\xf6\xbd\xed\x07c\xbeZ\xec\xb9Gm>\xb3\xa0\x0f'
 b'\x00\x00\x00\x15\x00\x00\x00F\xc39\xbe\xdc\xf0\xeam\xe0\x9aQ:Gp2\t\xc5'
 b'\x01\x99>L4\xaf\xbe\x87\xfd|?\xc9\xb0+\xbf\x1b\x00w\x82\xde-q\xa0\xde%n\xcdH'
 b'\xb7\xce\xb7\xef\xffr\xf3\x91\x0c\x18-{\xa1\x88[\x1c$x$\x02\x00\x00\x00+'
 b'\x00\x00\x00\xd1\x07]-\xd42\x04\x81\xd6v\x9c\x03\x04\x00\x00\x003'
 b'\x00\x8f\xb0\xbez\xf2SL\x15\xfa\xbc\x95\x18\xf1\xfc\xa5\x0b\x84\x8bQ'
 b'R\xd29\xe1?\xa0\x11\xe8~X\x81\xee\xbf\xc0\x86lYj;\xe7?\xf6~-\xa9\x92+\xed'
 b'\xbf\xa0\xa0\x17\x81\xd3\x9b\xda?')

{'A1': 809593409,
 'A2': {'B1': {'C1': [{'D1': -0.22170992195606232, 'D2': -5030},
                      {'D1': 0.23171891272068024, 'D2': -24397}],
               'C2': -0.18140897154808044,
               'C3': 1844113628},
        'B2': {'E1': 769557111,
               'E2': {'F1': [41073,
                             9694,
                             52590,
                             46920,
                             47054,
                             65519,
                             62322,
                             3217],
                      'F2': 11544,
                      'F3': 2627890086784049531},
               'E3': [978426592, 154300487],
               'E4': 9296611417675073489,
               'E5': 60585686,
               'E6': [0.2988416254520416,
                      -0.34219586849212646,
                      0.9882435202598572,
                      -0.6706662774085999],
               'E7': 1534693873933004943,
               'E8': 839355018004249850},
        'B3': [0.5383082969459427,
               -0.9532892683642338,
               0.7260028597413211,
               -0.9115689567806544,
               0.4157608757655087]},
 'A3': 28,
 'A4': -0.12048088759183884}

(b'CCF,=P\xbc\x88K\x00\xf8G\x7fG\xbf\x98\xd6[\xbe{\x1c\xa16\x03\xbf\x93\xe5\x0f'
 b'\x00\x00\x00\x15\x00\x00\x00\n\xebf\xbfB\xb8\x85=D\xffb\xf1R\x82\x0b\r\xff'
 b'?\xc6\xcfI\xe6t>%XP?\x07Oj\xbfVz-\xbe\xc5\x15\xa1>\x1b\x00\xe3\xc8\xd4'
 b'U2\x91I\x98\xd1n_y\x81g\xbf.\xa2\xec\xbc|@\x06\x07\x9d\xcf\xb4\xb9'
 b'\x13\r~\x03\x00\x00\x00+\x00\x00\x00j\xce\xe7f\xba\xecom\x0b<\x075\x05'
 b"\x00\x00\x007\x00\x1f\xcbK\x91V\x1d\xa66\xf5k'W\xa8s\xf3FF;\xca\xdeA\xa1\xe2"
 b'\xbfj#6$\xbad\xe5\xbfZ\xe9[\x16\xf7\x7f\xef\xbfl\xb0\x93c\xb4\xf3\xdb'
 b'?\xf0\xfd3\xcc\x88\x14\xcc?')

{'A1': -2000924611,
 'A2': {'B1': {'C1': [{'D1': -0.21468579769134521, 'D2': 7291},
                      {'D1': -0.5125523209571838, 'D2': -6765}],
               'C2': -0.9020239114761353,
               'C3': 1032173634},
        'B2': {'E1': 1440008419,
               'E2': {'F1': [37170,
                             38985,
                             28369,
                             31071,
                             26497,
                             11967,
                             60578,
                             31932],
                      'F2': 1600,
                      'F3': 9082937711799540999},
               'E3': [-245170364, 218858066, -809091073],
               'E4': 7885781757883567722,
               'E5': 889666571,
               'E6': [0.2391597181558609,
                      0.8138449788093567,
                      -0.9152683615684509,
                      -0.16941198706626892,
                      0.3146192133426666],
               'E7': 3937867181824133919,
               'E8': 5112557168849546229},
        'B3': [-0.5821847297064344,
               -0.6685457904105594,
               -0.9843707501125138,
               0.43674955105121316,
               0.2193766591153543]},
 'A3': 248,
 'A4': -0.7792858481407166}

Вариант №4

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

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

Поле	Описание
1	int16
2	uint32
3	Структура B
4	float
5	float
6	float

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

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

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

(b'RFN\xd6j1q\xd8\xa7\x0f\x00a?\xac\x02\x1e\x1d\xbb\x19\xed\xbb\xbf\xb7\xeb'
 b"\xa4\xf7wT\xe0=.\x01n\xbf\nl\x13\xbd\xce3\xee=\xd0A\x1e\xb1'\x88\xbf?Y7"
 b'\xc6\x95\x00\x1d\xdc>9\xccin\xf07\xeb\xbd\x97}\xb6q\xe4\x93r\xbe\xd8b'
 b'x\x00\x00\x00-\x00\x00\x005\x00\x00\x00=\x00\x00\x00E\xb0\x83[S\x00\x04\x00'
 b'M%\x87\x8e\xa9C\xd3\xd7F\xbah\x84x\x08\x81\xd1\xf8i\xca\xe1\xe1\xe9\xd02'
 b'\xb5\xda\x8f\x88\x02Z\xc4\x00-\x8aH\x9b(I\xf6\xe7\xd2\\n\x05\xadh a'
 b'\xf2\x00\x02\x00]=\xc3<$')

{'A1': -10646,
 'A2': 829544615,
 'A3': {'B1': 15,
        'B2': {'C1': [{'D1': -1322809153, 'D2': 0.848507285118103},
                      {'D1': -1795154468, 'D2': 0.18144382536411285},
                      {'D1': 1861236715, 'D2': -0.0739702433347702},
                      {'D1': 1910805362, 'D2': -0.422626256942749}],
               'C2': [2704286958897846086,
                      13432131539706171896,
                      7623153679684612789,
                      15748955965632020525,
                      9964384772899137490,
                      6660267141261976050],
               'C3': [-20349, 23379],
               'C4': 0.09532955288887024},
        'B3': [63, -84, 2, 30, 29, -69, 25],
        'B4': -4677,
        'B5': -0.09343939820913105,
        'B6': 0.04248183220624924},
 'A4': -0.5407115817070007,
 'A5': -0.1006849855184555,
 'A6': 0.10168670117855072}

(b'RFN\x12\xbd\x03\x12\x1a\x1bj\x00m\xd6\xfa:#\xb3\x87y\x0c\x81\xbf\xc6w'
 b'\x94.\xf5\xdd\xa8\xbe\xac\x9c\xd9?\x16\xf9i?\x07\xfa\xeb>\xb9\xf4\xbe\xcfb+'
 b'\x0c\xbf\x15\xecZ\xd3\xa1\x87C\xbe\xa6\x99g\x17\x1f\xdcY\xbf8\xb7'
 b'\xabT\xd5\xd5\x03>P\x0e\xeeh\x9cV-?uf\xb0\x00\x00\x00-\x00\x00\x00'
 b'5\x00\x00\x00=\x00\x00\x00E\x00\x00\x00Mo\xbf\xb2w\x00\x05\x00Ud\xbf;'
 b'\x8d\x91\x8b\xae\xf5\xf1\r\xb2\xb8\xacf\xf3\xca\x0c\xa2\x9e\x88q\xc1\xde'
 b'\x82\xd2\x80\xa7r_F\n\x8f\xc5-\x88\xd71$\x94d\tj!\x1c\x05\x9a\xe4'
 b'\x1f\x00\x02\x00i\xbe\xb5"\x89')

{'A1': 4797,
 'A2': 51517979,
 'A3': {'B1': 106,
        'B2': {'C1': [{'D1': -815650036, 'D2': -0.5856376886367798},
                      {'D1': -744388797, 'D2': -0.3253891170024872},
                      {'D1': 387963993, 'D2': -0.7215525507926941},
                      {'D1': 1423299843, 'D2': 0.20318195223808289},
                      {'D1': 1755076141, 'D2': 0.9585981369018555}],
               'C2': [7259586603562807029,
                      17369735844074025930,
                      910464383543533186,
                      15168307654650366607,
                      14208162857247609956,
                      678391098109518879],
               'C3': [28607, -19849],
               'C4': -0.3537791073322296},
        'B3': [-42, -6, 58, 35, -77, -121, 121],
        'B4': 3201,
        'B5': -0.1755242566393751,
        'B6': -0.33713415265083313},
 'A4': 0.5897431969642639,
 'A5': 0.5311724543571472,
 'A6': 0.36319535970687866}

Вариант №5

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

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

Поле	Описание
1	int8
2	Адрес (uint32) структуры B
3	uint8
4	Структура C
5	int32
6	Структура D
7	int32
8	int16

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

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

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

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

(b'RPI\xdc\xbc\x00\x00\x00[\xeeU\x9f\xa1\x9c\x00\x08\x00\x00\x00p\xbf\xb6 \x1c'
 b'\x0b\xd2u \xac\x8e\x8e\xe2\xbfAw\xa2\x0c5\x9dT\x00\x04\x00\x00\x00\xb8\xbf\t'
 b'\xcc]\xbf9\x82\xec\xbe_\x81\x07\xbe\x1b\n\xc4>\xb2\nM\x18\x945>\xb1\x94'
 b"\xaf\x07s6oK\x81\x13\x1b\x98\xc0K'\x83\xbe\xd4\x7fNCU\x93\x87\xb9z4\tV\x12"
 b'<8\x98\xbd\xe7<R\xbc\xcct\xd8\xdeyidtgchm\x9d\xd8\x00\x02\x00\x00\x00x'
 b'>D\xa8\xc6\xbe\x8a\xffvZg\x00\x02\x00\x00\x00\x88=\x8eXi?L\x9e\xfb'
 b'\x0e]\x00\x02\x00\x00\x00\x98\xbf\x02.\x19>\x81n\xc0{\xa8\x00\x02'
 b'\x00\x00\x00\xa8>\x14/\xd3\xbfs~~\x00z\x00\x8a\x00\x9a\x00\xaa')

{'A1': -68,
 'A2': {'B1': 1435731897,
        'B2': 8805673436693936280,
        'B3': -0.1129080206155777,
        'B4': 188,
        'B5': -864757538},
 'A3': 238,
 'A4': {'C1': 1436524956,
        'C2': 'yidtgchm',
        'C3': -0.08642745293260079,
        'C4': -1399943454,
        'C5': -0.7557317018508911},
 'A5': 204840276,
 'A6': {'D1': [{'E1': [157, 216],
                'E2': 0.19205006957054138,
                'E3': -0.2714802622795105},
               {'E1': [90, 103],
                'E2': 0.06950456649065018,
                'E3': 0.7993008494377136},
               {'E1': [14, 93],
                'E2': -0.5085158944129944,
                'E3': 0.25279808044433594},
               {'E1': [123, 168],
                'E2': 0.14471368491649628,
                'E3': -0.9511488676071167}],
        'D2': [-0.5382745862007141,
               -0.724653959274292,
               -0.21826563775539398,
               -0.15140825510025024,
               0.34773483872413635],
        'D3': 1771099096847003399,
        'D4': 115,
        'D5': 13935,
        'D6': 5440650834088053543},
 'A7': -2084645761,
 'A8': 20035}

(b'RPI\xdch\x00\x00\x00[e\xe3^\xff\xfc\x00\x05\x00\x00\x00p\xbf\xc6G2'
 b'\x03\x8e\x04xm\x9d$B\xbe\x9b\xa3x\xdb\xbf5\x85\x00\x02\x00\x00\x00\x95>\xe6'
 b'L\xa9>\xc7C\x9f>\xd0\xab\x15\xbe}\xe8\xcb>\xd6\xa8V\xf7\x8c\xfe\n\x0ek'
 b'\x0fx\xb1s\xdah\n\x1db\x86\xd8\xf4\xe2\x12\x93\xf9\xfd\xa7\x0fr\xa1\xa1D!'
 b'd&\xa6\xc4\xc2\xdc2?1\xb7\xd9\x85\x86R\xb7Ifcgye\xc4\x1b\x00\x02\x00\x00\x00'
 b'u?F\xd6\xad\xbeH\xab\xc8q\xf0\x00\x02\x00\x00\x00\x85=\xd3o\xeb\xbe\xe0\xa1'
 b'\xc9\x00w\x00\x87')

{'A1': 104,
 'A2': {'B1': 1923195204,
        'B2': 2406090598630218802,
        'B3': 0.6942115426063538,
        'B4': 133,
        'B5': -2041399479},
 'A3': 101,
 'A4': {'C1': -480313348,
        'C2': 'fcgye',
        'C3': -0.17404771016666465,
        'C4': 1839014978,
        'C5': -0.3039815425872803},
 'A5': -608225915,
 'A6': {'D1': [{'E1': [196, 27],
                'E2': 0.7767131924629211,
                'E3': -0.19596779346466064},
               {'E1': [113, 240],
                'E2': 0.10324081033468246,
                'E3': -0.4387343227863312}],
        'D2': [0.4498036205768585,
               0.3891877830028534,
               0.4075552523136139,
               -0.24795834720134735,
               0.41925305128097534],
        'D3': 17837911543252717432,
        'D4': 177,
        'D5': 29658,
        'D6': 7496836838717977826},
 'A7': 311687677,
 'A8': -22769}

Вариант №6

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

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

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

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

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

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

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

(b'VPT]r\x89\x86\x88\xd4]M\x00$[J|3\xab\xbfY\x00\x00\x00\x02\x00m\x00\x01'
 b'\x02H?\x02\xe7\xeb.\xf3\xa7\xb9\xe71\xd2z\x15\x1d-\x81s\x90F\x7f\x00\x00'
 b"\x00\xbf,'\t\xf9\xed\xacZ\xfd\x06\x02\x00\x00\x005\x00fA\xa0>\xce\x02\xb5"
 b'\x98e\xf7\x02\x00\x00\x007\x00\xcb\xd9}\xbe\x02\x00\x00\x009\x00\x00'
 b'\x00\x98\x1e\xd4-\x10Q"\xc2\xcaB\x10\xa3\xc6\xd9\xac\x93\x03\xf5*'
 b'}\x98\xa6\x91\xbfB\x91\xcb\x91\xc2\xee0\xa2E\xe0D\x14\xd6\xbf\x8f'
 b'\xbf\xe6\x8e\xa7\xefL\x97^\xdd\xfc\x805?`_,\x00\x02\x00\x00\x00o\x00')

{'A1': 5574845596592337501,
 'A2': -0.0531271782652496,
 'A3': {'B1': {'C1': [{'D1': -4615,
                       'D2': 117267116,
                       'D3': [191, 44],
                       'D4': 0.3129989504814148},
                      {'D1': 718,
                       'D2': -144336715,
                       'D3': [39, 9],
                       'D4': -0.24790112674236298}],
               'C2': -4457911551213166952,
               'C3': -1559215414},
        'B2': [-58, -39],
        'B3': 0.7812805771827698,
        'B4': -1749182317350623486,
        'B5': [-11727, 5498, 11549, 29569],
        'B6': 18064},
 'A4': {'E1': -0.344987124457961,
        'E2': -7544391772816359537,
        'E3': -8866,
        'E4': 0.7089993953704834,
        'E5': 2908000,
        'E6': [12004482430208807852, 17204473830010175377]}}

(b'VPT\xc5\x17\x8b\xe5\x11#h\x9bpwq\x8b\xa3\xd5\xdd?Y\x00\x00\x00\x02\x00m\x009'
 b'2^\xbf(E\x93n\x176\x8aO)\xbe\x04\xd0\x9d\xab\x84\xe1\xc6\x7f\x87\x00\x00'
 b'\x00.\x9e\x1a\xf8\xd2\xd3\xe3\xa1\xa6\xf0\x02\x00\x00\x005\x00\xd4\x1c_'
 b'\xbfH\r\xad\x8ch\xa4\x02\x00\x00\x007\x00_\xf7$?\x02\x00\x00\x009\x00\x00'
 b'\x00Tq\xc3\r8H2O4W\x9c\xe5z\x8b\xcaq\x9b?\x08r\x95\x1aGL\x95\x8d\xef'
 b'\xf6Uf\x88\xc4\x02T\xe39\xcfDh) \xfc\x1eu\xcf\xbfX\x82\xdb\xa5\xc5'
 b'H\xd4\xa9\xd5\xb5h`i\xbfr:\xce\xde\x03\x00\x00\x00o\x00')

{'A1': 11198239033229252549,
 'A2': 0.46616448037627034,
 'A3': {'B1': {'C1': [{'D1': -11310,
                       'D2': -257515037,
                       'D3': [46, 158],
                       'D4': -0.8715336322784424},
                      {'D1': 3400,
                       'D2': -1536652115,
                       'D3': [26, 248],
                       'D4': 0.6443995833396912}],
               'C2': 5706703083418120532,
               'C3': -442738892},
        'B2': [122, -117],
        'B3': -0.8679538369178772,
        'B4': 5731452950049670440,
        'B5': [-16855, -12284, -21603, -7804],
        'B6': 32710},
 'A4': {'E1': -0.2457617503244578,
        'E2': -6209257972508687784,
        'E3': -18987,
        'E4': -0.9116272926330566,
        'E5': -556909966,
        'E6': [1915562596268470730, 7374071473622043719, 4958245363288032392]}}

Вариант №7

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

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

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

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

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

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

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

(b'ZDE\x009\xba\xe2\x96\x86m\xe6\x1d|\x8f\xc2o\x8a\xe6X\x9d\xf6\x96\xb8\xeb'
 b'X\x92\xc8\x00\x03\x00\x0b\xbd\xb7\xb5>\x9b\x00\x03\x00\x11\xb0N[\x86'
 b'\xb2./\x9d\xcb\xa4\xc6p56G+7\xd7\x00D\x95\x00\x02\x00\x00\x00\x17\x00'
 b"\x00\x00)\x00\x04\x00\x00\x005\x1e'\xac\xfas\xe8\xeeP\x16B\xaf3\xe2\xee5"
 b'\xb1\xf4\xfd\xedW\x85\xbf\x13\xebj?A\xb2L\xbf\x1c\x83D=\xfa\xea0\xbd\x86'
 b'\xc7\xf2>\xd8)l\xbe\r\x13#>')

{'A1': {'B1': 3607118997,
        'B2': [{'C1': 3948450504, 'C2': [7548, -28734, 28554], 'C3': -67},
               {'C1': 3082108571, 'C2': [-6568, -25098, -26952], 'C3': -80}],
        'B3': {'D1': 78,
               'D2': 23430,
               'D3': -1305596003,
               'D4': 203,
               'D5': -1530499019},
        'B4': [54, 71, 43, 55],
        'B5': 30,
        'B6': {'E1': 10156,
               'E2': [4201900270, 1343636143, 870510133, 2985623021],
               'E3': 22405,
               'E4': [-0.5778108835220337,
                      0.7566268444061279,
                      -0.6113779544830322,
                      0.12251698970794678,
                      -0.06581105291843414],
               'E5': 0.4221910238265991},
        'B7': -0.13776831328868866,
        'B8': 62},
 'A2': 186,
 'A3': -30,
 'A4': 2525392358}

(b'ZDE\x00A\xefn\xa8yO\x81\x82\xdd:\xff\xb2\xb0\x01\xf8|\xcf\x90\xab\x8f'
 b'3\x92\x1eQ\xdd\xe3\x04\xadl\xac"\x00\x05\x00\x0b\xee\x93\xa5\xde]'
 b'\x00\x05\x00\x15M\x8f\r"\xbd\xb2\x07\xa5>\x96\xa6\xf7\xc5\xadH\x0c\x84^8\xda'
 b'^\x00\x02\x00\x00\x00\x1f\x00\x00\x001\x00\x04\x00\x00\x00=\x03H*'
 b'\xdb\xae"\xb7\\-\x85V\xfe\xccKJ\xf2\xf9\xc8g\xc4\xfe\xbfS\x9f\xd2>:'
 b'\xc28\xbe\x08\x19\x94\xbe\xbd\xbe\xb7=x\x81\xbd\xbfz\x0c-\xbcF\xa9\x9a\x98')

{'A1': {'B1': 1580784222,
        'B2': [{'C1': 2909580322,
                'C2': [-32035, 15103, -19792, 504, 31951],
                'C3': -18},
               {'C1': 2477121117,
                'C2': [-28501, -28877, -28130, 20957, -7420],
                'C3': 77}],
        'B3': {'D1': -113,
               'D2': 3362,
               'D3': -1112406107,
               'D4': 62,
               'D5': -1767442491},
        'B4': [-83, 72, 12, -124],
        'B5': 3,
        'B6': {'E1': 18474,
               'E2': [3685622455, 1546487126, 4274801482, 4076456039],
               'E3': -15106,
               'E4': [-0.8266574144363403,
                      0.1823815107345581,
                      -0.13291007280349731,
                      -0.37059566378593445,
                      0.060670603066682816],
               'E5': -0.9767482876777649},
        'B7': -0.012125397101044655,
        'B8': -104},
 'A2': 239,
 'A3': 110,
 'A4': 2826522497}

Вариант №8

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

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

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

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

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

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

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

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

(b'ECAS\x03\x00\x00\x00I\x00\xe5Q\xa4\x12\xe7\xdel\xb0Fe\x92?\xe5?R\x02d\x00'
 b'\x02\x00\x87\x00w.\xa3\x00\xe6\xb1\xb5\x19\xd6\xe1y\x96/QP\x92\x8dH\x91\x88'
 b'\xab\xd2Z\x82\xaco\x19y\xb3\xdb\x0e\xeen \xc1\xab=\x9cc\xac\r\x9d\x84<'
 b'\x8f#wgog\rr\xa9a\xcetdji\x08n\xa7H\x8buamzW\x9a|\x86\x8e\x92\xdd\xab'
 b't\x1ez\xbf6;"m\xdc \xe8\xbf\xb4\x01Q\xeb\x86\xfeUs\xf8z\xaf(\x97:\x1c\x03'
 b'\x8d')

{'A1': [{'B1': -99, 'B2': 596589700, 'B3': 'wgog'},
        {'B1': 13, 'B2': -832460430, 'B3': 'tdji'},
        {'B1': 8, 'B2': -1958172818, 'B3': 'uamz'}],
 'A2': 20965,
 'A3': 3739685540,
 'A4': 0.664010236554089,
 'A5': 594,
 'A6': {'C1': -6062528382531495337,
        'C2': {'D1': -0.977027177810669,
               'D2': -0.7540113574521914,
               'D3': 8310828542809145780,
               'D4': [-8, 122],
               'D5': 175,
               'D6': 473601832}},
 'A7': {'E1': [3, 141], 'E2': 1852582423144115831},
 'A8': {'F1': [-1770397226,
               -1840230097,
               -2003744627,
               -2107977045,
               2031710124,
               -301016141,
               -1413406610,
               -1402758083],
        'F2': 13}}

(b'ECAS\x03\x00\x00\x00I\x00\x03L\x9eg\xaav\xc4\xcd\xcc\xaf\xab!\xe2?Q\x07d\x00'
 b'\x04\x00\x87\x00`\x06$!\xf1\x02,\xac\xc7\x9a\xee\x15\xa3\x9e\xaf\xaa'
 b'\xe3L+\xbb3\x95\xb57"<\x18\x8c\xb5}d\xf5\xd2zz\xe7\xbd\x18\t \xbfl\xff\xea'
 b'\x96Xxpxn\xc1\xd5\xd3Q\xe4dajx\xbd\xfe\xf5\x08\x12fqbp\xc0N\x04K\x1c:C\xb5'
 b'\x8a\x1cc?X\x04o\x04\xdeb\xc4\xbf{7K\x0b\x9cV\xe5\xbe\x1a\x00\xb4H\xa9cg\xd1'
 b'\x95\xb4#')

{'A1': [{'B1': 108, 'B2': 1486285567, 'B3': 'xpxn'},
        {'B1': -63, 'B2': -464399403, 'B3': 'dajx'},
        {'B1': -67, 'B2': 302577150, 'B3': 'fqbp'}],
 'A2': 19459,
 'A3': 1990879134,
 'A4': 0.5666101869195974,
 'A5': 1873,
 'A6': {'C1': -5385396836212912448,
        'C2': {'D1': 0.887154221534729,
               'D2': -0.1592671891831141,
               'D3': 13755495865077413755,
               'D4': [26, 0],
               'D5': 180,
               'D6': 1734584648}},
 'A7': {'E1': [209, 149, 180, 35], 'E2': 12406294308165256800},
 'A8': {'F1': [367958727,
               -1431331165,
               -1154790173,
               934647091,
               -1944568798,
               -177963595,
               -411403566,
               537467069],
        'F2': -65}}

Вариант №9

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

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

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

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

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

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

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

(b'\x93WIWW\x00\x00\x00\x02\x00\x1c\xbe\xd5i\xbf\xbbV5\x19\x9f\xb1\x00t['
 b'Nc\x18\x1fcm=\xbf\xb1\x83\xd3\x00\x05\x00\x00\x00\x1e\xec\x96\xaf[-\xe9\x00'
 b'\x02\x00\x00\x00-\xc2f\x16\xca\x94\x91\xc6\x00\x03\x00\x00\x009)x'
 b'\x83\xda\x15$EgG\x8a"\xc8\x84\xc6\xf5\xc4\t\x08\xbc\xd1\xc0!\xbe\xca\xcc\n'
 b'>\xb4\xdb\xa6\x00\x03\x00T?\xe8\xc1\xc8\xad9ZF\xbb\x8b`\xfd\xeb%\x1f\xd3'
 b'\x00#\x00/\x00<\xcd\xcd\x00\x00\x00F\x00\x00\x00`')

{'A1': 'cm',
 'A2': -0.4168224036693573,
 'A3': -17578,
 'A4': 890871729,
 'A5': {'B1': [{'C1': [61, -65, -79, -125, -45], 'C2': -325669029},
               {'C1': [45, -23], 'C2': -1033496886},
               {'C1': [-108, -111, -58], 'C2': 695763930}],
        'B2': -12851,
        'B3': {'D1': 1523418883842253512, 'D2': 2227631556, 'D3': 2312},
        'B4': {'E1': [-0.025604309514164925,
                      -0.3960879445075989,
                      0.3532382845878601],
               'E2': 0.7736552603990468,
               'E3': 13514001750543376339}},
 'A6': 91,
 'A7': 1315117087}

(b'\x93WIWW\x00\x00\x00\x02\x00\x1c?\x02\xed\xea\x98\xe0\x05\x1c\x18'
 b'\xe4\x00q\xa1_\xd2\x7f\xb2hv\xeb\x9bl\x00\x03\x00\x00\x00\x1e\x06'
 b'\xae\x89\xb4\xaf\x1b\x1e\xaa\xb1\x00\x05\x00\x00\x00+\x80\x05'
 b'\x94\xb0\xf7\xc2\x87\x00\x03\x00\x00\x00:\x96\xd5\xba\xf74\xd5{3\xa7'
 b'\xf5b\xbfs\xf2\xd7\xf9\xa4\x08\xbf<Am=\x87\x85\xfb\x00\x02\x00U?\xe3\x8a'
 b'\xcd\xdaH\xbb\xaa\xee\xb7\xda\x8aI\xe7\x88k\x00!\x000\x00=\xfa_\x00\x00\x00'
 b'G\x00\x00\x00]')

{'A1': 'hv',
 'A2': 0.5114427804946899,
 'A3': -26400,
 'A4': 85727460,
 'A5': {'B1': [{'C1': [-21, -101, 108], 'C2': 112101812},
               {'C1': [-81, 27, 30, -86, -79], 'C2': -2147117904},
               {'C1': [-9, -62, -121], 'C2': -1764377865}],
        'B2': -1441,
        'B3': {'D1': 3807084521803047615, 'D2': 1945294841, 'D3': 41992},
        'B4': {'E1': [-0.735373318195343, 0.06617351621389389],
               'E2': 0.6106938613282769,
               'E3': 17201457589245151339}},
 'A6': -95,
 'A7': 1607630770}

Вариант №10

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

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

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

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

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

(b'LZNW\x89{\xeb\xe89b\xadftk\x9d\x02\x00\x00\x00\xb2\x00\x00\x00:\xe204U'
 b'\xebd\xb1\x02\x00\x00\x00\x17\x00\xdd\x0c\x02r\xc0\x021\xd0?\xfe\x86'
 b'\xe4\xbe\x11M5\xee\xcc\xfb\x94j\xe9v?\x06\x00\x00\x00\x19\x00\x00\x00\xf2_z'
 b'?\xe6\xb8e\to\x0b9\xe1\xd8K\xe2\x1a\xad\xadhwS\x80\xa1E?`\xfa|R\xd0\xb0'
 b'\xe2\xa1\xe5Ng\x9a\xc5\x90\x03\x00\x00\x00e\x00\xa5\x92\x0bS9\x01\xe3\xe6?('
 b'\xf7\x17\xbf\xdad&`\x87\x0e\xfe}_e\xbf\x04\x00\x00\x00h\x00\x00\x00L\xee8?a!'
 b'\xb4\xab\xc3\xf0\x7f\x89\xd26\xbe\x05\xf0\x1d\xac\x02\x81\x9b\xab\xe3!\xcf'
 b'\xf6*\x19\\\x1d\x87\x1f\x00\x00\x00l\x00\x00\x00')

{'A1': 7398677763699997577,
 'A2': 'tk',
 'A3': -99,
 'A4': [{'B1': [58, -30],
         'B2': {'C1': 221,
                'C2': 0.2529913787221012,
                'C3': -0.446342408657074,
                'C4': 17,
                'C5': 77},
         'B3': 53,
         'B4': -1795437330,
         'B5': {'D1': 0.9644991159439087,
                'D2': [48, 52, 85, 235, 100, 177],
                'D3': 0.9780265092849731},
         'B6': 157661414,
         'B7': [1937194184586365807,
                5017432555841433005,
                16334784901175468095]},
        {'B1': [-95, -27, 78],
         'B2': {'C1': 165,
                'C2': 0.715210544549665,
                'C3': -0.5936150550842285,
                'C4': -38,
                'C5': 100},
         'B3': 38,
         'B4': -32602272,
         'B5': {'D1': -0.8959882855415344,
                'D2': [103, 154, 197, 144],
                'D3': 0.7223861217498779},
         'B6': -1414258335,
         'B7': [413828493642559683,
                16405377046025084400,
                9736039232609636129]}]}

(b'LZNW\x94\xe7\x126\xdd\xe09\x7ffe\xc2\x02\x00\x00\x00\xb1\x00\x00\x00f'
 b'\x8c\x1e\xe9TQ\x1d\x02\x00\x00\x00\x17\x00\xfe\xd8n\xf66\x14\xea\xd2'
 b'\xbf\xe6\xdfv\xbf{\xf0\x0e\xc8\x9b\x89{`\x8e\x8d>\x05\x00\x00\x00'
 b'\x19\x00\x00\x00\xe7s(\xbfu\xd0\xe5w\xa3E`\x8dS\xbc\xec.w)\x7f\xe030\n\xcb'
 b',E\xddlL\xdb\x18\xdbu\xcb\x83\xc1\x9f$=\x03\x00\x00\x00d\x00\xa24\xc8'
 b'\x8f/\xf3\x8a\xe8?j\xc2\xbb\xbc\xcf\x8f\r\x10D\xf1}<\xc5m\xbf\x04\x00\x00'
 b'\x00g\x00\x00\x00{\xfd\xe8=\xaf*}u\xd2A\xf6Ou7\xbd\xc8$\xb8H]\xc5^\xc7'
 b'\xddt5p\xfe0\xd7Wu\x1e\x00\x00\x00k\x00\x00\x00')

{'A1': 9167605757188958100,
 'A2': 'fe',
 'A3': -62,
 'A4': [{'B1': [102, -116],
         'B2': {'C1': 254,
                'C2': -0.29553704612201903,
                'C3': -0.9643539190292358,
                'C4': 123,
                'C5': 240},
         'B3': 14,
         'B4': 2072615880,
         'B5': {'D1': 0.2764768600463867,
                'D2': [30, 233, 84, 81, 29],
                'D3': -0.6580185294151306},
         'B6': 2011549813,
         'B7': [3381284487288604067,
                14630559338834372983,
                15787609615037711660]},
        {'B1': [117, -53, -125],
         'B2': {'C1': 162,
                'C2': 0.7669616631449174,
                'C3': -0.022919852286577225,
                'C4': -49,
                'C5': 143},
         'B3': 13,
         'B4': 2112963600,
         'B5': {'D1': -0.928790807723999,
                'D2': [193, 159, 36, 61],
                'D3': 0.11376472562551498},
         'B6': 1971137199,
         'B7': [14464778555176141266,
                15980846004514109476,
                8455463430838564212]}]}

Вариант №11

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

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

(b'REBC<}\x81lTE\xdaD\x90\xc9\xd3\xbfz\x00\xe3\x06\xc4(\xd6\x159\xe6\xca\xc1'
 b'\x10H\x0e\x08k\xd9\xf4<?\t\xbe)j\x08\t\xf1\x08\xbc%!\x93lum\xc4\xbe\xed\x04'
 b'\xc46\xe4\x0c\xec\x92\x96"\xda\xf1 \x00\x00\x001\x00\x00\x00\x00b\x0c?Z\x96'
 b'\x03\xd6\x17\xf8><6\xe3\xcc\xf0\xd7\x81\xd6\xb3j\xcf\xe1M\xbcn\xaf\xe1&l'
 b'O \x02\x00B\x00J\x00\x00\x00\x8c\x10~NFO\xe7\x88b\x00\x00\x00\xa7Tw1P\x02'
 b'\x00r\x00\x00\x00\x85T')

{'A1': 1820425532,
 'A2': -0.3091774628056403,
 'A3': {'B1': {'C1': 2328198446624763580,
               'C2': [{'D1': 107,
                       'D2': 0.7381110787391663,
                       'D3': [-16887, 27177, 2312, 2289, 9660, -27871]},
                      {'D1': 108,
                       'D2': -0.3836475908756256,
                       'D3': [1261, 14020, 3300, -27924, 8854, -3622]}],
               'C3': {'E1': 0.548370361328125,
                      'E2': [-27046, -10749],
                      'E3': [1010759703, -255007946, -1277787689, 1306644330]}},
        'B2': 21671,
        'B3': 12663,
        'B4': 80,
        'B5': [1316884620, 2296860486],
        'B6': -123,
        'B7': 84},
 'A4': 683935459,
 'A5': 5590,
 'A6': -6599,
 'A7': 1209057738,
 'A8': 2062}

(b"REBC\xdaR\xe3'l\xc0\xa7\xe1\xb2\xc9\xd5\xbfz\x00\xf9\xbfv\xf8\xfe\t"
 b'`\x0e\xc4\x7fH(\xba\xc5\xf4\x1b<\xe3>\xca\x82\xfd\xe7\x9a\xf5\xc2\x90g\x04]'
 b'W\xf3a\xc6[?\xb4\xaa>\x93:\xcd,\x0e\xea\xa4#s \x00\x00\x001\x00\x00\x00W\xa7'
 b'^\xbd`\x91Mbj\xfe\x0f\x93\xb9i\xf2\r\x9f_{C>\x01A?\\\x07\x11.,\xb2'
 b'\x10\x02\x02\x00B\x00J\x00\x00\x00c\xd7\xf4\xa7\xe1\xf2\xc9\xd8b\x00'
 b'\x00\x00\x93\xafo\xdeJ\x02\x00r\x00\x00\x006\x9f')

{'A1': 669209306,
 'A2': -0.3404357150711863,
 'A3': {'B1': {'C1': 148814690524399452,
               'C2': [{'D1': -12,
                       'D2': 0.44381794333457947,
                       'D3': [-32054, -6147, -2662, -28478, 1127, 22365]},
                      {'D1': -13,
                       'D2': 0.8584957718849182,
                       'D3': [-21836, -27842, -12998, 3628, -23318, 29475]}],
               'C3': {'E1': -0.05435880646109581,
                      'E2': [-28320, 25165],
                      'E3': [-1827668374, 233990585, 1132158879, 1061224766]}},
        'B2': -20589,
        'B3': -8593,
        'B4': 74,
        'B5': [2817840995, 3637113569],
        'B6': 54,
        'B7': -97},
 'A4': 4168531961,
 'A5': 2558,
 'A6': 3680,
 'A7': 675839940,
 'A8': -14918}

Вариант №12

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

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

(b'MTUM\xe7v\xee\xe0\x84`\xc3RO\xc1\xb7\xb4"\x02\xb2\xddr\x00\x00\x00'
 b'\x05\x00\x00\x00\x88\x00\x03\x00\x8d\x00\x00\x00\xc2e\x10/n\xc0\x1d\xf0'
 b'\xc9Np\x9feU\x1a\x83!Vfr\xd0%\xd6\xb0\x04\xb7\xdeM,2\x85\t\x0ej\xf8W'
 b'dc\x85\xc3\xbe\xe4\xbe\xa9\x8b\x01\xc4\xe0\xefc<Ym\xcb\xbf^Sj\x95qo\xc6\xd9B'
 b'Je\xb4\xe8?0y\x01\x12Plcvk \xd1\x04\xf1\x02\x00\x00\x00R\x00\x00\x00\x04\x00'
 b'n\x00\x00\x00\xd7\xc4 \x1erbwezo\xd6??\xd5f\x0f\xbe\x12\xb6\x7f?')

{'A1': 5963716455394342631,
 'A2': -2471910897388895921,
 'A3': {'B1': 32,
        'B2': 209,
        'B3': -3836,
        'B4': [{'C1': -60,
                'C2': -0.21427455376385662,
                'C3': -1788193954,
                'C4': 113},
               {'C1': 111,
                'C2': 0.7720209551251223,
                'C3': 302086448,
                'C4': 80}],
        'B5': 'lcvk',
        'B6': 505464023},
 'A4': 'rbwez',
 'A5': {'D1': [0.7493657469749451, -0.14004071056842804, 0.998871922492981],
        'D2': 17302196922895852994,
        'D3': 9446957063318032073,
        'D4': [22049, 29286, 9680, -20266, -18684, 19934],
        'D5': 6338933084045783596,
        'D6': 100,
        'D7': 99,
        'D8': 111369253147296645}}

(b'MTUMM\x1f\xaf\x96\x8f\x1dP[\xb7Y\x8eF0\xa2\xf8\x12q\x00\x00\x00'
 b'\x05\x00\x00\x00\x87\x00\x03\x00\x8c\x00\x00\x00H\xa6\xed\xfb\x11\xc3=\xe7'
 b'@\xbc\x865C\xa6\x9a\xe8\xa2\xc1\xeb( k\x84\x0b\xba\xfd\x05\x1e>y\x13\r'
 b'\x8e\x1a+\r\x16\xec\xbd\xe3\x100\xec\xfd\xf9#H\x00u{\xfa\xfa\xda\x9f\xbf\xd6'
 b'\x85\xfeb\x05\x9b\xc8#e\x7f\xe9/\xc1?\x82R?\x03}ijtE\xd4.\xae\x02\x00\x00'
 b'\x00R\x00\x00\x00\x03\x00n\x00\x00\x00j\r\xa7#bxubs\xcf\xa8T?\x9b\xcc;\xbe'
 b',$2?')

{'A1': 6579791558133882701,
 'A2': 1367020815132809655,
 'A3': {'B1': 69,
        'B2': 212,
        'B3': -20946,
        'B4': [{'C1': 72,
                'C2': -0.03110878137419082,
                'C3': 1660847574,
                'C4': 5},
               {'C1': -101,
                'C2': 0.134274661259296,
                'C3': 54481538,
                'C4': 125}],
        'B5': 'ijt',
        'B6': 598150506},
 'A4': 'bxubs',
 'A5': {'D1': [0.8307008147239685, -0.18339769542217255, 0.6958644390106201],
        'D2': 16662688678349219400,
        'D3': 16760891770803764288,
        'D4': [-15966, 10475, 27424, 2948, -582, 7685],
        'D5': 948881343898679614,
        'D6': 22,
        'D7': 236,
        'D8': 2592382251388953533}}

Вариант №13

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

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

(b'HOU\xfc\x7f\xe4?W\x1f\xf5}\x0c\x02\x00\x00\x00\x82\x00w\xe2\xd4\xf8F\xc1'
 b'{\xa4\xceDa\xbe\x9d\xbe?\xe8\x9ar*l-\xff\x86\x00\xe8\x12\x17A\xae/'
 b'\xc0?\xaa\xa5\xf0&\xb8o\x18\xc7\x913\xbbF1`4?c\xd0)?f6\xbc\xbe\xef\x13'
 b'\xc1>`\xe2H\xbfRH\xcc\xbc\xeb\xa4\x1b\xbf8\x8c\x89\xbeEg6\x06\xf5\x9a'
 b'=\x19\x11N\xbd\xb5\xb6)\xbea\x94i?+\xe3\\?6)\xb4>\xf6\xf5\xea>\xaaK\xf0'
 b'\xbe"<\x00_\x00\xb6}\x10\xc8\xcc57\x0b\x9c:\x81\'\x9f\xd04t#\x1c\x91\xd9nc'
 b'>\x80O%\xeb')

{'A1': 1071939580,
 'A2': {'B1': {'C1': 2113216343,
               'C2': 12,
               'C3': [{'D1': 18107,
                       'D2': [0.704592764377594,
                              0.6633359789848328,
                              -0.36760252714157104,
                              0.3771052062511444,
                              -0.7847042083740234,
                              -0.024936828762292862,
                              -0.6079851984977722,
                              -0.2686479091644287],
                       'D3': 69},
                      {'D1': 13927,
                       'D2': [0.07566265761852264,
                              -0.05030927434563637,
                              -0.16573603451251984,
                              0.9124203324317932,
                              0.8628413081169128,
                              0.3518769145011902,
                              0.4589077830314636,
                              -0.46932727098464966],
                       'D3': 34}],
               'C4': -6594464718787386761,
               'C5': -0.21998903155326843,
               'C6': 48797},
        'B2': {'E1': 1922754623, 'E2': 27690, 'E3': 65325}},
 'A3': {'F1': {'G1': 182,
               'G2': 4221,
               'G3': [-13112, 14133, -25589, -32454],
               'G4': -7990472656852836569,
               'G5': 0.22210253775119781,
               'G6': -349876352},
        'F2': 0.1264550988982116,
        'F3': [-23126, 9968, 28600, -14568, 13201]}}

(b'HOUn\x8e\xc2L\x01\x89\xe9\xb3I\x02\x00\x00\x00\x82\x00\xc1\xe23\x14\xb0\xd8'
 b'\x11\xee\x84D\xb8>\xf8*q\x1d\xeb\xd4+\xfd\x08\x98\x86\x00z\xf3\xc6V\xca\x14'
 b'\xe7?\xab\xfc\xf8\xbf\xaf\xee\xd7\x13P\x9b`\xab\xe5\xdf\xa9\xbe\x899'
 b'4\xbf\xeb?\xa6>\xcc\x1cO?\xc3\x0e\x1d>\x91\xf9\x96\xbe30!\xbfh|`?N\x96'
 b'\x0c\x86\xe0:>\xae8b?\x85b+\xbe\x94\xc2\xcd\xbe9\x85\x10?\xc2\xfb\xc8'
 b'\xbe\xe5l\x10\xbf7,D>\xb8<\x00_\x00\xf3\xe8\xa7\xd8\xbc\xb8U\x98D\xbc'
 b'\x9cQx\xcf\x93rZ>\xdeN?3?\x00\xfe\x06\x8b')

{'A1': 1287818862,
 'A2': {'B1': {'C1': -1276540671,
               'C2': 73,
               'C3': [{'D1': 43872,
                       'D2': [-0.33178630471229553,
                              -0.7040029168128967,
                              0.32470640540122986,
                              0.8090331554412842,
                              0.15337662398815155,
                              -0.29487279057502747,
                              -0.6296417117118835,
                              0.8768982887268066],
                       'D3': 78},
                      {'D1': 3222,
                       'D2': [0.18249711394309998,
                              0.8836773633956909,
                              -0.16736800968647003,
                              -0.4018751382827759,
                              0.5645328164100647,
                              -0.39254575967788696,
                              -0.5641615986824036,
                              0.19157491624355316],
                       'D3': 184}],
               'C4': -1292013367313833279,
               'C5': 0.3598977327346802,
               'C6': 11000},
        'B2': {'E1': 3572178289, 'E2': 64811, 'E3': 38920}},
 'A3': {'F1': {'G1': 243,
               'G2': 42984,
               'G3': [-17192, 21944, 17560, -25412],
               'G4': -2432407300580870063,
               'G5': 0.70018470287323,
               'G6': -1962476032},
        'F2': 0.7212878889909995,
        'F3': [-853, -16392, -4433, 5079, -25776]}}

Вариант №14

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

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

(b'NDUC\xa3J\xf5\xe6D\x00\x00\x00\x02\x00\x00\x00\xbc\xcd\xb8E\xae\x00\x00\x00'
 b'\x02\x00\x00\x00\xbes\xb2N\x99\x00\x00\x00\x02\x00\x00\x00\xc0\xe1\xcd\x92'
 b'\x9d\x00\x00\x00\x02\x00\x00\x00\xc2\xa59\x1c\xbe\x00\x00\x00'
 b'\x02\x00\x00\x00\xc4`\x81H\x85\x00\x00\x00\x02\x00\x00\x00\xc6\xe2\x0c\x92'
 b'\xc9\x00\x00\x00\x02\x00\x00\x00\xc8\xa9t\xfa\xc0r\x9d\x9e\x9f\xc0\x16\xeb'
 b'y\xf2\x99\xef@H\xc8\xde~`\x8at-\xfb;\x02\xdb\xcd\x0f[\xf6\xa0\x06\x14'
 b'\xefe\r\xb1\x01\x00\x00\x00\x02\x00\xca\xbfP\xcb\xf1=\xf7u\xa7\xbc'
 b'\x84\xd3\xff>=*\x9e>\xb0w\x8d><\xc5G>\xf0\xbd\x85g\xd7?k\x12G\x0e\x960'
 b'\xa6\xd2\x1c?H\xb2x\xbf\xef\xde\xf3}\x82\xac\xb2pfyoooxvehgbkwn}='
 b"\xfa\x8d\\\xce\xac\xe9\x17\xd4't\xc3Sq\xb0")

{'A1': 163,
 'A2': [{'B1': 19189, 'B2': 58948, 'B3': 'fy'},
        {'B1': -12872, 'B2': 17838, 'B3': 'oo'},
        {'B1': 29618, 'B2': 20121, 'B3': 'ox'},
        {'B1': -7731, 'B2': 37533, 'B3': 've'},
        {'B1': -23239, 'B2': 7358, 'B3': 'hg'},
        {'B1': 24705, 'B2': 18565, 'B3': 'bk'},
        {'B1': -7668, 'B2': 37577, 'B3': 'wn'}],
 'A3': 2843015872,
 'A4': {'C1': 1922932383,
        'C2': 192,
        'C3': 1651547771233058888,
        'C4': 51422,
        'C5': 32352,
        'C6': {'D1': -8470094442126976051,
               'D2': 1106749300606824293,
               'D3': 3505,
               'D4': 1,
               'D5': [9024644713374723305, 1717040740381716912],
               'D6': [-0.8156118988990784,
                      0.12082987278699875,
                      -0.016214368864893913,
                      0.18473288416862488,
                      0.3446621000766754,
                      0.1843463033437729],
               'D7': 0.4701959192752838,
               'D8': 7482519035000065686}},
 'A5': 816239132,
 'A6': 0.783973217010498,
 'A7': -0.9959657145858698,
 'A8': 112}

(b'NDUC\xac\xe3j4\x97\x00\x00\x00\x02\x00\x00\x00\xbc#W\xf0\xae\x00\x00\x00'
 b'\x02\x00\x00\x00\xbe\x8f\x17\x97\xa2\x00\x00\x00\x02\x00\x00\x00'
 b'\xc0\xf3\xa5\xe1\x12\x00\x00\x00\x02\x00\x00\x00\xc2oc4\n\x00\x00\x00'
 b'\x02\x00\x00\x00\xc4>c\xb7J\x00\x00\x00\x02\x00\x00\x00\xc6\x1e\xa7-'
 b'\xcb\x00\x00\x00\x02\x00\x00\x00\xc8rf\x89\x13\xeb:y&$\xcf\xad\xb9/\xfaQ'
 b'\x86\x1c\x97`\xf2\xcf\x94=Q\x17\x15[Gq\xd4X\x8b\x1c+\x1a\xf4\xa9qu'
 b'\xc7\x00\x00\x00\x02\x00\xca=\xc4\xed\xd7\xbff\xae\xc8?6\xfe\x00\xbf'
 b']\xc0\x87\xbfk\xa7\xf0\xbfc\xc7\x06>(\x00\x7fzH\xd0\xa4\xcf\xcfW\x0c\xaf'
 b'\xf2\x11\x89\xbfY\x97\x84?\xe1\x1a\xc0\x87\xdbt\x8e\x18flztuongxxumal,\x08'
 b'F\xa1\xb9\xf2\xf0\x96\xd8{\x9d\xfe\x7fh\xe8!')

{'A1': 172,
 'A2': [{'B1': -7318, 'B2': 13463, 'B3': 'fl'},
        {'B1': 9047, 'B2': 61614, 'B3': 'zt'},
        {'B1': -28905, 'B2': 38818, 'B3': 'uo'},
        {'B1': -3163, 'B2': 57618, 'B3': 'ng'},
        {'B1': 28515, 'B2': 13322, 'B3': 'xx'},
        {'B1': 15971, 'B2': 46922, 'B3': 'um'},
        {'B1': 7847, 'B2': 11723, 'B3': 'al'}],
 'A3': 1919322387,
 'A4': {'C1': -348489434,
        'C2': 36,
        'C3': -3481923321173277156,
        'C4': 38752,
        'C5': 62159,
        'C6': {'D1': -7764961022932465807,
               'D2': -3145611386619759447,
               'D3': 29045,
               'D4': 199,
               'D5': [3172863597905899670, -2847508622996871135],
               'D6': [0.0961567685008049,
                      -0.9011044502258301,
                      0.714813232421875,
                      -0.8662189841270447,
                      -0.9205312728881836,
                      -0.8897556066513062],
               'D7': 0.16406439244747162,
               'D8': 8811522077230061324}},
 'A5': -1343090295,
 'A6': -0.8499681949615479,
 'A7': 0.5345156339132175,
 'A8': 24}

Вариант №15

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

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

(b'\x87GAIJ\x00\x042\xb7a\xbb\\\xb2qrzzgat\x02\x00\x00\x00J\x00\xb7\xfa'
 b'\xc7<2\xbf\xe4 \xff\xf1um\xf7_\xa8\x07T\xc9\xbbi\x92?\xc0 G\xfd'
 b'\xfa\x9a\xad\xf6\x1f/~?\xfd\xb3\xbd\xa6\x8e\xec1\xecd\x00\xfa|g\xd0\xa1\x04'
 b'h\xb0\x01\x192\x95\xfd\x8a\xa3\x80\xb1\xd8v\x1d\x8ft\x99D\xf9\xe1'
 b'y\x15\xb0\xd5\x88\xe3|\x9f\x01{\xc7Z\x94\xb8\xddX4j\xbf\xda\x04\xddo\xe3'
 b'\t\x15\xfe\xa1EJ\x1a\xb1\x17\xc4\xddl\xe2?\x15\x97$\\\x12\x1a0@')

{'A1': {'B1': 12852353464968283136,
        'B2': 'qrzzgat',
        'B3': [{'C1': 161, 'C2': 28338180, 'C3': -5656341314622115303},
               {'C1': 216, 'C2': 1955536246, 'C3': -3048913334503390055}],
        'B4': [1019738807,
               551862066,
               1836446207,
               128475127,
               1773914452,
               549470098,
               2600140103],
        'B5': 173},
 'A2': -10,
 'A3': 0.9929065108299255,
 'A4': -1427099509472775171,
 'A5': {'D1': [2675762056,
               1523022593,
               1490925716,
               3669977652,
               3815759108,
               2717783305],
        'D2': 19013,
        'D3': 0.5757893400127927,
        'D4': 4625225483467134741},
 'A6': 31994,
 'A7': -12185}

(b'\x87GAIJ\x17\x1c7\xa8m\x03\xab\xdenogjdbn\x03\x00\x00\x00J\x00Y\xcd'
 b'\xce\x7f\x94\xccW\x9f\xb2\x9a\xf2z\xb8\xc0w%\xed\x8e\x9f\x83R\xdf'
 b'\xd6\x1c\xe9\xd1\xac\x9b\xfa\x16\x1d\xb1L\xbf\x97\xbfR\xb4\x922i\x8d'
 b'q\x00\xdb\xe8\xd9\x11\xdf(\xd3\xa64\x94\x19\xe0)\xac\xb7{"Z\x8aK\xd5\xad'
 b'\xe5\xe7z\x90\xe6\xf6R1\x8a\x92d\x14\x1b\xde\xb8\x81d\xfeE\xca'
 b'\xce\x8c\x97\xf9\xce\xa4\xbaflA"L6a:\xcdW2\xe4\x8b\x97\xa7nx\xba\xb7x '
 b'\x1a1\xec\xebS\xea?\xc0\x03\x9f\xae\x0fah\xa3')

{'A1': {'B1': 16044921866946026519,
        'B2': 'nogjdbn',
        'B3': [{'C1': 223, 'C2': 883348264, 'C3': 2484781569489770900},
               {'C1': 90, 'C2': 2916436874, 'C3': 3554174526075627493},
               {'C1': 138, 'C2': 454321298, 'C3': -3545944797690611490}],
        'B4': [2144259417,
               2673331348,
               2062719666,
               628605112,
               2208272109,
               483843922,
               2611794409],
        'B5': 250},
 'A2': 22,
 'A3': -0.799577534198761,
 'A4': -8257012836135157865,
 'A5': {'D1': [3472463756,
               1818671780,
               910959169,
               1473067617,
               2542527538,
               3128454823],
        'D2': 30903,
        'D3': 0.8227443326111974,
        'D4': 11774767945742222272},
 'A6': 59611,
 'A7': 4569}

Вариант №16

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

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

(b'ZLYZ\xe7\xcc\x9b\x93\xd1\xff\x00\x00\x00X\x00\x00\x00\\\x00\x00\x00`\x00\x00'
 b'\x00d\x00\x00\x00h\x02`\x8e\xedd"\xbf\xef\xe9|0\xfbs\xach\xf0P2'
 b'\xd9\xc6\xfc\xab:-\xe0\xd5\tz\xbf\xbc\xd3c\xb4M\xd3\x00l\x10\xcd\x00\x03\x00'
 b'\x00\x00lhu\x01\xcd}\xd6\x88\xa7\xa5\xddO\xf0\x05Y\x92tqw\xf6ox\xa8Hqx'
 b"\r\xdcqz\xcd\xdaug\xc3'\xa9")

{'A1': 3888946067,
 'A2': 53759,
 'A3': [{'B1': 22930, 'B2': 'tq'},
        {'B1': 30710, 'B2': 'ox'},
        {'B1': 43080, 'B2': 'qx'},
        {'B1': 3548, 'B2': 'qz'},
        {'B1': 52698, 'B2': 'ug'}],
 'A4': {'C1': 608,
        'C2': -1897044958,
        'C3': -0.9972516018566373,
        'C4': [26864, 20530, -9786, -853, 14893],
        'C5': 3772057978,
        'C6': {'D1': -0.11260054733231684,
               'D2': 108,
               'D3': 4301,
               'D4': [-61, 39, -87],
               'D5': 26741,
               'D6': 461}},
 'A5': 32214,
 'A6': [136, 167, 165, 221, 79, 240],
 'A7': 5}

(b'ZLYZo\x9d\xb3\xc7\x0ei\x00\x00\x00X\x00\x00\x00\\\x00\x00\x00`\x00\x00'
 b'\x00d\x00\x00\x00h?\x95\xc5\x1e\x1c\x8d?p\xde\xb1\xc4\xd6\\\x00\x91>\x03C'
 b'\xa7\x93\xab\xc5lI)\x16\xda^\xbf\xdd\x90\x8el\x9c\xe4@\xeb\xe6'
 b'\xa2\x00\x02\x00\x00\x00l\x08\xa5\xef\x08j\xb7C\x04\xaf\x94\xdf,\xa2u\xe3oi'
 b'\xdf\xfabf\xbflcp_\xa2eu\xb9\xc3vg\xe6\x8d')

{'A1': 1872606151,
 'A2': 3689,
 'A3': [{'B1': 30179, 'B2': 'oi'},
        {'B1': 57338, 'B2': 'bf'},
        {'B1': 49004, 'B2': 'cp'},
        {'B1': 24482, 'B2': 'eu'},
        {'B1': 47555, 'B2': 'vg'}],
 'A4': {'C1': 16277,
        'C2': -987882355,
        'C3': 0.00411862793898532,
        'C4': [-28354, 835, -22637, -21563, 27721],
        'C5': 689363550,
        'C6': {'D1': -0.4619480190918388,
               'D2': 235,
               'D3': -6494,
               'D4': [-26, -115],
               'D5': 2213,
               'D6': 61192}},
 'A5': 27319,
 'A6': [67, 4, 175, 148, 223, 44],
 'A7': -94}

Вариант №17

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

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

(b'wGXLMV\rpqda\xb2\xc8c\x1ai\xe6\xa4\x9a{S\xd7\xd3\xb07\xf7 \xb2\x8d\xeb\xf5q'
 b'Kr\xe9be\xbf\xac\xbaL\xeetF`\x12\x8b\xc8\xb2\x00\x00\x00\x02\x00\x00\x00'
 b'D.\xbf\xee\xff7\x07\x92\x14\xa6\x00Fmx\xa9\xb1]\x9a\xe6\x06\xc7\x9c\x86\xb9'
 b'\xabg !Z6-\xc7\x08\x8a!\x05h\\a\xc1I\x01\xcc\xdd\x91\xbd\x1b\xdeZ\xb0t+'
 b"o$G\xf2 <j\xa5\xdc\xc9\xa05M\x15\xb4\xf3\xec\xeb'<\xa8\xe8\x85")

{'A1': 22029,
 'A2': 'pqda',
 'A3': -19768,
 'A4': {'B1': [{'C1': 99, 'C2': 6761},
               {'C1': -26, 'C2': -23398},
               {'C1': 123, 'C2': 21463},
               {'C1': -45, 'C2': -20425},
               {'C1': -9, 'C2': 8370},
               {'C1': -115, 'C2': -5131},
               {'C1': 113, 'C2': 19314},
               {'C1': -23, 'C2': 25189}],
        'B2': -0.056108860119036263,
        'B3': 4747,
        'B4': 200,
        'B5': -78},
 'A5': 'mx',
 'A6': 46,
 'A7': -0.9686541698325939,
 'A8': {'D1': 12227657383153158044,
        'D2': [-2034652313, 539056694, 768018570, 554002524, 1640057089],
        'D3': [14762115394992757424, 8370906534014754876, 7684791097712004373],
        'D4': 13039025840887474408,
        'D5': -123}}

(b'wGXLM\x16\x99gwut\xe7\xf4X\xde\x8c\x10t\xe2\x1d\x92\x89\x92\x8eg\x15\x97\x1a'
 b't\xbf?Ox+K)\xcd?\xe33J\x86eu\xe2xp\xf0N\x00\x00\x00\x02\x00\x00\x00'
 b'D\xad?\xa6Z\xcbA\x1bX\xa0\x00Fem6\x83\x88\x17\xa0Lq\xa5I\xbd\x19\x89\t1'
 b"\x06.Y0_#\xb3\xb6\xf5\x02&\xb1\x132\xe19F\xf7\xdd\xf1\t[\xde\xdb3\x0e'\x89"
 b'\xc4)\x9a`\x1c\xfb\x9f\xb0w\x0fi\xdeM\xbapl\x13\x03G')

{'A1': 5785,
 'A2': 'gwut',
 'A3': -6156,
 'A4': {'B1': [{'C1': 88, 'C2': -8564},
               {'C1': 16, 'C2': 29922},
               {'C1': 29, 'C2': -28023},
               {'C1': -110, 'C2': -29081},
               {'C1': 21, 'C2': -26854},
               {'C1': 116, 'C2': -16577},
               {'C1': 79, 'C2': 30763},
               {'C1': 75, 'C2': 10701}],
        'B2': 0.6000111222198792,
        'B3': 30832,
        'B4': 240,
        'B5': 78},
 'A5': 'em',
 'A6': 173,
 'A7': 0.04366145295868873,
 'A8': {'D1': 3928132935052194213,
        'D2': [1237129609, 154207790, 1496342307, -1279855358, 649138994],
        'D3': [16229080762600720731,
               16058485032205534249,
               11123922946646636303],
        'D4': 7628620281957585667,
        'D5': 71}}

Вариант №18

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

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

(b'IMX\x04\x00\x00\x00C\x00e\xd0S\x00\xb8|\x8a\x99\xbb\xa3\xb9\xa9z\xbf\x02'
 b'\x00\x8a\x00_\x18\x02\x00\x92\x00\x00\x00\x8fq\x8e>\x91\xcf}?r\xf5M?\xb1'
 b'd\x18>y\xea\x07?\x13\x85\xf3<\xea*\x01\xbfc\x92}>\xcdO1\xbe8\xe7{\xbe\xd5'
 b'}\x9f\xbe}\x89q\xbf\x06\xdcJ\xce\x1c\xf4o\xbeS\xd4\x93\xe3\xfd'
 b'\xbc\x97\x91\xaa\xc0\xd5\x81\x92W9\x91\xbf\xf4\xefZ7\x82\xb8\xa7\x92'
 b'\x7f\xd3!Z\x85\xa4\xe00x\x97\xf4\xcdm\xdf?*\xd2Y\xc7\xff\xfcN\\\x00'
 b'\x00\x00s\x00\x00\x00\xf2\xfe\xbb\x89\xacA\xffcew\xa4\xb0\xef\xdaa\x19')

{'A1': [-0.1731559783220291,
        -0.24599921703338623,
        -0.31150689721107483,
        -0.9435041546821594],
 'A2': {'B1': -12187,
        'B2': {'C1': 6,
               'C2': 19164,
               'C3': -50,
               'C4': -0.23432964086532593,
               'C5': 83},
        'B3': 31928,
        'B4': 39306,
        'B5': -23621,
        'B6': -0.979152262210846,
        'B7': [{'D1': 12290771696039990228,
                'D2': -0.016820305173004035,
                'D3': 928706548,
                'D4': 47234,
                'D5': -89},
               {'D1': 16187209582837464978,
                'D2': 0.4910769356337168,
                'D3': 3344552490,
                'D4': 64767,
                'D5': 78}],
        'B8': 6239},
 'A3': [7205550138117062386, 1828983646684739429],
 'A4': [0.2782101333141327,
        0.9914484620094299,
        0.8045264482498169,
        0.1488216072320938,
        0.5309215188026428,
        0.02972654066979885,
        -0.5045610666275024,
        0.24762873351573944]}

(b'IMX\x04\x00\x00\x00C\x00\x00\x01S\x00\xd1\xd2\xb0\xa3\x99w\xde*a?\x02'
 b'\x00\x8a\x003^\x02\x00\x92\x00\x00\x00\x1ed\x95\xbe\xc1\xbb\x9e\xbb\xc8'
 b'\x92\xb3\xbd\x05\xec\xa7>h\x1b~\xbe\x99\x03\xf8\xbd\xfe\xac:\xbe*.+\xbf\x82'
 b"\xd7z?;\xda\x95\xbe<{\x8b<<\x19\xcf>'\xe6p\x1f ~\x10\xbf\r\n\xa1\xee\xab"
 b'\xeaj\x14\nh\xebl\xd3\xb5|\xdd\xbf.\xc3_C\xac\xb0<\xc4w\x9b\xfa\x1b'
 b'uc\x1c\xb0\xbf\x85i}h\xc9?\xe8\x04[ \xe9ln\\\x00\x00\x00s\x00\x00\x00ID'
 b'\xe8\xcbvr6\xb82Wz\xc0\xc9\xe8Yp')

{'A1': [0.9798508882522583,
        -0.2926805913448334,
        0.017026536166667938,
        0.4044893980026245],
 'A2': {'B1': 256,
        'B2': {'C1': 39,
               'C2': 28902,
               'C3': 31,
               'C4': -0.5644245147705078,
               'C5': 13},
        'B3': 53969,
        'B4': 41904,
        'B5': 30617,
        'B6': 0.8795603513717651,
        'B7': [{'D1': 726322996052926730,
                'D2': -0.46073671004312766,
                'D3': 1130349358,
                'D4': 45228,
                'D5': 60},
               {'D1': 2045607418785396676,
                'D2': 0.19850127842391663,
                'D3': 542835944,
                'D4': 27881,
                'D5': 110}],
        'B8': 24115},
 'A3': [13273922806273819721, 8095757758390490930],
 'A4': [-0.29177945852279663,
        -0.0048441593535244465,
        -0.08768230676651001,
        0.32797256112098694,
        -0.24815142154693604,
        -0.12110061198472977,
        -0.18230053782463074,
        -0.6686731576919556]}

Вариант №19

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

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

(b'LFT\xc62\x9d\x06\xb8\xc7c{H\xcc\x8a\x9e\xb5pydxudu\x7f\x00\x00\x00\x91'
 b'\x00\x00\x00w\x03U\xa9X\x8fB\xd1Te\x03\xc2\x9d\xf5,\x9f\xf6A\x8b\x8b\xb7'
 b'\x99\xb7\x88)\x98\xc2\xfa\x97\xedr\xb4\x94\xeb\x92h4irfC1\x98\xf7z\xaar\xc7)'
 b'{\xc3\xdbYP=\xd1aeW\xb6?\xf6\x89\x7fp\x9f\x88\xb6j\rM\xfb!d\xba!\xb5'
 b'&\xfe\xaa\x9d\xc3\xb5\x87\xf6\xf3\xe6\x1f\x86\xf6\xc8b\x81\x90E%\x1bU\xf3k2'
 b'=\x8di\x80P\x08e\x01*\xcb\x1a\xe0?\x8a\x98Y\x99"\x9d\xff\x00\xa1\xf4\xc8'
 b'\xb1\xfc\xa6\xfe\xa6\xc0\xbf')

{'A1': 3087441202,
 'A2': -5359693896530304057,
 'A3': 'pydxudu',
 'A4': {'B1': [{'C1': [21787, 27635, 15666, 27021, 20608],
                'C2': 0.5032707043093589},
               {'C1': [39050, 39257, 40226, 255, 62625],
                'C2': -0.13009627488771813}],
        'B2': 119,
        'B3': 1487492355,
        'B4': 1423000207,
        'B5': {'D1': 101,
               'D2': 4120756739,
               'D3': -7370268834945130708,
               'D4': 2552858807,
               'D5': -1342,
               'D6': [7535344150459379095, -605679984329987788]},
        'B6': 122,
        'B7': 6474983823024550570},
 'A5': {'E1': 0.08727105749243447,
        'E2': 7689483632150284790,
        'E3': -5394825939383530227},
 'A6': [-1649738202, -158878269],
 'A7': {'F1': -9123508933961455885, 'F2': 17808, 'F3': 37}}

(b'LFT\xc6\xcb\x01\xbf\xbe\x83\xbe\x9f*\x0e\xf5\xdcssndzfsg\x7f\x00\x00\x00\x91'
 b'\x00\x00\x00\x85i\xe914p\x15H\xab\xc9\xe6\xb4)\x17\xb4\xcfR$a\xedA'
 b'C\x93\x85\xeb\x99v\xaf\xe0\xba\xbe\xfc\x85\x1c\xad\xa59\xb6\x1c\xf1\xe1'
 b'\xb4\x8dO\x17\xe9\xa0\x96\xac+~\x0c&\xc8\xde\nw\xa1\xc6\xd5\xbf\xeb(|D'
 b'\x9c7\xd9n\xa9\x7fN)\xb19(\x01\xa4\xe8\x9f\xb1]\xa4\xba^\x90&$\xde'
 b'l\x8f\x00\xe2ba\xae\xf8\xf7\x0c\x971\x8d9~T\xc4 ?\xc7\x93-\x1b\xb9\xbf=\nk'
 b'\xe2XG\xa0\xa6#Nbd\x03a\xb4\x90\xef\xbf')

{'A1': 3200188875,
 'A2': 8348817250431516291,
 'A3': 'sndzfsg',
 'A4': {'B1': [{'C1': [63480, 38668, 36145, 32313, 50260],
                'C2': -0.09807095392102072},
               {'C1': [2621, 57963, 18264, 42656, 20003],
                'C2': -0.986414136389737}],
        'B2': -123,
        'B3': 875686249,
        'B4': 2873628016,
        'B5': {'D1': -55,
               'D2': 388609254,
               'D3': 4846415675504381876,
               'D4': 2582349203,
               'D5': -20618,
               'D6': [-6508514524683912480, 5732436783218341433]},
        'B6': 23,
        'B7': 2741704999206035689},
 'A5': {'E1': -0.34024845719566743,
        'E2': 7987476558421698795,
        'E3': 83380026171359145},
 'A6': [-1314920284, 1589290077],
 'A7': {'F1': -2161570123391687024, 'F2': 24930, 'F3': -82}}

Вариант №20

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

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

(b'\xfdVBLBNJ\x00\x08\x00\x00\x00\xb4\x00j}\x7f\x98\x9aGQ?+\xea<\x9f\xa5\x1d'
 b'|\x80K\xe4\xb1>\x0c\xb1<\xdfnD\xe0X\x12#}\xbf\xbd\xf1\xba\x16q\x16'
 b'\xfe\x8b\xb1\xd6\x00\xbe`\x06d\xb0p\xcc\xce\n\xc5Y\x04\xbf\xf5i:\xbf\x12\x00'
 b'\x00\x00\x1e\x00\x00\x00*\x00\x00\x006\x00\x00\x00|\xaes\xb7/\xe9P\x86<\xd9'
 b'f\xa2\xbc\x02\xee?&\xa5\xaa\xe6q\xd5Z\r\xe0e\xef&\xb5\xef\xbe\xe8\xdb\x1d'
 b'\xbe`=o\x11\x9d\xc2m\xb18\x83L\xe66"~&\xd3+\x87\x1d\x80\x12\xde2\x8a\xa0\xdd'
 b'\xefQ\xbe\xaa\x97\x9f\x82\xcahu\xca\xfc\xdd\xba\xd6\xae;\xd4-\x02'
 b'\x00\x00\x00B\x00\x00\x00\x08N@\x1c\x0b\x18}\xde\xaa')

{'A1': 78,
 'A2': {'B1': [{'C1': 0.8174988031387329, 'C2': -1623397845, 'C3': 2155617701},
               {'C1': 0.3474448621273041, 'C2': -549670644, 'C3': 1491092590},
               {'C1': -0.9888163805007935, 'C2': 381350333, 'C3': 2348684913},
               {'C1': -0.12581898272037506,
                'C2': -1335622048,
                'C3': 181324912}],
        'B2': {'D1': 9678491990369742460,
               'D2': 0.9378340885075782,
               'D3': 38,
               'D4': 165,
               'D5': {'E1': -86,
                      'E2': 17250440295675687398,
                      'E3': [-0.468178927898407, -0.15415918827056885],
                      'E4': 96,
                      'E5': 61,
                      'E6': 4463,
                      'E7': 49821},
               'D6': [2465411062325358957,
                      1333097956094715518,
                      -4732737998229458210,
                      -3858062286788782166,
                      3302330048882335228],
               'D7': [-0.5169947743415833, -0.7281792759895325],
               'D8': 8}},
 'A3': [78, 64, 28, 11, 24, 125, 222, 170],
 'A4': 2558492010}

(b'\xfdVBLB/J\x00\x02\x00\x00\x00\xb4\x00AQ\xd4k\x8e]\x1c\xbe+[8q\x12\xda'
 b'\xa5\x03\x97t\xe8=\x93N\x04!%\x867\xe9;\xcb\xf0>\x94U\xb4+\r\xe0\xb9\xcbF@'
 b'S\xbf\x125\xab\x97\xca\x128i\x1d\x9fM?X\xad_?\x12\x00\x00\x00\x1e\x00'
 b'\x00\x00*\x00\x00\x006\x00\x00\x00\xd6\x12\x1c\\+\xe7\xb2K\\\xe7\x98o\xc4='
 b'\xdf?\xb0K\x14\xefh\x86\xb5\xef(\xdaX\x85\x85S\xbf\xe3\xfbI?z\xaa\xa5'
 b"{\xa4\x88\x02\xee\xf3\x17=\xe3\xf9\xa1-\xbe\xa7\x89\x02\xf8\xf5\xb8\xb6'L9I"
 b'9a\xcb\xf6\xf47\x94?\xc6I6n\xc0m>\xf0\xfdd\xcb\x02\x00\x00\x00B'
 b'\x00\x00\x00\xb8{\xcb')

{'A1': 47,
 'A2': {'B1': [{'C1': -0.15270063281059265, 'C2': 1899518763, 'C3': 61200914},
               {'C1': 0.11350362747907639, 'C2': 553930387, 'C3': 3912730149},
               {'C1': 0.4703005254268646, 'C2': 733238676, 'C3': 3417956365},
               {'C1': -0.8251994848251343,
                'C2': -1750387438,
                'C3': 1765282506}],
        'B2': {'D1': 5454676272114045654,
               'D2': 0.4881449785058203,
               'D3': -80,
               'D4': 75,
               'D5': {'E1': 20,
                      'E2': 6402474830268360943,
                      'E3': [-0.8262560963630676, 0.7889997363090515],
                      'E4': 122,
                      'E5': -86,
                      'E6': 31653,
                      'E7': 34980},
               'D6': [-6775134312867828222,
                      -5118912711653605843,
                      -3791686424612558922,
                      3911875727719920886,
                      -3790625778057756562],
               'D7': [0.803209125995636, 0.8737387657165527],
               'D8': -72}},
 'A3': [123, 203],
 'A4': 1809076545}

Вариант №21

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

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

(b'CQT\xe1\x90\x9a\x1b\xf8\xa3u;/\x00\x00\x00\x03\x00*\x00\x03\x00-\xd7p'
 b'\xa2\xe5e{\xdb\xbbQ@W\x95d\\\xcev\xd9>\x00dskg\xcc?\xe6O\xf5\xc6\x95'
 b'\xfe\xd0?\xcd\x0eJ\xc8]uX\xa2?\xe0\x92Gz\x9b\xb5\xaa\xbf\xe1\xf8iT'
 b'\x91`\x86\xe0?\xeb\xd1\x9d\xdc\xb4\xea4\xbf\xed\xe0\xd8*j\xb7p\xdaP\xee\xdb'
 b'\x00\x00\x00\x02\x00\x00\x00`N\\\xdb\xf0\x0e\xb8\x1b_\xd5\xeb\xe6|'
 b'\xcb\xe5\x13\xf3\x0b\x9a')

{'A1': 10419671442583272239,
 'A2': {'B1': 'skg',
        'B2': [{'C1': -52, 'C2': [0.6972607496863592, 0.226998660883434]},
               {'C1': -94, 'C2': [0.5178563494388773, -0.5615736629215611]},
               {'C1': -32, 'C2': [0.8693379698445995, -0.9336968258337333]}],
        'B3': 55152,
        'B4': 11737899586452934976,
        'B5': 6311060802593282366},
 'A3': {'D1': [55888, 61147],
        'D2': [1314708464, 246946655, -705960324, -874179597],
        'D3': 2970}}

(b"CQT\xe1\x962(1[\xf4\x15\x92\x00\x00\x00\x04\x00*\x00\x02\x00.\x9d'E\x899f"
 b'\x96\xcf\xe7\xb3\xf8!\xebfe[QB\x00Tlhmn\xfa\xbf\xe4\xb0P\xce\trz\xbf'
 b'\xda \xbeOKD\xa8\x1c\xbf\xe5h)\xdb\x97;\xd0?\xc9\x16\xb2W2\x0bX\xd4\x1b\xe5T'
 b'\x00\x00\x00\x02\x00\x00\x00P\x99\xdd\xb8\xe3z\xf7\xed\x1a\xca\xb2\t\x02'
 b'\x19\x85R\x96\xb2\x06')

{'A1': 10822757046985954706,
 'A2': {'B1': 'lhmn',
        'B2': [{'C1': -6, 'C2': [-0.6465229057462942, -0.40824849837833677]},
               {'C1': 28, 'C2': [-0.6689652718431436, 0.1960051465758521]}],
        'B3': 40231,
        'B4': 5010599173206042547,
        'B5': -566913253052296894},
 'A3': {'D1': [54299, 58708],
        'D2': [-1713522461, 2063068442, -894301950, 428167830],
        'D3': 45574}}

Вариант №22

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

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

(b'AZMM\x007\x00A\x00K\x00U\x12K\x12\xebI\xe8\x12\x01\x00\x00\x00\x7f'
 b'\xa1\xaa\xf6\x9fa\r$\xc6]\xfff\xf2R\xd5\xdb\xf2z\x00\x00\x00\x05\x00\x00\x00'
 b'\x8c\xd7\x04T\x7fF\xbb\xb8\xb6JL;\x10>\xa5\xec\xb84&6\xe7!@\xbfrHk '
 b'/\xcd\x81\xf7O\xbe\xf03vY\xf5k\xbc1L\xbd\xf0Nu\x9eV4e\x9d\xadrH\xb9'
 b'\xf1=\x10\xfe\xc9y\xd2\x83\x1e\x00\x00\x00\x02\x00o?\xd4\x87\xd9s'
 b'\xaf\x0e\x88\x00_J\x00q.\x19\x99\x88"\x91\xe1\x1b\x9eY\x85\xbb\xe3*m\xbe'
 b'\xb9\xef')

{'A1': [{'B1': 47286, 'B2': 1246509840, 'B3': 0.32407164573669434},
        {'B1': 13350, 'B2': 921116992, 'B3': -0.946417510509491},
        {'B1': 8239, 'B2': 3447846735, 'B3': -0.4691426157951355},
        {'B1': 23029, 'B2': 1807495500, 'B3': -0.11733714491128922}],
 'A2': 1318168117702562305,
 'A3': {'C1': {'D1': 11409364317031461448, 'D2': -1175372528, 'D3': -20350510},
        'C2': 74,
        'C3': {'E1': {'F1': [-125, 30], 'F2': 0.3207915906643639}, 'E2': 11801},
        'C4': 2575835793,
        'C5': 57627},
 'A4': {'G1': 11649394550535693510,
        'G2': [93, -1, 102, -14, 82, -43, -37],
        'G3': 62074},
 'A5': [-24999, -31301, -7382, 28094, -17937],
 'A6': -10492,
 'A7': 1417627323}

(b'AZMM\x007\x00A\x00K\x00U\xe8D\xb4y\xa2\xe6\xac4\x00\x00\x00\x7f\xe9:\xa9\x82'
 b'VCw\xe1\xb8\xe0\x1c\xd2D\x8c\xaf\xc6\x04\x00\x00\x00\x05\x00\x00\x00'
 b'\x8c\xa1m\xe3\xc9\xf1\xbaB\xd1\xbe<\x08\xbe<\xf9Z\xb6\xe0\xc4H\xde\x8d\x9e<'
 b'\xa0\r\x1f\xd6\xa5\xc6\x89\x8bp=\xdb\xa5\x8d\xfb\xbbC\xdf(\xe7\xbbi\xbb\xda|'
 b'\xda\x84"\x95\x98Q\xfc\xc0\xf9A\xa9u\x01\x87z\x01\'\x00\x00\x00\x02\x00o?'
 b'\xe1\x83\xc1 ,]"\x00_\'\x00q\xbf_\xa8\xad\x1e\xcez`~>\xe9g\x19\xe9$@-\xd0')

{'A1': [{'B1': 17105, 'B2': 3191605438, 'B3': 0.03043876215815544},
        {'B1': 57540, 'B2': 1222544798, 'B3': 0.019537506625056267},
        {'B1': 54949, 'B2': 3330902896, 'B3': 0.10724935680627823},
        {'B1': 64443, 'B2': 1138698471, 'B3': -0.0035664946772158146}],
 'A2': 16736700549732674612,
 'A3': {'C1': {'D1': 8996648489699529212, 'D2': -1057406551, 'D3': 1963034490},
        'C2': 39,
        'C3': {'E1': {'F1': [1, 39], 'F2': 0.5473333004364671}, 'E2': -16545},
        'C4': 2829917902,
        'C5': 31328},
 'A4': {'G1': 16805931336744531937,
        'G2': [-72, -32, 28, -46, 68, -116, -81],
        'G3': 50692},
 'A5': [32318, -5785, 6633, 9280, 11728],
 'A6': -24211,
 'A7': -473304646}

Вариант №23

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

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

(b'DEPY\x9a\x00\x19\x00\x1f\x00%\x00+\x001\xe3F\xb5\x83\x00W\xd1p\x84\x88zjl'
 b'db\x1aisnlcfemeve\xbeuqgqq\xa8nvact ^9I\x87\xde?\x87\xf9\x00\x02\x00\x00\x00'
 b'7S\xe0\xcb\xeez\x0b\x1c\xcd-.\xd9f\xf7\x0e\x0f\xd6\x8d\xa3\x10\xf7\xe2v\x00'
 b'?9\xad\xbf3\x16\x90\x00\x00\x00\x02\x00\x00\x00O')

{'A1': [{'B1': 'zjldb', 'B2': 26},
        {'B1': 'isnlc', 'B2': 102},
        {'B1': 'emeve', 'B2': 190},
        {'B1': 'uqgqq', 'B2': 168},
        {'B1': 'nvact', 'B2': 32}],
 'A2': -481905277,
 'A3': {'C1': 284680822,
        'C2': {'D1': [1580812679, 3728705529],
               'D2': 21472,
               'D3': 14694816822302944558},
        'C3': 14765,
        'C4': -0.6995630264282227,
        'C5': [3647403790, 265719203]},
 'A4': 3513812104}

(b'DEPY\x9a\x00\x19\x00\x1f\x00%\x00+\x001EU}\xc1\x00_\x1d\xb75\x9bedgcu1rgpcr'
 b'\xecqbpse{xuhvs\xa4sltty\xab\x06"\x9c\'(\xf8\xd5"\xe9\x94-?\xfb'
 b'\xfe\xaf\xe5\x00\x04\x00\x00\x007%\xab\xc2\xf3\xees\xd2^L\xa2\xd1'
 b'\xe2\xd0\xd8\xe3\x16\xe2\xdc\xcag\xbau\x00G\x02\x0f\xbfw\xd8\xb9\x00'
 b'\x00\x00\x02\x00\x00\x00W')

{'A1': [{'B1': 'edgcu', 'B2': 49},
        {'B1': 'rgpcr', 'B2': 236},
        {'B1': 'qbpse', 'B2': 123},
        {'B1': 'xuhvs', 'B2': 164},
        {'B1': 'sltty', 'B2': 171}],
 'A2': 1163230657,
 'A3': {'C1': 3395795573,
        'C2': {'D1': [102931495, 687396130, 3918802239, 4227772389],
               'D2': 9643,
               'D3': 14047833843916754082},
        'C3': 527,
        'C4': -0.9681506752967834,
        'C5': [3521302744, 3809927900]},
 'A4': 498546075}

Вариант №24

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

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

(b'ONBS\xc5\x001\x00A\x00Q48\xe5\x00\x02\x00a\x00\x00\x00\x02\x00i'
 b'\xaa\xb8\x05\x0fR\x1em\xcbu\x83\x1e\x96\x8e5\x04\xca S\xebT\x8f\x89\x0b\x9f'
 b'\xed\x10\xd3-"\xc1\xc0 \xa7\xbf\x9ct[R\x04\xb1@\xd6\x08\xfa\xcb\x16,(}?\xe98'
 b'\xae\xa7\xe8\x97\xfc\x8au\xf8\\\xac|\xbe9\xbf\xe5\xb8\xd43\xf2\xcf'
 b":\xa3\x8e\xeb\xd7\xbc\x1d\x0f\xa7\xaf'\x0ed\xed\x1d\xb4\xb0\xb4Hb\xbc\tZ\xee"
 b'kN\xde\x11\xa4\xfe?\xe85\xce4J\xfd\xe6\x8ai\xf4\xf1\xd8\xf7\xad{F\xd0'
 b'a\x9d\xde\x9e\xa4\xd5\x15q\xe8B\xe3Z\x9e\xbf\xb0.T\x15d<\xd0\xf4\xa2')

{'A1': [{'B1': 1212362351995527335, 'B2': -0.02778761566257626},
        {'B1': 15422852674087561341, 'B2': 0.7881692199196091},
        {'B1': 9977153626423737913, 'B2': -0.6788121237391131}],
 'A2': 52,
 'A3': 14565,
 'A4': [{'C1': 163, 'C2': -114, 'C3': -5161},
        {'C1': 188, 'C2': 29, 'C3': 4007}],
 'A5': [{'D1': 12621072307366769840,
         'D2': 180,
         'D3': 1214430217,
         'D4': 6552292494347969790,
         'D5': 0.7565680524202747,
         'D6': 35433},
        {'D1': 17650126972920743632,
         'D2': 97,
         'D3': -1646354780,
         'D4': 15354303746958121630,
         'D5': -0.06320691606764517,
         'D6': 62626}],
 'A6': [-6145156128186667573, 8467645356366431434, 2329464180698581919],
 'A7': -19}

(b'ONBS\xc5\x001\x00A\x00Q\xf0_j\x00\x03\x00a\x00\x00\x00\x02\x00m\xaa\x87\xfcv'
 b')\xc7/\x16Z\x1aG\x17\xdd\x11\x92=6\xfbn}\x02\x055Gv\t&\xce1\x17\xd6\xf0'
 b';\xbf\xe3\x19U\x8a\x15\x8c\xbc\xc0\xc6\xab\x98\t\xcbB\x82?\xa9Wo\xd3q]'
 b'\xc0\x94tr\xc4\xaf[\x8b\x0b\xbf\xd4r\x9a\xce\xebu\x04z\x82\xb8>\x15\xa9\xc0'
 b"\x1b\xd0\xdar\x11\xa2C\xf1F[g\xa6\x82\x86\xae\xbd\xca}}Hh'\x95:\xc2\x8d?\xe8"
 b'\xb8\x856\x8a\x99R\xdd\x92\xf6\xca\x15\xd3\xbbL\x03\x8e\xefX\x9ai'
 b'\xf0\x00/\xea~(\x16\x90\x1b?\xd0A\xe5\xa1\x96[\xa4y\xf4')

{'A1': [{'B1': 659441105705037883, 'B2': -0.5968425461727729},
        {'B1': 13890978770158568066, 'B2': 0.049495214997189674},
        {'B1': 10697301203992939275, 'B2': -0.3194949169827199}],
 'A2': 240,
 'A3': 24426,
 'A4': [{'C1': 122, 'C2': -126, 'C3': -18370},
        {'C1': 21, 'C2': -87, 'C3': -16357},
        {'C1': 208, 'C2': -38, 'C3': 29201}],
 'A5': [{'D1': 11692454342067463810,
         'D2': 134,
         'D3': -1363293571,
         'D4': 9027579972280828557,
         'D5': 0.7725244584333189,
         'D6': 56722},
        {'D1': 17783050077750428558,
         'D2': 239,
         'D3': 1486514672,
         'D4': 13487151464747035,
         'D5': 0.2540220335007979,
         'D6': 31220}],
 'A6': [-6158676380968603882, 6492579980626727485, 3961881780386346311],
 'A7': 118}

Вариант №25

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

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

(b'\xcePPH\x02\x00\x00\x00}\x00\x00\x00\x0b\x8b\x11\xb0G\xfd\xe4\xfa'
 b'H\xa8\x85\xf3\x1a\xd2k?\xd8o\x02\x00\x00\x00\x81\x00\x00\x00\xed\xd7JFR9'
 b'\xba\x15\x04\x00\x00\x00\x83\x00\x00\x00\xa531\x96\x93\xcfa\xa0Z\x80'
 b'\xc2 \x96lU\xd6?\x03\x05\xb65k\xe1\x1f\xab\t[7\x10\xfa_\x05dv\x9d\xe4G\x00'
 b"\x00\x00\xe9\x05\x08W\xf5\x16\xd691'\xad\xcd)\xf7\xc2\xf9nUujq4\xfcb\x00\x00"
 b'\x00$\x9b\xd0ZV\x00q\x00-\x9c\xa18\xdc\xbd\xa2\xd2M\xbf=\x0c\xac;J'
 b'\r\xa0\xbe')

{'A1': [{'B1': 'dv',
         'B2': -7011,
         'B3': {'C1': 901121283,
                'C2': 107,
                'C3': 225,
                'C4': [-21729, 23305, 4151, 24570],
                'C5': 5},
         'B4': 1460143593},
        {'B1': 'jq',
         'B2': -972,
         'B3': {'C1': 970331893,
                'C2': 49,
                'C3': 39,
                'C4': [-12883, -2263, -1598, 21870],
                'C5': 117},
         'B4': 1523620644}],
 'A2': 2953939723,
 'A3': 4209311047,
 'A4': {'D1': -22456,
        'D2': 8059261265498534789,
        'D3': [45, 156],
        'D4': 1565626845994080237,
        'D5': [-0.1075298860669136,
               -0.8039952516555786,
               0.005250482354313135,
               -0.31260138750076294],
        'D6': -6889997722113199195,
        'D7': 90,
        'D8': 0.3489638773053585}}

(b'\xcePPH\x03\x00\x00\x00\x98\x00\x00\x00VC<3\x96\xf8\xe2^MJ`\xec\x9b3\x90S'
 b'#\xc6\x02\x00\x00\x00\x9e\x00\x00\x00\x97\xc75\xe5\x93{\xd2_\x06\x00'
 b'\x00\x00\xa0\x00\x00\x00\\\xc9\xbc6\x8f\xcf3\xe8^0\xc1\r\x04\xd5s\xbc\xbf('
 b'\x84\x95\x03\xd1\x9aROA\x1e,\xb3\x0f\xc0\xcfcv\x93\xc4G\x00\x00\x00\xa42'
 b'\xb7\xa2\xc6M\xf2\x17\xe6\xb9{\x1b\t\xd4n;z\x08,hu\xca9b\x00\x00'
 b'\x00c\x96\x04u\x8d\x03\x12W\x1d\xb9\xd7\xdc<_\xee\xecT~avb\x10\xf6'
 b'}\x00\x00\x00\x04\x88\xca\xdeV\x00q\x00\x8c\x001\xbd_\xa4Y\xbf:\x01\xe4>'
 b'\xbet`?\x19\xb3\x19?\xd6*\n?\x8a\x08\xed>')

{'A1': [{'B1': 'cv',
         'B2': -15213,
         'B3': {'C1': 60130344,
                'C2': -47,
                'C3': 154,
                'C4': [20306, 7745, -19668, -16369],
                'C5': -49},
         'B4': -1565052252},
        {'B1': 'hu',
         'B2': 14794,
         'B3': {'C1': 401755590,
                'C2': -26,
                'C3': 185,
                'C4': [7035, -11255, 15214, 2170],
                'C5': 44},
         'B4': 1963234915},
        {'B1': 'vb',
         'B2': -2544,
         'B3': {'C1': 1460798349,
                'C2': 29,
                'C3': 185,
                'C4': [-9001, 24380, -4882, 32340],
                'C5': 97},
         'B4': -557152252}],
 'A2': 859587414,
 'A3': 1591933078,
 'A4': {'D1': 19021,
        'D2': 14277347122500856928,
        'D3': [49, 189],
        'D4': 6904717053848307607,
        'D5': [-0.8501643538475037,
               0.44532185792922974,
               0.8767813444137573,
               0.6003890633583069,
               0.5397161245346069,
               0.4629557728767395],
        'D6': -1714798819092412068,
        'D7': 94,
        'D8': -0.111142457475357}}

Вариант №26

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

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

(b'TLHO\x1e\x00\x00\x00\x02\x00\x00\x00&\x00\x04\x00`\x00\x00\x00\x02\x00d\x87'
 b'\xbe^?!\xb4\xc2\r\xfc\xf8>\xcf\x14=\xa9\x9c\xb85u9\xbes\xae\x02P'
 b"\x1d\x00\x03\x00\x00\x00\x17\x9e\xc3'\x0e\x00\x00\x00\x1ai\x1fM\x02\xc7"
 b'\x80\xa3\xeaA\xe7Z\x83\xd5\x87\x1e\x00\x02\x00\x00\x00\x1f6GZ\t\x00\x00\x00!'
 b'\xff\xac\xde\x8dqeep\xc4\x02\x14\x82\x0f\xe1\xaa\xa3')

{'A1': [{'B1': {'C1': -25416,
                'C2': 3852048546432680528,
                'C3': 29,
                'C4': [135, 190, 94],
                'C5': -1631377650,
                'C6': {'D1': 0.6316643953323364, 'D2': 13}},
         'B2': 1763659010},
        {'B1': {'C1': -14464,
                'C2': 11811325434644387207,
                'C3': 30,
                'C4': [252, 248],
                'C5': 910645769,
                'C6': {'D1': 0.40445128083229065, 'D2': 169}},
         'B2': 4289519245}],
 'A2': 'qeep',
 'A3': [3288470658, 266447523]}

(b'TLHO\x1e\x00\x00\x00\x02\x00\x00\x00&\x00\x02\x00`\x00\x00\x00\x03\x00b!'
 b'\x93\xbe\xa2:\x83mR\x08L>\xe2|\xe7-M\xfbZ\xf7\xb7\x96j\xa4"\xbd~\x00\x02\x00'
 b'\x00\x00\x17\x1b\xec\xb5(\x00\x00\x00\x19\xc0\x9fG.\x0e\x10\xa741\x154\xa6J'
 b'.\xb0\x00\x03\x00\x00\x00\x1e5v\xaa\xf1\x00\x00\x00!\xb2z\xa7\xc9hd\x88b'
 b'\x04\x14\xd7\xfe=\xbd\xc0\x9a~\xb9')

{'A1': [{'B1': {'C1': 19963,
                'C2': 6554909639323165373,
                'C3': 126,
                'C4': [33, 147],
                'C5': 468497704,
                'C6': {'D1': -0.3168526589870453, 'D2': 109}},
         'B2': 3231663918},
        {'B1': {'C1': 3600,
                'C2': 12048308870270306862,
                'C3': -80,
                'C4': [82, 8, 76],
                'C5': 896969457,
                'C6': {'D1': 0.44235917925834656, 'D2': 45}},
         'B2': 2994382793}],
 'A2': 'hd',
 'A3': [2288124948, 3623763389, 3231350457]}

Вариант №27

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

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

(b'\x80XQGS\x89\x1d\\C\x00\x00\x00L\x00\x00\x00\x07\xfc\xbf2)\xbf\r\xd1'
 b'?]\x00\x83\xa38\x01#\x89\x8eX\xd9\xbfck/c\x02\x00\x00\x00\x9e\x00\x86'
 b'\xbf\xfb\xa56\xa5\xd9\xe5c\xf5Ud{:\xd9\x05G\xf4\xa2\x19s\xce\xfa\xc0\xb1'
 b'\xe5F\x83\xcb\x18\x06\x1f\xd6\x1f\xb6\x1b?\x87\xdc\xbdG\xb7\xaca\xb7'
 b'\x93\xc6\xe6\x80\xe9\xb6\xd2\xb8\xe0\xe4\xe9m\x81h\x12\xf6\xe7\xdasG'
 b'\xe7}\x10f\xbcYr\xd9\x1c4\xe5\x16\xd5\x84Y\xc1\x04\xff\xe5e\xd3\x04(x'
 b'\x02\x84V\xa2\x9e\x86\n\xf1\x10\xd1t\xac\x08 \x02\x00\x00\x00U\x00'
 b'\x00\x00)\x93')

{'A1': {'B1': {'C1': 1545439571,
               'C2': [{'D1': -8987243454761611661, 'D2': 203},
                      {'D1': 4547428496613246488, 'D2': 135}],
               'C3': 7,
               'C4': 0.26646403334871116,
               'C5': {'E1': -58,
                      'E2': [-1954359023127396122,
                             -2672897294897943063,
                             6466155386015008627,
                             -8875162316986066574,
                             347733634738078041,
                             -8746374933841283032],
                      'E3': 3507548426,
                      'E4': 44148,
                      'E5': 8200,
                      'E6': [3074932188, 2478268844]},
               'C6': 41859},
        'B2': -0.3960300769067717},
 'A2': 1664052067,
 'A3': [41, 147],
 'A4': 16562450758763265926,
 'A5': 421432341774595427,
 'A6': 430109767}

(b'\x80XQG\xffB\x0e~C\x00\x00\x00L\x00\x00\x00>\xc4\xad\xcf\xe2q\xb8\xd0?]\x00E'
 b'\xc86\xac\x91\xca"\xa5\xe9?\xbd\x87\x04`\x02\x00\x00\x00\x9e\x00\x18'
 b'\xcf\x00\x98\xf3\xd2l\xe0s\xf6uP\xcc\x1bOQ0\xdc\xeb!C}\x90\x13\xb5'
 b'\x85\x15\xc9,"\x93\x9e\xd2*B\xde\x8e\xffh9B\xbao\x18\xf5Y\x00\x9b\xfb'
 b'D\x81,\x14B\x9b\xd2\x8eh\x90\xf8\xb7\xc9<\x05\xb6+.\xedl)\xca\x11\xd4'
 b'\xfb\x08U\x19\x18\x9cP\x84\xc4\x9c\xcflw\xa3\x89\xa5\x00>\x90\xf1'
 b'B\xdf\xb5\xf3\xb4\x13\xbc\xe4\xd6\xf9\x02\x00\x00\x00U\x00\x00\x00s\xea')

{'A1': {'B1': {'C1': 2114863871,
               'C2': [{'D1': -3957109684811301565, 'D2': 44},
                      {'D1': -8152005523804351710, 'D2': 255}],
               'C3': 62,
               'C4': 0.2612576212838713,
               'C5': {'E1': 0,
                      'E2': [-7259217467987919973,
                             4380234390797061842,
                             -3879449838065306107,
                             -7198976151338101743,
                             -6667741084354575280,
                             -2359057652970904183],
                      'E3': 330625973,
                      'E4': 58556,
                      'E5': -1578,
                      'E6': [3124902248, 1509234799]},
               'C6': 51269},
        'B2': 0.8014081913401074},
 'A2': 1610909629,
 'A3': [115, 234],
 'A4': 16171532305649684248,
 'A5': 5858932204569491059,
 'A6': 569105456}

Вариант №28

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

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

(b"IAH\xc3\xe6\x08?\xee/\xa06\xaf\x0e\xda\x00\x00\x00\x1f'\x16\x1b\x00\x00\x00"
 b'\x94\xa7{pxsc\xb5?Ar\xec\x00\x00\x00\x04\x00\x00\x00\x1b\xab<\x01\xa9-0!\\'
 b'\xbf\xe8}\xe8\xfa\xf2\x85`\x00\x04\x00,?\xcaz\xa8\xe2\x8eC\xf8\xbf\xe6G\xca'
 b'U\x1f\xf3(!\xf2\xc0\xea\xd4\xef;\xc2k\xbf\xf4\xedPf\xc7\xfe\x99\xbe\x8b,'
 b'\xc4\xe1\x1bxv\xe6\xbf\xc5\x9e\x8e\xfe"-\x80\x00\x06\x00^\xbf\xc5'
 b'\xd8\x98\xc28\xb8\xa0?\xef\xa8X\xe3\xc3-\xda\x06[\x1f{\xd1_\xf3\xeck\xa7'
 b'\x01 \xce\xd9\xe5\x90\x81l\x95\x94;f\xb9\x8eo\xbf\xda\x01\x1c\xfa9xH)'
 b'\xd9\x99\x07J\x80\x8bW0{\x004\x00j')

{'A1': 58888,
 'A2': 0.9433137004893652,
 'A3': {'B1': 181, 'B2': 0.755659818649292, 'B3': 'pxsc'},
 'A4': 10006,
 'A5': 27,
 'A6': {'C1': {'D1': -27, 'D2': -1870566251, 'D3': -27589},
        'C2': 1723436655,
        'C3': -0.4063179439161826,
        'C4': 10713,
        'C5': -7419879945115586437,
        'C6': [{'E1': -0.7653698827090629,
                'E2': [-21700, 425, 11568, 8540],
                'E3': 0.2068682771901249,
                'E4': -0.6962634718507603,
                'E5': 8690,
                'E6': -64,
                'E7': [60116, 61243, 49771, 49140, 60752],
                'E8': 102},
               {'E1': -0.16890132340300212,
                'E2': [-14338, -26178, -29908, -15135, 7032, 30438],
                'E3': -0.1706725071284767,
                'E4': 0.9893001984104857,
                'E5': 1627,
                'E6': 31,
                'E7': [31697, 24563, 60523, 42753, 8398],
                'E8': -39}]},
 'A7': -22661}

(b'IAH\xc3<\x88?\xe6\x01%m}E\xac\x00\x00\x00\x1d\xed\xac\xe0\x00\x00\x00'
 b'\x8a\xa8Qnv{?m\xcc\x1d\x00\x00\x00\x02\x00\x00\x00\x1b\x9ed0\xf1\xc6/'
 b'\x00g?\xb33%Qv3p\x00\x04\x00*\xbf\xec=\x07\x16\xf5\xf4\xbc?\xcd'
 b'\xd9\x96\xb2\xec\x08P\xc7~\xdc@w{Vn\x7fY*\xec\x89,_t\xf3_?\xe5.\xa8'
 b'm8\xcd\x82\x00\x02\x00\\?\xe8X\x9b\x07\xae\xd2f\xbf\xec\xe0j\xca\xb6iX'
 b'\xc5\x8f\xa8\x12\x05\xe3cT$k0\x00R%ES\x9b\xeb\x14\xf3\xab\xe0O\xe0P\xbf\xdbm'
 b';\x07\xd1\xe7`\xc9<\x93\xd0_\xefG\xb1\xc2\x8b\x002\x00`')

{'A1': 15496,
 'A2': 0.6876399172271497,
 'A3': {'B1': 123, 'B2': 0.9288957715034485, 'B3': 'nv'},
 'A4': 60844,
 'A5': 224,
 'A6': {'C1': {'D1': 69, 'D2': 1402727188, 'D3': -3157},
        'C2': -531636144,
        'C3': -0.4285419060103006,
        'C4': 51516,
        'C5': -7795625473673674101,
        'C6': [{'E1': 0.07499917258082944,
                'E2': [-24988, 12529, -14801, 103],
                'E3': -0.8824496696903661,
                'E4': 0.23320277916360732,
                'E5': -14466,
                'E6': -36,
                'E7': [16503, 31574, 28287, 22826, 60553],
                'E8': 44},
               {'E1': 0.6619455464591939,
                'E2': [24436, -3233],
                'E3': 0.760816111570034,
                'E4': -0.902394672320308,
                'E5': -14961,
                'E6': -88,
                'E7': [4613, 58211, 21540, 27440, 82],
                'E8': 37}]},
 'A7': -22447}

Вариант №29

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

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

(b'TGTFP\xffF"w\x99\xc2\x9a\x1b\x00)\x007\x00F\x00U\x00\xb8\x00ubm^'
 b"\x0c\x03\x00\x00\x00\x18\x00\x00\x00\xb5%vn=#\x02\x00\x00\x00'"
 b"\x00\x00\x00\xeb\x1cse!\xb9\x02\x00\x00\x005\x00\x00\x00u\xd5sjo'\x9e"
 b'\x03\x00\x00\x00C\x00\x00\x00\x15ikva\xd8x\x03\x00\x00\x00R\x00\x00\x00\xea'
 b'\n\x80\xc1\x1f\x1d\xcc}pp\xfd@abr;\x11\xe9?XW\xdc\x93\xee\x05\xdd\xbfrU'
 b'\xe0\xdc\xa3\x08\xef?\x90\xb4\x9a\x13U~\xe0\xbf\xf4\x1a\x0c\xe4\x88\x1a'
 b'\xea?,NV\x96\x81\xe4\xdc?\xce\xbc\xc4\xe6L\xfc!\xbd\xde\r\x16\xbf\xeb\xae'
 b'\xe0\xbe%\x97J\xbdj\xb0n\xbf\x92\x84K\xaa\x1e\xb2\x9c*\xaa\xbd\xc0O4\x01'
 b'\x036\xc4l\xbf\x91\xaea\x00\x00\x00\xc1\x0f$\xc7CCI')

{'A1': -7295099709431546032,
 'A2': [{'B1': 3166, 'B2': 'ubm', 'B3': 9653},
        {'B1': 9021, 'B2': 'vn', 'B3': 7403},
        {'B1': -18143, 'B2': 'se', 'B3': 54645},
        {'B1': -25049, 'B2': 'sjo', 'B3': 26901},
        {'B1': 30936, 'B2': 'kva', 'B3': 2794}],
 'A3': {'C1': -0.08308908343315125,
        'C2': -64,
        'C3': 50410575,
        'C4': -0.9248689413070679,
        'C5': -20847,
        'C6': {'D1': 8102114045254943104,
               'D2': -3,
               'D3': [0.7833535417621889,
                      -0.4534870571090912,
                      0.969804698370963,
                      -0.5154214270493345,
                      0.8157391027496872,
                      0.45144691163406736],
               'D4': -423314226,
               'D5': [-0.03954724967479706,
                      -0.5861490964889526,
                      -0.4388345181941986,
                      -0.04946054890751839,
                      -0.9323793649673462],
               'D6': -31598,
               'D7': 2988354123},
        'C7': 193,
        'C8': [15, 36, -57, 67, 67, 73]}}

(b'TGTFc\xdc\xc0\\\x86\x13v\xd9\x1a\x00)\x008\x00F\x00T\x00\xb7\x00zl9p'
 b'\x02\x00\x00\x00\x18\x00\x00\x00?Jvyl\xfe\xba\x03\x00\x00\x00&\x00\x00\x000'
 b'\xd8rpd\x00 \x03\x00\x00\x005\x00\x00\x00\xeagsxP\t\x02\x00\x00\x00'
 b'D\x00\x00\x00S\xdepi\x93\xc4\x02\x00\x00\x00R\x00\x00\x007T \x04a\x92'
 b'd\xad0\xb2\x0f\x00\xee\x00w\xc2\xc9\xe6\xbf \x18\xa2w&\xaa\xc7\xbfxj\xe2'
 b'\xec\x94N\xcc?\xec\xe0\xdf\x94m\xc3\xdb?&\x06\x8e3\x81\x02\xe9?\xfe\xa7C'
 b'~\xe7\xc6\xe4?\x16\x8f\x94i]\xd8\x8c\xbe\x99\xad\xce=<B;\xbf`\x97!'
 b'\xbfF\xf2\xe5=r\x06\xea\x8f(4\xd1V\x99>G\xac\x9b\xd8\xca\x1c\x1ck\xbf'
 b"\x1c0`\x00\x00\x00\x1f\xeb\xbcZw'\x19")

{'A1': -2777010652424643485,
 'A2': [{'B1': 28729, 'B2': 'zl', 'B3': 19007},
        {'B1': -17666, 'B2': 'vyl', 'B3': 55344},
        {'B1': 8192, 'B2': 'rpd', 'B3': 26602},
        {'B1': 2384, 'B2': 'sx', 'B3': 56915},
        {'B1': -15213, 'B2': 'pi', 'B3': 21559}],
 'A3': {'C1': 0.29949048161506653,
        'C2': 71,
        'C3': 3403193260,
        'C4': -0.9183976650238037,
        'C5': 12316,
        'C6': {'D1': -5606790888612101088,
               'D2': 15,
               'D3': [-0.7121288608827285,
                      -0.18488007394279382,
                      0.22114812437651543,
                      0.4338029817440787,
                      0.7815557486466715,
                      0.6492803064440975],
               'D4': 1771343638,
               'D5': [-0.27508822083473206,
                      0.10091704875230789,
                      -0.7314794063568115,
                      -0.6312160491943359,
                      0.11227850615978241],
               'D6': 1650,
               'D7': 875073514},
        'C7': 31,
        'C8': [-21, -68, 90, 119, 39, 25]}}

Вариант №30

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

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

(b'DZAC\x84c6l\x16\xca9\x11\x00\x00\x00\x02\x00\xa0\xaa\xaa?\x9c\x81h'
 b'\x87\xf2\x85\x00?z\xbf\xa8\xbf\xec\x918mE\x10\xba\xbe\xb3\x0e\xd4>\xe52\x8f'
 b"\x9df\x08\xfb\x00\x00\x00\x02\x00\xa2\xab\xb0\xbf\xc4'\xe5\x84\x96\xebP"
 b'>\xe3\x964?\xc1\x91\xc6Y\xd3f\x00\xbf+N\xc6\x80;\x92\x98\x91U\x17\x04'
 b'\x00\x00\x00\x02\x00\xa4\xf9,?\xdb\x0c\xd9E\xd7\x06\x94\xbfI\x95\x1c'
 b'?\xbb\xbfsp\xa5\xd9\x90>\x18i\x8a\x00\x02\x00\x00\x00\xa6b\xf4'
 b'\x00\x00\x00\x06\x00\x00\x00\xa8\xee_\x0c\xd5n\xde?\xed\xa4n\xaa:'
 b'\xce\xee\x95\xfb\xb4\xfd\xcbilekzlrdi\x1d\xf5{H\xfe\xd0')

{'A1': [{'B1': -8907215800141989615,
         'B2': 'le',
         'B3': -21846,
         'B4': {'C1': 0.027837403581206566,
                'C2': 0.9794869422912598,
                'C3': -0.8927271017241971,
                'C4': -0.3497225046157837}},
        {'B1': 4532084192420694267,
         'B2': 'kz',
         'B3': -21584,
         'B4': {'C1': -0.15746754621599246,
                'C2': 0.44450533390045166,
                'C3': 0.13726119409584214,
                'C4': -0.6691707372665405}},
        {'B1': -9206603829257890044,
         'B2': 'lr',
         'B3': -1748,
         'B4': {'C1': 0.4226592237501816,
                'C2': -0.7874314785003662,
                'C3': 0.10839005947295832,
                'C4': 0.14884009957313538}}],
 'A2': 'di',
 'A3': 25332,
 'A4': [29, -11, 123, 72, -2, -48],
 'A5': {'D1': -4513,
        'D2': 3285,
        'D3': 28382,
        'D4': 0.9263223004149646,
        'D5': -107,
        'D6': 4222942667,
        'D7': 105}}

(b'DZAC\xcc\xa3\x00\xe8RE\xa1\xe6\x00\x00\x00\x03\x00\xa0\xa5\xb8\xbf\xd8z/'
 b'\xc6\x16K\x98\xbe\xcc\xd6!\xbf\xc0a\x10\r\x88\x00x\xbfvs\xe1R+"\xb2'
 b'\xd8q\x08\r\x00\x00\x00\x02\x00\xa3=\xec?\xd0#dj\xd9\x9bt=\xe1K\x07'
 b'?\xd0\xbf{\xd1;\xbe$\xbe\x9bR\x13N\x8e\xabIn\xe0\xf1\x1b\x00\x00\x00\x03'
 b'\x00\xa5tt\xbf\xd8\x19X\x8f\xb4\x11h?V\x1cy\xbf\xc4\xe9\r\xed\xe2D\xd0'
 b'>\xc4\xbd\xf0\x00\x03\x00\x00\x00\xa8\xc74\x00\x00\x00\x08\x00\x00\x00\xab'
 b'\x05\x8d>,\xf3\x9e\xbf\xee\x83\xdc\xc5\x0c\xec\xda\xcf\xe1\x1e$78dtyfuuyl'
 b'lfo\x03kE\x19\x11\xeaV\x8f')

{'A1': [{'B1': -3701113470955707930,
         'B2': 'dty',
         'B3': -23112,
         'B4': {'C1': -0.38245767921869733,
                'C2': -0.4000711739063263,
                'C3': -0.12796211872774044,
                'C4': -0.962705671787262}},
        {'B1': 5920864286639458317,
         'B2': 'fu',
         'B3': 15852,
         'B4': {'C1': 0.2521601718385036,
                'C2': 0.11000638455152512,
                'C3': 0.2616872351927404,
                'C4': -0.30336055159568787}},
        {'B1': 5660650113532490011,
         'B2': 'uyl',
         'B3': 29812,
         'B4': {'C1': -0.37654699357542265,
                'C2': 0.8363719582557678,
                'C3': -0.1633622561971948,
                'C4': 0.3842616081237793}}],
 'A2': 'lfo',
 'A3': 50996,
 'A4': [3, 107, 69, 25, 17, -22, 86, -113],
 'A5': {'D1': 1421,
        'D2': 15916,
        'D3': 62366,
        'D4': -0.9535964821474423,
        'D5': -49,
        'D6': 3776848951,
        'D7': 56}}

Вариант №31

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

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

(b'GSCM\xbc\x04\x00\x00\x00:\x00\x00\x00Z\x00\x00\x00\xd6<H\xd1\xf0\xd1\x12'
 b'\xcb\x0b\x03\xbf\xbfx\x00\x00\x00b\xc8\x14\xff\xc3\xe5\xeb\xbf1\xe3\xe6'
 b'\x01\xee-\xb2\xc9\x9bQ\xed\xbf`\x19\x92N*uuzi`x`\xc9oyed\xc1/\xd2\x87iknoWK'
 b'\xf9\xf4pfxc\xf9\xd0\xa3\xd7\x08\x0c\xcd\xa0V5KxkgdK\x18X\x04\x99\xe5\xed'
 b'\x12+W\xaa\xbe\x90\xc0-\xd1\xd45\xd4\xff\x13\x08)c\xf8\xca\xb9'
 b'\xa9\xab\xa1\xda\xcei\x12d\xee\x11\xbd\xbd\x02\x00h\x00\xd3\xf0\xb3J'
 b'\x11\x0b\xfa')

{'A1': [{'B1': 'uuzi', 'B2': -916424608},
        {'B1': 'oyed', 'B2': -2016268351},
        {'B1': 'ikno', 'B2': -184988841},
        {'B1': 'pfxc', 'B2': -677129991}],
 'A2': {'C1': {'D1': 2697792520, 'D2': 5432580761793017174, 'D3': 22552},
        'C2': 15574,
        'C3': -11960,
        'C4': -0.12114022930001744,
        'C5': {'E1': [255, 19, 8, 41, 99, 248, 202, 185],
               'E2': 43945,
               'E3': 1775164065,
               'E4': 25618,
               'E5': -0.09231935441493988,
               'E6': [12274326669722228996, 15291362104687235262],
               'E7': [-45, -16, -77, 74, 17, 11],
               'E8': -6},
        'C6': -0.871797559934077,
        'C7': 31908657,
        'C8': -0.9162119807601223},
 'A3': 96,
 'A4': 709792281}

(b'GSCM\xbc\x04\x00\x00\x00:\x00\x00\x00Z\x00\x00\x00!_\xaf#\x88\x11<\x1f`V\xd5'
 b'\xbfx\x00\x00\x00<Vo\nx}\xd4?(\x9d(\xb8PD\x8c\xab\xe0\x98\xb9?*\xe2a\x0fjwv'
 b'dq^[\xca\xf7roip\xe8\x91\xa3\xfbidle\x0bcH\x8asvad\xc2\xd6-/G\xf7'
 b'\xf9\xcc#\xdf(3um\x89~\x0f"\x06T\x07\xbdD\x941\x9d\xba\xa4e"8\xbc5u'
 b'\xb7%\xc2\xad/\xfaK8\x87z\xf5\xad\x06\x84\xd3\xf2\x1a\xa8\xca\xbe'
 b'\x02\x00h\x00\xe46\xb6W%T\xd0')

{'A1': [{'B1': 'wvdq', 'B2': -137733282},
        {'B1': 'roip', 'B2': -73166360},
        {'B1': 'idle', 'B2': -1974967541},
        {'B1': 'svad', 'B2': 791533250}],
 'A2': {'C1': {'D1': 3438933831, 'D2': 9117939270725197603, 'D3': 8719},
        'C2': 24353,
        'C3': 9135,
        'C4': -0.3333969407106214,
        'C5': {'E1': [183, 37, 194, 173, 47, 250, 75, 56],
               'E2': 31367,
               'E3': 2215030261,
               'E4': 62163,
               'E5': -0.3958137631416321,
               'E6': [11326997560763569158, 8445863625484510394],
               'E7': [-28, 54, -74, 87, 37, 84],
               'E8': -48},
        'C6': 0.32015801447900905,
        'C7': 3089669416,
        'C8': 0.0999889773195417},
 'A3': 42,
 'A4': 1779392994}

Вариант №32

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

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

(b'KCW\x9b]1Mj\xdc\x10\xaf\x7f\xc4=R\xe9\xaa\x87\xea\\\xff\xcc\xa4='
 b'\xec\xb8|\x05\x0f\xcb\x03\xc8\xa9ea\xaf\xad\xa0\xa9\x03\x00\x00\x00\x9d'
 b'\x00/\xfe\xa9\xa2\xd2>\x02\x00\xa0\x00\x00\x00\xa4\x008\x07\\2\x06'
 b'\xd4\x1c\xb1\x04B"L\x02\x00\x00\x00\xaa\x00e\xa6Bb\xdc>\x02\x00\xac\x00\x00'
 b'\x00\xb0\x00\xda\xban\xaf\xdc\x13\x8dY\xf2\xf9\xac\xbd\x04\x00\x00\x00\xb6'
 b'\x00a\x95\xecw~\xbf\x02\x00\xba\x00\x00\x00\xbe\x00\xcf\xca\xab..\x10=l\xb5'
 b'\xec\xa6\r\x02\x00\x00\x00\xc4\x00\xe2\xa6;{E\xbf\x02\x00\xc6\x00\x00'
 b'\x00\xca\x00\x00{\x85z\xfc\xc4\xc7CAM\xa1\x02\x00\xa2\x00\x18P+\xcf\x01\xca'
 b'/\x8a\x02\x00\xae\x00L\xd9J\x96\xebY\x87\xb8\x1f\x18\x02\x00\xbc\x00Ir\xdb]'
 b'\t6:\x12\x02\x00\xc8\x00')

{'A1': 93,
 'A2': 3697954097,
 'A3': 12315465081264516880,
 'A4': -10687865,
 'A5': 1082408419131761868,
 'A6': [{'B1': {'C1': 12515328978753946571,
                'C2': 43424,
                'C3': [-123, 122, -4],
                'C4': 65071},
         'B2': 0.411397248506546,
         'B3': [-60, -57],
         'B4': {'D1': 41293, 'D2': [67, 65]},
         'B5': 1848},
        {'B1': {'C1': 4757121843784462940,
                'C2': 19490,
                'C3': [24, 80],
                'C4': 42597},
         'B2': 0.4304371476173401,
         'B3': [43, -49],
         'B4': {'D1': 35375, 'D2': [1, 202]},
         'B5': 47834},
        {'B1': {'C1': 18010556322266525550,
                'C2': 48556,
                'C3': [76, -39, 74, -106],
                'C4': 38241},
         'B2': -0.9940173625946045,
         'B3': [-21, 89],
         'B4': {'D1': 6175, 'D2': [135, 184]},
         'B5': 51919},
        {'B1': {'C1': 17056658173255888555,
                'C2': 3494,
                'C3': [73, 114],
                'C4': 42722},
         'B2': -0.7714115977287292,
         'B3': [-37, 93],
         'B4': {'D1': 4666, 'D2': [9, 54]},
         'B5': 31488}]}

(b'KCW\x9b"\x1bi\xd6\xa4@\xf4\x8e\x92\x84\x9en\xa2\xd3\xf0u\x19\x02\x81\xad'
 b'I\xdc\x8f\xa4\x97!\xdbfr\xa3\xa6U\xe1\xf9t\x03\x00\x00\x00\x9d\x0036\xd5'
 b'\x9e\t\xbf\x02\x00\xa0\x00\x00\x00\xa4\x00H\tI\xe8T:\xael\xef4\xe8\x90\x04'
 b'\x00\x00\x00\xaa\x009\x9a5I\x13<\x02\x00\xae\x00\x00\x00\xb2\x00}\x1e@\x9fG'
 b'\xb3\xa5\x1eg\xfff\xca\x02\x00\x00\x00\xb8\x00\xd70\x17\x04\x83\xbe\x03'
 b'\x00\xba\x00\x00\x00\xbf\x00n7vj\xc6\xb0\xb9"\xab\xc0<\'\x04\x00\x00\x00\xc5'
 b'\x00?\xf3_I\xb8\xbc\x02\x00\xc9\x00\x00\x00\xcd\x00\x15\rR\x0f\rmLC\xa1'
 b'\xca\xd4\x02\x00\xa2\x00\x03\xf8S\xa0\xc4Z\x99\xa8\x0f\xf4\x02\x00\xb0\x00'
 b'\xe6f\xba52G\x94\x84\x84\x02\x00\xbd\x00\xace\x15\xcd\xac\xe8\xf6'
 b'\xb3\xa6\xd6\x02\x00\xcb\x00')

{'A1': 34,
 'A2': 2765515035,
 'A3': 11704466773814211648,
 'A4': 427159763,
 'A5': 10927016772199350530,
 'A6': [{'B1': {'C1': 16237067252483414817,
                'C2': 29945,
                'C3': [82, 15, 13],
                'C4': 13875},
         'B2': -0.5375798344612122,
         'B3': [109, 76],
         'B4': {'D1': 54474, 'D2': [67, 161]},
         'B5': 2376},
        {'B1': {'C1': 3814386904964851785,
                'C2': 37096,
                'C3': [3, -8, 83, -96],
                'C4': 39481},
         'B2': 0.008989621885120869,
         'B3': [-60, 90],
         'B4': {'D1': 62479, 'D2': [153, 168]},
         'B5': 7805},
        {'B1': {'C1': 18403712099299073856,
                'C2': 51814,
                'C3': [-26, 102],
                'C4': 12503},
         'B2': -0.2558905780315399,
         'B3': [-70, 53, 50],
         'B4': {'D1': 33924, 'D2': [71, 148]},
         'B5': 14190},
        {'B1': {'C1': 13883228457229773430,
                'C2': 10044,
                'C3': [-84, 101, 21, -51],
                'C4': 62271},
         'B2': -0.022495923563838005,
         'B3': [-84, -24],
         'B4': {'D1': 54950, 'D2': [246, 179]},
         'B5': 3349}]}

Вариант №33

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

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

(b'CMV\xa5x\xe6Cb20=\xfa\xaeN\xbeR\xbd\x00\x00\x00i\xf17Q\x10[\x82\xd1'
 b'\xf2\xf3\x11\xc04~\xbe\x81\xc5\xb8\x8e\xd6_l\xa2\xd5\x00\x02\x00*\x02]`j'
 b'I\x00\x03\x002\x03\x94\xc7X\xf0\x00\x03\x00;^\xe9L\xdb\x00\x02\x00D\xda\x17'
 b'\xf7\xc3\x17\x00\x03\x00L\x11\x1c\x00\x00\x00,\x00\x00\x005\x00\x00\x00'
 b'>\x00\x00\x00F\x00\x00\x00Oajhtmina{u:\xbc\x00\x00\x00\x05\x00UL2\xc2~&'
 b'\xa7\xad\x04x\xdf\x10\xf9b\xcb\xb2\x1f\xfc\xd0[\xd6\x86\x93\xde\xd0\x8f'
 b'e\xa4C\xac\xe7\x80\xdf\xc3-\x8aE\xc3')

{'A1': 30950,
 'A2': 17250,
 'A3': 50,
 'A4': 3476210113952240317,
 'A5': {'B1': 'ajhtmina',
        'B2': 2071280316,
        'B3': [{'C1': [-94, -43], 'C2': 605},
               {'C1': [96, 106, 73], 'C2': 916},
               {'C1': [-57, 88, -16], 'C2': 24297},
               {'C1': [76, -37], 'C2': 55831},
               {'C1': [-9, -61, 23], 'C2': 4380}],
        'B4': {'D1': 1278395006,
               'D2': [9895, -21244, 30943, 4345, 25291],
               'D3': 2988440784},
        'B5': 91,
        'B6': [54918, 37854, 53391, 26020, 17324],
        'B7': 16681579049155970499},
 'A6': {'E1': -3785,
        'E2': 5841269334125769489,
        'E3': -64,
        'E4': 13438,
        'E5': -0.2534615993499756},
 'A7': 2396413804}

(b'CMV\xa53\xa0\xb4sJ\xd1\xbf\x17\xc5\xe6\x1f\xeb\xac\x00\x00\x00C\x93&\x1f'
 b'\xaa\xda\xa0xB\x9a\xa5w{\x91<\x9c\rlP\xb0\xc0Xd\xbc\x00\x02\x00*0\x86L}'
 b'\xed\x00\x03\x002\n\x85\x00\x00\x00,\x00\x00\x005vuzdwvsy-y\xb1\x0f\x00'
 b'\x00\x00\x02\x00;\xa5\x08\r\xec\xa4?\xae\x83\x98\xee\xeaeF\xbc\x0e'
 b'k\xbd\xa5\xbal~_\x81[\xd1\x88\x9f1\xb5H\x07G\xc64\x02\x1d\x15')

{'A1': 13216,
 'A2': 46195,
 'A3': 74,
 'A4': 15113825013215521708,
 'A5': {'B1': 'vuzdwvsy',
        'B2': 762949903,
        'B3': [{'C1': [100, -68], 'C2': 12422},
               {'C1': [76, 125, -19], 'C2': 2693}],
        'B4': {'D1': -1526198804,
               'D2': [-23489, -20861, -26386, -5531, 18108],
               'D3': 241941925},
        'B5': -70,
        'B6': [27774, 24449, 23505, 34975, 12725],
        'B7': 5190196012169436437},
 'A6': {'E1': -27866,
        'E2': 2281876543963830949,
        'E3': 119,
        'E4': 31633,
        'E5': 0.019049368798732758},
 'A7': 1353760856}

Вариант №34

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

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

(b'MAIA\x00\x00\x00\x167\x8a=O\x10>\xe9\xd6\xe6b\x07\x11\x00\x9c\xe4\xa9'
 b'ia\x18\xc9G\x8d_o%#\xea\x1c\x10\xc2}5/`\x16xz!\xde\x80\x81\xde\xc2/v\x98]g'
 b'!@".>p\xec<\x8aW\xdc\xbd\xb0\x88\x02?D|\xa5n\x00\x00\x00\x03\x00\x00\x00\x1e'
 b'zu\xf6+\xfe~Z2{\x05\xf6\x03o\xd3Z\x1a\xff\x89(\x01\x01\x967(\xbd\x12[\x05'
 b'=\xa3m\x9c?Y>\xd7?md\\>*\x05N\xbfWU\x0c>\xf9\xae\xf4\xbf\xd4\xffr\x0eE\r\xf4'
 b'\x8c\x96m^\x00\x02\x00\x00\x00?\xc3I\x03\x8f*V\x00G8E\xc1j0\x07\xfe\x18\x9fh'
 b'\xb1\x88LpW<>[\xd4;')

{'A1': {'B1': 58537, 'B2': 1767971017, 'B3': 71, 'B4': -115},
 'A2': 931806543,
 'A3': 1170630062360364817,
 'A4': {'C1': 59714134,
        'C2': {'D1': 0.7675269246101379,
               'D2': 110,
               'D3': [{'E1': 95, 'E2': 8008847000748475005, 'E3': 13615},
                      {'E1': 96, 'E2': 1619178351925166558, 'E3': -15825},
                      {'E1': 118, 'E2': 10979044859106700862, 'E3': 28908}],
               'D4': {'F1': 8824229713716075058,
                      'F2': 8864761936170146330,
                      'F3': -33451537441867992,
                      'F4': [-0.03573133423924446,
                             0.07979890704154968,
                             0.8486151099205017,
                             0.9273126125335693,
                             0.16603586077690125,
                             -0.8411414623260498,
                             0.4876629114151001],
                      'F5': -0.32809115785150245,
                      'F6': 2358668638},
               'D5': [0.016887597739696503, -0.0861969143152237],
               'D6': 49993},
        'C3': [944095594, 805830168, 2674438536, 1282430780, 1046205499]}}

(b'MAIA\x00\x00\x00\x16\x87\xd9^\x08I\x14\x96$g\x83V\x9e\x00\x9c@N\xbbG\xd7\xa4'
 b'I\xb0kL\xc7>!\xda\xa1\xd6\x8f\x16-\xf7>\xb1\tU\xaa\x07XF \x18\xe0\xce_\x8e'
 b'M{\x11\xe6Cl\xbd\xbf \xa3\xe0\xbf\t\xd0\xfe\xbf\\\xaa\xa3\x94'
 b'\x00\x00\x00\x03\x00\x00\x00\x1eg\xe6\xdc\x9b52\xc1\rA\xf7aO\x85\x8dt\xd1'
 b'\x14sU8~\xd7\x9eH\xbf`\xden>e\x14\xc4\xbe\xd2\xfb\xf4?Nc\x10>m\xad\xed'
 b'?U\xe1\xc6\xbe\x9b\xd9\x08?\xb1\x1a\x9c\xc1\xe1\xf8\x80O2\xcc\xa8'
 b'\x00\x02\x00\x00\x00?\xd4\xfa\xe8,<n\x00GA#\x1b\xd5\xd3\xef\x80\xb3\nI'
 b'\xd8\x81\x02F\x99\xcd\xf7\xf1\xabh')

{'A1': {'B1': 16462, 'B2': -1152919644, 'B3': 73, 'B4': -80},
 'A2': 2279169544,
 'A3': 5265998947402602142,
 'A4': {'C1': -399754130,
        'C2': {'D1': -0.8619787096977234,
               'D2': 148,
               'D3': [{'E1': 107, 'E2': 5532458982370825871, 'E3': 5677},
                      {'E1': 247, 'E2': 4517402164758796358, 'E3': 8216},
                      {'E1': 224, 'E2': 14870760958029063747, 'E3': 27837}],
               'D4': {'F1': 7486913989720588557,
                      'F2': 4753374925883798737,
                      'F3': 1473615204214873672,
                      'F4': [-0.8783940076828003,
                             0.2237120270729065,
                             -0.41207849979400635,
                             0.8061990737915039,
                             0.23210878670215607,
                             0.835476279258728,
                             -0.30439019203186035],
                      'F5': 0.06681232198204334,
                      'F6': 1328729256},
               'D5': [-0.6275005340576172, -0.538345217704773],
               'D6': 54522},
        'C3': [1092819925, 3555688627, 172611713, 38181325, 4159810408]}}

Вариант №35

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

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

(b'\xcfSQM\xbf\x99\n\xb7\x0el\xe6@il\x00\x14\x00\x00\x00\x9a\ttkjtrxh'
 b'2\xa6\xcc\xb4\x00\x02\x00\x00\x00\x1c\xee\xea?\x0by\xc0\xbf\xe3{\xbc'
 b',r\xb8\x86K\xd16\xc1\xfe\xd7y|,\x11\x0fe\x96\x00\x05\x00\x00\x007\x8c\x9d?m8'
 b'\x9a\xbf\xed\x80\x8c\xc5\x98 \xa4\xa3\x7f\x87\xe4\xf6\xdd\xb3'
 b'\xb6\xed\x00\x03\x00\x00\x00X\xb9%=\xa7\x99\xf9\xbf\xec\x85\xe67\x1ca\xfeas'
 b'\xb9\xb3\xc8,\x80\xdar\x00\x03\x00\x00\x00u\x1d\xae\xbe\xf7\x87\x01\xbf'
 b'\xe7)p\x18\xa9\xd2F\xd1\xe4\xee\x00 \x00A\x00^\x00{\x00\x04\x00\x92?\xe5'
 b'\xe2\x8d\xd6\xd5\xa5\xf2\x1c\xd4\x9bgPJ\xec;q\xed\xffB?\xe4\x06\xd7\xfa\xf5'
 b'\xe0N\x93\xfcR{')

{'A1': -0.024454937224822837,
 'A2': 26988,
 'A3': {'B1': 9, 'B2': 'tkjtrxh'},
 'A4': {'C1': [{'D1': [12966, -13132],
                'D2': -4374,
                'D3': 0.5448265075683594,
                'D4': -0.6088543766143324,
                'D5': 75,
                'D6': -11978},
               {'D1': [-15874, -10375, 31788, 4367, 26006],
                'D2': -29539,
                'D3': 0.9266449213027954,
                'D4': -0.9219421252501161,
                'D5': 163,
                'D6': 32647},
               {'D1': [-6922, -8781, -18707],
                'D2': -18139,
                'D3': 0.08183664828538895,
                'D4': -0.8913451267608818,
                'D5': 97,
                'D6': 29625},
               {'D1': [-19512, 11392, -9614],
                'D2': 7598,
                'D3': -0.48345187306404114,
                'D4': -0.7238083345133155,
                'D5': 209,
                'D6': -6930}],
        'C2': 0.683905524824864,
        'C3': [483695463, 1347087419, 1911422786],
        'C4': 0.6258354093142857,
        'C5': 2482786939}}

(b'\xcfSQM\xbf\xec\xcbC\x95\x11\xe7\xc0\xf1S\x00\x14\x00\x00\x00{ijzvjerj'
 b'\xd5\xda\xaa\\\x00\x02\x00\x00\x00\x1c|n>\xa8fb?\xcd\xb48\xfdN\x11 '
 b'%4\xaf\xb6\xacW\x13\x99`\xa6\xef6\x7f\x00\x05\x00\x00\x007\xb4\xce?4\xa4'
 b'1\xbf\xa1\xfd\xcc\x02J\x0f`I\xe1=\x85\xbcm\xaf\x90\xad\x00\x03\x00\x00\x00X'
 b'\xb0\xe9>\xbf\x0b\x18\xbf\xe7\xcfB\x03\\\xa1\xe6@\x11\x0e\x00 \x00A\x00^\x00'
 b'\x03\x00u?\xe6\x9cO/\xba\xb9\x92\x17\xa6\xf5\xb3\x0e\xa2.\xa4\xbc'
 b'\xf6\xc8\xb3\xbf\xee\xb3\xa9\x1d/3>\x14vdi')

{'A1': -0.8998124991915049,
 'A2': -3757,
 'A3': {'B1': 105, 'B2': 'jzvjerj'},
 'A4': {'C1': [{'D1': [-10790, -21924],
                'D2': 31854,
                'D3': 0.3289061188697815,
                'D4': 0.2320624577370234,
                'D5': 37,
                'D6': 13487},
               {'D1': [-18772, 22291, -26272, -22801, 13951],
                'D2': -19250,
                'D3': 0.705630362033844,
                'D4': -0.0351394417566826,
                'D5': 73,
                'D6': -7875},
               {'D1': [-31300, 28079, -28499],
                'D2': -20247,
                'D3': 0.37313151359558105,
                'D4': -0.7440500322018664,
                'D5': 64,
                'D6': 4366}],
        'C2': 0.7065807277884224,
        'C3': [396817843, 245509796, -1124677453],
        'C4': -0.959431225777372,
        'C5': 343303273}}

Вариант №36

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

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

(b'\x89LRN?\x00\x058\x8d&2\xd5\xdcu\x86\x14\x15\x1f\x02\x00G\x00\x02\x00'
 b'e\x00\x00\x00\xd8RG\x1a%\xfdj\xdbG_:\xf0\xa6\xfd\n\xec\x8c\xad\x8ff'
 b'?\x03\x00\x00\x00g\x00\x02\x00\x00\x00\x7f\x00\x00\x00\xb7+#ngqdg\x08'
 b'\t\xe4 \x03\x00\x00\x00B\x00r`]S?\x02\xae".\x02\x00\x00\x00E\x00'
 b'\xc6\x82\xc8\xa6<dgs\xbd7\x93bst\xfb\xec\xfb&\xedW\xc5\xc2\x82X\x10s\xf5\x18'
 b'|e\x04\xd5\x8dL\xa4')

{'A1': {'B1': -73, 'B2': 9003},
 'A2': 5,
 'A3': 56,
 'A4': 9869,
 'A5': 2239718957422269746,
 'A6': [{'C1': 551815432, 'C2': 'ngq', 'C3': 114, 'C4': 0.8256435394287109},
        {'C1': 774024706, 'C2': 'dg', 'C3': -58, 'C4': 0.020359281450510025}],
 'A7': 'dg',
 'A8': {'D1': -2636016296075504936,
        'D2': 4030357319,
        'D3': -334824026,
        'D4': -116,
        'D5': 0.9006298184394836,
        'D6': [-327510005677310605, -9024433721865470996, 316795795438506072],
        'D7': [36309, 42060]}}

(b'\x89LRN?\x00\xb6\xa8J\x8bJyKC\xc6+-Q\x02\x00G\x00\x02\x00e\x00\x00\x00'
 b'#\xc2\x05\xaa\xbc+\xc2\x1e\xec\x9c\xf8\xb5\xa0T\x99\xb2\xa0\x8a\xcd\x06'
 b'?\x05\x00\x00\x00g\x00\x02\x00\x00\x00\x8f\x00\x00\x00\xaf\xf4\x03saqec\x1b'
 b'd\x82\x93\x02\x00\x00\x00B\x00<\xd5bT\xbf\x88\xe3\x89\xb6\x03\x00'
 b'\x00\x00D\x00y\xb4\xb5\x0c?az0S\xdd\xd9\x88\x8al\xcc\xd4\xc2W\xae9'
 b"'\xbe\xd0\xe1\xa5\x14\xec\xcb\xd4V5V\xf6\x9ay\xd8n^\xefz\xccS\xf8\x00"
 b';\xa5\xff\x00\xa1\x17\x86')

{'A1': {'B1': -81, 'B2': 1012},
 'A2': -74,
 'A3': 168,
 'A4': -29878,
 'A5': 5849379621556681034,
 'A6': [{'C1': 2474796059, 'C2': 'sa', 'C3': 60, 'C4': -0.8296330571174622},
        {'C1': 3062489992, 'C2': 'qec', 'C3': 121, 'C4': 0.5496475696563721}],
 'A7': 'az',
 'A8': {'D1': 2216382055926055459,
        'D2': 3052969196,
        'D3': -1298574176,
        'D4': -96,
        'D5': 0.5265737771987915,
        'D6': [-3716443272112155856,
               -3405241139553910060,
               3843493304311522785,
               -1198398574801783210,
               -25549347528389510],
        'D7': [41216, 34327]}}

Вариант №37

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

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

(b'NHS\x0f*\xc3\x19\x89M\xd8o\x0b\xc8D\x94\xb383\xffN\x00T\x9e\xb1B\xd6&\xe6'
 b'?\x02\x00\x8a\x00\x11\x95\xc7\xfe\xd4\xe5\xac\x9f\xa2\x00\x00'
 b'\x00\x94\x8c\x93A\x00\xb1\xd2?\xb9*9\xbf,\xde8?\xba\xfc\xffhX\x96\xad'
 b'\xc0\xa8\xcc?=\x00\xa1h\x18\xbf\xbdp\x85\x10\x98\xc3\x86)\xe0\xd1'
 b'\xef\xbe\x02\x00\x00\x005\x00H\x00,\xf9\xa2\xb2+\x84\xef\xbf\xba '
 b'\xcf\x07\x02\xc0"\xe0\x1bV\xc7\xe4o\xd1)*\x81\xb3\xa5\xb0CVOh4\xee\xf5,\xb0S'
 b'\xd2<\x02\x00\x00\x00r\x00\x02\x00v\x00\x00\x00\x02\x00\x00\x00~\x00'
 b'\x02\x00\x82\x00\x00\x00f=\xaa\xa7\x8e(\xe6\xbf&\x11S\xf5\xda\xbb')

{'A1': 432220687,
 'A2': -7762859906233250423,
 'A3': 4281546931,
 'A4': {'B1': 2992294060313899197,
        'B2': -0.4683980941772461,
        'B3': [-0.7233081459999084, 0.7221400737762451],
        'B4': {'C1': {'D1': 186, 'D2': -4, 'D3': 0.22389992214147303},
               'C2': -0.5953465104103088},
        'B5': -0.9848841179844263,
        'B6': 16150682328657502394},
 'A5': {'E1': 0.6922408392537798,
        'E2': [{'F1': [22043, -6969], 'F2': [707383663, -1331317887]},
               {'F1': [22083, 26703], 'F2': [754314804, 1020416944]}],
        'E3': -6940920222714456815,
        'E4': {'G1': -0.6924508356768626, 'G2': 4390, 'G3': 3151689043}},
 'A6': 0.29205328372899797}

(b'NHS\xa0}8\xde\xd5Mv\xe8\x96`\xc3\xe0\xc2\x9dd\x9dN\x00\xfc\xf1t'
 b'\x03\x17\xb0\xd8\xbf\x02\x00\x8a\x00\x06f\xdd\xaf\xb4\xe8W\xc8\xa2\x00\x00'
 b'\x00"l/\x84\x12\x01\xe1\xbf\xa5o\x07?r\xbd[?\x15\x90\xc9\x94l\xc4\x85'
 b'\xa4\xd7\xd9?=\x00\x01\x0c\xb3\xbe<[\xaa\xc4?}\x01\xae&\xd1\x8e\xbc\x02\x00'
 b"\x00\x005\x00H\x00\x12^'\xb3\x1a\xcc\xec\xbf0/S\xd0\xffh\xc6n\x98\t"
 b'\x161\x9c\x85\xe2\x87)\xbf.a\x9e0\x0bO\x89\x92\x9aJqv\x8d>\x02\x00'
 b'\x00\x00r\x00\x02\x00v\x00\x00\x00\x02\x00\x00\x00~\x00\x02\x00\x82\x00'
 b'\x00\x00x\xfb6\xe8\x05\x8f\xc5\xbf\x99H\xb3\x1b(\xd3')

{'A1': -566723168,
 'A2': -2250849187493687851,
 'A3': 2640616898,
 'A4': {'B1': 12538440550412081980,
        'B2': -0.017433714121580124,
        'B3': [0.5290473103523254, 0.8583594560623169],
        'B4': {'C1': {'D1': 21, 'D2': -13936, 'D3': 0.4037867838212119},
               'C2': -0.3497009575366974},
        'B5': -0.899915075216031,
        'B6': 7982182837481844528},
 'A5': {'E1': -0.3857476743467314,
        'E2': [{'F1': [2456, 12566], 'F2': [-2015197796, 1630453545]},
               {'F1': [12446, 20235], 'F2': [1251644041, 1049458289]}],
        'E3': -4010481080407857658,
        'E4': {'G1': -0.16842721785175363, 'G2': 18585, 'G3': 3542621107}},
 'A6': -0.5313808995955507}

Вариант №38

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

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

(b'XJKQ\x00\x00\x00_?`\xd1\xd4?R\xcd\x1eQ\xb3\xb9}\xb8\xe9\x82gt\x08\x11\x8e'
 b'\xef>\xddb\xf6\x0fg\x8b\x8f\xcf\x00\x00\x00\x06\x00\x00\x00\x1b\xcf}'
 b'\x99i\xe9c\xa43\x00\x00\x00\x03\x00\x00\x00.E\x18Lk\x00\xa3Z\x00\x00\x00'
 b'\x02\x00\x00\x00>\t\x89+b\xc4\x95[\x1b\x05\\\x00\x00\x00\x05\x00'
 b'\x00\x00M\xd3\xb3[}\xa1\xaf\xd7nF~j\xd6i\xb4m\x84T*\x8fh\xc0\xe6?\xe1\xcb'
 b'\x000C\x92\x06\x00\x00\x00!\x00\x00\x001\x00\x00\x00@\x00\x00\x00R')

{'A1': {'B1': {'C1': -3192107115733854354,
               'C2': 1182690006,
               'C3': 7616833284905537384,
               'C4': -16154,
               'C5': 0.5560303633361066,
               'C6': [{'D1': 258444175,
                       'D2': 207,
                       'D3': [142, 239, 62, 221, 98, 246]},
                      {'D1': 1776903076, 'D2': 51, 'D3': [207, 125, 153]},
                      {'D1': 1282080931, 'D2': 90, 'D3': [69, 24]},
                      {'D1': 2505775877,
                       'D2': 92,
                       'D3': [9, 137, 43, 98, 196]}]},
        'B2': [0.8782017230987549, 0.8234423398971558],
        'B3': 20915},
 'A2': [-71, 125, -72],
 'A3': 233,
 'A4': 2187817992,
 'A5': 17}

(b'XJKQ\x00\x00\x00`\xbe"\xf2o?J\xcb\xf7.d\xa7\x16K\x01\x1d\xa2}\xd0\x9e\xff'
 b'j\xe4\x18noV\xfc\x00\x00\x00\x03\x00\x00\x00\x1b\x85,\x85\xbf\xdc'
 b"\x16\xae'\xfc#\x00\x00\x00\x05\x00\x00\x00+\x82M.&\x9f71\xb3j\x00\x00"
 b'\x00\x04\x00\x00\x00=\xb6b\x08\xa3$3\x82\xdb\xdb\xbb\x00\x00\x00\x05'
 b'\x00\x00\x00Nh\xb4M-\xca 0\x05\xff\xf5\x04\xf3\x87\x94\xc9\xcf\x9e\x0e\x1bI'
 b'\r!\xbf\xd1\xde\xba\x86\x08`H\x00\x00\x00\x1e\x00\x00\x000\x00\x00'
 b'\x00A\x00\x00\x00S')

{'A1': {'B1': {'C1': 7544740134812397573,
               'C2': 4294247667,
               'C3': -8677088688488965303,
               'C4': 3361,
               'C5': -0.27921927537090996,
               'C6': [{'D1': 409890646, 'D2': 252, 'D3': [255, 106, 228]},
                      {'D1': 380512252,
                       'D2': 35,
                       'D3': [133, 44, 133, 191, 220]},
                      {'D1': 2671194547, 'D2': 106, 'D3': [130, 77, 46, 38]},
                      {'D1': 864213979,
                       'D2': 187,
                       'D3': [182, 98, 8, 163, 36]}]},
        'B2': [-0.15912793576717377, 0.792174756526947],
        'B3': 11876},
 'A2': [-89, 22, 75],
 'A3': 1,
 'A4': 497188304,
 'A5': -98}

Вариант №39

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

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

(b'URSL\x1d\xbf\xec\xc9K\xa3Vt\xfc\x00\x00\x00vyUh\xb7\xe9\xcbJa1\xe8W'
 b'\xf4\xa8\xe2\xbc\x00\x03\x00\x12,\x80\x08U\x82\x0b\x9713O\xa2<\x1a3X\xcb'
 b'J/\x7fE\x00\x02\x00\x18\xaf\xd3\xa2\xcd\xd7WN\xc6C\xceC\x86\x97\xe6\x83\xa0'
 b'E.\x9e\x00\x02\x00C\x0f_\xa0\xb8\xf4\xa3)\xa4n.(\xd5\x80\xb9\x8e\\\xc1'
 b'\xec0\xd9\x00\x02\x00Gh\x89t\xbca\xd9\xe4\x00 \x00O\x00\x00\x00\x02\x00r'
 b'\x02\x90\x9c')

{'A1': -0.8995721998395818,
 'A2': {'B1': [{'C1': [21864, -18455, -13494],
                'C2': {'D1': [746588245, 2181797681],
                       'D2': 3697352198115776715,
                       'D3': 1244626757,
                       'D4': [1630660695, 4104708796],
                       'D5': 45011,
                       'D6': -1563568297,
                       'D7': 78}},
               {'C1': [-14781, -12733],
                'C2': {'D1': [257925304, 4104333732],
                       'D2': 7939328090553552476,
                       'D3': 3253481689,
                       'D4': [2258101891, 2688888478],
                       'D5': 26761,
                       'D6': 1958502873,
                       'D7': 228}}],
        'B2': 2,
        'B3': 37020},
 'A3': 121}

(b'URSL\x1d\xbf\xe5\x13\xcb\xf0L\xee\x9c\x00\x00\x00v\x8bTvd\x1as0Q\x8bY\xf7'
 b'\xfd\xb4\x8d\xd3\x00\x03\x00\x12\x12Z|\\-r\xecd\x94\xef+\xcf&1\xb1\x1fP!d\n'
 b'\x00\x02\x00\x18\xfee\x91\xa0{\xecb_\xe7\xf2jg\xb1\x93.\xa1F\x0b\xcf\x00'
 b'\x02\x00C\x85\xf4^\xe4\xba\xd5\x8b2`\x82Im5Y\x86\xa2\x8d\xc1\xe3\xe9\x00'
 b'\x02\x00G\x8ea\x8dEa\xb3\x1d\x00 \x00O\x00\x00\x00\x02\x00r\x00\x1b\x8e')

{'A1': -0.6586665814752055,
 'A2': {'B1': [{'C1': [21622, 25626, 29488],
                'C2': {'D1': [307919964, 762506340],
                       'D2': 10731844605746196767,
                       'D3': 1344365578,
                       'D4': [1368087031, 4256468435],
                       'D5': 65125,
                       'D6': -1851753492,
                       'D7': 98}},
               {'C1': [24551, -3478],
                'C2': {'D1': [2247384804, 3134556978],
                       'D2': 6954201508008789666,
                       'D3': 2378294249,
                       'D4': [1739690798, 2705722319],
                       'D5': 36449,
                       'D6': -1924832845,
                       'D7': 29}}],
        'B2': 0,
        'B3': 7054},
 'A3': 139}

Вариант №40

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

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

(b"\x15CWSHxrqwbj\xcf\xbf\x9b\xfc\x9b'\xef\x01\x92bzpfqu\x02\x00.\x00\xae\xca"
 b'`;P\x00\xb0J\x05\xe9\xbe\xf4\xa3Q\x0e\xb0\x8d\xee\x04\xd8\xbe\x82'
 b'\x8d\xfd\x8aYO\xa8\n\x96\xe19{\x88\xf6\x06\xe9<Y\x17F\xb9`\xd1\r%t\x9b\xf76'
 b'\\\xef\xdb\xbdY\xe6t\xc3\x81= \xf4\x00\x1b\xf7\xc7\xa9\x00\x16\x91'
 b'\x92\x0e\xb07\xff\xd1\xbf\xae\xedH?_\xaeN\x8b9\xc5\xea\xbf\x96'
 b'\xf5\xba\xdc\xc3')

{'A1': {'B1': 'xrqwbj', 'B2': 4238065615, 'B3': 32450459},
 'A2': -110,
 'A3': 'bzpfqu',
 'A4': [{'C1': 141,
         'C2': -0.42191261053085327,
         'C3': 2331872642,
         'C4': 8879376174877790041},
        {'C1': 136,
         'C2': 0.02844570204615593,
         'C3': 3108378457,
         'C4': 3960805320435814752}],
 'A5': 0.0034300494007766247,
 'A6': {'D1': -0.1073901355266571,
        'D2': -1015749031,
        'D3': 4095753601,
        'D4': [3354860288, 2434138281, 934284946, 2931806719],
        'D5': 18669,
        'D6': [24383, 20142, 14731, -5435, -26945, -17675, -15396]},
 'A7': 5882814639066401456,
 'A8': 45070}

(b"\x15CWSHyesyxqoUb\x9aZ2\xb1j'dvjamf\x03\x00.\x00\x1c\xf9\x11?a\x00\xd0f9\xb2"
 b'\xf2\xf2\xbei-g\nn\xc3P?\xbd\xcco\xd3\xce\xcc\xbdg0\xd4s\xe7u>\xfai?'
 b'\xcc\x1b9n\x85F9\xe8\xf6Zt\xfeqy\xed\x14\xbe\xce\xec \xa0Q\xe3\xdb'
 b'\x82\xc6\x08\x14g\xbd\x01\x00\xbf\x800\x08\x92\xbd\t\xd3\xc3\x8c\xe7\xbc'
 b'\xee\xb6\xffo\x8f\x9a\xfb=\xdb\x12\x10\xe1\xb9N\xbfa\xf9n\x01\xb2'
 b'\xf1\xf2\xff\xe4\xc4\xf5\xbc\xe3^')

{'A1': {'B1': 'yesyxq', 'B2': 2590135663, 'B3': 1789997658},
 'A2': 39,
 'A3': 'dvjamf',
 'A4': [{'C1': 10,
         'C2': 0.8154820203781128,
         'C3': 3547319485,
         'C4': 16677907149447089358},
        {'C1': 117,
         'C2': 0.9139746427536011,
         'C3': 1849236428,
         'C4': 18335379999436654213},
        {'C1': 113,
         'C2': -0.14543713629245758,
         'C3': 2686512334,
         'C4': 7427571334132786001}],
 'A5': 0.5702073574066162,
 'A6': {'D1': -0.500026524066925,
        'D2': -1844957056,
        'D3': 3285387709,
        'D4': [4005357452, 2406481846, 3678272410, 3118534674],
        'D5': 48974,
        'D6': [-1695, 366, -3662, -14, -15132, -17163, 24291]},
 'A7': 7619794743743571664,
 'A8': 26413}

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

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

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

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

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

Поле	Описание
1	Массив структур C, размер 8
2	double
3	uint16
4	uint8
5	int8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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