ИВБО-09-22

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

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

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

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

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

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

Поле	Описание
1	int32
2	Структура F
3	uint8
4	uint32
5	uint32

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

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

(b'\rQXTY\x00\x00\x00}\x00\x00\x00\xc5-\x86\xb3\xce\x0b\x9b\x0c\x8e%0\xf5'
 b'\xfb\xa6;G.\x1e\xf8\xaa5W\xb0\xa6<+I\x93z\xda\x06\x1b$\xa6\xe2N_\x95D\x14'
 b'\x87\xe5?\x02\x00\x00\x00\xa3\x00\xda\ny\xd0\xe1\x83\xe8\x96\x17\x82\x85'
 b'.\xc1?\xee?\xca\x98\x9e\xa0\xa4\xdf&\x9a9\xce\xbf\x1a\xd5\xf0\xa7\xd2%_\xea'
 b'>\x17)$-\xef\xea\xfd\x04\xa3B\x17\x00\x95\xc4\x8f\xbb\xa2\xe1p'
 b'\x06\xae\x02\x00?\x00\x00\x00\x1a5^\x84\xc2\xdf\x1en\xe7QpGx0\x13\x0c'
 b"\xee<\x18+\xbd\xd2j\xf5k*A\xd9\x9f\x89'\xf8\x1b\xb1a+\xfbs\\@\xb6M>\xcd"
 b'\xca0=')

{'A1': {'B1': -760745771,
        'B2': 0.4577571451663971,
        'B3': 359701858234935575,
        'B4': 163,
        'B5': -6720619944444160190,
        'B6': 2919657697,
        'B7': {'C1': [{'D1': [121, -48],
                       'D2': 33761,
                       'D3': 0.1342322240081366,
                       'D4': -18},
                      {'D1': [63, -54],
                       'D2': 40600,
                       'D3': -0.2361328782856491,
                       'D4': 26}],
               'C2': 26}},
 'A2': {'E1': -1031512523,
        'E2': {'F1': 8667019504975224543,
               'F2': 3993768752,
               'F3': -0.04177115857601166,
               'F4': -46,
               'F5': -8529860295308610198},
        'E3': 39,
        'E4': 1638996984,
        'E5': 1551104811},
 'A3': {'G1': 908332732248370629,
        'G2': 5132879801399387534,
        'G3': [46, 30, -8],
        'G4': 5272374475388040618,
        'G5': -2114963276506170733,
        'G6': 0.6727391566773606,
        'G7': [0.20089054107666016, 0.04316215589642525],
        'G8': 2778}}

(b'\rQXTY\x00\x00\x00}\x00\x00\x00VOA\xd2^S\x8f\x16\x93A\x84M\x15\xfe\x9b\xf3'
 b'#\xc0\xf6\x8c/\x19\t)\x87\xae\xda\x8e[\x989u\xd9\x8b\x8a\xda\xb2\x10\xc4\x16'
 b'\xdb\xe5\xbf\x03\x00\x00\x00\xa3\x00\x92\r\x18_\x0eP\x00\x1c\x12\xb7\x96'
 b'jo\xbfy\xbf\xc8P\xa4`\xc7\x08\xe0E\xb9\xcf?\xf8\xb8\x8c\xbd!G\x1dI\xbf5\xc9_'
 b'\xdb\xe1\x0e\xed\xe59\xbaS\xd7\xd0\x91\xdb\xe4;^\xcf\x07_\x02\x00'
 b'?\x00\x00\x00ea\x99\x0fz\xa8B\xbd\xac\x7f\xf2m\xa07\x91\x8c\xc8\xe6G0\xbf%!j'
 b'\x83\xf4\xa3\xb0\x00\x90\xd7<T\xc1\xdcYn\x85\x8a6z\x13\xbft\x84j>\x0e\xfa@?')

{'A1': {'B1': 566070456,
        'B2': -0.7856029868125916,
        'B3': 16567914967376841013,
        'B4': 57,
        'B5': 4315815762248291258,
        'B6': 1594347358,
        'B7': {'C1': [{'D1': [24, 95],
                       'D2': 20494,
                       'D3': -0.0038350051550568587,
                       'D4': 121},
                      {'D1': [-65, -56],
                       'D2': 42064,
                       'D3': 0.24784158171820092,
                       'D4': -8}],
               'C2': 101}},
 'A2': {'E1': 2047842657,
        'E2': {'F1': -6886581625006767448,
               'F2': 3364655415,
               'F3': -0.6885970830917358,
               'F4': 37,
               'F5': -8070256314019517919},
        'E3': 215,
        'E4': 3703657532,
        'E5': 2324000345},
 'A3': {'G1': 1625609657223565142,
        'G2': -892840733654629997,
        'G3': [35, -64, -10],
        'G4': -2689063317177553012,
        'G5': -8463431977212028018,
        'G6': -0.6829942540549283,
        'G7': [-0.5760835409164429, 0.229020893573761, 0.7538155317306519],
        'G8': 3474}}

Вариант №2

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

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

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

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

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

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

(b'\xebKRF\x02\xaaD\xbf\x02\x00\x00\x00F\x00\x00\x00\xc4(@[%y\x02\x00'
 b'j\x00\x00\x00`\xa5l\x15\xecr\x87\x1fa7\xbf\xdfq\x85\xc5\xb4j\xfd\xaa\xc4'
 b'\xbew\x98\xdc\x01A\x87p,\xca\x08>\x1f\x9f\xf8Va\x8ag\xb3K>\x1c\x00\x00\x00hw'
 b'"\x00\x00\x00i\xa0Y4\xe3\x14,\xef1\x00\x00\x00ou7\x00\x00\x00\x91n'
 b'\xb4\xca\xe3\x00\xa7\xccIf\xbb\x9a')

{'A1': -0.7682191133499146,
 'A2': [{'B1': {'C1': 359441760, 'C2': 29420},
         'B2': 'hw',
         'B3': {'D1': 135,
                'D2': -0.7163257002830505,
                'D3': -33,
                'D4': 113,
                'D5': [-123, -59, -76, 106],
                'D6': -0.3841170370578766},
         'B4': -1212571233601085335},
        {'B1': {'C1': 31234167, 'C2': -30911},
         'B2': 'ou',
         'B3': {'D1': 112,
                'D2': 0.13358372449874878,
                'D3': 31,
                'D4': 159,
                'D5': [-8, 86, 97, -118],
                'D6': 0.19892655313014984},
         'B4': -3699987590503174511}],
 'A3': -60,
 'A4': 626737192,
 'A5': 121,
 'A6': [26185, 39611]}

(b'\xebKRF\xaa\x84@\xbf\x02\x00\x00\x00F\x00\x00\x00=F\xa6^\x85\x1b\x02\x00'
 b'j\x00\x00\x00(\\\xf0-h\x0b.\xbc"\x86>7\x87G\x18\xad\x04PU\xb5>\xac\xc9\x85'
 b'B\xd7\xf2\xa1\xc48\x94\xbe\xednV\x84\x017\x99\x169\xbf\x1c\x00\x00\x00al'
 b'"\x00\x00\x00\xd6\xd9\xc4\x1eX\x9e\x14E1\x00\x00\x00fa7\x00\x00\x00J\xbc'
 b'\xa3\x92\xbd\xa1\x0bAl\x85H\xa2')

{'A1': -0.7520242929458618,
 'A2': [{'B1': {'C1': 770726952, 'C2': 2920},
         'B2': 'al',
         'B3': {'D1': 46,
                'D2': 0.2619837522506714,
                'D3': 55,
                'D4': 135,
                'D5': [71, 24, -83, 4],
                'D6': 0.35416650772094727},
         'B4': 4977777589461768662},
        {'B1': {'C1': 1116064172, 'C2': -3369},
         'B2': 'fa',
         'B3': {'D1': 161,
                'D2': -0.289495587348938,
                'D3': -19,
                'D4': 110,
                'D5': [86, -124, 1, 55],
                'D6': -0.7230010628700256},
         'B4': 4687017672790228042}],
 'A3': 61,
 'A4': 2237572678,
 'A5': 27,
 'A6': [34156, 41544]}

Вариант №3

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

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

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

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

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

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

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

(b'\x8eHDUR{\x0f\xee>H\xc8^_A\xfe\xde?\xe7\xb8\x1c\xf9:\x00\x00\x00Q\x00\x00'
 b'\x00h\x00\x00\x00/\x87gdtN6\x9f?V\xdc?J\x87\x00\x00\x00T\x98\x97\xa2^8'
 b'tw\xb2_\xa9\x1b\xa5o.\x03\x1b\xe2<\x8d\xad4?cto?bB\x88\xbe\x02\x8e\x10'
 b'R\xf3\x12$\x85?~\xbf\x0c\xc2\t>\xc6m\x01\xbf\x80\x8b\xcd\xbe\xb6\xe4\t='
 b'\x81DtI]i?V\x00\xea\xbd\xe7\x96\x9b>\xfa<e\xbfv\xaa\xeb\xb5y\xe3X\xff\x19'
 b'\x04\x00\x00\x00\x7f\x00\x00\x00\x9e\xdc@\xbd\xa3z\xd3\xbe\xc0o\xa0~'
 b'\xda\xf9+\xdd\xd9\xbf\xbd')

{'A1': {'B1': {'C1': 0.46496185660362244,
               'C2': 0.48426851571560237,
               'C3': 4179409127},
        'B2': [{'D1': 464084914,
                'D2': 165,
                'D3': 11887,
                'D4': [0.027600770816206932,
                       0.7057731747627258,
                       0.9353696703910828,
                       -0.2661314606666565]},
               {'D1': 1376816642,
                'D2': 243,
                'D3': 9234,
                'D4': [-0.9931567311286926,
                       0.13452929258346558,
                       -0.505581259727478,
                       -0.4014549255371094]},
               {'D1': 1024058550,
                'D2': 129,
                'D3': 29764,
                'D4': [0.9115796685218811,
                       -0.11425845324993134,
                       0.30388566851615906,
                       -0.8954616785049438]}]},
 'A2': -30929,
 'A3': 'gd',
 'A4': 0.4427641920858385,
 'A5': 74,
 'A6': {'E1': 25,
        'E2': [-21898, -18965, -7303, -168],
        'E3': -0.04708539694547653,
        'E4': -0.4130450189113617,
        'E5': 28608,
        'E6': -0.4041242542243513,
        'E7': 189},
 'A7': 8607566766917785684}

(b"\x8eHDUR\xb7b/\xbf>\xd7{w2\xe5\xe7?\xd0pp':\x00\x00\x00Q\x00\x00"
 b'\x00h\x00\x00\x00\xbfeta0\xe8\xc5\xd2\xa2\xc2\xbd\xbf\x95\x83\x00'
 b"\x00\x00~\xa5'\xa9\t\x1a\xa6|\x92\x8c\xfb4\xb0'\x93\x06<\x92=\x9f\xf5N"
 b'?A\x88\xcf\xbeY\x83\xa7=\t\x8aEr\xae\xea\x91xQt\xbf\x19\xf3%=G_M?@KO?'
 b'\x9b\x7f\xb6y~\x0b\x88Q\x04J? 3J?\xaeH+\xbcv\xb4;\xbf\x06\x82\x8b\xa0\xd1'
 b'\x02\x00\x00\x00\x7f\x00\x00\x004]e\xbfQ\x87\x08\xbf&\xec\xd0\x8ea\xf2\xe28'
 b'\xc8\xbf,')

{'A1': {'B1': {'C1': -0.6851000189781189,
               'C2': 0.7467281659762433,
               'C3': 661680336},
        'B2': [{'D1': 888900754,
                'D2': 176,
                'D3': -27865,
                'D4': [0.07140354812145233,
                       0.8084353804588318,
                       -0.4053364098072052,
                       0.08179349452257156]},
               {'D1': 1917159945,
                'D2': 174,
                'D3': -28182,
                'D4': [-0.9543681144714355,
                       0.04051503911614418,
                       0.8022350668907166,
                       0.8097419738769531]},
               {'D1': 2042003355,
                'D2': 126,
                'D3': -30709,
                'D4': [0.7891283631324768,
                       0.7898426055908203,
                       -0.010454339906573296,
                       -0.7332223653793335]}]},
 'A2': 26047,
 'A3': 'ta',
 'A4': -0.11625116010500913,
 'A5': 149,
 'A6': {'E1': -47,
        'E2': [-32250, -24437],
        'E3': -0.8959534168243408,
        'E4': -0.5333147644996643,
        'E5': -5082,
        'E6': -0.18923603854192672,
        'E7': 44},
 'A7': 8981895135632008574}

Вариант №4

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

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

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

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

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

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

(b'KJII\t\xba\xed\x04\x00\xed\xe0\xc2Ta$\xa0\xa6\xc6F+yb\x9dy5\x1b\xf3\x1c'
 b'\x95\xe3\x1cq\x0f\x87\x9fm\x171]T\x9d\xa3\xb6\x1e\x03\x0e\\\xc0\xceF\xa7\xbf'
 b'\x19\xa1u\xd1\xa2\xf0\xfb\x89\xce\xf9B\x0bR\x0c7M1\xae\x00\x11pcc\xc8'
 b'{\xaf\x89\xe9\x17\xc7\x0c3\xb4\x89Jw\x86\nT\x8f\x94\xbf\xe3\xb2\x8a\xcf\xdf{'
 b'\x88\x94\x10d\xdb>\x97\x16\x11\x13\xc9\x98\xbb`+\xa2\\\x96E?E\xfdB\xbf'
 b'\xebo6\xfa\xa7\x95F\x00\x05\x00\x87\x15>3ISe\xd69\x9f59N\x88\xe7\xe2\xf5$'
 b'\x1f\n/')

{'A1': -4977317611137088940,
 'A2': [{'B1': [1629790374, -968479879], 'B2': 98},
        {'B1': [-1653000933, -216230429], 'B2': 28},
        {'B1': [1896843167, 1830236509], 'B2': 84},
        {'B1': [-1650215394, 51272896], 'B2': -50},
        {'B1': [1185398553, -1586114142], 'B2': -16},
        {'B1': [-74854663, 1108038156], 'B2': 55},
        {'B1': [1295101440, 292578147], 'B2': -56}],
 'A3': {'C1': [2075101673, 398920755, 3028896375, 2248823951],
        'C2': -108,
        'C3': -0.6155447063464274,
        'C4': -1810864933,
        'C5': 0.2950902283191681,
        'C6': 5065,
        'C7': -7441248218775775675,
        'C8': 0.7733956575393677},
 'A4': {'D1': -0.8573260207746578,
        'D2': [356397897, 1399182905, 2671065422, 2296898293, 606013999]}}

(b'KJII\t3\xec\x7f_x\xe7\xc2\x8c\xdc\x18\xd2\x9c\xcf\x14\xc3\x1eQ\xe9E'
 b'\x05\xecJL\xec\xf3\x9e\xfe\xc6r\xb2\xdfWN\x85< %_KAa\x92\x9c\x89J\xbc\xd5'
 b'\xdb\xed(\xb7\x08\\3\xdd\xf5\x08\x85h\x16Oo\x9d\xed\xe4\x18\xa5QK\x98t'
 b'$\xffs\x1dN\xbb\xd5h\xab\x1e\xdf\x16/\x9d\x0c\xbe|?\xeb\n\x98\x93K\xef'
 b'\x10TQ[\xa6>\xbat:z\x10I\xb8\xe6\x88\x94@9l\xbf?\xf5|?\xberg\x16'
 b'\xc0\x16\xe0\x00\x08\x00\x87\x18\xf3V\x0et\x8dM\xc2\x1e,\xad5\xd8\x0c}7-'
 b'\x1a\x9a\x83\x94:\xcb\xa2~\n\xbc\xb2r\x88\xf9!')

{'A1': 3741505438465114764,
 'A2': [{'B1': [-602352996, -820722914], 'B2': 81},
        {'B1': [-381352468, 1246555379], 'B2': -98},
        {'B1': [-20548942, -547926395], 'B2': 60},
        {'B1': [539320139, 1096913564], 'B2': -119},
        {'B1': [1253889499, -316098808], 'B2': 92},
        {'B1': [870184200, -2056776113], 'B2': 111},
        {'B1': [-1645353960, -1521398888], 'B2': 116}],
 'A3': {'C1': [620720925, 1320932712, 2870927126, 798821566],
        'C2': 124,
        'C3': 0.8450434567343752,
        'C4': 1414618022,
        'C5': 0.3641679883003235,
        'C6': 31248,
        'C7': 5312249234760677740,
        'C8': -0.7498395442962646},
 'A4': {'D1': 0.11893314652851528,
        'D2': [418600462,
               1955417538,
               506244405,
               3624697143,
               756718211,
               2486881186,
               2114632882,
               1921579297]}}

Вариант №5

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

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

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

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

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

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

(b'DXVS\x9c\x1e#\x00Y\x00\x02\x00\x00\x00\x87\x00\x00\x00j%\x13\xfc\x1d\xc4'
 b'\xe0c)\xc0Udg\x89\xdf\xbfCc\xdb\x05$\x91\x1a\r\x8f[E\xf6\x18\xc4'
 b'\xaak\x05\xde\xb4\x91%9`\xdb\xfe\x18\xf5\xa5j\xcf-\x03\x8c\xe7\xc4\x95\xf0b'
 b'&\xb2\x01\x1b\x00a\x91\x92\x14GLQ0\xc3K\x90\xc7\xa3H\xcfq\xca\x94\xd6'
 b'd\x08\xc2\x12\xb8\x14\xbcy\xf9\xd11\xc9%\x02\x08\xbb\xef;,}&\xef\x03Y'
 b'\xaf\xbf\x9d\x80\xf2\xe0x/FQ\x00\x15^\x01\xe6w\xe1\x8e\x19')

{'A1': 7836,
 'A2': [{'B1': {'C1': -8138819740911674525,
                'C2': 390593551906784603,
                'C3': [630306014, 4275789881, 1789261080, 2349018575]},
         'B2': -258620185,
         'B3': [98, 38],
         'B4': 178,
         'B5': 1,
         'B6': {'D1': 21952, 'D2': 26468, 'D3': 1136648073},
         'B7': 345149793},
        {'B1': {'C1': 7266158646022588579,
                'C2': 17976606184799650312,
                'C3': [633942481, 4022011906, 645737531, 2941846511]},
         'B2': -226452033,
         'B3': [-32, 120],
         'B4': 47,
         'B5': 70,
         'B6': {'D1': 19527, 'D2': 12369, 'D3': -946844733},
         'B7': -436117995}],
 'A3': [-7817, 6542],
 'A4': 7196967837600261482,
 'A5': 41}

(b'DXVS+\x00#\x00Y\x00\x02\x00\x00\x00\x87\x00\x00\x00-\xc4\x9by\x03\xef\x17hyF'
 b'\r\xca]f\x81\xcd\x96\x9dz\xcc\x13\xfbc\x88p\xa7\xc9\xf8zv\xabT\xe5\t'
 b'\x0f\x13\xa8C\xc0\xce2\x97\xc4DT\x9f\x1b\xd1\tY\x15\x02\x88\x8a'
 b'\xba\xb7\x9e\x1b\x00\x9d\x84cQ\x17\x08\xe1\xd5\x07\x8fi\x85A\xe9\x0bW\xde(U'
 b'\x7fx\xe85&U\x1b{\xd0\x9d\xac\x85\x8b\xbd\x93\xd9;\xa9\xdf\xa2tg\x7f\xee'
 b'\xe8\xd5\x96\x18.\xa5\x82>6Q\x00\x11\x92\xa0s\x05\xea\xd3\x83')

{'A1': 43,
 'A2': [{'B1': {'C1': 8108841059100687005,
                'C2': 16525021458086807975,
                'C3': [2819821321, 852410435, 1413792919, 164699039]},
         'B2': -2013129383,
         'B3': [-118, -70],
         'B4': 183,
         'B5': -98,
         'B6': {'D1': 3398, 'D2': 24010, 'D3': -1764916890},
         'B7': 1365476509},
        {'B1': {'C1': 9175284751245502785,
                'C2': 15022631034551658616,
                'C3': [2340793501, 1004114877, 1956831145, 3907944295]},
         'B2': 773363413,
         'B3': [-91, -126],
         'B4': 62,
         'B5': 54,
         'B6': {'D1': 2071, 'D2': 54753, 'D3': -2056679673},
         'B7': 1939902993}],
 'A3': [-5627, -31789],
 'A4': 7500726502613042221,
 'A5': 121}

Вариант №6

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

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

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

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

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

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

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

(b'\xecYCW\x00\x02\x00\x00\x00Y\x18\xc2lH\xbf\xeae\x8d\xb6\x07f\x12$\x00'
 b'\x06\x00]\x00cT,\xfd\x10d\x1c\xd9\xed~\x1e\t\xac\xb3\x83\x18\x05\x8eJD'
 b'\xff\xbc\x9a\x8aL]\xf6\x00\x06\x00\x1d\xbea\xa6\x00\x11\xaf4\x16\x0e'
 b'\x95A\xcf?\x11\x88\xad\xc5 ^\xb3\x00\x03\x00A\x91\xf6h\t\x81C\x005\x00'
 b'M\x8f\xd3\xec\xc5[\xe2>\xc2\xb7e\xbf\x04\xf8\xb8;\xff\xdb\xb8\xbf~\r\xf0\xbd'
 b"n\xd2\xaa?:\xf6&?n\x99v\x9eG\xe4\xd1'?\xe1p\xd2\xb2l\x80\xd4")

{'A1': [{'B1': [93, -10],
         'B2': {'C1': [1412234512,
                       1679612397,
                       2115897772,
                       -1283254267,
                       -1907735297,
                       -1130722740],
                'C2': 48737},
         'B3': 42496,
         'B4': 4527},
        {'B1': [94, -77],
         'B2': {'C1': [873860757, 1104101137, -2001877728], 'C2': 37366},
         'B3': 26633,
         'B4': -32445}],
 'A2': 415394888,
 'A3': {'D1': -0.8248966746570565,
        'D2': 36,
        'D3': [-113, -45, -20, -59, 91, -30]},
 'A4': {'E1': [0.3803054392337799,
               -0.5194201469421387,
               0.007808174937963486,
               -0.9924001693725586,
               -0.05830637365579605,
               0.7303184270858765,
               0.932029128074646],
        'E2': -25017,
        'E3': 58577,
        'E4': 39,
        'E5': 0.5450223431435242}}

(b'\xecYCW\x00\x02\x00\x00\x00YCKK\\\xbf\xe5\xe1\xfa\xa6\xf1-p\xeb\x00'
 b'\x05\x00]\x00b\x15\xe6\x01\xc2\x08\xf0\x1d\x0e\xda\x02\xbcr\xd0Q\x00'
 b'\x03\x00\x1d+\xee\x89\xadi\xef0\xd2\xf8\xafB\xdbB)\x9d\x93\xbc\xd3/p\xe0'
 b'u\xc5_\xbd\x1a8x\xb7\xa9SR\x00\x06\x005\x82PG.\x9ey\x00)\x00Mu\xfe\xcd'
 b'z\xbc?\x1f\x8f\x80>\x9an\x05\xbfq"\xdb?\x19\x8d|=\x19\xd6`\xbe\x92\x0c\x84?['
 b'\xae\xe5B\x9dQ{\xee\xbf\xd1\xb6LQp\xe8\x08')

{'A1': [{'B1': [-48, 81],
         'B2': {'C1': [367395266, 149953806, -637354894], 'C2': 11246},
         'B3': 35245,
         'B4': 27119},
        {'B1': [83, 82],
         'B2': {'C1': [819132591,
                       1121665577,
                       -1651262253,
                       795926645,
                       -983581414,
                       947435433],
                'C2': 33360},
         'B3': 18222,
         'B4': -24967}],
 'A2': 1129007964,
 'A3': {'D1': -0.6838353405559428, 'D2': -21, 'D3': [117, -2, -51, 122, -68]},
 'A4': {'E1': [0.6232833862304688,
               0.30162063241004944,
               -0.9419381022453308,
               0.5998151302337646,
               0.03755795955657959,
               -0.2852517366409302,
               0.8581374287605286],
        'E2': 17053,
        'E3': 20859,
        'E4': -18,
        'E5': -0.27675159409739125}}

Вариант №7

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

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

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

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

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

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

(b'AGIL\x98\xef\xed<W6yB*\x1e\x9a\xbcrosfsn\x03\x00c\x00\x06\x00\x00\x00u\x00'
 b'\x00\x00{\x00XR}\xd0!\x8b\xf4\xbd\xae\x05,z\x97\xce/4\xd3\xde\xdd\x04'
 b'\xa6R\xd4\x92\xa7\xe3#\xc9]\xd9\x06}u\xbd\\\xf5#\n/\xf1\xc2\xf9\x9a%2#X\xfd'
 b'2+\x11\xe1\x8e9-\xd7)\x7fv\x84wp\x8e\x8a$\x00\x00\x00/\x909\x00'
 b'\x00\x00\xc5\x9fN\x00\x00\x00;eiivix\xf0\x0c\r\xa2\xdb\x144Z*\xf0\xd6;$'
 b'\x88\x7f3!\x87&\nm[\x84\x1c\x92\xde$\x86\xd6\xa9\x93\xe2?\x00\x93y\xe2'
 b'\xad\xcbp?\x98\x8d\xd8h\xf1`\xc7?0\ts\xd6;_\xdf?>\xb5')

{'A1': 4789919426997514136,
 'A2': 7722,
 'A3': -17254,
 'A4': 'rosfs',
 'A5': 110,
 'A6': [{'B1': 138,
         'B2': {'C1': 13687718144833835608,
                'C2': 174,
                'C3': -1753601019,
                'C4': 11962930459298770894},
         'B3': 47},
        {'B1': 144,
         'B2': {'C1': 6757972176522105938,
                'C2': 217,
                'C3': -1116373754,
                'C4': 17997212245261808988},
         'B3': -59},
        {'B1': 159,
         'B2': {'C1': 3112828847455872410,
                'C2': 17,
                'C3': 758746849,
                'C4': 10263834961584794071},
         'B3': 59}],
 'A7': 'eiivix',
 'A8': {'D1': 6499843095751625968,
        'D2': 0.006559391506016254,
        'D3': 36,
        'D4': 7857134861720715144,
        'D5': -1843624869,
        'D6': [0.5805253209993244,
               0.0041004936570956385,
               0.1826459657614634,
               0.4901876062614461],
        'D7': -19138}}

(b'AGIL\xf1\x15=qa\x12\x83\x870\x90@\x85yideb\n\x03\x00c\x00\x06\x00'
 b"\x00\x00u\x00\x00\x00{\x00'V'G\xb4\xf9\x80en\xc7U\xa7\xa0\xf2\x9d\x08"
 b'\xf6\xa7\xa1\x8c\xd9\xb1\xb8\xadh|\x0f\xec\xbf\xfcMu\xdc\x8f\xfa\xac'
 b"\x07\xa7\x04\x11\x91\x9b\x88\xc1\n\xa7'\xe8\xfa\xfd\xe7?\xbc#T\xe4"
 b'\x10\x85F\xd3\x1d\xb0Tm$\x00\x00\x00o\x929\x00\x00\x00$\xdfN\x00\x00\x00'
 b"\xb7wpvqze\x8e\xf0\x18\xbf\xdc\x14\xa7\xa4'\xd6\x10?\x16/\xde\x0e\x8c"
 b'\xef\xc2\x89Q\x0e\x18\x98\n\xc0\xc4\xaa[`\x18\xca\xbf\xe0\xbe\xd0\x96'
 b'\x93Y\xb9\xbf\xa4\xcbD\xc3\r\xc0\xdb\xbfX\x9f\xf2\xed\xae\xae\xda?3\x16')

{'A1': 9764668626790323697,
 'A2': 36912,
 'A3': -31424,
 'A4': 'yideb',
 'A5': 10,
 'A6': [{'B1': 109,
         'B2': {'C1': 7314120347532875303,
                'C2': 110,
                'C3': -1599646265,
                'C4': 15676082145729224178},
         'B3': 111},
        {'B1': 146,
         'B2': {'C1': 13829445582754527409,
                'C2': 252,
                'C3': -1881377459,
                'C4': 11209759659181714682},
         'B3': 36},
        {'B1': 223,
         'B2': {'C1': 18301195292777300360,
                'C2': 231,
                'C3': 1411628095,
                'C4': 6102410288345452772},
         'B3': -73}],
 'A7': 'wpvqze',
 'A8': {'D1': 11864474681662304398,
        'D2': 0.5657677054405212,
        'D3': 22,
        'D4': 5875441522984279599,
        'D5': 177739790,
        'D6': [-0.2038689086526002,
               -0.09902307922379405,
               -0.43359703129970684,
               0.41691182362636914],
        'D7': 5683}}

Вариант №8

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

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

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

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

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

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

(b'CBMS\xb5`%\xbfcq\x85?\xbd\xbb\xa8Nm\xb2\xb0\x00<\x00\x03\x00\x00\x00E\x00'
 b'\x00\x00K\x00\x00\x00f\xa2;vslnemp@Z\xa3*\x11Td\xaf?\xd8\xca2'
 b'\xe9\x8f\x94\xf0 \x00\x00\x00%\xe0c{edxy\xbe\xc0\xa9)\xee\xa7R?\xedn.\x10'
 b'\xe9)\xac\x00\x03\x00H5o\xd0I\x96\x9b\xfb;\t\xa7\xe6\xd0#4\x9f?\xc5'
 b'\x8a\xc6\x85\xf3`\xf0\x00\x02\x00dVSu?Q\x94\x00H\xc7')

{'A1': 24613,
 'A2': -0.8884509205818176,
 'A3': 0.11614467539556972,
 'A4': {'B1': 32,
        'B2': {'C1': 'vslnemp',
               'C2': 4637198167406044335,
               'C3': 0.38734124001196246},
        'B3': 3764616037},
 'A5': 'dxy',
 'A6': [{'D1': 703506258,
         'D2': 0.9196997003830822,
         'D3': [-66, -64, -87],
         'D4': 53,
         'D5': 8057020644576672521},
        {'D1': -802999137,
         'D2': 0.16829759159623547,
         'D3': [-89, -26],
         'D4': 86,
         'D5': 6013782497031112903}],
 'A7': -24005}

(b'CBMS\xb5\x14U\xbf\x0c\xae?\xbf\xeb\x0f\xcbS\x96N\xc0\x00<\x00\x02\x00'
 b'\x00\x00E\x00\x00\x00I\x00\x00\x00earxpjuvomv2\x01\x93\x9b\x08\xc0<'
 b'\xbf\x8d\x85\xae\x9f\x0e&\x00 \x00\x00\x00%\x020\x02 xeW]o\xd0\xc4'
 b'\xa7?\xef\xd1s\xf4 \x8e\x98\x00\x02\x00GFlI\xe6\xb6\x88\xa9C\x17\xd4\xf2'
 b'C\xc0\\\x85z?\xd0\xcbT<1^\xe0\x00\x03\x00bJ\x966\xa3O\x93\xa1\xce?')

{'A1': 5205,
 'A2': -0.5495337843894958,
 'A3': -0.8456780083237945,
 'A4': {'B1': 32,
        'B2': {'C1': 'xpjuvom',
               'C2': 8516871578783891516,
               'C3': -0.014415134648305461},
        'B3': 36700704},
 'A5': 'xe',
 'A6': [{'D1': 1875952807,
         'D2': 0.9943179863079932,
         'D3': [87, 93],
         'D4': 70,
         'D5': 7803021501047325463},
        {'D1': -1067678342,
         'D2': 0.2624102199383582,
         'D3': [-44, -14, 67],
         'D4': 74,
         'D5': 10824018316606164543}],
 'A7': 24946}

Вариант №9

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

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

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

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

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

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

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

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

(b'@LSHJ|\x00\x00\x00:j\xa0\xe3\xbb\xaf\x8e\xd4~\x05\x18\xab\xee\xec\xc4'
 b'\x91A\x86\xb8~\xdd\xbf\xbc\xea\xed\xbcV9)s\xf0D\xa7\x90\xbf\xef\xf8\x92\x00'
 b'cr4\x92\x9a\x1c\x87{\x84\x1e\xa8LHAQ\xbf\x81\xd6\xb8\x1e\x10\xa9ut'
 b'\x1f\xe0\xf83\xd9m\xe7\x19a\xc0\rARLS\xba\x93g2\x00\x00\x00:\x00'
 b'\x00\x00B\x00\x00\x00J\x00\x00\x00R\x00\x00\x00\xaf\xd4\x83]\x1f\x0c'
 b'\x01s\xd01\xe4\x94\x8f\xf3\x02\x000\x00\x00\x00\x05\x00Z\x00j\xca'
 b'\xe7\x87\x18\x01=\xbfn\x00\x00\x00\xc22I9c\xa4\xf8]\xf2kt\xe0W\x16\xa7z')

{'A1': {'B1': 'cr',
        'B2': [{'C1': -28108, 'C2': 154, 'C3': 28, 'C4': 511998855},
               {'C1': 19624, 'C2': 72, 'C3': 65, 'C4': 3598827345},
               {'C1': 7864, 'C2': 16, 'C3': 169, 'C4': 3760157813},
               {'C1': 13304, 'C2': 217, 'C3': 109, 'C4': 3227589095},
               {'C1': 16653, 'C2': 82, 'C3': 76, 'C4': 1737734739}],
        'B3': 2280114794,
        'B4': -0.7382979393005371,
        'B5': {'D1': -11089, 'D2': 3589495351349828995, 'D3': 4086273252}},
 'A2': -3130371469463229894,
 'A3': 1406,
 'A4': 3975064344,
 'A5': -0.46085942374181976,
 'A6': {'E1': [-68, -22, -19],
        'E2': -6393721193555732804,
        'E3': -16496,
        'E4': [239, 248]},
 'A7': {'F1': 6771342785821356738, 'F2': 8838057360421579762}}

(b'@LSHJd\x00\x00\x00\x0c/PX\xd3W\x07Y\x1e\xd4\xc7\n\xf0\xb1\xe4'
 b"\x99\x85\xd4\xd9\x9d\xda?\xf8\xf6c\x80\x9bb\x12\xbb\xe4\t\x08\xb7+'\xfdz\x00"
 b'uyIb\xd0\x88\x00\xaeO\xd9\x88P\xfd\xac\x81\x11OX\xacN\xb5\xe2\xe4)I\x8d2\x00'
 b'\x00\x00:\x00\x00\x00B\x00\x00\x00\x16\x8a\xdc\xf3|\xf7\xe6\x9e\xc3\xda'
 b'j\xa0m\xb3\x02\x000\x00\x00\x00\x03\x00J\x00\xf9\xea+G\xae\xc2m?V\x00'
 b'\x00\x00\\\xbb)\xd6=\xe1k\xb6i\xe9\x97b\xd3\xe2ZL')

{'A1': {'B1': 'uy',
        'B2': [{'C1': 25161, 'C2': 208, 'C3': 136, 'C4': 3645877760},
               {'C1': 20616, 'C2': 253, 'C3': 172, 'C4': 1481576833},
               {'C1': 20140, 'C2': 181, 'C3': 226, 'C4': 2370382308}],
        'B3': 1194060537,
        'B4': 0.9287518262863159,
        'B5': {'D1': -30186, 'D2': 15763617835558695900, 'D3': 3010306154}},
 'A2': 6415192759443926796,
 'A3': -11234,
 'A4': 2985298631,
 'A5': 0.41588445428933896,
 'A6': {'E1': [-8, -10, 99],
        'E2': 579245519212288896,
        'E3': 11191,
        'E4': [39, 253]},
 'A7': {'F1': 13144847593113238364, 'F2': 5501959292306581865}}

Вариант №10

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

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

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

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

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

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

(b'KCXP\x00\x00\x00-\xbe\xbal|\xdb\x9e\xb3S\xfat\x8dr\xa2\xa5\xdcnl\r\x1b\x85'
 b'\x08\x1e?\xf8\xcc\x87&\xdaL\x88\xff\xa8\xa9\xb9\xb9\xfa\x81\x8b\x1a\xe2'
 b'\xfb`m\xa0Lfckyip\xd2BC\xe6\xc7\xfe\xdc\xd7\xef\xf61\x00\x00\x00\x04\x00\x0c'
 b'Z\xf5\xa2\x1d\xfe\x8a"l\x00\x00\x00\x03\x00\x10\xfc\x15\t\r1c\xcf2\x00\x00'
 b'\x00\x05\x00\x13\xfd\xe4r\xf68\xfd\xa8\x80\x00\x00\x00\x02\x00\x18\x7f\x1d'
 b'\x94Ol\xb6)\xbc\x00\x00\x00\x04\x00\x1a\xad\xb3\xb5\xab2\x14\xe5\xaa'
 b'\x00\x00\x00\x05\x00\x1e\xe4fS\x9eh\xc6\x9a\xb6\x00\x00\x00\x04\x00#'
 b"\x97J\xda\x8a:\xb1\x1d\x90\x00\x00\x00\x02\x00'Z\xd0\r#\x8f>\x7f\x9d\x9c\x00"
 b'\x02\x00)')

{'A1': {'B1': {'C1': 10023573489948926028, 'C2': 'fckyip'},
        'B2': -46,
        'B3': 16963,
        'B4': [{'D1': [-26, -57, -2, -36, -41, -17, -10, 49],
                'D2': [-37, -98, -77, 83]},
               {'D1': [90, -11, -94, 29, -2, -118, 34, 108],
                'D2': [-6, 116, -115]},
               {'D1': [-4, 21, 9, 13, 49, 99, -49, 50],
                'D2': [114, -94, -91, -36, 110]},
               {'D1': [-3, -28, 114, -10, 56, -3, -88, -128], 'D2': [108, 13]},
               {'D1': [127, 29, -108, 79, 108, -74, 41, -68],
                'D2': [27, -123, 8, 30]},
               {'D1': [-83, -77, -75, -85, 50, 20, -27, -86],
                'D2': [63, -8, -52, -121, 38]},
               {'D1': [-28, 102, 83, -98, 104, -58, -102, -74],
                'D2': [-38, 76, -120, -1]},
               {'D1': [-105, 74, -38, -118, 58, -79, 29, -112],
                'D2': [-88, -87]}],
        'B5': 90,
        'B6': 14991677832722095516,
        'B7': [47545, 64129]},
 'A2': -0.3641089200973511}

(b'KCXP\x00\x00\x001\xbf*~o\x9e\xbd\xb7,\xeaB\xbf\xc9\xd2\n\xa8\x92'
 b'\xb0\xd0\xf7`\xbeq\xf8\x04U\xd5\xd4%\xb1\xfe\xc8\xfa\x14GO\x90\x97\xfc4\xb6'
 b'\xc3\xda\xfe\xfe\xa5\xd1\xeb\x16\xd1mbabyt\xbe\x8e\xb6\x92D0\n@e'
 b'\x83\xf8\x00\x00\x00\x02\x00\x0c~5\x13\x1ef\x80\xf1\x84\x00\x00\x00\x04'
 b'\x00\x0e\x18\xbf.&\x95\x9b\x18\x04\x00\x00\x00\x03\x00\x12#}\x94>>\x91m\xa4'
 b'\x00\x00\x00\x05\x00\x15\x01\xed\x94\xc2\xd6\x92\x9a_\x00\x00'
 b'\x00\x02\x00\x1a\x8e\xb0\xf7\xfdUvZ)\x00\x00\x00\x03\x00\x1c\x84muz\xe4J'
 b'\xd3U\x00\x00\x00\x03\x00\x1f\x0c\x1429?\xc2\x97`\x00\x00\x00\x05\x00"\xa3b'
 b"\x1cv\x03;@\xba\x80\x00\x05\x00'")

{'A1': {'B1': {'C1': 15780330132497700561, 'C2': 'mbabyt'},
        'B2': -66,
        'B3': 36534,
        'B4': [{'D1': [-110, 68, 48, 10, 64, 101, -125, -8], 'D2': [-98, -67]},
               {'D1': [126, 53, 19, 30, 102, -128, -15, -124],
                'D2': [-73, 44, -22, 66]},
               {'D1': [24, -65, 46, 38, -107, -101, 24, 4],
                'D2': [-65, -55, -46]},
               {'D1': [35, 125, -108, 62, 62, -111, 109, -92],
                'D2': [10, -88, -110, -80, -48]},
               {'D1': [1, -19, -108, -62, -42, -110, -102, 95], 'D2': [-9, 96]},
               {'D1': [-114, -80, -9, -3, 85, 118, 90, 41],
                'D2': [-66, 113, -8]},
               {'D1': [-124, 109, 117, 122, -28, 74, -45, 85],
                'D2': [4, 85, -43]},
               {'D1': [12, 20, 50, 57, 63, -62, -105, 96],
                'D2': [-44, 37, -79, -2, -56]}],
        'B5': 163,
        'B6': 7069655271315913344,
        'B7': [64020, 18255, 37015, 64564, 46787]},
 'A2': -0.6659917235374451}

Вариант №11

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

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

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

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

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

(b'LNK\x81\xfc\xb7\xd1\xdc\xae\x99\\\xd8\xf4?v\xba:\x90\xfc\xfa]\x0e\x05\xd8'
 b'\xbc\xf4F\x00T?\xe6\xa3\x84\xf5\xf9\x82\x06\x98N\x05\xf8u\x92\xb5\xaa\xd9gA'
 b'\xda\x07\xca\xe3+y\xf8\x00{?\xef\xe8(6\xfb\xaeH\xc1\xe4\x0f\xde\xa1\x8f<'
 b"/\xff\xa1T\xfe!\xef'\x04D\xa4\xe8LW\x18XR).\xb8~\xa7\xba\xcb\xf3\xbf\xe1#"
 b'\xdb\xc5\xa3\xd0\x1b\x85\xda\x11\xd2\x83\x00\x03\x00\x00\x00QC\x96c\xa8'
 b"\xbb'\x03\xc7\xca\x1f\x0e\xd90m\xb5\n\xe6\x98#\xb4%\x0b\xd6c\x17!\x11\n"
 b'\x7f\xa2\x0e\x8e\x83\x00\x07\x00\x00\x00t')

{'A1': -4,
 'A2': 13245610621528758516,
 'A3': {'B1': 0.963779091835022,
        'B2': [{'C1': 2432498269,
                'C2': [14, 5, -40, -68, -12, 70],
                'C3': {'D1': 5500892237470969528,
                       'D2': 32423,
                       'D3': 13460119916768385989,
                       'D4': -1546642555,
                       'D5': 3658601091,
                       'D6': [68, 164, 232]},
                'C4': 0.7074608616058533,
                'C5': [152, 78, 5, 248, 117, 146, 181, 170]},
               {'C1': 3647422938,
                'C2': [7, -54, -29, 43, 121, -8],
                'C3': {'D1': 14396353307477044661,
                       'D2': 2790,
                       'D3': 10962803989155308311,
                       'D4': 554764927,
                       'D5': 2718862979,
                       'D6': [67, 150, 99, 168, 187, 39, 3]},
                'C4': 0.9970894884003849,
                'C5': [193, 228, 15, 222, 161, 143, 60, 47]}],
        'B3': 18420097401389786884}}

(b'LNK\x81\x88(\xc6\x81o\xb3\x10\x9d\x0b\xbe\x0fO\xbc\x0b\x8e\x8d\xdf\xfaS\x9f'
 b'h6\xb8\x00V\xbf\xdc\xcdZ\xa2\x99\xc7D\xd8\x12u\x84\xb9Q\x06\n\xab\xd6@'
 b'\xf1f\x12h\x14\x00X\x00|?\xe7\x0ef!\x99\x88\xb8\xb2\x8eJd@+\x86\x02U\xd0\xff'
 b'U\x90\xac\xfa\xc8\xcf\x03\x01\xd3#R\xd2\x8eh\x83\x99\xed\xe9\x9cp'
 b'\xbe\xa8\x04\x98+M\x04\xdf<nU\x07\xf3\x90|\x9c\x00\x05\x00\x00\x00Q<\xa4'
 b'\xe7\xe4T\x9a\xd2\x1f\xee\x92~zwv\x87\x1d\x04\xd7]\xdfED\x9a\xc4j\xa9'
 b'\x84;^\x83\xa7\xf5\x00\x06\x00\x00\x00v')

{'A1': -120,
 'A2': 2938178123651390731,
 'A3': {'B1': -0.13995260000228882,
        'B2': [{'C1': 193891807,
                'C2': [-6, 83, -97, 104, 54, -72],
                'C3': {'D1': 5967989035754974697,
                       'D2': 40048,
                       'D3': 13738235714901705951,
                       'D4': 1013863687,
                       'D5': 4086332572,
                       'D6': [207, 3, 1, 211, 35]},
                'C4': -0.4500338161370687,
                'C5': [216, 18, 117, 132, 185, 81, 6, 10]},
               {'C1': 2882945265,
                'C2': [102, 18, 104, 20, 0, 88],
                'C3': {'D1': 15141082785197487990,
                       'D2': 34589,
                       'D3': 348850709665716932,
                       'D4': 1789494331,
                       'D5': 1585686517,
                       'D6': [60, 164, 231, 228, 84, 154]},
                'C4': 0.7205076843495339,
                'C5': [178, 142, 74, 100, 64, 43, 134, 2]}],
        'B3': 6183723031344249544}}

Вариант №12

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

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

(b'VCFM\x8d\x00\x00\x00\x08\x00\xa5\x00\x92B\xfa+\x07\xcc\x91\xe9\\,\xb1\xc2'
 b'\x1a\x7f$>\x02\x00\x00\x00\xb5\x00\x1ba\x10\x96^\xfc\x14$\xea+\r\xf0\x07\x16'
 b'\x06\x1eywtofyf\xdb\xa9\xed\xe7\xe8\x04]\x07\xfe[\xc7\xc8\xbb\xc5\xb1'
 b'\nc\x85,\xd8\x03\xe3jg\r\x84\xc6\xb50\xc5\xe0\x11\x93\xf2i\x14"\x13\xcf'
 b'\x84\xed\xcf\xf4K\xe9\x84\x85!\x85\xbcN\x19\xd1*1\xe4;\xe3\xe2\xf7l\x8c\xa5'
 b'2h\xee@\xae\xdf\xad\xb7\xf9\xf2B\x0b\xd1\xa3O\xda\x8d2\xa6*>C\x07\x00'
 b'\x00\x002\x00\x9a\xa2\x87>\x07\x009\x00\xe9\x94d\xaf\x9aHz\xe1\x0b3\x89\\'
 b'\xbe\xc5<E\x1d\xd7\xa39\x8f\xa0\x16e\xf9\xb0\xa9')

{'A1': {'B1': 67,
        'B2': 'ywtofyf',
        'B3': 0.2649124264717102,
        'B4': [{'C1': 530585729469622747, 'C2': [254, 91, 199, 200]},
               {'C1': 15576971871595382203, 'C2': [3, 227, 106, 103]},
               {'C1': 1288246306426749965, 'C2': [147, 242, 105, 20]},
               {'C1': 5473228066204357410, 'C2': [233, 132, 133, 33]},
               {'C1': 16442970792067513477, 'C2': [59, 227, 226, 247]},
               {'C1': 12556297892402662508, 'C2': [223, 173, 183, 249]},
               {'C1': 10221569869276201714, 'C2': [50, 166, 42, 62]}],
        'B5': -23,
        'B6': 856099856428524692},
 'A2': [-30413, -16804, 15557, 7493, -23593, -28871, 5792, -1691],
 'A3': {'D1': 17042,
        'D2': 11258,
        'D3': 52231,
        'D4': 59793,
        'D5': 4477843682425384028,
        'D6': [-80, -87],
        'D7': 2517655835},
 'A4': 605355102,
 'A5': 2163440894346079210}

(b'VCFM}\x00\x00\x00\x08\x00\x95\x00MM\xfc\xaf6]-xz\x89;m\xb4\xbb=\x10'
 b'\x04\x00\x00\x00\xa5\x00O\xaen\xcfg\x90\xd6\xd8\x89\x8a\xe5,Wu\xdf\x87tz'
 b"w6\t\x81\xb5\x07\x13\x87.\xfd\xcb\x96\xc4m,\xcb\xfew>(\x96'5\x030\xe5W1"
 b'\x1e\x98\xeb\xc96rES)\xf1\x98\x1fr\x94\x15"\x0e\xd4n\x19\xd8\xf4\x12\xed'
 b"'E_\x95\xd9\x00\xbd\x8a\x9cn\xa73O\xad\x9f\xff\x8a\x82\xee\xf1"
 b'\xc1\x88\x03\x00\x00\x002\x00\x80\x9dA>\x06\x005\x00\x003\xb9g\xd7\xa6\xa8U'
 b'iZ\x8f\x14\x8c\x14L\x01\xee\x91\x91^\xb3\x0f\x80A\xef_\xbd\xcd\xa0')

{'A1': {'B1': 136,
        'B2': 'tzw',
        'B3': 0.18907737731933594,
        'B4': [{'C1': 3352669371431455030, 'C2': [253, 203, 150, 196]},
               {'C1': 10819966789854375021, 'C2': [39, 53, 3, 48]},
               {'C1': 3947945586941056997, 'C2': [114, 69, 83, 41]},
               {'C1': 1018400193053169905, 'C2': [212, 110, 25, 216]},
               {'C1': 15678542428387480308, 'C2': [0, 189, 138, 156]},
               {'C1': 10015899663002216302, 'C2': [130, 238, 241, 193]}],
        'B5': 0,
        'B6': 7590158181534775603},
 'A2': [-28838, -29676, 19476, -4607, -28271, -19618, -32753, -4287],
 'A3': {'D1': 19789,
        'D2': 45052,
        'D3': 23862,
        'D4': 30765,
        'D5': 1170297861787322746,
        'D6': [95, -67, -51, -96],
        'D7': 3480137295},
 'A4': -657026969,
 'A5': 9790673132202592905}

Вариант №13

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

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

(b'IDNH+\x89%\xf0\xdb\xbe\xe4}\xdfd\xc5(\xd2\xbf\xd9c\xc2\xe6\x8eC\xf5K\xa7T'
 b' WA\x93\x02\x00.\x00\x00\x00\x0bT\xbf\x88\x02\x00P\x00owZ\xdb\n\xbd\xdet/?'
 b'\x7f\x1bG?\xc1\x01\x15?\xa4uq\xbf\xfd\xb6l?\xe5dR\xbfz5\xbf>\x05\x000\x00'
 b'IRgk\x9ev\xc6\x98\x03\x00D\x00\x9en\xdc\x90\xacO\xbf\xb0')

{'A1': 35115,
 'A2': -0.42956653237342834,
 'A3': -0.28373846865539876,
 'A4': {'B1': 5473355203174622169,
        'B2': {'C1': 21671, 'C2': 2470532896},
        'B3': 'ow',
        'B4': 2294240267,
        'B5': [{'D1': [-0.03390059620141983,
                       0.6853770017623901,
                       0.777763307094574,
                       0.5820580124855042,
                       -0.9432013034820557],
                'D2': [21065, 27495, 30366, 39110]},
               {'D1': [0.9246671795845032,
                       -0.8218520283699036,
                       0.37345486879348755],
                'D2': [28318, 37084, 20396, 45247]}]}}

(b'IDNH@\x9c\x9b\xc9[\xbf\xc0\xa7\xe5GL!\xac?!\xe4\xe0\xa2\x80s\x1cN\x8c\xd2'
 b'Vn\x07\xbf\x02\x00.\x00\x00\x00\xa7\xaf ,\x02\x00H\x00nz\x1b\x07C\xbf~kN?'
 b't\xb5\x01\xbf\xab<m\xbe\x88\x05\xaf\xbe@\xd3V?\x02\x000\x00{;\x05\xcb'
 b'\xea\x1dpH\x04\x008\x00V\x83=\xa5F\xa1\x05\xa3')

{'A1': 40000,
 'A2': -0.8585450053215027,
 'A3': 0.05494154336595569,
 'A4': {'B1': 5628500630631932961,
        'B2': {'C1': -11636, 'C2': 3204935254},
        'B3': 'nz',
        'B4': 740339623,
        'B5': [{'D1': [-0.7618271708488464, 0.8063277006149292],
                'D2': [15227, 51973, 7658, 18544]},
               {'D1': [-0.5066750049591064,
                       -0.23167674243450165,
                       -0.341839075088501,
                       0.8391609191894531],
                'D2': [33622, 42301, 41286, 41733]}]}}

Вариант №14

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

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

(b'\xabRQO`\x13\xb5\xbc\xd2\xee\xab\xbf,\xb6\x9f\xbe\xabB\xb6:\x93{\x828'
 b'\x02\x00\x00\x00W\x00\x00\x00wq\x06\x00\xeb\xab\xae\xc7\x02\x00\x00\x00'
 b'g\x00\x00\x00\x19\xc4\x8c\xd8\x16\x04\x86[\x02\x00\x00\x00w\x00\x00\x00'
 b'\x93\x00\x00\x00\xdai\x1d>\x03\x00\x00\x00\xaf\x00\x02\xeb[\xf8\xf86'
 b'\x01\xc9\xc8sX\xc0\xb5\x1f\xe9\x12R\x05\xe1\xf2\xd7\x14\xcb{/\xc5'
 b'\xacS\xc9\x90A\x8f\xed\xb3\x1aJ[j\x19\x19\x7fo\x01Gr`\xbe\xe7\x90\xed'
 b'\xf6\xcb\xec\xe8\xa4%\x82\x93\xf4\x02O\xaa\x04*\x03\xc6\xa0\xf6\xb4\x94'
 b't\x84|\xdd\x9a\xa3\xa0\xbc\xae\x1e\xc0\x02\x00\x00\x00\x87\x00\x00\x00\x02'
 b'\x00\x00\x00\x8f\x00\x00\x00@uu`\xed\xb2')

{'A1': -0.05455645135456311,
 'A2': {'B1': -0.31193673610687256,
        'B2': [{'C1': 985023147,
                'C2': 948075411,
                'C3': [5914045583093422195, 3421551632300826885]},
               {'C1': 422263,
                'C2': -944854037,
                'C3': [17117972798767344837, 9158379261823425203]},
               {'C1': 3633103897,
                'C2': 1535509526,
                'C3': [10441523582525178223, 9378083119381083885]}],
        'B3': {'D1': -6871478330369739628,
               'D2': 44732,
               'D3': -16354,
               'D4': [1325593747, 53085354],
               'D5': [-24378, -19210]}},
 'A3': 0.15372410416603088,
 'A4': [30016, 24693, -19731],
 'A5': 4166773506,
 'A6': 3372300024,
 'A7': -56}

(b"\xabRQO\xb6\x7fda\x16\x18\xe7\xbfDV9\xbe\xc3TQ3L\xfb'\x03\x02\x00\x00\x00"
 b'W\x00\x00\x00\xd7\xc4\x00\x06\x13\xda\xc9%\x02\x00\x00\x00g\x00\x00\x00'
 b'\xd2;\xcb\xe5\x99\xf7\x92\x10\x02\x00\x00\x00w\x00\x00\x00\xa1\x00\x00\x00'
 b'"\x1e\x1f\xbf\x05\x00\x00\x00\xbd\x00\x8f\xceq\x01V\x837\xe1\xb5\xdb'
 b'\xfdP\x81\xcd\xb8\x15\x14\xd1\x0e\xc3\xb3\xe1\xd3-\xcdX8\xc8\xf2\x1c'
 b'X\xc7\x06\xc6\x9b\x7f(L4\x11\x8en\x7fD\t\x9e\x031\xcaOt\xc8.\xca'
 b'\x88\xc3\xd9|\xd7\x85:tg\xcf*z\xd8y\xbd\xeed\x1b\xc7Q\xd8\xc3\xd9\x8d'
 b'\xa8\xb5\xd3>kzRxa\xbe7g\x0e\xaf^#\xc5\x03\x00\x00\x00\x87\x00\x00'
 b'\x00\x07\x00\x00\x00\x93\x00\x00\x00\x08_@\x83\\|O\xda\xe9\x99')

{'A1': -0.7216903593252855,
 'A2': {'B1': -0.18099313974380493,
        'B2': [{'C1': 860968131,
                'C2': 52951884,
                'C3': [1447266048046857691, 14784706118064213713]},
               {'C1': 100713687,
                'C2': 633985555,
                'C3': [488455965948524632, 10237020929691458502]},
               {'C1': 3855301586,
                'C2': 278067097,
                'C3': [14569430246815465326, 15691535928638600271]}],
        'B3': {'D1': 1037859529950777978,
               'D2': 24239,
               'D3': -15069,
               'D4': [981849980, 718235508, 3178879098],
               'D5': [25838, -14565, -10159, -9789, -22387, -11339, 27454]}},
 'A3': -0.6215535402297974,
 'A4': [24328, -31936, 31836, -9649, -26135],
 'A5': 24235663,
 'A6': 3778511702,
 'A7': -75}

Вариант №15

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

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

(b'INDX\x1b\x05\x00,\x00\x8b\x00;\r\xfd\xc4\x9e\xafaV\xc8R\x0e\xbf\xb8'
 b'\xf7\x81\xbe\xc5}r\xbe\x06\xb6?%}\xda\xec\xbf\x00\x81\xfd\xb0\xf1x\xf98I'
 b'm\xbfc\x8ex\xa0N?\x15\x1e\xe0\xbf\r\xbf5f\xd5\xc9#<\xcfrW\xd2'
 b"\xa0\xbe\xf7\xb0&>\x98E\xc2\xbep\x14\xb2>\x00'+?\x14k\xb6\xbd\xb4 z?\\\xe2"
 b'\x0b>\x8f\xb2\x1a?\x940\x90\x7f)A)\xbf\x08\x00J\x00\x00\x00\x10\xcf\x9dE'
 b'\x1dK\xca?\x02\x00\x00\x00j\x00\x00\x00\xe8f\xa2\xd9Gb\xbeE\x13\xb6\xcf.'
 b'\xbf\x98\xb8l\x00')

{'A1': [{'B1': -1672, 'B2': -0.9268984794616699},
        {'B1': -29085, 'B2': 0.807136058807373},
        {'B1': 7701, 'B2': -0.5537090301513672},
        {'B1': 26165, 'B2': 0.009996850974857807},
        {'B1': 29391, 'B2': -0.31410476565361023}],
 'A2': {'C1': -0.22097720205783844,
        'C2': 69,
        'C3': 19,
        'C4': -0.6828569173812866,
        'C5': -18280,
        'C6': {'D1': 32656,
               'D2': {'E1': -0.6611505150794983,
                      'E2': [0.16278444230556488,
                             -0.3794372081756592,
                             0.3478121757507324,
                             0.6685638427734375,
                             -0.08907142281532288,
                             0.9770615100860596,
                             0.13660567998886108,
                             0.6042870879173279],
                      'E3': 0.2054173078464534,
                      'E4': [148, 48],
                      'E5': -24},
               'D3': 41574}},
 'A3': 6224449256447348027,
 'A4': [-0.5559506416320801, -0.2538430690765381, -0.2368078976869583],
 'A5': -0.9016710021512047,
 'A6': 0,
 'A7': 4054908289}

(b'INDX\x1b\x03\x00,\x00{\x00y"3V\x05\x92\x04f@#|\xbf\xd3\\\xb0>\x97\x1c ?\x96'
 b'\xa0B\xbc}\x82\xee?\x96\xae\x03\xfc\xd4\x13yd\xbb\xd7;\xc8\xe3l[\xf6>'
 b'@s\xac\x00\t?\xe9\xa6\x0e?\xb5\xb5\x0f?-*]\xbf\xb4\tL?\x9b\xed\xb0<(\xa9'
 b'#?&\xec\xc1\xf0\xa93\x01c\xf2\xe7\x15>\x06\x00>\x00\x00\x00\x00\xe3\xac\xc3'
 b'\xf9\xea\xe6?\x06\x00\x00\x00V\x00\x00\x00\xc5\x19\xed#-\x86\xbe\x8b'
 b'\xd59\xa3\x8f>\xf7\x95\\\x00')

{'A1': [{'B1': 30995, 'B2': 0.006583618000149727},
        {'B1': -7224, 'B2': 0.4811662435531616},
        {'B1': 29504, 'B2': 0.5351665019989014}],
 'A2': {'C1': -0.2620631158351898,
        'C2': -117,
        'C3': -43,
        'C4': 0.28054216504096985,
        'C5': -27145,
        'C6': {'D1': 25345,
               'D2': {'E1': 0.1463926136493683,
                      'E2': [0.5572343468666077,
                             0.5613663792610168,
                             -0.8639248013496399,
                             0.7970230579376221,
                             0.02159767411649227,
                             0.6392998695373535],
                      'E3': 0.7161835500511131,
                      'E4': [38, 236, 193, 240, 169, 51],
                      'E5': -59},
               'D3': 60697}},
 'A3': 7351161043394175609,
 'A4': [-0.9849128723144531, 0.3444581925868988, 0.6254362463951111],
 'A5': 0.9534290959318408,
 'A6': 150,
 'A7': 3573285806}

Вариант №16

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

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

(b'GGR\xf9N\x00\x00\x002e\xe8\xa2\x04\x00^\x00c\x84\xbb0\xbf\xdc\xa0:'
 b'\x92\xfd\x1cJ\x16<\x91 $\x9f\x04\x00\x00\x00\x86\x00\xa2\xd7\x1b\xcc'
 b'\x1f\xfe\xf7_\xe6@\x8f\xa2*\xa9G\xd0N\x0fo`|\x89\x88\xa8\xb2A\x02\x1f'
 b'\xfa\x0e"\xff\x03\x00\x00\x00\x8e\x00\xe943\x97H\x8c!\xcb\xfbu\xc5\xa0?vs vn'
 b'wb\x87\xbb\xf6\x1f_\xe2T\xba\xfb\xd4K\n\x19M\xdb\x1c\\}E\x01\xdc\xd3'
 b'\xa8\x8b\xc6\xfd\xd5$jk[\xa2Ig\xdf=b\x00k\x00t\x00}\x00\x81\xc8\x8f\x8bL\xe5')

{'A1': {'B1': 14637134507333072105, 'B2': 2338342647187731963},
 'A2': -1561828046,
 'A3': 'vnwb',
 'A4': 99,
 'A5': -0.6903612613677979,
 'A6': 1606128092516622556,
 'A7': {'C1': 60,
        'C2': -1625022319,
        'C3': [{'D1': -5020138786425226361, 'D2': 251},
               {'D1': 6637421075016338388, 'D2': 125},
               {'D1': -160287179499896507, 'D2': 213},
               {'D1': -2348827718983128540, 'D2': 61}],
        'C4': [3424376738,
               1610087967,
               2727297254,
               3494357290,
               1617891150,
               2827520380,
               520241586,
               4280422138],
        'C5': [-14207, -29809, -6836]}}

(b'GGR\xf9N\x00\x00\x00Y/\x96\xd0\x03\x00^\x00A\xa1\xeb\xa8\xbe\xd5\x04#'
 b'V\xcb\xf9^\xad\x0b\x8d6\xa9\x99\x04\x00\x00\x00\x85\x00\xdd\xcb\xfd\xab'
 b'#S\x17\xeaw\x9d&\xb6W^N\x06\xe0\xc85\x83\xdbM\x1a\n\xeaC\xdc\x92'
 b'\xcc9\xca\xa6\x02\x00\x00\x00\x8d\x00\xc6\xc1K \t\x8b\xa7 ZF\x86<g.1\xd6hk'
 b'xf\x9f\x9c\xb7\xe4\x8c\x0eQ\x04 T\xc3\xd9\xf1\xca$9V\x03N\xbc\x81\xb8'
 b'\xcca6\x0b5&\xe9\x9b\x14uS\xc2\xe4a\x00j\x00s\x00|\x00\xa1\xaa\xa7T')

{'A1': {'B1': 2353002201637175750, 'B2': -3012575654802209190},
 'A2': -795463847,
 'A3': 'hkx',
 'A4': 65,
 'A5': -0.32992270588874817,
 'A6': 12492697068091147477,
 'A7': {'C1': 11,
        'C2': -1716963699,
        'C3': [{'D1': 5840760680707039078, 'D2': 4},
               {'D1': 4117639099412861984, 'D2': 86},
               {'D1': 3918638243611692547, 'D2': 11},
               {'D1': -4444079675909003723, 'D2': 228}],
        'C4': [2885536733,
               3927397155,
               3055983991,
               105799255,
               2201340128,
               169496027,
               2463908842,
               2798270924],
        'C5': [-21855, 21671]}}

Вариант №17

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

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

(b'TUII\x9d\x98\x92\xecP*\xa3\xcc\x17\xfc4\xd8\xb0\\\x89\xab\xe2?\xc0\xe9eUYh'
 b'e\x9a\x02\x00\x00\x00U\x00\x00\x00\xa5\x9b\x05\x00\x00\x00]\x00\x00\x00'
 b'\t\r\x04\x00\x00\x00q\x00\x00\x00\xadC&\xe9l\xbe\x99S\xcd>;y&?'
 b'\xb2\xb3\x0e\xbf-\xb0o>7\x8f\x00n\xcd$\xe9\xa7\xbe\xada\t?)\xe4\xb2'
 b'\xbeO\xffu\xbe\x06!9\xbeG|-\xbf\xf4\xb6\x1b\xbf\xde\x9f\x88>\xd9!\x19?K\x83b'
 b'\xbf\x14 >\xbf\xe0@Zv>{\xe3,MJZ\xa6\xd98\x9c\xfbyn\xf0\xb2\xdc\x06\xbc'
 b'T\x889H\xe4\xee\xe6\xf7P5\x00\x10\xed\x07\x00\x00\x00\x81\x00')

{'A1': 1714924960262951576,
 'A2': -4,
 'A3': {'B1': 0.583439522778241,
        'B2': -7321330886326752832,
        'B3': [{'C1': [-0.3279505968093872, 0.5366466641426086], 'C2': -25691},
               {'C1': [-0.3493969738483429,
                       -0.2402317374944687,
                       -0.1807900369167328,
                       -0.677677571773529,
                       -0.6082603931427002],
                'C2': 3337},
               {'C1': [0.2668446898460388,
                       0.5981727242469788,
                       -0.8848158717155457,
                       -0.7426769733428955],
                'C2': 17325}],
        'B4': [-0.231358140707016,
               0.40102842450141907,
               0.6502873301506042,
               -0.5574294328689575,
               0.23407049477100372],
        'B5': 55,
        'B6': {'D1': 1853488028,
               'D2': -19728,
               'D3': 1756,
               'D4': -1806255401674976068,
               'D5': 3494135,
               'D6': 16,
               'D7': 237,
               'D8': [16608, 30298, 31550, 11491, 19021, 42586, 14553]},
        'B7': 110},
 'A4': -51}

(b'TUII\x9d+\xc2\x8b\xc3\x11\xed\xa5\x01f"\xa2M\x17\x16\xfa\xe7\xbf*\xb8'
 b'\xea\x82\xec\x1dM\xa3\x02\x00\x00\x00U\x00\x00\x00\xb3\x93\x05\x00\x00\x00'
 b']\x00\x00\x00\x08\xa6\x05\x00\x00\x00q\x00\x00\x00 \x9c\x8fp\x1c?\x128\x01?'
 b'\xc7l\xc7>83\xcc\xbe\\\x8es\xbf\x03\x91\x00\xe6\x80\xe8\xe7\x1a=\xda[7'
 b'?|v\xc3>\xa3G\x82\xbe\x9d\xb3\xf3>\xc1\x06\x84>\xf9m>>\x9d\xdc\xf3> \xcbc'
 b'\xbf^\xccj\xbf\xa1^q\xbeM[=?\x8aC\xa9\xe4\x12W\xc4KU\xb02m\x81\x8f1tA\xf2:'
 b"r\x1fg\xbc\xc5V\x7f:\x14\x13'Yt\xcb\xed\x06\x00\x00\x00\x85\x00")

{'A1': 118761625746129451,
 'A2': 102,
 'A3': {'B1': -0.7492781119481757,
        'B2': -6679649770674669526,
        'B3': [{'C1': [0.03781881928443909, 0.7162452936172485], 'C2': -27725},
               {'C1': [0.3817633390426636,
                       -0.25445279479026794,
                       0.4759797155857086,
                       0.2578640282154083,
                       0.1859663873910904],
                'C2': -23032},
               {'C1': [0.47629252076148987,
                       -0.8898181915283203,
                       -0.9171808958053589,
                       -0.23571254312992096,
                       0.7396743893623352],
                'C2': -25568}],
        'B4': [0.6110925078392029,
               0.504761815071106,
               0.38950178027153015,
               -0.39882826805114746,
               -0.9513909816741943],
        'B5': 3,
        'B6': {'D1': 1949405057,
               'D2': -3519,
               'D3': 29242,
               'D4': 1457617440069150495,
               'D5': 1951999763,
               'D6': 203,
               'D7': 237,
               'D8': [17290, 58537, 22290, 19396, 45141, 27954]},
        'B7': -26},
 'A4': -128}

Вариант №18

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

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

(b'NBN\xfa\xb9c\xbb#`8\x00\x00\x00V\xbf\x02\xeaz?\xee\xdd\xd1\x96t\x03N;\xd4'
 b'\xc5\xb7\xc7\x8b\x01\xa4t\xb2\x12\r\xe3\xd3^\x9e?9\xe9]\xbf\x06'
 b'\x0f\xae\xbf\xe6\x17oV\xc8\xf2\xe2\xe8?\xf0\x91tp\xe9z\x0ec\t\x8f]mP\xca>='
 b'\xc4\x94EMc\xcf\x9f\x0b\xd5O\x00\x02\x00\x00\x00\x0e\xac\x00\x02\x00'
 b'\x00\x00N\xbf\xe7\xfd[\x0cCv\xf2?\xe3X~,9\xd1\xea\xbf\xda\x92H\x9e'
 b'\x9b]\xc8\xbf\xe0\xe1c\x93Q.^\xbf\xe4\x19^\x0f\xce&\xce?\xdc\n4\xb1'
 b'\x05\x10 ')

{'A1': -1184646365,
 'A2': 24632,
 'A3': {'B1': [{'C1': -0.5113903284072876,
                'C2': {'D1': 0.9645774782694418,
                       'D2': [1003799991, -947191388, 1957827085, -472686946],
                       'D3': 0.7262170910835266}},
               {'C1': -0.5236767530441284,
                'C2': {'D1': -0.690360707761638,
                       'D2': [-398462831, 1953556858, 241371535, 1567445194],
                       'D3': 0.1853201985359192}}],
        'B2': 172,
        'B3': [1162699727, 2668352847],
        'B4': [-0.7496772040865081,
               0.6045523513590159,
               -0.41517844666438153,
               -0.5275133015906694,
               -0.6280966099449985,
               0.43812291419112803]}}

(b'NBN\xfa\xc1\xb9$f$\x98\x00\x00\x00b\xbfq\x19\x84\xbf\xe8j\xa3\x0e\x99'
 b'o\xd8\xde\xda|\xfd\x02\xa6)\xae{X\xea\x10\\\x05\x08\xff?9\xc9\xaf\xbe\x17'
 b'x\xf8\xbf\xec\x0b\x00;\x98\xf1\xe4\xb3Dq\x8fS5\xdfb\x96\x91H\x0c\x8a\xb6'
 b'|\xe0\xbf\x04e\xe5\x8b\xe84\x1d\x94\xa9>*K\x8e,\x05\x92\xaa\x1d\x16z\xe4'
 b'\xee7\x00\x02\x00\x00\x00\x0eD\x00\x05\x00\x00\x00N?\xe4\xc7\xcd\xc5[~`\xbf'
 b'\xe6\xdb?\xbf\x08s8?\xb6M\xba\xcf7\x1e ?\xebbP\xb1\xed\xca\x9a?\xe3\x94 <'
 b'\xc9\xd9\xbe?\xd4\xd3\x07yE\xb2\x88')

{'A1': -1044831130,
 'A2': 9368,
 'A3': {'B1': [{'C1': -0.9417955875396729,
                'C2': {'D1': -0.7630172047752195,
                       'D2': [-556106499, 44444078, 2069424656, 1543833855],
                       'D3': 0.7257336974143982}},
               {'C1': -0.14792239665985107,
                'C2': {'D1': -0.8763428844463843,
                       'D2': [-1287360113,
                              1396039522,
                              -1768863732,
                              -1967751968],
                       'D3': -0.5171797871589661}}],
        'B2': 68,
        'B3': [2347250717, 2494119466, 1267608581, 2460622102, 2061823543],
        'B4': [0.64939011141173,
               -0.7142637950051727,
               0.0871235614678132,
               0.8557513690160079,
               0.6118317782664275,
               0.32538019984239286]}}

Вариант №19

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

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

(b'YUR\xa8?ee\xbexdz\x00\x00\x00?\x19\xc8\x19`\x01@X2\xcc6\xca\xd6F'
 b'\xad\x7f\xdd\xe4C\x1a\xd4\x89\xb0\xdd|\xc8\xf7b5\xed&\xa9\x00\x00'
 b'\x00\x07\x00\x00\x00\x16\xb3Jk\x8bfgL\xe2L\xbf\xd2\x8e\x14\xbd\xe9\xf9\x1cq'
 b'~+R\xd5\xb6F\x12C\xd8\x12\xa4\xd1\x91\x01Z?\xe8Zwi@\x91\xa4_\xdbh\x96\x10'
 b'\xf5\xba\xeb\xe6\xb7\xb3\xf3\x9d\x9b0sf\x0e\x9d\xe2\x11\xd5\xf5\x84U'
 b'\xd2r\xc6\xb3\xea%\xaaY\x1f\xd3\xd1\x17\xad\x00$d\xc1\x08\xd7L\x83\xef\xe3')

{'A1': 0.8960837125778198,
 'A2': 'xdz',
 'A3': {'B1': [{'C1': -0.28992193743023775,
                'C2': 1904094034,
                'C3': -709474798,
                'C4': 4888677894610551130},
               {'C1': 0.7610432677943675,
                'C2': 1608214678,
                'C3': 284539627,
                'C4': 16624954408364093555}],
        'B2': 26126,
        'B3': 2648838613,
        'B4': -755384475134282774,
        'B5': 2714079718676699053,
        'B6': {'D1': -20259,
               'D2': [124, 200, 247, 98, 53, 237],
               'D3': 9897,
               'D4': [13004, 14026, -10682, -21121, -8732, 17178, -11127],
               'D5': 12919256727528361186,
               'D6': 76},
        'B7': 7260093795092656099},
 'A4': 6600,
 'A5': [25, 96, 1, 64, 88]}

(b'YUR\xa8\xbf>9ytdn\x00\x00\x00=\xe3\xacn\xba\xacF\xd3-Uv\x85\xef\xfa'
 b'\x16p\x9c9\x855\x01\xcb\xb9\x907\xe5\x8a\t\xa5\xe7\x00\x00\x00\x06'
 b'\x00\x00\x00\x16\x07kx\xe0\xeeJ\xdchs\xbf\xe4\xed\x9f\xde\xa0\x96|9\xfd\x92'
 b'\xd0\x12\xc0\xd9\x11\x1e\xdb\xc1\x92.\xee3k?\xe73\xe4\xfd\xff\xfb<\x19d%'
 b"'\xe2\xdb\x93\x7fw\xf1\xe3\x088\xb9h\xe3P\xfa\xf1\xa1\xb3{\xcf\x00^\xcd\xba"
 b'\x83=\xd5\x05&o\xe5\xfe\xe5\x98P\x00"\xc5w\xef\xf2B\x04)\x1c')

{'A1': -0.7430644631385803,
 'A2': 'tdn',
 'A3': {'B1': [{'C1': -0.6540068958463077,
                'C2': 972919504,
                'C3': 314628369,
                'C4': 2223583674634220395},
               {'C1': 0.7250847779213028,
                'C2': 425993511,
                'C3': -488926337,
                'C4': 8642938784351611107}],
        'B2': 20730,
        'B3': 4053906299,
        'B4': -3530717870167999019,
        'B5': 371107052919298128,
        'B6': {'D1': 459,
               'D2': [185, 144, 55, 229, 138, 9],
               'D3': 42471,
               'D4': [11605, 30341, -4102, 5744, -25543, -31435],
               'D5': 534653888239426664,
               'D6': 115},
        'B7': 14229105371469064476},
 'A4': 58284,
 'A5': [110, -70, -84, 70, -45]}

Вариант №20

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

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

(b'QIEM\x85M\xbfG(9\xf5e\x98\xb2>\xc7v2rtagog\x00\x00\x00`\xbaY\xbdB'
 b'\x1a\xdf\xf07oq264\xdc=#\xfa\xb1\x019\x84@c)NN\xc9\r\xfc.\xa4<\xba\xae\xb0Q'
 b'D\xcbe?\xa2\n\xf8\x8e*m\x0f\xa4\xb7\n\xa4\x8d\x98[\xbc\x0c\x1e\x9bc\xc0'
 b'\xa1L\xe5]\x9c\xfe\x7fX\x040F[\x00\x00\x00"\x00\x00\x005\x9fv#mG\xbdk\x15'
 b"\x80\xa3L\x00\x00\x00\x06\x00Hf\x80\xa8@Q\xe5D\xc3L\xd7\x96\x99h\x86y'F\x1fz"
 b'O\xc0')

{'A1': 77,
 'A2': -0.7779574990272522,
 'A3': -177891150,
 'A4': 0.3895736336708069,
 'A5': 'rtagog',
 'A6': {'B1': 70272603,
        'B2': [{'C1': -16,
                'C2': 55,
                'C3': 111,
                'C4': 8156641475782583290,
                'C5': -5692205213840889522},
               {'C1': 78,
                'C2': -55,
                'C3': 13,
                'C4': 18171642127223533649,
                'C5': 4957167138827335822}],
        'B3': 11490410451544402709,
        'B4': -128,
        'B5': -23732,
        'B6': {'D1': [711790500,
                      -1224039283,
                      -1738818548,
                      513500096,
                      -1588796067,
                      -1661042856],
               'D2': [26240, -22464, 20965, 17603, 19671, -26983]},
        'B7': 7531840636410886735,
        'B8': -64},
 'A7': [186, 89, 189, 66],
 'A8': 6879}

(b'QIEM\x85U?u`\x82\x9d\xfc}\x8c\xbe\xca\xff7nigeia\x00\x00\x00d\x01E\xd2\x19'
 b'\xb6\x8eh\xee\xb7\xb1v\xac\xf8D\x97\xd1\xb6\x1d\x81\xd5&\xd0g1[W+i5\xc3|h'
 b'<\xd8\xf1\xc3\xd3\xc9\xbb\x0e\x11Y \xc1^\x07\xb6\xa24?\x90\xe5\x96\xc1\n\xff'
 b'\xa7Lz\x06b+f\x06\xfd\x02\xc3\x0b<QUH7\xeft\x10\x00\x00\x00"\x00\x00\x005'
 b'\x10\x88i\xfa\x03\x7fd\x86\n\xd7\xb5\x00\x00\x00\x07\x00H\x9a4\xe1'
 b'[\xe6\xef\x01\x07\xa9d\xfay\x04\xa2\x1f2t\x02^\xd0\xa2')

{'A1': 85,
 'A2': 0.9585038423538208,
 'A3': -1644397172,
 'A4': -0.3964783847332001,
 'A5': 'nigeia',
 'A6': {'B1': 938439696,
        'B2': [{'C1': 104,
                'C2': -18,
                'C3': -73,
                'C4': 12787598374267769270,
                'C5': 2126214861777482075},
               {'C1': 87,
                'C2': 43,
                'C3': 105,
                'C4': 3874076891608052163,
                'C5': -3185809592292925247}],
        'B3': 1191318623960917126,
        'B4': 10,
        'B5': -10315,
        'B6': {'D1': [1577563810,
                      876581093,
                      -1765733633,
                      -1488160250,
                      1647011334,
                      -50150645,
                      1011963208],
               'D2': [-26060, -7845, -6417, 263, -22172, -1415]},
        'B7': 333863623933976272,
        'B8': -94},
 'A7': [1, 69, 210, 25],
 'A8': 46734}

Вариант №21

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

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

(b'FBDO\x02\x00\x13\x00\x00\x00I\x15v\xcd\x99-\x00\x00\x00!\xf5\xbf~\x99\xe0z3"'
 b'\xd2\t\xee?\x15[p\xd8\xa4@s\x0c\xe5\r\xc3\x9d\xbfps\xaa\x83I,pnqoxbr\x98\xc4'
 b'K\x8d\x8d\x17,\xd7\xe3\xf5\x9c\x18\xb8\xa8\xe1\xc1mJm\xccO\r\xf1\x08\x14\xd4'
 b'\xe9\xfa>\x9f\xb3\xe1\xbe%,\x85=_#\xa6\xbe`\x19?\xbf')

{'A1': {'B1': [{'C1': 2126509345, 'C2': 153, 'C3': 0.9386988323202239},
               {'C1': -663725291, 'C2': 164, 'C3': -0.02906438551427759}],
        'B2': 73},
 'A2': 2580379157,
 'A3': {'D1': 29552,
        'D2': 743015338,
        'D3': 'pnqoxbr',
        'D4': -104,
        'D5': [-2029104627436401724, 7908850535398677749, 1443668720047910218],
        'D6': [0.49006521701812744,
               -0.4408235251903534,
               0.06502560526132584,
               -0.3244886100292206,
               -0.7464809417724609]}}

(b'FBDO\x03\x00\x13\x00\x00\x00fp\xd1\x1fo:\x00\x00\x00\x11\xffk\xbf\xdc'
 b'x\xcb\xd5$\x83\x06\xdc\xbf@\x03\xf8\x9b\xc6\xec`\xd0j\xf0?\xee?\x10x\xbf'
 b'\x18\xef0.k\xa1\xa5@\xe1?.\xf9\xacZ=&dyfnypa\x16Z\xae\x186\r\x86`\xe1'
 b"\xb9\x18\xb8a&;\x94\x9b\x0c'\xba\xa4\x90\xaf\x99=\xa5xi?\x02F<\xbf"
 b'\xb7\xef\xae\xbec\xa3\xe6\xbd\xeb\x95\x99>')

{'A1': {'B1': [{'C1': -1083441391, 'C2': 220, 'C3': -0.43789747807675594},
               {'C1': -1678245056, 'C2': 198, 'C3': 0.9453050695620084},
               {'C1': 415201296, 'C2': 239, 'C3': 0.5391414787968127}],
        'B2': 102},
 'A2': 1864356208,
 'A3': {'D1': -1746,
        'D2': 641555116,
        'D3': 'dyfnypa',
        'D4': 22,
        'D5': [-2206616426111259046, -7236093665243293511, 4438771943524149004],
        'D6': [0.9119971394538879,
               -0.7354432344436646,
               -0.3416726291179657,
               -0.11261632293462753,
               0.29997190833091736]}}

Вариант №22

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

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

(b'ZKO\x00\x00\x00\x17\xd2X\xe9\x12\x00\x00\x0005\xc8&\x93\xa4T\x12R\xf47\x80^b'
 b'@g\x08\xb2\x14\xbc\xc3\xaf\xa4\x1eNfYYH\xcd\xf6U\xa2\xba\x00\x00\x00\x02'
 b'\x00\x00\x00&Q\xb3\x00\x00\x00\x02\x00\x00\x00(\x14E\x00\x00\x00\x02'
 b'\x00\x00\x00*\xc2u\x00\x00\x00\x02\x00\x00\x00,\xca3\x00\x00\x00\x02'
 b'\x00\x00\x00.K\xc6f9\xb8\xbf\xe4\xbc\x1f34\x16/@\xedh\n]2\\LtY\x8e'
 b'\xf8\x8b\x82K\x8c\xffv')

{'A1': {'B1': 17597675211837171464, 'B2': [178, 20, 188, 195, 175, 164, 30]},
 'A2': 3529042194,
 'A3': {'C1': [{'D1': [78, 102], 'D2': 20915},
               {'D1': [89, 89], 'D2': 5189},
               {'D1': [72, 205], 'D2': -15755},
               {'D1': [246, 85], 'D2': -13773},
               {'D1': [162, 186], 'D2': 19398}],
        'C2': 7366121799856955187,
        'C3': [3753239295367318109, 3628859462356236427],
        'C4': -32181,
        'C5': 140,
        'C6': -138},
 'A4': 902309523,
 'A5': -1537994158}

(b'ZKO\x00\x00\x00\x17F^l\xdc\x00\x00\x000\xe1\xca\x03V\xc0_\xc6\x01\x0c'
 b'\x8a\xd9\xbf\xd6\x96\xff\xf5\x0c\xf8L\xc3\xed\x01\x89J}:\x94\xa5\x8f'
 b'.\x14\xb2E\x00\x00\x00\x02\x00\x00\x00&\xb9\x9b\x00\x00\x00\x02\x00\x00'
 b'\x00(\xe2\xb0\x00\x00\x00\x02\x00\x00\x00*Q\xa9\x00\x00\x00\x02\x00\x00'
 b'\x00,\xd6\xce\x00\x00\x00\x02\x00\x00\x00.\xf6\\W}a\xb9F\xf0\xe5\xd4\x97+'
 b'}\xee\xb1\xd7\xc7\x8f\xd8\tg\xeb\x99\xf1"E\xb5\xeb+#S')

{'A1': {'B1': 903774093203406837, 'B2': [12, 248, 76, 195, 237, 1, 137]},
 'A2': 1180593372,
 'A3': {'C1': [{'D1': [74, 125], 'D2': -18021},
               {'D1': [58, 148], 'D2': -7504},
               {'D1': [165, 143], 'D2': 20905},
               {'D1': [46, 20], 'D2': -10546},
               {'D1': [178, 69], 'D2': -2468}],
        'C2': 6304302501775599060,
        'C3': [-7553805485844478065, -2879656225129029051],
        'C4': -18965,
        'C5': 43,
        'C6': 9043},
 'A4': 3788112726,
 'A5': -1067465215}

Вариант №23

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

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

(b'QCK<\x04r\xb7y\xee\xc2S\xa2j\xe6\xe7v\xaf\xae\xb3\x007\x00HWK\xd38\xf3'
 b'\x89\x00\x04\x00OH\x82\x0c\xdf\xf1\xa1@\xfc\x00\x00\x00W\xa0\xd8\x89'
 b"'0\xbf\xd7\xfe\x00\xc7\x00\x05\x00-\xf8\t\n\xef\x99\xd1^r\x01a\x16u\x02"
 b"\x00\x05\x00>(<u\xb2\xdeW\x9d;\xfc\xebK#\x1bMW\x9d\xea\n'\x0b")

{'A1': {'B1': 4324707674532790867,
        'B2': 11703420463478714035,
        'B3': [{'C1': [41176, 35111, 12479, 55294, 199], 'C2': [248, 9, 10]},
               {'C1': [61337, 53598, 29185, 24854, 29954],
                'C2': [40, 60, 117]}],
        'B4': {'D1': [22347, -11464, -3191],
               'D2': [-19746, 22429, 15356, -5301]},
        'B5': 1216482527,
        'B6': 4053876988},
 'A2': {'E1': 2529700654405519911, 'E2': 11}}

(b'QCK\x8e+\xe1-\xf8\x8c\x93\xc8\xac\xb8?\xed\xc3V\xd60\x005\x00@\xae'
 b'\xfb\xff\xbe\x07\x9b\x00\x02\x00G\xcd1.\xf9\x9b\x8e\x1br\x00\x00\x00'
 b'K\xf9\xff&\xc9)p\xd5\x8a\x00\x04\x00-\x8b\x13r\x87!\x8dQ\x00\x02\x00<'
 b'B\x9f\xc7\xd5\xe1\x0b\x8d\xbd\x16\xab<\xe9\x8f\xd84\x94')

{'A1': {'B1': 10244529364944065480,
        'B2': 12445767860655412784,
        'B3': [{'C1': [63999, 9929, 10608, 54666], 'C2': [139, 19, 114]},
               {'C1': [34593, 36177], 'C2': [66, 159, 199]}],
        'B4': {'D1': [-20741, -66, 1947], 'D2': [-10783, 2957]},
        'B5': 3442552569,
        'B6': 2609781618},
 'A2': {'E1': -4821478072948631500, 'E2': 148}}

Вариант №24

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

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

(b'pAZNN\x12\xd4\x7f\x02\x00\x00\x00l\x00\xf0\x93\x12\x14\xa0\\\x8b\x81Z\xf3'
 b'\xb0\xf4\xb1\xff\x04\x00\x0e\x00\x00\x00C\x9ck\xfd|\xbfp;\x12\x00'
 b'\x00\x00V\xac\xf7\x82\xff\xe8\x9c\xe0\xcb\r=\xf6\xc3\x14\x85Oi\xf4'
 b"\x9fI\xbd\x94\x1e\x05\xfe\xd9'\xbf\x02\x00>\x00\x00\x00\x11^\xf8\xff"
 b'\xc1\xbep\x8f@\x00\x00\x00\x16vL8[5Y\xe6\xae\xeb\xd5\xee\x96T\x01]\x1a\x00/<'
 b'\x0e5\x02\x00.\x00\x00\x00\x93\x9d.?9h\xe4\xd2\xf3\x15\xdd\xb1\xd5\xbfH\x00'
 b'\xf5\x8cLa\x02\x00\\\x00\x00\x00\xa3\xee\x03?h\xe6\xb0oC\xad\xe1\xb0\xd1\xbf')

{'A1': 54290,
 'A2': 127,
 'A3': [{'B1': {'C1': -79,
                'C2': [-16, -109, 18, 20],
                'C3': 40003,
                'C4': -0.9882418513298035,
                'C5': 15216,
                'C6': {'D1': [160, 92, 139, 129, 90, 243, 176], 'D2': 244}},
         'B2': 890125359,
         'B3': [-2261676728735257514, 5730008932781198795],
         'B4': 0.6820918917655945,
         'B5': 57,
         'B6': 104,
         'B7': -0.3389809336070313},
        {'B1': {'C1': -16601,
                'C2': [105, -12],
                'C3': 24081,
                'C4': -0.3789060115814209,
                'C5': -28816,
                'C6': {'D1': [159, 73, 189, 148, 30, 5, 254], 'D2': 217}},
         'B2': 1632406773,
         'B3': [-1848387506156046826, 6701730727732833198],
         'B4': 0.5153600573539734,
         'B5': 104,
         'B6': -26,
         'B7': -0.276420993044435}]}

(b'pAZNN\x90O\x94\x02\x00\x00\x00q\x00/\xdd_\xe96\x82\xdbEI\x88\xbf :\x16'
 b'\xdeBR\x07\x00\x0e\x00\x00\x00\xf7\xf1\xc8\xffS\xbdm*\x15\x00\x00'
 b'\x00\xd7\xc4\x8b\x16\x97\xf2\x8fm\x18=\xd5\x12(%.\xbf\x17\xbb\xc3\xf27\xaa*'
 b'\xce\xb4\xf94\xb2\xcb\r\x04\x00A\x00\x00\x00\xba\xab\xc557>W\x96E\x00\x00'
 b'\x00w&\x7fT\x88\xb0\xd8T5\xdc$1\xe4Q\xe1\xea\x1d\x00\xf9/\x00\xd5\x02'
 b'\x001\x00\x00\x00N\x9cK?H\xaa\xa8\xb4\x98\\h\xcd\xe6\xbfM\x00\xb7\x8e\x03'
 b'\x16\x02\x00a\x00\x00\x00\x15\xc5\xf5=\xc6\x18\x14\xd1T\xdc\xeb\xe4\xd1\xbf')

{'A1': 20368,
 'A2': -108,
 'A3': [{'B1': {'C1': 21058,
                'C2': [47, -35, 95, -23, 54, -126, -37],
                'C3': 61943,
                'C4': -0.051757603883743286,
                'C5': 10861,
                'C6': {'D1': [69, 73, 136, 191, 32, 58, 22], 'D2': 222}},
         'B2': 3573559289,
         'B3': [7894795402536010967, -4670754909491741416],
         'B4': 0.7953537702560425,
         'B5': 72,
         'B6': -86,
         'B7': -0.712574177601387},
        {'B1': {'C1': 3531,
                'C2': [23, -69, -61, -14],
                'C3': 43962,
                'C4': 0.1789160519838333,
                'C5': -27049,
                'C6': {'D1': [55, 170, 42, 206, 180, 249, 52], 'D2': 178}},
         'B2': 369331895,
         'B3': [6113830593735108215, -1521845158555624395],
         'B4': 0.1200048103928566,
         'B5': -58,
         'B6': 24,
         'B7': -0.2795972491906167}]}

Вариант №25

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

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

(b"\xd9ZOO\x06\x00'\x00\x96$\x07;\xf6\xea\xc5\x9a\x80{\x08Z(\x15\xef\x17"
 b'6\x00R\x00\xd1k2\xf5\xe0o\xfb\xfaM\x82\xcajdkjrb\xec\x0b+\xa7D\x02\x00'
 b'-\x00\xda1\x00\x00\x00\x02B\xbed?\x1b\\\x13fbz\x08\x95\x11\xee\xe6\xc3'
 b'\x912\x02\x00I\x00dM\x00\x00\x00O-\x8b\x84\xbd\xe5\xd5uPy\x03\x81+E')

{'A1': 'jdkjrb',
 'A2': -7294165678183471978,
 'A3': 1510505344,
 'A4': 401544488,
 'A5': [{'B1': -38,
         'B2': {'C1': 68, 'C2': [3052, -22741]},
         'B3': 2,
         'B4': 0.8935281038284302,
         'B5': 27,
         'B6': {'D1': 1650856796, 'D2': 294979706}},
        {'B1': 100,
         'B2': {'C1': 50, 'C2': [-6418, -28221]},
         'B3': 79,
         'B4': -0.0647185817360878,
         'B5': -27,
         'B6': {'D1': 2035316181, 'D2': 1160478979}}],
 'A6': [27601, 62770, 28640, 64251, 33357],
 'A7': -54}

(b'\xd9ZOO\x04\x00\'\x00"\xe1u\xed\x96c\xf4F\x9f\xba\r\x82\xad\xadD\xda'
 b'4\x00P\x00-\xefp\x9a\xe5\xd4\x91mp\xa8Lquqq\xa1sb\\\x17\x02\x00+\x00'
 b'\xb9/\x00\x00\x00\xd8\x92L\xb0\xbe]\xc8\xf8|*\xe8\x1d|%\x18\x97\xa4]y'
 b'\x02\x00G\x00JK\x00\x00\x00!\xc7PY\xbf\x01Y?\xb0\x88\xe7\xe3hi')

{'A1': 'quqq',
 'A2': 5112820976852525346,
 'A3': 2181937823,
 'A4': 3661933997,
 'A5': [{'B1': -71,
         'B2': {'C1': 23, 'C2': [29601, 23650]},
         'B3': -40,
         'B4': -0.3443341851234436,
         'B5': 93,
         'B6': {'D1': 712833224, 'D2': 628891112}},
        {'B1': 74,
         'B2': {'C1': 121, 'C2': [-26856, 23972]},
         'B3': 33,
         'B4': -0.8488888144493103,
         'B5': 1,
         'B6': {'D1': -2001715367, 'D2': 1768481767}}],
 'A6': [61229, 39536, 54501, 28049, 43120],
 'A7': 76}

Вариант №26

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

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

(b'XMVT\xbf\x0f\x8d\xbbjmflh\x00`\x00\x00\x00\x03\x00h\xd1vv\x12\x1f9\xef'
 b'q\xc3bij/<\xf3\xc2\x12g\x85\xb7H>JC\x88$\x00)"\x93+\xa1\x8dI#\xdeh\xeb!'
 b'\\Y\xf3\xff+\xc6{\x97\xf9Xv\x1f\x00\x00\x00\x04\x00*\xddGe{Gsup-\xbc'
 b'9\x8e\x00\x00\x00\x05\x002\x00\x02\x00\x00\x00<;A\x04\xebL')

{'A1': -0.5607563853263855,
 'A2': 'jmflh',
 'A3': {'B1': [{'C1': 1549399039,
                'C2': 3154344481673213471,
                'C3': [15946, 17288, 9216, 10530]},
               {'C1': -582523525,
                'C2': 5148587923678706062,
                'C3': [-27861, -24179, 18723, -8600, -5343]}],
        'B2': 15169},
 'A4': {'D1': [4, -21, 76],
        'D2': 209,
        'D3': 30326,
        'D4': 1305826117529330281,
        'D5': 1781480691,
        'D6': 49682},
 'A5': 1736816456}

(b'XMVT\xbfo\x10\xedwdwjp\x00|\x00\x00\x00\x02\x00\x84f\xd7\xd2\xab\x05\x8dP'
 b'\xa1k\xea\x88\xc7\xa1M|\\\x8c\x07\xac)\x03}GkEPR\x8f\xfc\x81?'
 b'\x91\xf7\xc8\x1cs"\xdd\x9a\xf6\xcc\n\xa5Z\xbc\x194U\xd7\x81\xb0yY\xe7~'
 b'jf\xac#\x1bX\x00\x00\x00\x02\x00*\x89y\xf2\xbf\xf5\x06\xc6\x8e(+\xcb\xe6'
 b'\x00\x00\x00\x06\x00.\xf9f\x93\x86&ng0j\xd9\x9a\xa8\x00\x00\x00\x06\x00:'
 b'\x00\x03\x00\x00\x00F\xacgq;')

{'A1': -0.9338520169258118,
 'A2': 'wdwjp',
 'A3': {'B1': [{'C1': -2119141031,
                'C2': -1765857014675465384,
                'C3': [32071, 27461]},
               {'C1': -1988496705,
                'C2': -790726370695328794,
                'C3': [20562, -28676, -32449, -28169, -14308, 29474]},
               {'C1': -110718074,
                'C2': 2769264278528170664,
                'C3': [-8806, -2356, 2725, 23228, 6452, 21975]}],
        'B2': 44135},
 'A4': {'D1': [113, 59],
        'D2': 102,
        'D3': 55250,
        'D4': -6123332740895217016,
        'D5': 3349237116,
        'D6': 23692},
 'A5': 128723203}

Вариант №27

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

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

(b'VKQ\xa1\xa9\x00hRcq/\x87\xd4\xf9\x99&\x00\x00\x00\x02\x00\x8b?\xe3'
 b'\xbe\xbc\x12f`\xa0s-\x0baS\x10\xc6Z\xbf\x18@^?H\x1c\xdd?W\xf4\xe1\xbe\x9f'
 b'\x91L6\xa3\xd5\xa48\n9k\x8e\xcaN\xa6\x0cr\xa9\xda\xc6\x1f3\xad\xea\x9e'
 b'\xbddI\xfeX\xfes\xcd]\x9b\xa0:\x7f\x83\x00\x00\x00D\x00\x00\x00O\x8d\x93'
 b'\xd17\xaeZ\x00\x02\x00\x00\x00Z:Lv.\xf7\xf2\xcb\x8f\xd8\xb6\x8c\xec\x0c\xdb'
 b'=B\xc5fS3\xc9~\x85\x01\xcf\x00\x03\x00b=\xd6\x0e\x0b\xbfy\x1a9')

{'A1': -87,
 'A2': {'B1': {'C1': [{'D1': 43482, 'D2': -4170557907863159452, 'D3': 73},
                      {'D1': 65112, 'D2': -111519763827508609, 'D3': -125}],
               'C2': 4200862496530287503,
               'C3': 3635842284,
               'C4': 3291,
               'C5': {'E1': 61, 'E2': 1120233043},
               'C6': 868843141,
               'C7': 463,
               'C8': [-29293, -11977, -20902]},
        'B2': 82,
        'B3': 7165560742563387686,
        'B4': [0.10451897233724594, -0.9730563759803772],
        'B5': 0.6170330390332488,
        'B6': {'F1': 8299302200947033690,
               'F2': -0.5947321653366089,
               'F3': [0.7816904187202454,
                      0.8435803055763245,
                      -0.3116554021835327],
               'F4': [13987, -10844, 14346, 14699, -28982, 20134, 3186]}}}

(b'VKQ\xa1j\x00f\xbd\xf2{h\xee6qW\xf6\x00\x00\x00\x02\x00\x89\xbf\xbc'
 b'\x12\x82\xe4\xadT0M\xbd\xee\xc9\x81\x14\xfe\xd9?T`\x93\xbe\r!n<t'
 b'\x82\xd8>\xde\xf9\xaa\xca\x1eb\xff\xc4\x02\x9e\xf7\xd2\x99,|bj\xb9\x9c\x17H'
 b'\xbc\xaa\x03\xd2\x81\x0eG\xc8S;\xa0\x13\x98\x15\xfb~sh\x00\x00\x00D\x00\x00'
 b'\x00O\x82\xfc=\x1f\x00\x02\x00\x00\x00Z\xdaQ\x12\xca\xd8p\x8dP\x84p\x89\xdc'
 b'Z\x04_I\x11x\xdcC\xd2\xbd\xa5\xda\x9e\x00\x02\x00b?n\x1f\xbc\xbf;9\xac')

{'A1': 106,
 'A2': {'B1': {'C1': [{'D1': 47516, 'D2': 1677798299590099214, 'D3': 71},
                      {'D1': 51283, 'D2': 4296455588436213363, 'D3': 104}],
               'C2': 15731375635805801808,
               'C3': 2221967836,
               'C4': 23044,
               'C5': {'E1': 95, 'E2': 1225881820},
               'C6': 1137884581,
               'C7': 55966,
               'C8': [-32004, 15647]},
        'B2': 189,
        'B3': 17472674551638874102,
        'B4': [0.9301717281341553, -0.7313487529754639],
        'B5': -0.10965746004997423,
        'B6': {'F1': 5601896060740239065,
               'F2': 0.829598605632782,
               'F3': [-0.13782283663749695,
                      0.01492377370595932,
                      0.43549853563308716],
               'F4': [-13794, 25343, -15358, -24841, -11623, 11388, 25194]}}}

Вариант №28

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

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

(b'ZHXM\x9br>\x95d\xba\xe4\x8f\x02\x00\x00\x00]\x00\x06\x00\x00\x00a\x00'
 b'\x00\x00iP\xb9>b\xe7\xb8>\xa3T\x95\x10k\x00\x00\x00\xa1\xe1\xe7\xd8\xae\x84'
 b'[H\xf7\x9d}<\xa4\xfd+\xdfbI\xc8?d\xbfC]\xfb\xdf\xc3d\x01\x82\x15v\x13\xcf'
 b'\x96x>\xa0\xc0nJO\xbf\xbf\x8a\x81\x18||\x02\xbd3\x00H\x00fgagve\xc4'
 b'\xdb\xb9w\xf7\x0b{5\x0e\x900\x85\x04\x00\x00\x00g\x00\x00\x00')

{'A1': -1791069541,
 'A2': {'B1': -1880835484,
        'B2': [{'C1': 32157,
                'C2': 738042940,
                'C3': 25311,
                'C4': {'D1': 73, 'D2': -0.8915982246398926},
                'C5': -9078864581363016381},
               {'C1': 30229,
                'C2': 2023149331,
                'C3': -24514,
                'C4': {'D1': -64, 'D2': -0.8097294569015503},
                'C5': -4827158978158818625}]},
 'A3': 'fgagve',
 'A4': {'E1': 0.3619416058063507,
        'E2': 0.36114031076431274,
        'E3': 278221987,
        'E4': {'F1': [3063, 13691, 36878, 34096], 'F2': [-60, -37, -71, 119]},
        'E5': 57761,
        'E6': -10009},
 'A5': 33966,
 'A6': 18523,
 'A7': -9}

(b'ZHXM=\xad\x9b\x85\x9c@\x05\xaa\x02\x00\x00\x00]\x00\x03\x00\x00\x00a\x00'
 b'\x00\x00\x942\x12?\x93N\xb2\xbe\xffe\x14\xb8f\x00\x00\x002\xfa\xa1k\x99\x8b'
 b'\x05\x8c\xec:4\x08<mS\xf2\x87\xc3H\x9d\x80=\xb0\x1a\x9c\x9c\x8c\xff\xb7i'
 b'\xf8lhH\xc8#\x19%\t\xa5v\xd2\xbe\xf3?\xebH\x96\t;\xed3\x00H\x00yso'
 b'\x89\x84\x8c0*\x04\x93\x9b\xa7\x9a\x02\x00\x00\x00d\x00\x00\x00')

{'A1': -2053395139,
 'A2': {'B1': -1442496356,
        'B2': [{'C1': 13370,
                'C2': 1399667720,
                'C3': -30734,
                'C4': {'D1': -61, 'D2': 0.06279999017715454},
                'C5': 7617838274108463792},
               {'C1': 27896,
                'C2': 600328296,
                'C3': 9497,
                'C4': {'D1': 9, 'D2': -0.41106143593788147},
                'C5': -1352476722021580813}]},
 'A3': 'yso',
 'A4': {'E1': 0.5710842609405518,
        'E2': -0.3482557237148285,
        'E3': -1206622721,
        'E4': {'F1': [12428, 1066, 39827, 39591], 'F2': [-119, -124]},
        'E5': 64050,
        'E6': 27553},
 'A5': 35737,
 'A6': -29691,
 'A7': -20}

Вариант №29

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

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

(b'OSPBxueei\xee\x0b\x87b7w\x06\xbe\xbcy\xd7O\xff\xe5\xbf\xa2)8B\x84\xf4\xebK'
 b'\xda?v\x00\x00\x00\xc4\x03\x00\x87\x00\x00\x00#\x86\xa0E\xed\xfb\n'
 b'\xdb\x02\x00\x8a\x00\x00\x00\xc24\xc5[G\x01\xc0}\xd5\x08\x06\x1c\xbf'
 b'\xea\x05\x00\x00\x00;\x00\x00\x00\xb4XE\x10\xe4GM\xd0\xd3\xf7\xbe'
 b'\x8a\x03\x00\x00\x00Q\x00\x00\x00PD\xd72Q\xc1J\xd7+6\x12C\xfe\x04\x92'
 b'\x80O@\x00T\x00e\x00j_\x88\xcea_"\x9cTo\xc8\xd1\x1af\xfbAj\x0b')

{'A1': 'xuee',
 'A2': 465901982768164457,
 'A3': {'B1': -0.6874160011774604, 'B2': -94, 'B3': 41},
 'A4': 0.4108838928087013,
 'A5': {'C1': [{'D1': -713179135,
                'D2': -0.6094670295715332,
                'D3': -22,
                'D4': [194, 52, 197, 91, 71]},
               {'D1': 1296557072,
                'D2': -0.4840378761291504,
                'D3': -118,
                'D4': [180, 88, 69]}],
        'C2': {'E1': -2933319652788976560,
               'E2': 1125266987,
               'E3': -2,
               'E4': 1333826052},
        'C3': 106,
        'C4': -30625,
        'C5': 14442855559568777678},
 'A6': {'F1': 196, 'F2': [209, 26, 102], 'F3': -2663039233142258141},
 'A7': [16891, 2922]}

(b'OSPBxypi-\xcb\xa8\xa5\xe3\x8b\xa2H\xd0\x1cT\xa2\xcb\x18\xd5\xbf'
 b'\xdd\xfc\xd4\x80 \xa7\xb9\xd4\xdc?u\x00\x00\x00b\x02\x00\x86\x00\x00'
 b'\x00\x81B\xed\xccY\xe8\x86\xad\x02\x00\x88\x00\x00\x00\x0e.\x929\xe6'
 b'a\xb7:\xd3u>\x13\x03\x00\x00\x00;\x00\x00\x00\x85\xfc\xa3u\xaa'
 b'\xe6\xad\xa7\x9f3\xfc=c\x04\x00\x00\x00O\x00\x00\x00\xb4\xd7\x9b[d$\xa4\x89'
 b'$\x8fd\x0c>>\xe4+\xc8>\x00S\x00d\x00\xad\xda\xd0\xc2GXn{\x93\xe2\x1f\xc58'
 b'\xea\xb9\x92\xcd')

{'A1': 'xypi',
 'A2': 5233899526811077421,
 'A3': {'B1': -0.3296383939018144, 'B2': -35, 'B3': -4},
 'A4': 0.45048371621124983,
 'A5': {'C1': [{'D1': -1218320839,
                'D2': 0.24006357789039612,
                'D3': 19,
                'D4': [14, 46, 146]},
               {'D1': -1481775446,
                'D2': 0.12314533442258835,
                'D3': 99,
                'D4': [133, 252, 163, 117]}],
        'C2': {'E1': -8528651780880607308,
               'E2': 207916836,
               'E3': 62,
               'E4': 3358319678},
        'C3': -83,
        'C4': -12070,
        'C5': 2297560918253914050},
 'A6': {'F1': 98, 'F2': [197, 56], 'F3': -5942807185880956287},
 'A7': [-17942, -12910]}

Вариант №30

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

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

(b'\x86CEO\x1c\x00\x00\x00/\x00\x00\x00\x97>*w \xd3\xb5\x97\x1a\x02\x00\x00'
 b'\x00N\x00\xb5\xab\xb5\x0bD\x99\xad\x161\xc5\xe8{\xbe\xe4\xfb\xd4\xb3z\x19Cs'
 b'iorel^\xc4\x04?t\xe43\\X`!\xcc\xbeV^.\xd2\xf76m/\xfcf\x9f\x84\xdc28\x8d{h'
 b'\xd7\xbfp\xd5\xa0EDb\xdb\xbf\xa4\x07a\xcbFd\xdc?\xf7\x0e\xea\xbe\x0f\xf6'
 b'.d\x89\xc5\xfd\xa8\xf4\xd5V-\xb2\xfa\xbdY\x8e\x95\xed?\xd0\x9b\xcc\t\xa4\xa8'
 b'\xc2?\x10\x99\x19[+$\xbf\xbf\xd3\xcc\xae\xbe1T\x99x\x97|\xf3\x82\xe1\xc01g')

{'A1': {'B1': 46507,
        'B2': -1673877713026726901,
        'B3': 1835977525447409275,
        'B4': 67},
 'A2': {'C1': 'siorel',
        'C2': 0.5186213254928589,
        'C3': 116,
        'C4': 1482437604,
        'C5': [3201048928, 3526254166, 795686647, 2225039100]},
 'A3': -105,
 'A4': 1916200084856842814,
 'A5': [{'D1': [-0.3657521132561621, -0.4278727226222463, 0.4436203943370123],
         'D2': -0.45714542269706726,
         'D3': 62991,
         'D4': 25646,
         'D5': 3267033826487813513},
        {'D1': [0.9245063545966643, 0.14577150801161887, -0.12164565061684507],
         'D2': -0.3414064347743988,
         'D3': 21553,
         'D4': 30873,
         'D5': 7435936534562569367}],
 'A6': -75}

(b'\x86CEO\x1c\x00\x00\x00/\x00\x00\x00\x08\xa4\xd7\xbe8go\xe3\x9b\x02\x00\x00'
 b'\x00N\x00\x069\xcf\x933\x9bz\xf6\x80\xdd\x0c\x98$\xe3\xaf\xb9\xfbS\x11\xf1f'
 b'yqnem\x90)\x1d?\xfd\xc9lX\xd6\xd6\xbd\x95\x0c\xad\x0e\xcc\xa2\xe4\x0c7s\xa3b'
 b'\xe22j\x95\xa7\x1a\x12+\xef?\xf4a\x1cN\xe9\x80\xd6\xbf\xbc\xa8K\xc5\xea\x99'
 b'\xd4?:\x02\xb0>\x18R\xe4\xb5\xbdt\x00)\xb1\xce\xdf+\x08\xfe\x07\x88.K'
 b'\xc3\xbfT\xe7\x8d\xd3\xed\x7f\xd0\xbf\x84\x9a\xd8v\x97\xd7\xdc?B\xcd'
 b'b\xbf\xc78\x81@Lw\\0P;}\x95')

{'A1': {'B1': 53049,
        'B2': 927038894415491987,
        'B3': 1248618296650179736,
        'B4': 241},
 'A2': {'C1': 'fyqnem',
        'C2': 0.6139154434204102,
        'C3': 253,
        'C4': 3596119241,
        'C5': [211140054, 2731282093, 1932987620, 853697187]},
 'A3': 8,
 'A4': 11232944384716494756,
 'A5': [{'D1': [0.9740076561544531, -0.3516181242753469, 0.32189435259955324],
         'D2': 0.343766987323761,
         'D3': 21016,
         'D4': -18972,
         'D5': 3161472723729806525},
        {'D1': [-0.15073186533116734, -0.2578081670723027, 0.45065867048325736],
         'D2': -0.8859444856643677,
         'D3': 14535,
         'D4': 16513,
         'D5': 10771831099334883148}],
 'A6': 6}

Вариант №31

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

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

(b'RRB\x03\xf1\xd6\xe6v\xdc\xdbXf\x13\xd0\ncf\x06Z\xbf?\n\xbe\xac\xbcW\x00\x00'
 b'\x00\x04\x00\x00\x00;\xcb-\xac\t\x00\x00\x00?\x00\x00\x00H\x00\x00'
 b'\x00Q\xbe\x00\xca\x85\x00rY\x1f\xa0fofy\x8f\xbf\xde\xe6\xb0s\xb3r\xb4'
 b'\xc1\xbf\xe4I\xb0\x81#.~\xdc?\xdc\x1f\xed\x0b\x03j\x1c\x92\xa2\xab\xccG\x0e'
 b'\x06>\xbf&\n\xe5.G<\xb5C)\xbc\xde\x1a\xcd\xb9\x12\x00\x00\x00\x02\x00Z'
 b"\xbd\x9d\xa0\xf3\x00\x00\x00\x04\x00\x00\x00j\x9e\xdf'\x11\xf8\xc4x\xc8"
 b'\xf3\xab"\x938YA@')

{'A1': -15,
 'A2': -2961549014004636141,
 'A3': 53258,
 'A4': 99,
 'A5': 1711692479,
 'A6': 0.5419719219207764,
 'A7': 48215,
 'A8': {'B1': 'fofy',
        'B2': -886199287,
        'B3': [{'C1': 143, 'C2': -0.4828301553623462},
               {'C1': 193, 'C2': -0.6339952966895479},
               {'C1': 220, 'C2': 0.43944860530396723}],
        'B4': -0.12577255070209503,
        'B5': {'D1': [-7880547504091167170, -4673035583910101835],
               'D2': -0.07696714252233505,
               'D3': [17193, 48350, 6861, 47378],
               'D4': -6998832337768908600,
               'D5': -888578485774630592},
        'B6': 89,
        'B7': 8096}}

(b'RRB\x034S7fs\xfb\xe4%3t\xf8\xad\xd9c\xb4~?<\x0f\x86\xcba\x00\x00'
 b'\x00\x02\x00\x00\x00;\xd5F\xd3_\x00\x00\x00=\x00\x00\x00F\x00\x00'
 b'\x00O\xbe\x12\xb3\xa3\x00rlbLqt\x9c\xbf\xb1\xcf\x87\xe0\xdd\x130\x96?'
 b'\xe8r\x8f\xc4%\x85J\xc8\xbf\xdc\xaba6B\xed\x14\xd8M\xaa\xa8\x1a\xcf\xc4\x00'
 b'3\xfe\xe8\xa5\xed\xa2\xb1\x1d!\x80\xfei\xda37V\xdf\xd1\x00\x00\x00\x02\x00X'
 b'?5\xf7\xec\x00\x00\x00\x05\x00\x00\x00hYt\xab\x16zQ\xf8\xb3$\xb5/\xf6'
 b'\x1f\xfd\xf0\xf6')

{'A1': 52,
 'A2': 5996374077200409907,
 'A3': 29944,
 'A4': 173,
 'A5': 3647190142,
 'A6': 0.7346118688583374,
 'A7': 52065,
 'A8': {'B1': 'qt',
        'B2': -716778657,
        'B3': [{'C1': 156, 'C2': -0.06957291831811285},
               {'C1': 150, 'C2': 0.763984568690071},
               {'C1': 200, 'C2': -0.44796018885581756}],
        'B4': -0.14326338469982147,
        'B5': {'D1': [-2860442549329345536, 3746687739372941597],
               'D2': 0.7108142375946045,
               'D3': [8576, 65129, 55859, 14166, 57297],
               'D4': 6445965079703845043,
               'D5': 2645073090295230710},
        'B6': 108,
        'B7': 25164}}

Вариант №32

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

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

(b'OXQL\xc6\xbf\x8c\xf8cH\xeb\xf3\x01M\xce\tB\xdc\xbb\r\xcb\xd2\xde6\x00\xeeAz'
 b'\xdf\xef\x19\xb4\x08\xbf\xf3!ka%\xdd\xc0\x94]]\x10\x14\x01\x8cQC\x9b~,\xbdt:'
 b'\xa0\x86:\x02\x00.\x00\x00\x00fX)f\xfdjK\x054\xa8V\x02!\x18\x18\xb7\xdfsP'
 b'\xae\x80\xdf\xceF\x1e\xeb\x02\x002\x00\x00\x00fb5\x82`\x91\xcc\xe2\x11\xe8u'
 b'\xf3\xe4\x8b\x07SC\xb7\xd6\xa2\xff\xf1\x18\x112:')

{'A1': -16442,
 'A2': 5548984407754537100,
 'A3': 2510,
 'A4': 56386,
 'A5': {'B1': -69,
        'B2': 51981,
        'B3': 57042,
        'B4': {'C1': 14964,
               'C2': -96,
               'C3': 14982,
               'C4': [{'D1': [-29695, 17233],
                       'D2': [102, 88],
                       'D3': [1794991657,
                              2821981515,
                              404816470,
                              1944041240,
                              3749752400],
                       'D4': 3944629966},
                      {'D1': [32411, -17108],
                       'D2': [102, 98],
                       'D3': [2439021109,
                              3893486284,
                              2347037557,
                              3074642695,
                              4060062422],
                       'D4': 976359704}]}},
 'A6': {'E1': [3749331438, 146020847, 1797387199],
        'E2': -1059248799,
        'E3': 23956,
        'E4': 4189},
 'A7': 20}

(b'OXQL\xb8\xccU\xfb;\xf5"\xfe}\x19uF\x12\x8c\xc8\x08\xb4`\x9f6\x00\xd6\xddN'
 b'\xb9-\xd5\xd6\xe2Is\xac\xc6\x882\xbd\xe4\x91$\xcb\xd9\x19\xb2\x07\x8ac\x1dT'
 b'\xa8\xaa\xc3w\xaaY\x18\x02\x00.\x00\x00\x00\xd7)Ti\x9d2$\xa0\xd4\xe3&UiH\xff'
 b'\t\xe70p\xeb\x91T\x97\x19j\xb5\x02\x002\x00\x00\x00\xc5\x9b\xb9'
 b'\\\xce\xdb\xe9q\xbd\x9e\xa6\xa0\xcc\x86\xda\xe1\x9c\x7f\xc1\x95\x18\x84~'
 b'\xa3\xffd')

{'A1': -13128,
 'A2': 1836903649133722453,
 'A3': 18037,
 'A4': 35858,
 'A5': {'B1': -56,
        'B2': 46088,
        'B3': 40800,
        'B4': {'C1': 30659,
               'C2': -86,
               'C3': 6233,
               'C4': [{'D1': [1970, 25482],
                       'D2': [-41, 41],
                       'D3': [849176916,
                              3822362660,
                              1214862630,
                              820447743,
                              1418849136],
                       'D4': 3043629463},
                      {'D1': [21533, -21848],
                       'D2': [-59, -101],
                       'D3': [3687734457,
                              2663215593,
                              2261557414,
                              2140987866,
                              2216203713],
                       'D4': 1694475134}]}},
 'A6': {'E1': [3108953558, 3805730093, 3333190473],
        'E2': -457362808,
        'E3': 9361,
        'E4': 55755},
 'A7': 25}

Вариант №33

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

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

(b'ISYZF\x02\x00\x00\x00a\x00\x00\x00\x84q\x00-M\xcf^\xb3\xba\x90g\xeb]>\x07'
 b'zo\xe9. \x80\xe7\xb65R1\x93\xbfD\xcb\xed\xf6\x02\x00\x00\x00}\x00\x00'
 b'\x00\xc6\xd3\x8e\x9d\xf9w\xa4\xa7\xc9\x1fn\xd0\x00\x8b \xf3\xf4S\x88'
 b'\xc8\xbe\xc1d\x89\xcbQ\xb2\x84!j\xba!Sr\xaaF\x0b3\xe2\x95\xc1\x98\xbe'
 b'\xe05\x00o\x96\xd5V\xac|\xc2~\x9e\\\xed\xbfK\x00\x14\t\x8e.\xa0\x8e\xb1'
 b'\x0e\xc5\x15\xed?n\xcc$\xe3h\xa1\t\xaa\xf0O@\xdd\xcfv\xd5!')

{'A1': [{'B1': {'C1': 198,
                'C2': -3915980515779440941,
                'C3': {'D1': 17650487145981308447, 'D2': -0.3916650712490082},
                'C4': -63},
         'B2': 1456838255,
         'B3': -0.9175560451293641},
        {'B1': {'C1': 100,
                'C2': -5014158381312521335,
                'C3': {'D1': 16299383874519192353, 'D2': -0.298351913690567},
                'C4': -32},
         'B2': 781060372,
         'B3': 0.9089074408515962}],
 'A2': 755003780,
 'A3': [-1285632179, -345534278, 2047295069, 539945327],
 'A4': -0.01874283268782717,
 'A5': [-13500, -2323],
 'A6': [12252501733097655406, 2437985408433278960]}

(b'ISYZF\x02\x00\x00\x00a\x00\x00\x00\xa7&Q\x85\xda\xab\x1aw\n\xcde'
 b'\xb9\x0f\xa4\r\xb5\xc9ap\xae`\xed\x0bR\xa2\x9e\xbe?S\xbeX7\x02\x00\x00'
 b'\x00}\x00\x00\x00\xe1\x19\xfai\xefi\xd7\xb6\x95\x9b\xa5\x15\xff%X'
 b'E\xe4\xd1\x85w?\x11U\xa7W\t[\xe8B\x81\xe9\xdaep\x7fk\xbft\xd9v7\xec>'
 b'\x175\x00\xd5j\x10#4t\x0f\x88\x9f+\xeb\xbfK\x00\xa9\xb9\x15\xee\x9eg\xbd'
 b'\x9d\xef\x88\xed\xbf\xe9\xa6\xb3\xd7\xbd\xaf\xfa\x1102\xf7&\x11)9\xd8')

{'A1': [{'B1': {'C1': 225,
                'C2': -7658697266308711911,
                'C3': {'D1': 16448650134257247643, 'D2': 0.9668856263160706},
                'C4': 17},
         'B2': 588278485,
         'B3': -0.8490750939778366},
        {'B1': {'C1': 85,
                'C2': -1620940825149483097,
                'C3': {'D1': 15669359471949276634, 'D2': 0.4613606333732605},
                'C4': 23},
         'B2': -300566103,
         'B3': -0.9229658203941999}],
 'A2': 2236688039,
 'A3': [1998236634, -1184510710, -1257397233, -1368366647],
 'A4': 0.11960806372728916,
 'A5': [-16813, 14168],
 'A6': [1295541072724993769, 15580529539509858864]}

Вариант №34

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

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

(b'HKYL\x00\xf3\x03\x0cX\xea\x06\xfab\xed[g\xe8\x03&(I9sO\x01\xfc\x03\xb1'
 b'\x9dc\x1ar\xc4rW\x876Y\x0b\xf3\xe2\xf6\xf8\xa7\xb1c<\xfc\x04RLXB\x9e\xe1\x96'
 b'\x07\x85\xa4/\xb0\xf6\xd2\x05Q\xff\x9c|\xe7\x9ck\xb2O\xae`\xed#\xf5\x0e+'
 b'\xe5\x07\xd2\xe5\xf5\xbe*\xb7+\x1aM\x812\x00\x00\x007\x00\x00\x00'
 b'\x02\x00\x00\x00<\x00\x00\x00=')

{'A1': {'B1': {'C1': [35, -11, 14, 43, -27, 7], 'C2': -0.48026901483535767},
        'B2': -18646,
        'B3': 2169313835,
        'B4': [{'D1': 76, 'D2': -509722024}, {'D1': -106, 'D2': 799311111}],
        'B5': [8979332480525072048, 17104863042072190183],
        'B6': 61},
 'A2': 1477182451,
 'A3': -22,
 'A4': [281588621233027590,
        -287861544874072026,
        8269860273425068291,
        -656695365575735465,
        5910125947317757944]}

(b'HKYL\x00[8\xcd\xa5\xd4N\xda\xb19\xad\x8eG\xb3_\xfa\xba\x82\x0b\x95'
 b'\xc4\xd9\x9b)\xaf\xf0n\xfe\xb9e\xd1\xd5Rws\x88\xbc\xa5\x98Vv\\\xc1<'
 b'\x98;\xcb_\xfdQ5\x94\x98\\\xf6\xb3\x8bb\xee*LUq\x85:\xca\x95\xf9'
 b'\xd8\x88\xd0@\xf3\xb5\xdb1p\x07%\xf3>><3W#\xae=2\x00\x00\x007\x00\x00\x00'
 b'\x02\x00\x00\x00<\x00\x00\x00\xf4')

{'A1': {'B1': {'C1': [-13, -75, -37, 49, 112, 7], 'C2': 0.18647439777851105},
        'B2': 13116,
        'B3': 1034822487,
        'B4': [{'D1': -53, 'D2': 894565727}, {'D1': -108, 'D2': -1275700072}],
        'B5': [9615560465038860939, 4670383279064861242],
        'B6': 244},
 'A2': 2781689947,
 'A3': -44,
 'A4': [-5528293142925551026,
        -2754913195373430177,
        7330169620960061851,
        -6504173732325304879,
        4294249045875381912]}

Вариант №35

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

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

(b'QRUE\xb6ciq\x8e\xa1\x00\x00\x00\x06\x00,$S\xf9\xee\xab\xb5\x99#C\xb3hZ'
 b'\xc1\x9e\xf4N\\\r\xbb[\x88\xf2\x00>\x00V\x00v\x0f\xd2\x7f\xcf=1\xa9\x9d'
 b'x+\xcahb{9)\xf6\xc3\x00\x00\x00\x02\x00\x00\x002\x00\x04\x00:\x89U'
 b'\xdb\xf4u\x14\xb2\x02\x1b\xbf\xa65\x00\x00\x00\x02\x00\x00\x00J\x00\x04'
 b'\x00R\xc3\x12\x05O\x87\x1d\x10\xcc\x014M|\\e\xef\x17!\xb8h{\x00\x00'
 b'\x00\x04\x00\x00\x00b\x00\x04\x00r')

{'A1': 'ciq',
 'A2': -29023,
 'A3': {'B1': {'C1': [15, -46, 127, -49, 61, 49],
               'C2': 36,
               'C3': 6051129995602502467,
               'C4': -1285006655},
        'B2': 158},
 'A4': 17604109207485516018,
 'A5': [{'D1': [2845669419, 3395838587], 'D2': [57, 41, -10, -61]},
        {'D1': [2304105460, 1964290562], 'D2': [27, -65, -90, 53]},
        {'D1': [3272738127, 2266829004, 20204924, 1550184215],
         'D2': [33, -72, 104, 123]}]}

(b'QRUE\xb6royv\xa7\x00\x00\x00\x05\x00,\xa5\x1c\x9br\xf3\xfc\x1b-\x82\xc4h\xe8'
 b'\xdd\xf7\xe4m\xd9+\xe2>\xd7\xf4\x00A\x00W\x00v\x9d\xdd\x1bx\xd2\xf6C#'
 b'_\xc6\xa0I\xff\\*h\xe6\xb0$\xaf\x97\x00\x00\x00\x03\x00\x00\x001\x00\x04\x00'
 b'=\xe2\xb4\xdd\xe1\xce\x11\x9f\xcd\xbb\x7f\x00\x00\x00\x02\x00\x00\x00M\x00'
 b'\x02\x00U\xf4\xbf\xa1\xcf45\xf5\xca\xcf&\xb0\x10-\xe1\x8co\xdd'
 b'\xea\xc2\x00\x00\x00\x04\x00\x00\x00c\x00\x03\x00s')

{'A1': 'roy',
 'A2': 30375,
 'A3': {'B1': {'C1': [-99, -35, 27, 120, -46],
               'C2': -91,
               'C3': 2061367646684392834,
               'C4': -999757603},
        'B2': 247},
 'A4': 16460050995611621364,
 'A5': [{'D1': [4131595103, 3332393471, 1546283238],
         'D2': [-80, 36, -81, -105]},
        {'D1': [3803504097, 3457261517], 'D2': [-69, 127]},
        {'D1': [4106199503, 875951562, 3475419152, 769756271],
         'D2': [-35, -22, -62]}]}

Вариант №36

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

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

(b'SZVN\x00\x00\x00\\\x00\x00\x00j\x00\x00\x00x\x00\x00\x00\x02\x00\x00\x00\x86'
 b'\x00\x95\xcf\xac\xffP\x04[z\xbf\xc4\xe2?\x8e\x00\x04\x00\x00\x00\x90'
 b'\x00\x00\x00\x03\x00\xa0\x00-yh\xa05\xe1\x93\x86`\x12^F4\xef\xdc\n\xb2'
 b'\xa4\t\x08sM\xcf\xfa\x18\xe4\xbf\xee\xfd\xa2\x9e\x0f\xa4t\xcak\xe9'
 b'\x9a\xe6\xef?\xadL\xf4\x11!\x8b\xa8\xdd1V\xa5\xf4\xc2\xbfu\xa2\x0f\xf2"\x89'
 b'<\xe8\xe2\x01\x08\n\xde?\x00\xfcz\xae\xbe\xc541\xd6C\xcfO\xdf\xbf\xfbo'
 b'\x936\xc8\xd8\xeb\x90\x00\x9a\x8a@\xcdf5{my\x95\xfctu5\x16N\x9d0\x1e\x80B'
 b'v\x05\xe9?\xe0\xf3\xed\x90\xf0)\xb1? \x84\x7f\x0ek\xee\xb9?')

{'A1': [{'B1': -530, 'B2': 2752487074, 'B3': 0.9969000395779646},
        {'B1': 19629, 'B2': 2334200308, 'B3': -0.14809099873285203},
        {'B1': -23947, 'B2': 2300768783, 'B3': 0.46936226066793885},
        {'B1': -1024, 'B2': 3317608058, 'B3': -0.4892461931674632}],
 'A2': [915632123, -1863591736],
 'A3': 4289515413,
 'A4': 0.5865170850521597,
 'A5': {'C1': 0, 'C2': -102},
 'A6': {'D1': [1724727434, 2037218101, 1970601109, -1655826891],
        'D2': [0.7819167422139284, 0.06704619921033794, 0.10129422286947021],
        'D3': [31021, 41064, 57653, 34451, 4704, 18014, 61236],
        'D4': 2780,
        'D5': 178,
        'D6': 2468},
 'A7': -0.6280492829206148}

(b'SZVN\x00\x00\x00\\\x00\x00\x00j\x00\x00\x00x\x00\x00\x00\x02\x00\x00\x00\x86'
 b'\x00\xce\xab\xb2\xa1\xf4\xc8>\xc3\xa5H\xeb?\x8e\x00\x03\x00\x00\x00\x90'
 b'\x00\x00\x00\x03\x00\x9c\x00\xcd\xf5AU\xdf\xadP\xa5\x17\x0c^mCg\x12\xa8q'
 b'i\x07\x10\x95\x86A\xb3\x0b\xec?0\xb1z>\xc81\xc8\x0c!\xfd\xd9\x13\xec?\xecGo4'
 b'\xb2\x1d\xa8\\\xc1\xc2\xac\xd0\xd2?z>k\xe7\x0f"r~]\xc8\x9d\xac\xeb?'
 b'\x15\x8e\x07H+<\xe4\x88\xfe8\x04t\xef?\xb8\xdaV\x7fp\x8d\x84\x0ej\xeb'
 b'\x92Z*\x13\xab?U\xdd\x10\xba\x98\xa7\xc0G\x07i\xff\x1d\xca\xbf0\xa4\x03\xad'
 b'\x8c\xf0\xbd?\xa4\t\x99\xab[J\xdf\xbf')

{'A1': [{'B1': -20176, 'B2': 835206778, 'B3': 0.8774232810905227},
        {'B1': 18412, 'B2': 498218095, 'B3': 0.2939865018756316},
        {'B1': 15994, 'B2': 571467627, 'B3': 0.8648213303931256},
        {'B1': -29163, 'B2': 1009469447, 'B3': 0.9829121697587451}],
 'A2': [2136398520, 243567984],
 'A3': 2712841166,
 'A4': 0.8526181043037284,
 'A5': {'C1': 106, 'C2': -21},
 'A6': {'D1': [321542802, -581615701, -1483163120],
        'D2': [-0.20404045704213836, 0.1169517443082817, -0.48891345746610626],
        'D3': [62925, 21825, 44511, 42320, 3095, 27998, 26435],
        'D4': 43026,
        'D5': 113,
        'D6': 1897},
 'A7': 0.876428249339968}

Вариант №37

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

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

(b'\x08TUY\xb75\x16s\x00\x02\x00C?\xec\xed\xe31\x06\x05\x88\x00\x00\x00Z'
 b'\xc3Z\xa5\x7f9\x1f(\xfe4\xc1Bmg\x00\x02\x00\x00\x00#\xf4\xb3\x0b\xe1\x05'
 b'\x00\x8enbu\x00\x02\x00\x00\x003}7\xa5\xbc\x0b\x07\xb7v\x00%\x005]'
 b'\xe8H\xec\xeaj\xac*\xff\xd0\x8b\xd3[\x7f\xa65\x83\xabw\x00\x00'
 b'\x00\x02\x00\x00\x00G\x00\x00\x00I\xfd\xcfh\xd7\xee\xde\xff\xda')

{'A1': -1221257613,
 'A2': [{'B1': 'mg', 'B2': 17632450027165093486},
        {'B1': 'bu', 'B2': 9022862605517567862}],
 'A3': 0.9040389974108374,
 'A4': {'C1': [93, 232],
        'C2': {'D1': 72, 'D2': [-1375169448519937909, -3216837156986967177]},
        'C3': 18288951888409722842},
 'A5': [-61, 90, -91, 127, 57, 31, 40, -2],
 'A6': 13505,
 'A7': 66}

(b"\x08TUYe\xd7\xf4\x88\x00\x02\x00C\xbf\xc2\xbc\xaa\xa2'\x97\xc8\x00\x00\x00`"
 b'\x90\x85\xbc\x8a-.\xd1\xf4\xc86\xe7tx\x00\x02\x00\x00\x00#\x964\t\xd8\xe9'
 b'b\xd9\x04cw\x00\x02\x00\x00\x003\x915\x88\x95(\xeby\xca\x00%\x005\x84'
 b'\xb4\n};\xd1\xc8\xbd\x85\x19x\xa8\x9d\xba5k\x9f\xe7\xe8\x11\xa4\x9bR?\xb8'
 b'\x00\x00\x00\x08\x00\x00\x00G\x00\x00\x00O\xba\x97\x95\xf9vm\x16~')

{'A1': 1708651656,
 'A2': [{'B1': 'tx', 'B2': 10823286631711299844},
        {'B1': 'cw', 'B2': 10463419483483240906}],
 'A3': -0.14638264577587123,
 'A4': {'C1': [132, 180, 10, 125, 59, 209, 200, 189],
        'C2': {'D1': -123, 'D2': [1835402243540872095, -1736118257673158728]},
        'C3': 13445380111204161150},
 'A5': [-112, -123, -68, -118, 45, 46, -47, -12],
 'A6': 51254,
 'A7': -25}

Вариант №38

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

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

(b'YDZ\x1a\xbf+\x80O\x00\x00\x00\x13\x00\x00\x00\x02\x00\x89\xbfew\xf7H\x83'
 b'^\\\x1c\x97\x98u\x03\xbb\xdb\x86\xfc\xe4\xa1+\x01D\xf1\xcb\x91F\xdb\x95y\xb7'
 b'\xf4\xb0cCk=|\xe2\x95\x8dJ?A\xd7[\xbe\xb9\xbbi\x00\x1d\x00\x00\x00'
 b'\x02\x00\x00\x00;Hg\xa7\x1cS\x1c\xca\xce\x8abE\xc1\xa1i/;\xccL\r'
 b'\x8e\x18\xad\xbc\x1b\xd5U\x02\x1f\xe4M\xf1\x87\xe03?*$\x11\xbe\xeeOm\xbe'
 b'..\x95\x00Q\x00\x00\x00\x03\x00\x00\x00o\xe1\n2\x0c\x00\x00\x00C\x00\x00\x00'
 b'{')

{'A1': -0.6699265837669373,
 'A2': {'B1': 'ew', 'B2': 17818636366986909592},
 'A3': [{'C1': {'D1': 1963178971,
                'D2': [-30980, -7007, 11009],
                'D3': [17649, 52113, 18139, 38265, 47092, 45155, 17259, 15740],
                'D4': 3801451850},
         'C2': [0.7571923136711121, -0.36275795102119446],
         'C3': 1214752540},
        {'C1': {'D1': 1394395854,
                'D2': [-30110, 17857, -24215],
                'D3': [12091, 52300, 3470, 6317, 48155, 54613, 543, 58445],
                'D4': 4052213811},
         'C2': [0.6646128296852112, -0.465449720621109, -0.17009957134723663],
         'C3': -519425524}],
 'A4': 191}

(b'YDZ\x1a>\xacT\x95\x00\x00\x00\x13\x00\x00\x00\x02\x00\x8diuy\xf7\xa8\xc1'
 b'\xf0\x9a\x90\xed\x85C\x0e\xd1\xc7v&^[)\xbbf\x9d\xf0NMj\x17\x1f)\xafZ\x1dK'
 b'\xe9\xba\x9dE\x9b@:\xbe\xc5z\x8e\xbfgT\x96\xbfm`A\x00\x1d\x00\x00\x00'
 b'\x03\x00\x00\x00;Q\xdb\xbce5c\xaa\xfe\x04\x93\x12+S\xd3J\x95`\x9d\xa7'
 b'\xa1\xed\xc1)yB\xb9\x1b\xb8\x9dxu\xcel\x9a\xbd\xbc\xec<\xbf\x1e\x03\x9b\xbc'
 b'\r\x8c\x11\x00U\x00\x00\x00\x03\x00\x00\x00s\r:V\x1c\x00\x00\x00'
 b'G\x00\x00\x00\x7f')

{'A1': 0.33658280968666077,
 'A2': {'B1': 'uy', 'B2': 17845726762585091461},
 'A3': [{'C1': {'D1': 1125044679,
                'D2': [30246, 24155, 10683],
                'D3': [26269, 61518, 19818, 5919, 10671, 23069, 19433, 47773],
                'D4': 1167802426},
         'C2': [-0.38570064306259155, -0.9036344289779663, -0.9272499680519104],
         'C3': 1373355109},
        {'C1': {'D1': 895724286,
                'D2': [1171, 4651, 21459],
                'D3': [19093, 24733, 42913, 60865, 10617, 17081, 7096, 40312],
                'D4': 1976462490},
         'C2': [-0.09224745631217957,
                -0.6172425150871277,
                -0.008639351464807987],
         'C3': 221926940}],
 'A4': 105}

Вариант №39

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

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

(b'LZXY\x95c\x87\xc3\x13S\x00\x00\x00_\x00\x00\x00k\x00\x00\x00w\x00\x00'
 b'\x00AQ\x07q\xb0\xf2\x86\xa5\x10=QmM\xc2i\xd3.\x03%sbB\xe2\x0c)\xa5\x07'
 b"\x00\x00\x00\x83\x00\xa4?*nX\x01\xd5\x82?'\xdau\x0eE\xafg7\xc6%"
 b'\x03\xeb\xbc\x91\x00\x00\x00.\x15l\xa2\xe3\xd7\xeb?\xda\x98=>t\x8d\xa5\xfaI'
 b'S\xe8\xbf\x9f\x07Q?\x9cz\xb8\x88\xb5\x9b\xd7?\xbaq\xd1=\x14\xe5\x99\x92>'
 b'\xd3\xe4?\xc6\xca\x8d>\xe9q\xaa\xc6\xa8d]\xcf\xff\x85OO\xfa\xb6\n\x9d\x95'
 b'\xcb\xa8C\xec?,\x8de\xea\xa4=&\r\xbb"B\xbd\xd8"\twG8')

{'A1': {'B1': 331581283,
        'B2': [{'C1': 0.8701036617573317, 'C2': 0.18515339493751526},
               {'C1': -0.7601671119158895, 'C2': 0.8165225386619568},
               {'C1': 0.368878730312568, 'C2': 0.10226769745349884},
               {'C1': 0.6507866729072327, 'C2': 0.27693766355514526}],
        'B3': [20801, 28935, -3408, -23162, 15632],
        'B4': [229353082227354961, -6545686417490414811],
        'B5': [29161, 50858, 25768, 53085, 34303, 20303, 46842]},
 'A2': 1848262564,
 'A3': 88,
 'A4': 1065538817,
 'A5': 242604583,
 'A6': 16934420557106491205,
 'A7': -68,
 'A8': {'D1': 0.8832591987856244,
        'D2': 36140,
        'D3': 0.08052519708871841,
        'D4': 582683942,
        'D5': 4055340870593461570}}

(b'LZXY\x95\xda\xd9\xcb\xa2S\x00\x00\x00_\x00\x00\x00k\x00\x00\x00w\x00\x00'
 b'\x00\x18X\x08\\!\xf7\xe5Y\xbc\\\xfa\x9dIwj\x83~qi\xb0\xd5\xa5\x00'
 b'\x94M\xc0\x06\x00\x00\x00\x83\x00GdZ\x94\xc9\xd9\x0b"\xe8\xacv\r\x08u\x87'
 b')1\x1f\xc4\x8f\x9dk\x8f\x00\x00\x00r:\xd8\x8b,\n\xe4\xbf\xe8\x9c(\xbf\xd0'
 b'$\x1d)#\xff\xe2\xbf\xbe\x15X?\x86M\xca\xadz*\xed\xbf25\x99\xbb\xc4'
 b'\xc8W\x8c\x8eg\xd4?~\xe6\xb4>\xdf\xd6-\x8e\x90\x07\xc5\x98\xa2#\x9cO@$T8\xd4'
 b'\xce\xd9?\xe2\xe4v\xf9K\xbf\x17\x1d\xc1"M\nM2S0>\x8b')

{'A1': {'B1': -1563698726,
        'B2': [{'C1': -0.6262419444409046, 'C2': -0.6586441993713379},
               {'C1': -0.5936446955685373, 'C2': 0.8440817594528198},
               {'C1': -0.9114354509678584, 'C2': -0.004675530828535557},
               {'C1': 0.3188206072365001, 'C2': 0.35332101583480835}],
        'B3': [22552, 23560, -2271, 23013, 23740],
        'B4': [8178118466642484730, -4589849714717511575],
        'B5': [55007, 36397, 1936, 39109, 9122, 20380]},
 'A2': -1806015417,
 'A3': 201,
 'A4': 3894545369,
 'A5': 135100076,
 'A6': 11353508823872145269,
 'A7': 107,
 'A8': {'D1': 0.4032488393864391,
        'D2': 58594,
        'D3': -0.796775221824646,
        'D4': 583081239,
        'D5': -8413233919997179315}}

Вариант №40

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

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

(b'UFP?-H\xacnqkxavsw\xc7\x00!?\x15\x14v\x06\x0f\xd6\xf4v\x00\x03\x00\x00\x00'
 b'FP>\xac\x96=\xb9Zz\xa6\xeaRc\x8f\x14\x85\xb3\xcaY\xe8-\xcf^ 0i\x8cR'
 b'\xc3\x8a\xfa7\xb8\x04p<\xe53\x00\x05\x00\x00\x00&\x00\x00\x00\x03\x00+\x88Q'
 b"[\x0b\xa4\xda\x8d\xb5\x00\x05\x00\x00\x001\x00\x00\x00\x02\x006\xb1'"
 b'\x1fX8\x1b6M\x00\x06\x00\x00\x00:\x00\x00\x00\x03\x00@\xbf\x99\xf8g\x1cd'
 b'\xcdS')

{'A1': 0.6768901348114014,
 'A2': 'nqkxavsw',
 'A3': {'B1': -57,
        'B2': {'C1': 80, 'C2': 0.33708372712135315},
        'B3': 0.5823434591293335,
        'B4': 101701364,
        'B5': 118,
        'B6': [{'D1': [185, 90, 122, 166, 234],
                'D2': [21091, -28908, -31309],
                'D3': 9822732367840316853},
               {'D1': [202, 89, 232, 45, 207],
                'D2': [24096, 12393],
                'D3': 12765206132563850829},
               {'D1': [140, 82, 195, 138, 250, 55],
                'D2': [-18428, 28732, -6861],
                'D3': 13806339254422654291}]}}

(b'UFP?V\xa5\xebrqwbljhi\x90\x00!=gM\xe3\xe4v\xa5\x89\x1b\x00\x03\x00\x00\x00'
 b'B\xeb\xbf \x85\xcf\xca<\x02\xab\xc7\xa3\x9d\xf2\xa3+=\x96<\xa3m\xf8\xa3\x7f'
 b'\x05\xb4\xf1\xe3\xbd\xcd\xb9\xbf\xd3\xa6\x00\x06\x00\x00\x00&'
 b'\x00\x00\x00\x03\x00,N\xe2\x93\xbe\x96\xf2\xa2\xb7\x00\x03\x00\x00\x002'
 b'\x00\x00\x00\x02\x005i\xc0\x98\xf0\xd5\xbdb\xff\x00\x03\x00\x00\x009'
 b'\x00\x00\x00\x03\x00<c\xc4\x80=rA|]')

{'A1': 0.8384692072868347,
 'A2': 'rqwbljhi',
 'A3': {'B1': -112,
        'B2': {'C1': 235, 'C2': -0.627041757106781},
        'B3': 0.05647076293826103,
        'B4': 3832980873,
        'B5': 27,
        'B6': [{'D1': [202, 60, 2, 171, 199, 163],
                'D2': [-25102, -23765, 15766],
                'D3': 5684268126480540343},
               {'D1': [60, 163, 109],
                'D2': [-1885, 32517],
                'D3': 7620258729656410879},
               {'D1': [180, 241, 227],
                'D2': [-16947, -17985, -11354],
                'D3': 7189011906588408925}]}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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