ИНБО-05-22

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

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

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

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

Поле	Описание
1	Массив структур D, размер 8
2	uint16

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

(b'QGZ\t\xa4\x1aR\x00\x00\x00\xde(\rj>\xdf\x98\x88\x7f\x84\x95\x0c\xb6R'
 b'g\xfbT\xd1\xc0\xd9rs\xd1\xfe\x0c\xc8\xc0\x8d\x8f\xcb$\xd9\xeeIlmwreg)\xe2'
 b'\xea>\xc3~\xbd\xbdq\xd0\xd6\xbe\xa3\x0fS?\x10\xea(\xbe\xc9HjMQ\xd3H\x99\t)'
 b"\xb6\xb6i\xcc\xa9'\xa6\xc0E\xd5\n\x00\xd7\x06\x00,\x00\x05\x00\x00"
 b'\x002\x00\x00\x00\x0bD\xab\xbc\x03\x00\x00\x00F\x00\x00\x00')

{'A1': 6820,
 'A2': {'B1': -3078842950375322519,
        'B2': {'C1': [{'D1': 10462, 'D2': 13, 'D3': 106},
                      {'D1': 57150, 'D2': -104, 'D3': -120},
                      {'D1': 33919, 'D2': -107, 'D3': 12},
                      {'D1': 21174, 'D2': 103, 'D3': -5},
                      {'D1': 53588, 'D2': -64, 'D3': -39},
                      {'D1': 29554, 'D2': -47, 'D3': -2},
                      {'D1': 51212, 'D2': -64, 'D3': -115},
                      {'D1': 52111, 'D2': 36, 'D3': -39}],
               'C2': 18926},
        'B3': -41,
        'B4': 'lmwreg',
        'B5': [0.4587567150592804,
               -0.09252693504095078,
               -0.4195590317249298,
               0.8244573473930359,
               -0.16495537757873535],
        'B6': -0.020906468853354454,
        'B7': [1298811081, 2571686737, 3065391369]}}

(b'QGZ\ty*A\x00\x00\x00Z\xbf\xae\r\xf4\x00-1\xc2\xf9\xe6u\xb3\x8eV\xb3lf,!\x8dr'
 b'\x95}\x9c\x9b\x00q\x03\x10\x96 \xa6Hwdcco\xbcA\x87\xbd\xde\x8e\xac'
 b'>\xa0\xe6\xfb\xb8\xe8\x8d\xaf\x18\xe3x\xf1b\x83Wv\x91\n\x00U\x05\x00,\x00'
 b'\x02\x00\x00\x001\x00\x00\x00G\x86h=\x02\x00\x00\x009\x00\x00\x00')

{'A1': 10873,
 'A2': {'B1': -7965082669145818909,
        'B2': {'C1': [{'D1': 48986, 'D2': -82, 'D3': 13},
                      {'D1': 244, 'D2': 45, 'D3': 49},
                      {'D1': 63938, 'D2': -26, 'D3': 117},
                      {'D1': 36531, 'D2': 86, 'D3': -77},
                      {'D1': 26220, 'D2': 44, 'D3': 33},
                      {'D1': 29325, 'D2': -107, 'D3': 125},
                      {'D1': 39836, 'D2': 0, 'D3': 113},
                      {'D1': 4099, 'D2': -106, 'D3': 32}],
               'C2': 18598},
        'B3': 85,
        'B4': 'wdcco',
        'B5': [-0.06604334712028503, 0.33702749013900757],
        'B6': 0.05676868185400963,
        'B7': [3103516320, 414158312]}}

Вариант №2

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

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

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

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

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

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

(b'*STTUmaoqe\x03\x00\x00\x00\x8e\x00\x00\x00\x10\x9eW\x08\x00\x00'
 b'\x00\x9a\x00\x00\x00L\t\xc2\xca\x14\x18\xc3\xfe\x950\xefY\x8b\x8f.'
 b'\xa3\xca\xd8\x9b\xd8d\xe8\xd1\x91+\x00\x00\x00\xf6E!\x1c\x04\xe5p\t\x955\xc4'
 b'\xac\xa7E$n\xb5}\xea\xd0_\xac&\xa0q\x11Fp\x12L\x00\x00\x00\xba\xc3E\x97\xe1v'
 b'\xb5\x02U*\x95\xb8\xe8\xad\xees\x8f\x01\x0cC\x1cG=}\n\x7f\xe6k\xb5m'
 b"\x00\x00\x00V\x110'\xb6\x99\x96\xf3y\xd0q=\xfb\x10K\xb1\xfb\xb3\x145\x00"
 b'\x00\x00V\x00\x00\x00w\x00\x00\x00Qv\x1a\xe0\x94\x00\xa2\x94')

{'A1': 'maoqe',
 'A2': [{'B1': {'C1': -1700996595370515666, 'C2': 37329},
         'B2': [-10, 69, 33],
         'B3': 14138370472980841500,
         'B4': -1549883212086007892},
        {'B1': {'C1': 5048941589916573648, 'C2': 4720},
         'B2': [-70, -61, 69],
         'B3': 10748496930795872663,
         'B4': 865130331520231608},
        {'B1': {'C1': -1837738589928612797, 'C2': 46443},
         'B2': [86, 17, 48],
         'B3': 8201189008552343079,
         'B4': 1491812640476953405}],
 'A3': 40464,
 'A4': 87,
 'A5': [81, 118, 26, 224, 148, 0, 162, 148],
 'A6': -893253300,
 'A7': {'D1': 4274198548, 'D2': 1508847765},
 'A8': -28789}

(b'*STTUgakpl\x02\x00\x00\x00m\x00\x00\x00\x9eh\x89\x04\x00\x00\x00u\x00\x00'
 b'\x00A\xd4\\\xc0\xd8jP\xef\xd3\xe5R\xce\xe9\xa8\xd7P\x0c\xeav\xd3P\xd3T'
 b'\xb7+\x00\x00\x00\x9a\xd0r\x9cz\x80\xcf\xbb\x85\xec\x82\xad\xe8mY8hM\xca'
 b'\x9c\xd2\x1a<&\xbd\xe2\x0c%1L\x00\x00\x00\x15\xf21\x854\xc5\xe7\xe4\xf1l'
 b'\x19\x1a\x1cz\xce\r\x05\x96\xb55\x00\x00\x00V\x00\x00\x00\xb5\xb2\x07\xaf')

{'A1': 'gakpl',
 'A2': [{'B1': {'C1': -3219841225883627305, 'C2': 46932},
         'B2': [-102, -48, 114],
         'B3': 9434062361121028764,
         'B4': -3869321913613555539},
        {'B1': {'C1': 928512445106541212, 'C2': 12581},
         'B2': [21, -14, 49],
         'B3': 1832105113876247685,
         'B4': -5362092749481173990}],
 'A3': 26782,
 'A4': -119,
 'A5': [181, 178, 7, 175],
 'A6': -1067658175,
 'A7': {'D1': 4015024856, 'D2': 3461539283},
 'A8': -22295}

Вариант №3

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

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

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

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

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

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

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

(b'%KCA\x18\x00\x00\x00D\x1e}(^\x1a\xd4\xbfp\xb83[\x8e\x00\x00\x00\x0f\xcb0\xb0'
 b'-\xd6/?d\xba\xbfE\xf2\xe1\xee\xbf\xa0\xdf\x91\xbf\xf6I\xbc?\xff\n\xe6\x10'
 b"'p\xa7\x8c\x1c~\\& 'f\x11\x038\xcd|\xf5\xd3\rz\xbf\x02\x00\x00\x00 \x00\xd7"
 b'x\xd9\x0f\xa7(t\xf2\xb5\xe9\r\xcc\xbf\xbeImm\xd13\xe6?\x04\x9e\xec\x81'
 b'\n[\xb6u\xcb\xefx\x95,\xbc*/i\x8esl\x7f\xbb s?\x02\x00\x00\x00T\x00=d\xa6,"'
 b'0\x00Vd\x00\x9cJ?+\xbfNpY^\xa0E\xca\x07p\x1c\xa0\xdfif\xb6\xbfo\xc6'
 b'{\xe6\xda\x05\xbf\xd1\x02\x00\x88\x00\x00\x00')

{'A1': {'B1': 2955987727, 'B2': 0.6868618130683899},
 'A2': -0.314109363117016,
 'A3': 1530116208,
 'A4': {'C1': -0.6689344644546509,
        'C2': 561337658641051726,
        'C3': -0.08750020703893013,
        'C4': 15113805312206554735,
        'C5': [{'D1': {'E1': 10135192799510137599,
                       'E2': [28, 126, 92, 38, 32],
                       'E3': 51471911,
                       'E4': 4118596920,
                       'E5': -0.9767734408378601,
                       'E6': [-0.9650813448223059, 0.11050359894750139],
                       'E7': [-41, 120, -39, 15, -89]},
                'D2': 86},
               {'D1': {'E1': 8482067048886476292,
                       'E2': [203, 239, 120, 149, 44],
                       'E3': 1764698812,
                       'E4': 2137813902,
                       'E5': 0.949718177318573,
                       'E6': [-0.2191745890058041, 0.693825448727061],
                       'E7': [61, 100, -90, 44, 34]},
                'D2': 156}]}}

(b'%KCA\x18\x00\x00\x00D\x12j\xe2\x82_\xef?\xb4_\xb7q\x8e\x00\x00\x00'
 b'\xe38\x8e\\:N\xaf\xbe\x92\xc0K\x7f\xf1\xd5\xe3\xbf\xc0\x81\xd4\xd4'
 b'\x81\xd4\xc7\xbf3:Va\xa3K\xe8\x98\xbeK$\x9f\xc3\xf2\x1e\x0f\xd7l\xf5\x1e'
 b'\xe4\x9d\x82\xab\xbe\x02\x00\x00\x00 \x00xXE\xe6G^\x83\x00\xd2\xc4\xe7\xe4?'
 b'\x1c\xc7\xf9\xe0\xc6\xf0\xec\xbf\xce\x0e\x9c\xdb]n\xecD\xeboO\x99'
 b'\xa1\xe7\xfa7\n\x15V\x94\x0ffV\n?\x02\x00\x00\x00T\x00e\x91Pe\xe60\x00Nd'
 b'\x002:I&>\xd6-\r~e\xd0\x97\xdd\x9e\x90\x1d{\x1d\x94\xed\xbf\xbe\x82'
 b'l\xb8I\x19\x8c\xa5\x02\x00\x88\x00\x00\x00')

{'A1': {'B1': 1552824547, 'B2': -0.342393696308136},
 'A2': 0.9804090902476408,
 'A3': 1907842996,
 'A4': {'C1': 0.16238871216773987,
        'C2': -2479283935519101482,
        'C3': -0.9243304638480543,
        'C4': 11928937317415027390,
        'C5': [{'D1': {'E1': 11018139653446711859,
                       'E2': [190, 75, 36, 159, 195],
                       'E3': -686874894,
                       'E4': 3827234156,
                       'E5': -0.33498087525367737,
                       'E6': [-0.6198661314247309, -0.18617270366759264],
                       'E7': [120, 88, 69, -26, 71]},
                'D2': 78},
               {'D1': {'E1': 4966465838478266062,
                       'E2': [235, 111, 79, 153, 161],
                       'E3': 171440871,
                       'E4': 261379605,
                       'E5': 0.5403808355331421,
                       'E6': [0.6532920934297228, -0.9043917078072101],
                       'E7': [101, -111, 80, 101, -26]},
                'D2': 50}]}}

Вариант №4

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

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

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

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

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

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

(b'\xf2TXN\x02\x002\x00\xbew\x80z\xf8\x8c\x8c\xf9\xfe\xc9\xad\xb3\x03\x00X\x00'
 b'\x00\x00hhb\x82\xa8\xcb\xc9U\x14~\xfa*\x980\xf8Up\x17\x0b\x08\x83R\xe8?jy'
 b'\x8c\x9f%`T|\x94!\xdd\xb0\x8c\x0e\xa3\x8e\x07,\xb1ZGa\x078\x19q\x11\xaaA\xef'
 b'\xadl\xf8\xca.Y\x8c\xb24\x00\x00\x00@\x00\x00\x00L\x00\x00\x00')

{'A1': 'jy',
 'A2': 2055239614,
 'A3': -29448,
 'A4': 140,
 'A5': {'B1': 249,
        'B2': 3014511102,
        'B3': [{'C1': 2419695601636974476, 'C2': 244101341},
               {'C1': 7009671062019870371, 'C2': 1897478151},
               {'C1': 14625559284184885777, 'C2': -1299424978}]},
 'A6': 'hhb',
 'A7': {'D1': [3385567362, 4202566741, 4163934250],
        'D2': 85,
        'D3': 0.7600722462745875}}

(b'\xf2TXN\x03\x002\x00f\x1c6\xf4\xbeQ\xca\x1f\x9b\xfb3#\x08\x00\x95\x00'
 b'\x00\x00axs\xc3V1\x93\xec.|\xbd\xe3\xc2\xd3Y!d\xfc\x94\xbd\xcb\x80\xd8?uq'
 b"h\t'\x87Sm\xdb\x7f\xe7\x81W\x94(\x07\x08\x93'\x1cj\x18W#\xe2E"
 b'\xd8\xf3\xe3\xb0\xc1[ \xa0W#\x96\xa1\xf7\xe5i\xf8\xeeAJ\xec\xff\xeb\xa7\xd7'
 b'P\xd2\xe8Gv\x13\xb9\xdfd9\xf8\xab\x17\xeb\xa4X\x02\x0c=\xf5\x9fi\xfa\xff'
 b'\x00n\x87\x875\xb3\xbcc\x0c\xcf\x17\xb5V\xa3\xb9\xe1\x02i\xdb\x8b'
 b'\xfb\xcd\xfbI\xf35\x00\x00\x00A\x00\x00\x00M\x00\x00\x00Y\x00\x00'
 b'\x00e\x00\x00\x00q\x00\x00\x00}\x00\x00\x00\x89\x00\x00\x00')

{'A1': 'uqh',
 'A2': -197780378,
 'A3': 20926,
 'A4': 202,
 'A5': {'B1': 31,
        'B2': 590609307,
        'B3': [{'C1': 16681292807402891017, 'C2': 680810369},
               {'C1': 6275882749896361991, 'C2': -666508765},
               {'C1': 6314082256037143539, 'C2': -140405213},
               {'C1': 18441196221217925605, 'C2': 1356310507},
               {'C1': 7268731816839211218, 'C2': 397146169},
               {'C1': 11526185943112918251, 'C2': 16775785},
               {'C1': 892764629032732526, 'C2': 1454708687},
               {'C1': 18125822369349089699, 'C2': -213255219}]},
 'A6': 'axs',
 'A7': {'D1': [2469484227, 3179032300, 1507050211],
        'D2': 33,
        'D3': 0.38286107553353177}}

Вариант №5

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

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

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

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

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

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

(b'GBWG\x82S\xe6\x02\x00\x00\x00\x7f\x00\x00\x00.\xdf\xb3\x8f\xea?\xea\xb9\x02'
 b'\x00\x87\x00\x00\x00l\x1b\xb6+\xd1D\xa3\x0c\x02\xb7\xec"\x87\x13\x1c'
 b'\x00\xc6`\xb8\xa6\x983\xbf\x97=\x12\xb2\xcb\x9cP?\x04\x00\x1f\x00'
 b"\x00\x00b\x1d_`\x91q\x02\x00'\x00\x00\x00z\x13\xd1kI\xbang\x94\xdb"
 b'\xe7\x95\xb2\x1d\x12\xf1\xc1\x1b\xdb\xf3\xf5e\xbf|\x9b\xfb%\xd7\x02e'
 b'?\x04\x00N\x00\x00\x00\x12\x8a\x0b\x98!!\x03\x00V\x00\x00\x00+\x00\x00\x00\\'
 b'\x00\x00\x00\xeeV\xfa\x8c\xff\xfa\xef\xbf\x04T\xe5\xc1\x80\xeb\xda?')

{'A1': 58963,
 'A2': [{'B1': {'C1': 28, 'C2': -14848},
         'B2': -18336,
         'B3': -0.7015479803085327,
         'B4': -1307427433,
         'B5': {'D1': 0.8148924708366394,
                'D2': [11190, 17617, 3235, 46850],
                'D3': 7522,
                'D4': 1905352799,
                'D5': [8940, 4999]}},
        {'B1': {'C1': 18, 'C2': -15887},
         'B2': -9445,
         'B3': -0.8982841372489929,
         'B4': 637246332,
         'B5': {'D1': 0.8945745825767517,
                'D2': [4986, 27601, 47689, 26478],
                'D3': 35346,
                'D4': 555849739,
                'D5': [56212, 38375, 7602]}}],
 'A3': 13396590318232788782,
 'A4': [-0.9993894341921228, 0.420623959876423],
 'A5': 7020}

(b'GBWG\x82e\xa5\x02\x00\x00\x00\x95\x00\x00\x00\xab\xca\x05\xd9\xabL5\x08\x04'
 b'\x00\x9d\x00\x00\x00H, \x95+7\x18f\xbb\x9b>\x0b\xb4\t\xdb\x19Z\xb4\xde'
 b'\xe3P\xba&\x87\x84\x86U\x7f7W\xc8\x1b\xbc%\xc7\xad\xbb\x13\x83'
 b"\x07\xb7\x19\xd8\x00\xbe\x05\x00\x1f\x00\x00\x00\xd6'\xe0\xba"
 b'\x19\x06\x08\x00)\x00\x00\x00Y\x07\x14)\x84$2s\x18\xa5\x0e\xe2\xfe\xd9D\xf3'
 b'm:\x80b\xc1\xa1\x94\x1a\xb1,\x1e\x15\x92\x1c>L\xe5\x1b\x1c\xcc=0\xbe\x03'
 b'\x00\\\x00\x00\x00\xb3\x87Z\x9e\xfe1\x08\x00b\x00\x00\x009\x00\x00'
 b'\x00r\x00\x00\x00\xf6"\xb6\x90lW\xe0\xbf\x88 /&\xe4G\xdb?\xd0`\xf5H\xd6L\xc1'
 b'?\x10\xa1\xe1oT+\xe0\xbf')

{'A1': 42341,
 'A2': [{'B1': {'C1': 55, 'C2': -14249},
         'B2': -17381,
         'B3': -0.005303280893713236,
         'B4': -1224244461,
         'B5': {'D1': -0.12582434713840485,
                'D2': [38176, 14123, 26136, 39867, 2878],
                'D3': 10198,
                'D4': 102349536,
                'D5': [2484, 6619, 46170, 58334, 47696, 34598, 34436, 32597]}},
        {'B1': {'C1': 148, 'C2': -20198},
         'B2': 7724,
         'B3': 0.15290100872516632,
         'B4': 471590220,
         'B5': {'D1': -0.17211073637008667,
                'D2': [1881, 10516, 9348],
                'D3': 34739,
                'D4': 838770266,
                'D5': [29490,
                       42264,
                       57870,
                       55806,
                       62276,
                       14957,
                       25216,
                       41409]}}],
 'A3': 591463227033242283,
 'A4': [-0.5106718851467054,
        0.4262628910914903,
        0.13515738069941685,
        -0.5052892861540688],
 'A5': 11336}

Вариант №6

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

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

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

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

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

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

(b'VJIU\xe6\nzsdot[\x00D\xf5I\x05\xae-\xfd\xc2.\x86\xce\xec\x0f\xdb\x08'
 b'\x10O\x0c\xe0\xc9\x84\xfb\xd6\xb4\xba\x8a\x15\xbc\xb7\x127\\v_\xc6n\xd6!\x84'
 b'\x9d\x87^y\xaf\xbb,\xd5\xbe\xe8z\xb6\xad+\x06:\xb9\x83Zb\x0f\x00"\x00'
 b'5\x00\xf8\xc5\x81a\x15[\xb9\x9b\x1a\xcb\xbb\x82:\x03\x00H\x00\x93\x80P\xbf@'
 b'\x96\xfd=\x17_\xed>\xd5\xe59?\xe6mu=\xac\x146\xbf\xfc\x82\x1a\xbe\xef'
 b'\x13\x1c?N\x00\x00\x00{\xb2P\xe2\xb2>0\xc5[Hk\xb2.U\x9e\xea\xe9'
 b'\xd6\xe6\x01\x9bS\x07\x8d<N\xe0\xea\x14\x93\xd0\x88q\xae\xea\xa3\x9f:Nw\x83'
 b'l\xfe')

{'A1': 2790,
 'A2': 'zsdot',
 'A3': {'B1': [{'C1': [73, 5, 174],
                'C2': 1147519080778104109,
                'C3': 9568425226796009691},
               {'C1': [251, 214, 180],
                'C2': 6644800355552299706,
                'C3': 11350234165745704822},
               {'C1': [135, 94, 121],
                'C2': 13149077968379493295,
                'C3': 7087121795186568109}],
        'B2': [-0.814461886882782,
               0.12382173538208008,
               0.46361610293388367,
               0.7261632084846497,
               0.05991926044225693,
               -0.7112529277801514,
               -0.1508902907371521,
               0.6096791625022888],
        'B3': {'D1': 1635894776, 'D2': 9420346360717728533, 'D3': 58},
        'B4': 123,
        'B5': 6612744673710723250,
        'B6': 27464,
        'B7': [16633739467627507378,
               16162922689090263809,
               16910578483251582186,
               18333172731555258275]},
 'A4': 62788}

(b'VJIUQ7atfkxF\x00@\x00tP \xa3\xdf\xc6\xfbH1eP\xeatC\xce\xb4\xcb\xf6|\x9dd'
 b'\x83\xbf\x9c\xadt\xa6$\xd2\xa3YR.\x17Y\xf7b2\x0f\x00"\x00\xf9\x86\xa5'
 b'\xde\xffs\xb8O\x15\xb5(B\xf2\x02\x005\x00[\x9d\xf2>\x83\x03C\xbe\x0b\xc9'
 b'\xf4\xbe\x91\x051\xbf\xc61\xd8\xbeL\xedD\xbf\xbc\xb7\x1e<u\xda\xac>9\x00'
 b'\x00\x00\x0f2\xaf|Z\x96Hl5\xd4\xbc\xbd\xd3|\xfa\x1c\xf1\xf4D\xe7w\x00'
 b'\xcc\xd1\x9e2A\xc8\xae\xe8\xb1DFyG\xb6\rN\x15\x90\x12)\x16')

{'A1': 14161,
 'A2': 'atfkx',
 'A3': {'B1': [{'C1': [116, 80, 32],
                'C2': 5793090685213532067,
                'C3': 9004608482388964586},
               {'C1': [157, 100, 131],
                'C2': 11804537870632197311,
                'C3': 3630736211627102809}],
        'B2': [0.47385677695274353,
               -0.19044308364391327,
               -0.4780963361263275,
               -0.6914911866188049,
               -0.422254741191864,
               -0.7692458629608154,
               0.009687360376119614,
               0.33760419487953186],
        'B3': {'D1': 3735389945, 'D2': 4767259308708099071, 'D3': -14},
        'B4': 15,
        'B5': 3849531592095346482,
        'B6': -17196,
        'B7': [4968861395660362685,
               4697991985208784871,
               5150224909731409608,
               1596827952921578934]},
 'A4': 64}

Вариант №7

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

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

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

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

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

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

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

(b'DHR\x13\xe9}\x00\x00\x00\x8c\xbf\xa1\xe2A\xe4#\xe8\xe0\xfc\x88\x96R\xe2\xed'
 b'\xd1\xb6\xbf\xc0\x9f\xbb\x01\x10\xef\xa0\x1e\xea\xeb\xb3\xcd\x83'
 b's\xdf\xf6\x84=\x0f\tGDqk\xdb\xef@\xc7\x01\\\xaey\xf0\x01\xac2\x91\xb1C\x8e='
 b'\x1b\xb1t\xc7>\xae\x00\xfc\x953,\xa8\x8e\x02b\xfb!\xd5\xf1\x9f\\,\xbe\x17'
 b'\xa5HP\xb1\xa6\x11$*\xcb[\x9b\xafQ*\x88\xf9\x89\x91\x02D\x04[t\xe21\x951\xae'
 b'}N=A\x07\xbb\xf6\xee\x93k\xe9\xc4\xd8\x1e\xac\xe6\x95\xeeuc\xa5\xe8\xdc\x00'
 b'\x00\x00\x04\x00Z\x00\x00\x00\x02\x00\x00\x00\x8a\xaa\xeeG6\xe67\xbeF-\xa4K'
 b'\x0c\x13\x95%KyT\x97\x1dEf\x13\xa90')

{'A1': -5763,
 'A2': {'B1': -23064,
        'B2': -36,
        'B3': [{'C1': 13697598521680700945, 'C2': 606784347},
               {'C1': 11218274439931726225, 'C2': 38011995},
               {'C1': 8422348769989655886, 'C2': 1027671995},
               {'C1': 17793321269480183838, 'C2': 2900792814}],
        'B4': 'uc',
        'B5': [170, 238, 71, 54, 230, 55, 190, 70],
        'B6': 3288836143127536971,
        'B7': 121,
        'B8': 6095372804571769136},
 'A3': {'D1': -0.0349293318740409,
        'D2': -249784496580341322,
        'D3': -0.12987458755548875,
        'D4': 2227852123167749087,
        'D5': -683354108664003471,
        'D6': 27611,
        'D7': [239, 64, 199, 1, 92, 174, 121, 240],
        'D8': 428},
 'A4': 3643888477226736561,
 'A5': 116,
 'A6': {'E1': 199,
        'E2': 0.3398512601852417,
        'E3': -27341,
        'E4': 749243906,
        'E5': 7132331637636815916}}

(b'DHR\x13\x11q\x00\x00\x00\x80?\xca5\x05\xf2\xd6\x98H\xfe\x0c]\xa2^\x9c'
 b"\xc0#?\xeb\xfdBS\x1b-b\x85\xc4Q'[\xf7M\x86\xa1\xa8]\x103g\x91\xb3\x1c\xb6"
 b'F\xce\xd6\xa7\xc0\xee\xad\xa8#\tR-\x9b\r\xda\x81;\n\xbb\x83>\x9cGs'
 b'\xda\x99:\xc0\xe5\xc3\xde\xb4&\xeb\xa1\xd9#mWC\xf0_\xcdSh\x8dM\x07A\x82Y\xd5'
 b'\x80\xc8qQ\x99Jv\x10>\xd3\x03\xa8@\xbe\xfd\xe1\x9c\xce\xc1\xd0(\xd9nq'
 b'L\x80\xb2\x00\x00\x00\x03\x00Z\x00\x00\x00\x02\x00\x00\x00~\x0c\x0f]'
 b'\x05N\x85\xab\xa8=E\x11%\xfc\x069\xc3\x04\x19PL{{\x87Bq')

{'A1': 4465,
 'A2': {'B1': 19584,
        'B2': -78,
        'B3': [{'C1': 6288133798996699277, 'C2': 1292321154},
               {'C1': 6473221637797943626, 'C2': 1980776147},
               {'C1': 263531767248559310, 'C2': 3251644633}],
        'B4': 'nq',
        'B5': [12, 15, 93, 5, 78, 133, 171, 168],
        'B6': 4414953864546367939,
        'B7': 4,
        'B8': 1824041942322201201},
 'A3': {'D1': 0.20474314076745004,
        'D2': -140634536401911773,
        'D3': 0.8746654151122295,
        'D4': 9638918331968212358,
        'D5': -6798081313352478285,
        'D6': 7350,
        'D7': [70, 206, 214, 167, 192, 238, 173, 168],
        'D8': 8969},
 'A4': 5921559568864852746,
 'A5': -69,
 'A6': {'E1': 131,
        'E2': 0.30523261427879333,
        'E3': -9575,
        'E4': 985720259,
        'E5': 16047494165702452077}}

Вариант №8

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

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

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

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

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

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

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

(b'STS\x00\x00\x00] \xc2pnl94D\x15\xe9\x82\xf9\x19G\x91\xd2f\xc2D\x14\xf1'
 b'\x95:\r\x82\xf6P\xc6\xeb w_"\xff\xee|\\R\xb5\x93@\x91)\xe7\x8b\x07\xf9\x0c,'
 b'\xcc\xf6\xfd\xd3\x00\x00\x00\x03\x00b==\x92\x1f\x00\x00\x00no\xf5\xc9n\xcb]'
 b'\x00\x04\x00\x8a\xbc\xbeV\xbbN\xa7\x00\xb8\xd6?j\xd1$\x85\xc6\x9b'
 b'\xae\xb2\xfdE\xaeE\xedj\xab\xb8\xbf\xb9\x12\x13\xcb&Q@I\xe0K\x03k.'
 b'q\xd4\xee\xd3\xe7\xbd\xd93)\x1dV\xb6\xdd}=\xd5\xa0u\xbe\x94\x1f-?\x16'
 b'\xc3}\xbc\xf4?\xc3')

{'A1': {'B1': 0.9172537326812744, 'B2': -123},
 'A2': 8386,
 'A3': 'pnl',
 'A4': [{'C1': 14644, 'C2': 1142286722},
        {'C1': 63769, 'C2': 1200738918},
        {'C1': 49732, 'C2': 351376698},
        {'C1': 3458, 'C2': 4132488939},
        {'C1': 8311, 'C2': 1596129262},
        {'C1': 31836, 'C2': 1387631424},
        {'C1': 37161, 'C2': 3884648441},
        {'C1': 3116, 'C2': 3438738899}],
 'A5': {'D1': [3332091570, 4249202245, 3983190968],
        'D2': 0.046281930059194565,
        'D3': {'E1': -0.09793208799084585,
               'E2': 1239436035,
               'E3': [27438, 29140, 61139, 59325],
               'E4': -2795845737681330819},
        'D4': 1878378862,
        'D5': 52061},
 'A6': [0.10430995374917984,
        -0.2893003523349762,
        0.5889204144477844,
        -0.029815560206770897],
 'A7': 13600403287183917240,
 'A8': 214}

(b'STS\x00\x00\x00]\xf1tyaa\xe2\x8a>c\xe5\xdeFL\xael7\x17\xa3\xcc6Fh\xd16S'
 b'z\\\xc8\x1e\xf6\x93\x83\xa1\x08B\x8b\xf4\xea\x93\xb2[\x067q\xf78Sb\xe2'
 b'"-a\xc7\x00\x00\x00\x07\x00b\xbe\xe2\xb0s\x00\x00\x00~\xe4u\xa8\x87\x1b\xc0'
 b'\x00\x04\x00\x9a\xa5\xd3\x0b\xe9\xbc\x9fL\xc1\x97\xbe\x95\xd2\xf5`\x98\x03'
 b'\x18\xfbu4{B\xdd\xb3\xeb\x8eVVO\x8dy\xc2\x8cMt\xf1\xec\xf6\x7f*\x86\xb1?\xdc'
 b'\xf6\xdc\xad\x0e\x11t\x97\x15\xc9\t\x83D\xe7\xb1=%\xba_\xab\xeb\x0c:\xd1z'
 b' A>\xa0_\xc8>\xed\xa4\x11?yJ\x05\xbe\x01\xa6\x04')

{'A1': {'B1': -0.2926250994205475, 'B2': 96},
 'A2': -3724,
 'A3': 'yaa',
 'A4': [{'C1': 57994, 'C2': 1046734302},
        {'C1': 17996, 'C2': 2926327575},
        {'C1': 41932, 'C2': 910584017},
        {'C1': 13907, 'C2': 2052900894},
        {'C1': 63123, 'C2': 2208368706},
        {'C1': 35828, 'C2': 3935547995},
        {'C1': 1591, 'C2': 1912027219},
        {'C1': 25314, 'C2': 573399495}],
 'A5': {'D1': [2550339835,
               1966373698,
               3719555982,
               1448497037,
               2042793037,
               1962011894,
               2133493425],
        'D2': -0.4427524507045746,
        'D3': {'E1': 0.4525672616948875,
               'E2': 2534787337,
               'E3': [33604, 59313, 15653, 47711],
               'E4': -6058735426934792127},
        'D4': -462051193,
        'D5': 7104},
 'A6': [0.3132307529449463,
        0.4641423523426056,
        0.9737856984138489,
        -0.12660986185073853],
 'A7': 11948907334863899841,
 'A8': 151}

Вариант №9

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

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

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

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

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

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

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

(b'KVF\x1cS\xdd\x15j<D\x14\xbbT\xee\xa7ho|\xfc><\x8f&\x8at\xc5\xd0\xf6big\x1f'
 b'\xde\x0ck_\xfd\x94\xe5\xab\x9f\xb20lj\x02\xca\xcd\x8a\xbc1\xaa\xf9\xfe\xbfd'
 b"\x02mw\xbe'\x82\x1b\xf4~Wg\xa4\x00\x00\x00~'\x94\x05\xa1e\x90\x81\xd5"
 b'rR\xbf\xec\x1c\xfa\xaaPN\x9a?\xe1W\xc4\r/  \xbf\xeb}\xf4\x94\xa8'
 b'\x87\\\xbf\xd1\x94\x98\xb0\xb0\xf7H\x13\xce\xefs\xe4\xb5\x84\x97S\x88'
 b'\xa9\xfb\xbe\x07C\xb0\x00\x04\x00R\x00\x00\x00\x03\x00\x00\x00r\x04\x8c'
 b'(\x1d\xd7\xe3\xccK\xbe\xd0\xffq\xa5\xe6')

{'A1': [{'B1': 2041218140175352852, 'B2': 3142905511, 'B3': 'ho'},
        {'B1': 9006141784654776948, 'B2': 3318806114, 'B3': 'ig'},
        {'B1': 2296286515317019877, 'B2': 2879369776, 'B3': 'lj'},
        {'B1': 201199129117960953, 'B2': 4273955842, 'B3': 'mw'}],
 'A2': -0.16358225047588348,
 'A3': -193046681,
 'A4': -92,
 'A5': {'C1': {'D1': -0.132094144821167,
               'D2': [-0.8785374952735368,
                      0.5419636018277778,
                      -0.8591254142267917,
                      -0.2746946073055949]},
        'C2': [332328819, -457866089, 1401465339],
        'C3': {'E1': 1164, 'E2': 2890703909226790608},
        'C4': 4285638118},
 'A6': 2851910654784209365,
 'A7': 29266}

(b"KVF\xa4\xa1I.S!'5\x85\xdd\xb8\xdekb\xec3KK0\x85Ge08\r\xc3xhi\x04\xb1\xc0\xf3"
 b"R\x193w\x0e\nEfjY\x93r\xde\xf1\xf9H\xff\xe0\x11\xe2\xd8iq=\xf9'C\x1e"
 b'\x19L\xc7\xd2\x00\x00\x00r\x9cf\xe4]:\xbd\x8bMK\x0f\xbf\xda\xd1\xa0F\x9d'
 b'\xd9d\xbf\xaa\xb5\xe7?\x1c\xf9\xa0?\xbdz\x01"\xc2gp\x84\xd6\x84\xd7\x03\xe8'
 b'k \xbf>\xac\xfe\x00\x03\x00R\x00\x00\x00\x02\x00\x00\x00j\n3\x19\xb0\xb2\x8a'
 b'f\xb4\x0b)\xa65\xfe\x10')

{'A1': [{'B1': -6583900716926949579, 'B2': 2245900510, 'B3': 'kb'},
        {'B1': -1426713870637643931, 'B2': 808979907, 'B3': 'xh'},
        {'B1': 7567368716163356979, 'B2': 1997408837, 'B3': 'fj'},
        {'B1': 6454628992820005119, 'B2': 3759268568, 'B3': 'iq'}],
 'A2': 0.12165691703557968,
 'A3': 504974535,
 'A4': -46,
 'A5': {'C1': {'D1': -0.744827151298523,
               'D2': [-0.41904456039573845,
                      -0.05216906209396943,
                      0.11514288996332112]},
        'C2': [-2066316073, 65563424],
        'C3': {'E1': 2611, 'E2': 1851175754347580201},
        'C4': 2788556304},
 'A6': 11269946206609836877,
 'A7': 19215}

Вариант №10

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

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

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

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

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

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

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

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

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

(b'yMXW\xbd\x15\xce\n\x00\x00\x00\x02\x00f:b\x00\x00\x00n\x00\x00\x00x'
 b'\xbd\xcc\xdb\xf9\xe8>\xe4\x19G?U<\x035O7z\x00\x00\x00\x02\x00\x00\x00'
 b'\x1dz<\xc1\xfb\x00\x18D\x99\xb5\x0c\xe0j\x00%>8\x89\xa7\xa5? \x94\x9b'
 b'\xbe\x9d\xf8\x9eO\xc0T)\x00\x00\x00\x02\x00\x00\x00DB\xce`\xce\x00?\x8c@'
 b'\xbc\xae\xe3\xc6\x00L\x00\x00\x001\x00\x00\x00X\x18\x1a\x96)\xd14'
 b'\x83\xfc\x01_\xe9\xb9-\xf9?\x11\xd6\xb3\xcc\xad\x16\x1e\x914A\x1b_I(Iaqv\xcb'
 b'\x9c\xe8\xf0;\xa4\x12\xe0\x1d')

{'A1': -0.03657344728708267,
 'A2': [{'B1': {'C1': [31292, -15877],
                'C2': {'D1': -0.10002893954515457, 'D2': 232}},
         'B2': 1150924044,
         'B3': -8086,
         'B4': {'E1': 894383994,
                'E2': [0.4455053508281708, 0.8329469561576843]}},
        {'B1': {'C1': [17102, 24782],
                'C2': {'D1': 0.18021260201931, 'D2': 165}},
         'B2': -1941914450,
         'B3': -7226,
         'B4': {'E1': 1338004521,
                'E2': [0.6272675395011902, -0.30853742361068726]}}],
 'A3': 14946,
 'A4': {'F1': 6170, 'F2': -1775644364, 'F3': 2214330719},
 'A5': {'G1': 3921227257,
        'G2': 0.5696823000907898,
        'G3': [-861071842,
               -1858846437,
               1598629961,
               1634825931,
               -1662455749,
               -1542266851]}}

(b'yMXW>\x17\x8e\x9e\x00\x00\x00\x03\x00\x8dJ0\x00\x00\x00\x99\x00\x00\x00\xa3'
 b'\xbfQPM\xaa=n\x80p\xbe\x19G\xf2\x8f\xe2\x16\xfd\x00\x00\x00\x02\x00\x00\x00'
 b'\x1d\\\x17\xa5\xe7\x00\x186\x9e"`\x0b\xad\x00%\xbe\xe8<\xfe\x8b\xbf\x12Am'
 b'\xbe\x99\xa9\x03pY\x1b\xaf\x00\x00\x00\x02\x00\x00\x00D\x8d7\xbb\x11'
 b"\x00?'\xa7V9\xd8\x18\x00L\xbf\t\x13.E\xbfG\xad~>\xd0n\xdacUG\x11\x00"
 b'\x00\x00\x02\x00\x00\x00k1^\xb6=\x00f\xac\xcf\xf0\xf9\x96~\x00s\x00\x00\x00'
 b'1\x00\x00\x00X\x00\x00\x00\x7f\x87d\xb5\x17*\r\xf6\x91\xdf\x94}uf\x15\xbf'
 b';\x98\xf1<\x04\xde\x10\xe5\xb9\xd9\x90U\x17\x1f>\xfeG\xf9&\xe9u\xa3\x91)'
 b'\xd9B&')

{'A1': 0.14800497889518738,
 'A2': [{'B1': {'C1': [23575, -23065],
                'C2': {'D1': -0.8176315426826477, 'D2': 170}},
         'B2': 916333152,
         'B3': 2989,
         'B4': {'E1': -1881008387,
                'E2': [0.05822795629501343, -0.1496885120868683]}},
        {'B1': {'C1': [-29385, -17647],
                'C2': {'D1': -0.4535903334617615, 'D2': 139}},
         'B2': 665278009,
         'B3': -10216,
         'B4': {'E1': 1884887983,
                'E2': [-0.571310818195343, -0.3001175820827484]}},
        {'B1': {'C1': [12638, -18883],
                'C2': {'D1': -0.5354489088058472, 'D2': 69}},
         'B2': -1395658503,
         'B3': -27010,
         'B4': {'E1': 1666533137,
                'E2': [-0.7799910306930542, 0.407095730304718]}}],
 'A3': 18992,
 'A4': {'F1': -30876, 'F2': -1256773107, 'F3': 4136755092},
 'A5': {'G1': 2104845845,
        'G2': -0.7328024506568909,
        'G3': [1006951952,
               -440804976,
               1427578686,
               -28837594,
               -378166383,
               702104102]}}

Вариант №11

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

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

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

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

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

(b'jESTn\x7f\x8f@0\xb1/\xbe<v\xb7\xbf#z\x90v?\x02\x00\x00\x00?\x00\x02'
 b'\x00\x00\x00U\x00\x00\x00L\xf8\x04\x00\x00\x00W\x009a\x91\xbeSc`\xd6\xce'
 b'#!\xfd\x11\xf6\n?\xd5]+\xa0\xab\xc4\xbe\xf0\x06\xc25\xd8!\xd6)\x96\x9a'
 b'\xa9\x00\xde\x9eo\xfe`\xf9\xe3\x92\x1f\xc3_l\x00\x18\xd8\x9b\xa4G'
 b'\x16\xecI\x0b\x0e\xfdB')

{'A1': 1083146094,
 'A2': -0.09164790766925957,
 'A3': {'B1': 35,
        'B2': 0.9631420373916626,
        'B3': [{'C1': -2867172252686826325, 'C2': 33, 'C3': [214, 41]},
               {'C1': -112696789329929578, 'C2': 96, 'C3': [249, 227]}],
        'B4': {'D1': [-110, 31],
               'D2': -1972,
               'D3': [7102403, -1533290472, 1240208967, 1123880459],
               'D4': -0.28394487500190735},
        'B5': 18239899337094095699,
        'B6': 0.5428171753883362,
        'B7': 2687196629}}

(b'jEST\x89\xc8Dd*a\x92\xfb\x12\xcc\xed\xbf\xcd\x1bYW?\x03\x00\x00\x00?\x00\x02'
 b'\x00\x00\x00`\x00\x00\x00\xb7\x80\x05\x00\x00\x00b\x00\xe9M\x03?\x9d'
 b'\x814\xae\xb3\xf79\xe8+\xd7\x19\xbfc\xf5v\xbc\xeb\x85>\xf3\x18gv\xe1\x91'
 b'\x19wN>\xdf\x86\xbd6\xda\x89\xe3\x04\xe8p*\xe3\xdan&\x97\xb2\x97\x03\x98'
 b'\x16\x85\x01\x19\x80N\x1f\xbbC\x86;\xc8\xc0\x91\xd2\xc1\xa5\xcbUM\r2')

{'A1': 1682229385,
 'A2': -0.9311613954078315,
 'A3': {'B1': 205,
        'B2': 0.8412033915519714,
        'B3': [{'C1': -2200458011066071573, 'C2': 145, 'C3': [25, 119]},
               {'C1': -8513431957951005106, 'C2': 227, 'C3': [4, 232]},
               {'C1': -5577947355914491280, 'C2': 151, 'C3': [3, 152]}],
        'B4': {'D1': [22, -123],
               'D2': -32585,
               'D3': [1317017857,
                      -2042381537,
                      -1849636805,
                      -878329390,
                      839732565],
               'D4': 0.5129075646400452},
        'B5': 16733678241565671837,
        'B6': -0.6009394526481628,
        'B7': 3161912675}}

Вариант №12

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

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

(b'IHISC\x00nnlV\x00\x9d\x95=@\xffcL\x10\xb6\xb4\xec6\xbb\x85qB\xdd'
 b'\xe3K\xad\xc7.n\x03\xba\xee\xe6;\xde\xa7\xac\t\x1aK\xd2\xf9\x0b\xcevg\xd2'
 b"z\x81\x03\xab\x96_\xaf?f\xb2\xbb'\x003\x00epc8!\x0c\xbf\x17I9&\x02\x00"
 b'\x00\x00?\x00\x00\x00\x12\x0f%`\xb5}\x00\x0f\xbd\x9aX\xfa\x05\xe8'
 b'\x1b\x00\xef\xcb\x07Y\xea\x07\xe9\r\xe7E\xc0f5<p\xc6z%r\xbeI\xd6Ofwm'
 b'S\xf2\x8b\x0f\xd3_\xf0\x1c\x8d$@\xa5\xdb\x7fC7wb\xe4\x0bt\xe4\xd2+~o\xe7.'
 b'\x04:\xdd\x1d7\xaa\xb7\xae\x1d\xe8|m\x8e|0')

{'A1': {'B1': 'epc',
        'B2': -0.5473818778991699,
        'B3': 641288471,
        'B4': [{'C1': 162310110, 'C2': 7455372783989705498},
               {'C1': 58817234, 'C2': -4921759019051280725}]},
 'A2': 'nnl',
 'A3': {'D1': 3858,
        'D2': 24613,
        'D3': [18039338444223708597,
               6415320421572012037,
               7403994646070233066,
               13723072223796804661,
               17461420539830589001,
               2633793175807004555,
               7095200500992943424,
               8033906970051480548],
        'D4': 12265304946165165799,
        'D5': 3894259383,
        'D6': 2089708924,
        'D7': 48},
 'A4': 1174423550782444957,
 'A5': 4787754917998408886,
 'A6': -1387535395,
 'A7': 4316399775570079431}

(b'IHISC\x00fqdV\x00\xbd\xf7\x19\x1a\xee\x82,\xef\x0f\xa7\xd0\xe2TtI\xd6\x01'
 b'\x1f\x06\xd5\xf3"\xd3\'o\xd4^\x0e,\xe4\xc0\x1a6\xa8>d\xcdu\xf4\x8fp'
 b"\x1bB\x08\xa0[\xaa-Hm\x17\xb8'\x003\x00thv\x83Lb\xbf\xdb\xa5\xc1\xec\x02\x00"
 b'\x00\x00?\x00\x00\x00\xf6b\x01zW\x1d5>\x82\xd5\xdb}\xc2\x99\x81\x0cr\xa8'
 b'\xe1\x87\x8b}R\x84S^\x8b\x86\x87\x12\xaa\xfe\x99\xdb\x10\xb5&\xe6'
 b'\x82\x9b\x14\xc3\xb6\xb1.+Gi\xc2~,\xfd\xf0\xb7\x0by\x8c\x0f\xf5\xaae\xf2'
 b'\xf0\x1aj\xd3\xc8B\xfcK\xf4K\xa0\xe5\xa3K\xa9\x00\xf6c.6\xdb\xfa\n')

{'A1': {'B1': 'thv',
        'B2': -0.8839799761772156,
        'B3': 3972113883,
        'B4': [{'C1': 448848940, 'C2': -8073698706957883338},
               {'C1': 138550128, 'C2': -5181552689495254112}]},
 'A2': 'fqd',
 'A3': {'D1': 25334,
        'D2': 31233,
        'D3': [9069077030006758743,
               9791292272669727170,
               9694946335640419723,
               13047169574941364871,
               12805637083750393382,
               18243095564026063662,
               12318769451742509040,
               4812328654517367397],
        'D4': 5450452450680261628,
        'D5': 1677066409,
        'D6': 4208670254,
        'D7': 10},
 'A4': -1212450240517769283,
 'A5': 15441000705347856143,
 'A6': -721019135,
 'A7': 1035498538216399603}

Вариант №13

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

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

(b'%KFZ:l\x16q\xd6\xd9\x7f.9\x0c\xa2\xce\xfc\x9d\xf0\xa8.\x84\xf7\xb3xh\x00#'
 b'\xd1?Qz"B\x81\xa3\xd30E\xde\xf9!\xd9\xbb\x87m$M\x80\x8c\x931^\xb4\x00\x03'
 b"\x00\x00\x00 4\x11'\xffy\xa5\xd9\xf1q$\x07k\x9e<D\x82\x188D\xa0\xbb\x8d4\xa8"
 b'=>\x14\xfaL(m\xb6\x0c+"T=?\\W\x97')

{'A1': 14956,
 'A2': [{'B1': 5745, 'B2': 3604578094},
        {'B1': 14604, 'B2': 2731474077},
        {'B1': -3928, 'B2': 780466099}],
 'A3': 'xh',
 'A4': {'C1': 163,
        'C2': -45,
        'C3': 12357,
        'C4': {'D1': [57081, 8665, 48007, 27940, 19840, 35987, 12638],
               'D2': 180,
               'D3': [34, 66, -127],
               'D4': 13329,
               'D5': 39,
               'D6': [65401, 42457, 61809, 9223, 27550, 15428, 33304],
               'D7': 4054542291928655933},
        'C5': 0.14548605680465698,
        'C6': 2913184697358111805,
        'C7': 0.8607115149497986},
 'A5': -784379526}

(b'%KFZ\xc7\xc8A\xf1\x00\x1c\xd2\x0e\x13\xd7_M9|<\x82__\xc5kmy\x00$}\x94\xedJ'
 b'\xa8\xd7\x15\x1c\x90]\xac\xb7\xa8_\xdd$\xf6\xc05\xc1s\xb1\x00\x80\xc5Q7\x00'
 b'\x04\x00\x00\x00 \\g\xf12\x07\xb7\x9d\x8eJ@\xf66\xb6\x82;M\xa6\x86k'
 b'=\xa39\x0e\xc1\xe1?V\x182\xc8\xa0\xcb\x0b\xc1\x8c@j\xbfLs\xf8')

{'A1': 51144,
 'A2': [{'B1': 16881, 'B2': 1888782},
        {'B1': 5079, 'B2': 1598896508},
        {'B1': 15490, 'B2': 1600111979}],
 'A3': 'my',
 'A4': {'C1': 144,
        'C2': 93,
        'C3': -21321,
        'C4': {'D1': [43103, 56612, 63168, 13761, 29617, 128, 50513],
               'D2': 55,
               'D3': [-88, -41, 21, 28],
               'D4': 23655,
               'D5': 241,
               'D6': [12807, 47005, 36426, 16630, 14006, 33339, 19878],
               'D7': 9685903194836615649},
        'C5': 0.8363066911697388,
        'C6': 14456778055211565162,
        'C7': -0.7986445426940918},
 'A5': 2106912074}

Вариант №14

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

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

(b'JHXIDK\x00\x00\x00\x02\x00x\x00\x00\x00\x9aG\x16?\x02\x00\x00\x00\xb6'
 b'\x00\xc9\x97\xda\xfd9\xd4\x8a\xbd\x84nt\xd6\x93zk\xa2h\xd4\xc0\xc9M\x00\xe3'
 b'?\x02/\x80\xf2\x0b\x98f\x19\xfbvpyrhx\xfcH\xca \\\x8f*\xae\x85\xce\xbf\x80'
 b'\x00\x9e\xd3`\x85\xc3?\x06\x00:\x00\x00\x00*s@\x00\x00\x00jL\xec>\xf6'
 b'\xf5s\xed{K\xe4\xbf\xef.c\x96\xb5\xae\x8bre\xec*\xf8\xd3|\xd1\x9c\xb3'
 b'\xf7\xd1\xee?2\xee\xaa\xeb\xf3\x9f\xbbA\x06\x00\x00\x00m\x00\xc6\xda'
 b'%\xf8\xf4\xcf\xe6\x0cA \xd2\x03a\xee\x98\xef?\xddg\xff\xb3\xbc\x84=\xb0\x05'
 b'\x00\x00\x00s\x00\xb8\x7fN\x80E.\x0e\xfb\xcf2C\x83\x1b')

{'A1': {'B1': {'C1': 0.15250788052435738,
               'C2': 'vpyrhx',
               'C3': 29482,
               'C4': {'D1': 18684, 'D2': 202, 'D3': -0.23845460012555098},
               'C5': 0.4615204930305481,
               'C6': -0.6342143666985851,
               'C7': 12015},
        'B2': [{'E1': 0.9631308086450612,
                'E2': 4736555303089925682,
                'E3': [99, -106, -75, -82, -117, 114],
                'E4': 929659024140786374,
                'E5': 65},
               {'E1': 0.9874183554480318,
                'E2': -5747291603446306851,
                'E3': [101, -20, 42, -8, -45],
                'E4': -356296444475441224,
                'E5': -49}],
        'B3': 0.5870300531387329,
        'B4': [17202, 7043],
        'B5': -4788781908217915447},
 'A2': -6743161241680449916,
 'A3': 0.5937870922558774,
 'A4': 2,
 'A5': -353138292550369233}

(b'JHXIDG\x00\x00\x00\x02\x00n\x00\x00\x00\x04\xc9]\xbf\x02\x00\x00\x00\xac'
 b'\x005\x9eF\xc10E\x927\x1d\xec3\x15\xf3\xe6\xea\xe06\xbe\x1a_\xb2\x9e\xe2'
 b'\xbf@f\xe2\xab\x06Y\xcd\x9ednf\x18\xf6\x00\xe4\x7f\x06P\x01\x01\xe1?\xaa'
 b'P\xa0\x9ddI\xeb\xbf\x02\x00:\x00\x00\x00\r\x1c<\x00\x00\x00I7\xb2>6'
 b'\xb5o\xd6v\xd2\xe9\xbfP\x92\x8b*P?\x19\x88\x18\xb1\xa8\x97n\xc7?\x9f\t'
 b'\xae\xa2\xb4\xb0w9\x02\x00\x00\x00i\x00\xdeW=D\t\x80E\xc2\xc8`-\x16'
 b'\xd4\x07\x10\xa0\xbf\x93\x12\xb3i\x8b\xed\x89z\x03\x00\x00\x00k\x00\xbf'
 b'\xdaD9*\xb1\x8a\xd1\x11,\xc7I\xbb')

{'A1': {'B1': {'C1': -0.8527091101300546,
               'C2': 'nf',
               'C3': 7181,
               'C4': {'D1': 63000, 'D2': 0, 'D3': 0.5313726962085608},
               'C5': 0.34807804226875305,
               'C6': -0.8069414318285115,
               'C7': 37456},
        'B2': [{'E1': 0.18306251274970387,
                'E2': 4140972672260376991,
                'E3': [-117, 42],
                'E4': -4448008279670564898,
                'E5': -56},
               {'E1': -0.031372303618889985,
                'E2': 8829849727466148499,
                'E3': [80, 63, 25],
                'E4': -3347668578088985921,
                'E5': 17}],
        'B3': -0.8663485050201416,
        'B4': [-14548, -17591],
        'B5': 4004339094389169717},
 'A2': -2239723932956234723,
 'A3': -0.5818721635350304,
 'A4': 64,
 'A5': 7250458232360788582}

Вариант №15

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

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

(b'RDZ\x1a\x00\x00\x00J4\x19^T\x19\x00\x00\x00\x02\x00\x00\x00X@\xa9~pV\x00\x00'
 b'\x00\x02\x00\x00\x00`\xb8Y3m\xf8\x00\x00\x00\x04\x00\x00\x00h\x82aq_$'
 b'\x8f\xea\xa8?\xba\xbb\x00\x00\x00\x02\x00\x00\x000\x00\x00\x00\x02\x00\x00'
 b'\x002\x00:?\xb4r\x16\xa4S\x0f\x00?\x0bu\xd3\xbe\xb3\x86\xf5\xbe\xc2Ih'
 b'\xbfM\xe9\xe9\xbe\t\xfa6?H\x80=\xbd~U\xf5?B3\xff>\x90\xea\x8f')

{'A1': {'B1': {'C1': 'aq', 'C2': [1596231658, -1472218437]},
        'B2': 0.07986585151507697,
        'B3': 0.5447666049003601},
 'A2': 52,
 'A3': [{'D1': 425612313,
         'D2': [-0.3506390154361725, -0.37946629524230957],
         'D3': 64},
        {'D1': 2843635798,
         'D2': [-0.8043504357337952, -0.13474354147911072],
         'D3': 184},
        {'D1': 1496542712,
         'D2': [0.7832067608833313,
                -0.062093693763017654,
                0.7586058974266052,
                0.28303954005241394],
         'D3': 130}]}

(b'RDZ\x1a\x00\x00\x00L\xd8:\xd6\xe0\xca\x00\x00\x00\x04\x00\x00\x00Z\xfer\xf7'
 b'\x04\xb3\x00\x00\x00\x04\x00\x00\x00j\x98S\\wX\x00\x00\x00\x05\x00\x00\x00zv'
 b'awcmk\x1d\xfa\x00S\xa0b.\x00\x00\x00\x04\x00\x00\x000\x00\x00\x00\x02'
 b'\x00\x00\x004\x00<\xbf\xe2]0YY\x038\xbe\xb8&(\xbf\x11\xa4\xea\xbf\x16'
 b"\x0e\xe9\xbf\x0c\xb9'<9\xec\xaf\xbf]&\xd4>\x8a\x02\x9f\xbe\xe0\x01\x99>\xdc"
 b'\x03|\xbeN3\xd6>C\x0bn\xbe\xad\xbe\xe5\xbf~\xf9\x8a\xbf0\x8d\x8d')

{'A1': {'B1': {'C1': 'awcm', 'C2': [1797126656, 1403019822]},
        'B2': -0.5738755936691637,
        'B3': -0.359666109085083},
 'A2': 216,
 'A3': [{'D1': 987160778,
         'D2': [-0.5689226388931274,
                -0.5861650109291077,
                -0.5497002005577087,
                0.011347933672368526],
         'D3': 254},
        {'D1': 1928791219,
         'D2': [-0.8638737201690674,
                0.26955124735832214,
                -0.43751218914985657,
                0.4297140836715698],
         'D3': 152},
        {'D1': 1398568792,
         'D2': [-0.20136961340904236,
                0.1904732882976532,
                -0.3393470346927643,
                -0.9959951639175415,
                -0.6896598935127258],
         'D3': 118}]}

Вариант №16

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

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

(b'LVZVN\x80\xba)h\xefdv\x16>\xf5\xca<\xd6\xf8\x88\xe1j\xd3\xfeG\xf1h\x00'
 b'\x06\x00\x00\x00?\xbfW\xd00\xfc@T;2\xb5:\xa0s}\x00\x03\x00\x00\x00'
 b'E\x8a\x1d\x00HsOi\x1d~C[\x8c]\xc7\x8f\xbe\xf7\xa2<\xe4\xbf\xb2\x97'
 b'U\x05\xf1\x95\xa0J\x06\x11\x06+\xe2\xa4H\xd17X\x9b')

{'A1': 78,
 'A2': 9275771913192633878,
 'A3': {'B1': [{'C1': 0.48005855083465576,
                'C2': -688355103,
                'C3': 27347,
                'C4': 4266127720,
                'C5': [91, -116, 93, -57, -113, -66]},
               {'C1': -0.8430204391479492,
                'C2': -62892997,
                'C3': 12981,
                'C4': 983593853,
                'C5': [-9, -94, 60]}],
        'B2': 35357,
        'B3': {'D1': 228,
               'D2': -0.07262164492711642,
               'D3': 18950,
               'D4': [4358, 11234, 42056, 53559, 22683]},
        'B4': [115, 79, 105, 29, 126, 67]}}

(b'LVZV7\xbe\xfa\xf5P0\xbf\xb3b\xbfM\xfcgOZ w{hT\xccp\xf1\x00\x05\x00\x00\x00'
 b'??8\xac\xef\x08\x01\xc0\x98Y\xcd\xa1}\x04\xf1\x00\x02\x00\x00\x00D\x94$\x00'
 b'F~c\xa0\x18Vk\xcf\x04\x10\xff\xb3\xcfQZ?\xe6\xcd`BI\x18\x94\x90t\xe3as'
 b'\x9c\x8d9$\xa0\xbf\xd0')

{'A1': 55,
 'A2': 13761581336148030306,
 'A3': {'B1': [{'C1': -0.8046326041221619,
                'C2': 1331306615,
                'C3': 31592,
                'C4': 1422684401,
                'C5': [-49, 4, 16, -1, -77]},
               {'C1': 0.7213887572288513,
                'C2': 134332568,
                'C3': 22989,
                'C4': 2709325041,
                'C5': [-49, 81]}],
        'B2': 37924,
        'B3': {'D1': 90,
               'D2': 0.7125703138961108,
               'D3': -28556,
               'D4': [58209, 29596, 36153, 9376, 49104]},
        'B4': [126, 99, -96, 24, 86, 107]}}

Вариант №17

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

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

(b'ZRGJ\xfd\xef\xe8\n@\x00\x83\x18c?\x12I\x1c\xcb\x89A\x9e\xb5\x1c!'
 b'\xbd\xf6\xb2b\xc5\x18!\xbb\x9ek\xde\xa4p\xb7V\x98t\x82\xd4Q\x96\xa1\x18\xee'
 b'\x87\xe5\x93,v\n\x08\xd9\xc5\xe7\xbe\xbd\xd9\xfd&\np\xd4u\x87\x8cM\xb8\x0e'
 b'\x00\x00\x00\x1c\x00\x00\x00*\x00\x00\x00\xa16~\x81\xc2h$.\x94n\xf6\xc4\xf1'
 b'\xb3:\xf9J\xdb\x85/\x90\x97\xe1+\xcdf\x99iIR\x12\x17 H\x01\xbf\xa3'
 b'\xfa\xdeh\xac^\x02\x00\x00\x008\x00\x00\x00')

{'A1': 59631,
 'A2': 10,
 'A3': {'B1': 112,
        'B2': -1937279532,
        'B3': {'C1': 47181,
               'C2': [{'D1': -887338734,
                       'D2': 17779403311118434697,
                       'D3': 25266},
                      {'D1': -1155458875,
                       'D2': 10977162836192422814,
                       'D3': 33396},
                      {'D1': -1583984172,
                       'D2': 753839001353842200,
                       'D3': 55560}],
               'C3': 13985,
               'C4': [126, -127, -62, 104, 36, 46, -108],
               'C5': [110, 246, 196, 241, 179],
               'C6': 3679123770,
               'C7': 7407625210004778885},
        'B4': 1380542873,
        'B5': 5906,
        'B6': 18464,
        'B7': 6821942842456522497,
        'B8': [-1111562299, 170327513]},
 'A4': 0.8870927691459656}

(b'ZRGJ\xfd\xa5\xddDT\x00+lB=\xa6\xa3\xbd\xa1\xe6\x15\xa8B\xe2\xd1\x83"Og'
 b'$\xb9\x9e;\xc7\x83)J=\xf2\xc53dF\xa0\xc8\xcf\xfe\xbfx\xfa\xd5\x8f\xfe'
 b'\xa2\xd7\xaeK\x01J\xeb\xd7\x05;%V\xd1\xec\x98}E\xa4\xc5\x85\xd0W{:.~Y?'
 b'x\x07Hc\xd1\xf9\xb2t\x85\xfa\x9b\x0e\x00\x00\x00\x1c\x00\x00\x00*'
 b'\x00\x00\x00(\x13j_\xbb3\xa2\xb5\xdf\x05\x1d\xac\xcc\x10\xf5\xa5\xfa'
 b'\xd0\xec\xbb\xf7p$\x9b\xf1\x05})\x04\x1a\xfcb=\x95\x86]\xd5B#\x06\x00'
 b'\x11\x07\x00\x00\x008\x00\x00\x00')

{'A1': 56741,
 'A2': 68,
 'A3': {'B1': 209,
        'B2': -2055949575,
        'B3': {'C1': 39930,
               'C2': [{'D1': -1581407322,
                       'D2': 2487062188949771750,
                       'D3': 26447},
                      {'D1': 1000257828,
                       'D2': 3730654211397485511,
                       'D3': 18020},
                      {'D1': -19937120,
                       'D2': 15538261558105372863,
                       'D3': 19374}],
               'C3': 4904,
               'C4': [106, 95, -69, 51, -94, -75, -33],
               'C5': [5, 29, 172, 204, 16],
               'C6': 3506087413,
               'C7': 428294020393319404},
        'B4': 436480381,
        'B5': 25340,
        'B6': -27331,
        'B7': 1224985847159676294,
        'B8': [-672445951,
               1445280517,
               2107174097,
               -2050644923,
               981161936,
               1062829614,
               1665664888]},
 'A4': 0.04746643826365471}

Вариант №18

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

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

(b'LHO\x00I\xc5*\xe4<96\x06W\xf7\xe9\t\xd1G[\xbe&Oy\x03\x10\xc6\xca\xc4'
 b'\x9a\x02\x89\x11\x82\xaf\xfc<\xe45\xaf\xf7?t1~KoI\x00\x93\x06\xaf\x18'
 b'sx\xc5\xef!s\x94J\nx\x84\xf4\xf0\x89\xf4yvy\x81\x16\xb6\xe4\xf0L\xca?S\x0e'
 b'T\x00\x00\x00\x03\x004?h\xa9\xa7\x16\x90\xf7#?\xea\xed$\xfb\xda\x94R\x00'
 b'\x02\x00\x00\x00C\x00\x00\x00\x02\x00\x00\x00E')

{'A1': {'B1': 3840953546,
        'B2': 0.8244373798370361,
        'B3': [{'C1': 1937294831, 'C2': 33},
               {'C1': 1939098122, 'C2': 120},
               {'C1': -2064322423, 'C2': 244}],
        'B4': 0.90883868932724,
        'B5': 378599203,
        'B6': 0.841448299314502,
        'B7': 'yv',
        'B8': [31105, 5814]},
 'A2': {'D1': 14207418921802663511,
        'D2': -9,
        'D3': 59657,
        'D4': 15080122749518051587,
        'D5': [1208876495741815057, 9417022684311957495],
        'D6': 0.004930013025800983},
 'A3': 2466688792}

(b'LHO\x00R~\x01E\x1c\x99\n\xee$>E="\xf2/\xb7\n\xcc\x93\x839\xc3\x16\x82'
 b'P}\xb4\x19F2Dz\r\xe5L\xb0\xbf\xc9\x8c\xfd\xf6\x1b`\x88m\xef\xd0\xf7MC\x102'
 b'\r\xce=,U\xea\xadw\xb9\x96p\xf3g\xa21Xse,\x8a0HB]\xd2\x97\xde\xabA&\xbe\x89'
 b"jC\x00\x00\x00\x04\x004>ar'\xa6\x9eJ\xd2?\xee0\x01%k\xafl\x00\x02\x00\x00"
 b'\x00H\x00\x00\x00\x04\x00\x00\x00J')

{'A1': {'B1': 3735765286,
        'B2': -0.2683888375759125,
        'B3': [{'C1': 1296240690, 'C2': 13},
               {'C1': -834851755, 'C2': 234},
               {'C1': -1384662634, 'C2': 112},
               {'C1': -211312079, 'C2': 88}],
        'B4': 0.2201620191335678,
        'B5': -1499575598,
        'B6': 0.943359921538542,
        'B7': 'se',
        'B8': [11402, 12360, 16989, 53911]},
 'A2': {'D1': 9079614312884661796,
        'D2': 62,
        'D3': 17725,
        'D4': 2518127604860228483,
        'D5': [4162195229572445209, 5058180622500318384],
        'D6': -0.19961523549023164},
 'A3': 1844433143}

Вариант №19

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

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

(b"AWUA_f\x15\x00)'\x8a\x9a\xeel\xa6\xa1G\xe4\\^?\xe7\xe8\x00\x00\x00\x02\x00"
 b'k\xbe\xb8\xe7c\x00\x02\x00s\x7f!\xd4\xc2eiqfr7\xc6\x19\xbd\x87\xd8'
 b'\xc6\xbf%\xd9[\xbf5\x9ba?d\x1f\xf2\xc4p\xe4g:\xd0\xa7\x9f\xc3\xc4o'
 b"\xd4i\x9c\x12\xdc\xff\xd2\xb5\xaaM\x9c\xaf\x90'X\xea\xa9\x12\x84\xf6"
 b'\x90k\xe0!\x81?\xc2\x9b\x90F6\x00\x00\x00Y\x00\x00\x00b?\xdb\xc6\xc5\x13'
 b'q\xad\xd0?\xe7\xf7\xb3}\xe8\xb2\xde')

{'A1': 26133,
 'A2': {'B1': {'C1': 'eiqf',
               'C2': 1916257817,
               'C3': [-0.06633143126964569,
                      -0.6478478312492371,
                      -0.7094021439552307,
                      0.8911124467849731],
               'C4': -4291679312864565345,
               'C5': 50116,
               'C6': 1876191644,
               'C7': 4828,
               'C8': -12748105877508208},
        'B2': 663395054,
        'B3': 27814},
 'A3': 11621508448822224872,
 'A4': [{'D1': 39, 'D2': 6407119316893208683},
        {'D1': -32, 'D2': 2414280980313425462}],
 'A5': -0.36114034056663513,
 'A6': [0.43400694750627355, 0.7489869555625679],
 'A7': 2132923586}

(b'AWUA_\x85S\x00)\r\xbcs\xcbWj7\x02\xf7\xadQ\x01,\x18\x00\x00\x00\x02\x00'
 b"k?T\xee\x85\x00\x02\x00s\xe1\xae\x01\naysi\xa1\xc7E'>Q\xa6\xeb\xbfA\xad"
 b'=\xbf{*\x0e?1\x07\x8b]\xb7`\xe8\xdc\x10\x8e\xc5\x8d%X\x05\xad\x9aG'
 b'\xaf\xcc\xf5*\xf9,9\xaa\x81\xbc\xce\xc0\xe4\xc0\xb5\x19\x0f\x83\x1cU'
 b'^\xd6\xbe\x1e\x1c3;\x00\x00\x00Y\x00\x00\x00b?\xef\x94y\x1c\xa2\x94\xe4?'
 b'\xbb9\xdebE\xdf ')

{'A1': 34131,
 'A2': {'B1': {'C1': 'aysi',
               'C2': 2714191143,
               'C3': [0.2047383040189743,
                      -0.7565496563911438,
                      -0.9811104536056519,
                      0.6915213465690613],
               'C4': 6752972719506099909,
               'C5': 36133,
               'C6': 1476767130,
               'C7': 18351,
               'C8': -3677986271000941951},
        'B2': 230454219,
        'B3': 22378},
 'A3': 3964002945799891992,
 'A4': [{'D1': -68, 'D2': 14898159083664772995},
        {'D1': 28, 'D2': 6151590253071971131}],
 'A5': 0.8317645192146301,
 'A6': [0.9868741568831436, 0.10635175608865355],
 'A7': -508690166}

Вариант №20

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

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

(b'EJPS\xfc\x8a\xeb\x9c\xc8Y\xd7?\x03\x00\x00\x00[\x00\x00\x00cyuwsqj\x9e'
 b'\x99\xb7\xbd\x83\xa8\xc6\xe1^\x92g\xc8?\xd8\xa7`U\x99\x9c\xdb\xbf\xb8\x8cbl'
 b'l\x81\xcb\xbf\xa2:\x87?0\xc1\xef?\x00\x80\x10lB\x85E?\xb8J\x85S\x8aU\x1c\xfb'
 b'A\x0b\xeb\x11\x14\xcd\xd3\x02\x1e\x83\x8f\xc1\xdb\xe2\x9d\xbd>@c\xed'
 b'\xfb\xaa3x\x14K\xbe\xa6\x0bpG8?\xd2hY\xf5\xa9>\xf1\xfc\xa3k\xc5@$\xb1\xc7'
 b'\x00!\xa7\x13\xd39\xbf\x92\xdf\x0f\xecr\xbf |40\x9e_\xa2\xf5\xad\x82y'
 b"'\x00\x97\t?")

{'A1': {'B1': 0.36485495876529206,
        'B2': [{'C1': 193,
                'C2': {'D1': -37,
                       'D2': 0.37034517526626587,
                       'D3': -68328640,
                       'D4': 839567610226422698},
                'C3': 0.7198400497436523},
               {'C1': 210,
                'C2': {'D1': 104,
                       'D2': 0.33194997906684875,
                       'D3': 1805909233,
                       'D4': 12042907736235851973},
                'C3': -0.7258769869804382},
               {'C1': 146,
                'C2': {'D1': -33,
                       'D2': -0.9489144682884216,
                       'D3': 808746016,
                       'D4': 2844448323323191198},
                'C3': 0.5374603271484375}],
        'B3': 'cyuwsqj',
        'B4': -0.08964847028255463,
        'B5': -125,
        'B6': [0.19066075928599457,
               -0.43143304193165255,
               -0.21488719265207634,
               0.9923325768266589,
               0.0006567549063483114],
        'B7': -72},
 'A2': -1974237878,
 'A3': [7253, 16891, 60171, 5137, 54221, 7682, 36739]}

(b'EJPS(\x11\xd2\r\x88\xc1\xd1\xbf\x02\x00\x00\x00[\x00\x00\x00kqhiste2'
 b'\x998?\xc6\x82\x13\xfdp\x85\xbb\xea?d\xac\xb6\xbd*G\xe1?h\xa0\xa7\x01'
 b'\x81\xac\xea?(\x8dr\xde\nW\xca?\xdcIo\x17\x04\xaa\xef\xbf1J/Q\x14\x88f\x96'
 b'.\xc6\xa7\x1e\x94\x12\x17\xf4"\x92\xf6\xba7\xfa\x184?\x17>!\xd4\x86`\xe3'
 b'\xe2\xa0\xe9\xe3\xc8\xe4\x18\xe1\xbc\x88\xb8\r\xfbH?3\xadI\tlnu\x95E'
 b'\x8dN\x81T\n[\xbf')

{'A1': {'B1': -0.27743722295442064,
        'B2': [{'C1': 186,
                'C2': {'D1': 55,
                       'D2': 0.7035061120986938,
                       'D3': -736018921,
                       'D4': 14475670504509497478},
                'C3': -0.0274776890873909},
               {'C1': 136,
                'C2': {'D1': -72,
                       'D2': 0.7850807309150696,
                       'D3': 155823411,
                       'D4': 9317540009075895916},
                'C3': -0.8556263446807861}],
        'B3': 'kqhiste',
        'B4': 0.7210875749588013,
        'B5': -58,
        'B6': [0.8353907782371695,
               0.5399373727172017,
               0.8335576088256973,
               0.20578132497494406,
               -0.9895039041242017],
        'B7': 49},
 'A2': 340864842,
 'A3': [26248, 11926, 42950, 37918, 5906, 8948, 63122]}

Вариант №21

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

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

(b'RVFH\xd4=\x91klvbm\x00\x04\x00KY\x08\xbf\\*\xe4>[\xe9\x11?9\xdf\xb6>\xb5'
 b'\xa7\xbe\xbeiK\x1e\xbe\x95=M\xbf/\x9e\x1e\xbf\x1a\x81\xea\xbe\x9c'
 b'\x903\xfb\x86\xae \xd4{\x00\x00\x00\x9b7\xa1o;\xb2\xd0\xf5\xa9w\\\xef\x00'
 b'\x03\x00\x00\x00@\xb7\xc5\x11\xe7\x98\x1d?$\xe4\x0e\xbej\x94<\x00'
 b'\x04\x00\x00\x00C \x92F\xafVN<\x9b\xb3\xa1:\xabv\xbf\x00\x02\x00\x00\x00'
 b'GN>\xf9\x12\x8eM>\xf6\x04\xc3?y\xb6\xf0\x00\x02\x00\x00\x00Iy\xd7\xde\xaeAr<'
 b'M\x90\xca\xbe\xa4\xa6\xa8\xbf\xd4\x8a+\x84\x80u`K\xa3')

{'A1': {'B1': 1221868945,
        'B2': 'klvbm',
        'B3': [{'C1': [55, -95, 111],
                'C2': -18491,
                'C3': 300390429,
                'C4': 0.6441048383712769,
                'C5': -0.22908109426498413},
               {'C1': [59, -78, -48, -11],
                'C2': 8338,
                'C3': 1185896014,
                'C4': 0.019006552174687386,
                'C5': 0.001308165374211967},
               {'C1': [-87, 119],
                'C2': 20030,
                'C3': 4178742861,
                'C4': 0.4805050790309906,
                'C5': 0.9754476547241211},
               {'C1': [92, -17],
                'C2': 31191,
                'C3': 3735961970,
                'C4': 0.012546727433800697,
                'C5': -0.32158398628234863}],
        'B4': 22792,
        'B5': [-0.8600294589996338,
               0.21475626528263092,
               0.7260698080062866,
               0.3547953963279724,
               -0.2278256118297577,
               -0.2914833128452301,
               -0.6860064268112183],
        'B6': [-0.6035448312759399, -0.3057876527309418]},
 'A2': 64390,
 'A3': -1373580165,
 'A4': {'D1': -0.3209332269633105, 'D2': 19363}}

(b'RVFV\x85\xaeCvtvti\x00\x05\x00P\xc16\xbe\x8cHT?@\x96t?>e\xd9\xbe\xc7'
 b'\xa6%>\xff\xabE\xbd\xe7\xa5s>"-\xbf>L\xa0:\xbeZ\x04\x01[\xdb|W\xac\xc4'
 b'\x00\x00\x00\xb4\xe9)\x96\x08\x89a\xec\xeb\x82\x07%\x16\xcc\x13\xa0\xd4'
 b'\x00\x04\x00\x00\x00@+ o\x05kq\xbc\n>\x8d\xbe\rAh\x00\x02\x00\x00\x00Dr\x13'
 b"\xc3\xa9\x90H?\x06h\x1c>\x02\n\xce\x00\x04\x00\x00\x00F-'g\xb1=_"
 b'\xbe\x1aP\x80\xbf(\xffI\x00\x02\x00\x00\x00J\xfbt\x87%D\xc5>\xb9B\xcc'
 b'>\xd1f\xec\x00\x04\x00\x00\x00L\xcd\x1aph?x\xbf\x12\xca\xf1>\x815\x14'
 b'\xbf\xdeq!\xae\xd7\xa3\xe4\xb8\xae')

{'A1': {'B1': 1451601475,
        'B2': 'vtvti',
        'B3': [{'C1': [-23, 41, -106, 8],
                'C2': 11040,
                'C3': 1862626161,
                'C4': -0.008437764830887318,
                'C5': -0.13794481754302979},
               {'C1': [-119, 97],
                'C2': 29203,
                'C3': 3282669640,
                'C4': 0.5250260829925537,
                'C5': 0.12699434161186218},
               {'C1': [-20, -21, -126, 7],
                'C2': 11559,
                'C3': 1739668831,
                'C4': -0.1506977081298828,
                'C5': -0.6601453423500061},
               {'C1': [37, 22],
                'C2': -1164,
                'C3': 2267366597,
                'C4': 0.3618377447128296,
                'C5': 0.408988356590271},
               {'C1': [-52, 19, -96, -44],
                'C2': -13030,
                'C3': 1885880184,
                'C4': -0.5734091401100159,
                'C5': 0.252358078956604}],
        'B4': -16074,
        'B5': [-0.27398931980133057,
               0.752295732498169,
               0.7437415719032288,
               -0.38993945717811584,
               0.4993535578250885,
               -0.11310853809118271,
               0.15837763249874115],
        'B6': [0.19982996582984924, -0.2129058986902237]},
 'A2': 23515,
 'A3': 2086120644,
 'A4': {'D1': -0.4756550033039828, 'D2': -18258}}

Вариант №22

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

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

(b'HSVp\xd0\xdax\xc5ydclxunc\xc5\xde\xd8GJ\x00\xa5\x9d\x98\xb1;(\xcc\xc4\x0f?'
 b'\xc1S\xaf>\xb6<\xca>9C\xd1=\x91`_\xben@\xdd\xbe\xc2\x83\xe30\xb6\xd2DT'
 b'\xd4\xfb\xf2\xcb\xbb\x85\x1a\xe5\x96\xae\x9c\xf8\x1e\xdbRIO\xe4\xd5\xe6'
 b'\xa1.?)\xcf@\xa1\xc3h\xa6\xa5\xb3\xe1\x1b\xa2o\xdfi\x99zD\x00\x00\x00'
 b'\x00#\x88\x06A\x04%n\x1f\xa8>I\x9cM\x9c\x9d\xe2q\x88J\xdc0\x05\xe3'
 b'\xf86\xa1\x12\x12}\xe8%\x01\xa3\xc9\xc8\x82T\xf93\xc8!H\xc8(B\xbd_')

{'A1': -981935408,
 'A2': 'ydclxunc',
 'A3': 57029,
 'A4': 18392,
 'A5': {'B1': -464565934,
        'B2': -43,
        'B3': [{'C1': -26, 'C2': 11937},
               {'C1': 63, 'C2': 53033},
               {'C1': 64, 'C2': 50081},
               {'C1': 104, 'C2': 42406},
               {'C1': -77, 'C2': 7137},
               {'C1': -94, 'C2': 57199},
               {'C1': 105, 'C2': 31385}],
        'B4': {'D1': -123949418, 'D2': 30, 'D3': -37},
        'B5': [7936754595639337728,
               11357037693960628255,
               16358534944194589154,
               2731570690575644408,
               3745117485826417409,
               6898742947127763400]},
 'A6': {'E1': 40357,
        'E2': 675000728,
        'E3': [0.5615966320037842,
               0.3424358665943146,
               0.39499443769454956,
               0.10217899829149246,
               -0.2181418091058731,
               -0.43213218450546265],
        'E4': [-31806, 12515, -11594, 21572, -1068, -13326, -31301]},
 'A7': -6886}

(b'HSVp\x10\x0fK\xd8sdwvgttr\xd6\xbaVhJ\x00\x88$M\x81-\xafS\x03\xe2\xbe'
 b'\x0e\xd3\x0b\xbf\x9c\'\x1c\xbfM\x85\x0f\xbf"\x03M?\x0f\xdd?\xbfV\xb4Yp'
 b'\xb0Qu\x0b`uR\r\xee\x9fV\xf8\xa0]\xa9\x9c\xf9\x99_\xd3\xa2N\xa0\x85\xfee3|'
 b'\xca3G\xdf\xc7B\xb4\x8c\x957\x91,\x04]\xd2SD\x00\x00\x00\x04\xfc\x95X'
 b"\xd3\xbcWd\r_\x01\xe3\xcb0\x98'\xdd\x94\x83\x7f\xc9Hf]\x87Ij\x07<\xe3\x9dM"
 b"\xad\xfb+!q4\xeb/y\x1b\xbf)\x17'\xf5\x82")

{'A1': -666169584,
 'A2': 'sdwvgttr',
 'A3': 47830,
 'A4': 26710,
 'A5': {'B1': 1319293791,
        'B2': -96,
        'B3': [{'C1': -123, 'C2': 26110},
               {'C1': 51, 'C2': 51836},
               {'C1': 51, 'C2': 57159},
               {'C1': -57, 'C2': 46146},
               {'C1': -116, 'C2': 14229},
               {'C1': -111, 'C2': 1068},
               {'C1': 93, 'C2': 21458}],
        'B4': {'D1': -1666622048, 'D2': -7, 'D3': -103},
        'B5': [7230455342676966404,
               2853084016184221453,
               6730146723416741085,
               5592876159225973127,
               3452911199802096557,
               9436491574662863737]},
 'A6': {'E1': 9352,
        'E2': -1355972275,
        'E3': [-0.44143161177635193,
               -0.5461891889572144,
               -0.6099793910980225,
               -0.5606277585029602,
               0.8008290529251099,
               -0.7494668364524841],
        'E4': [-19370, 28761, 20912, 2933, 30048, 3410, -24594]},
 'A7': -1962}

Вариант №23

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

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

(b'<GRVC\nW\x87\xc9\xd4\n\xbc>v;A\xd4-7}v8^N!\x95bprlgfjmH"\xf5\xc1\x14\xe1'
 b'P\xfa\x8d\x00\xaa\x85G\x16\x9a\x1e\xd9\xe4J\x81m\xe1\xbf#\x1e\xc8\xe1r}\xda'
 b'\xdb~\xee\xd4\xd4\xf4j\xa7u\x1b_\x0b\x1dt\x86E\xa9O@&\xd5\xfc\xe7I\xed\xc6^6'
 b'\xb9\x1b\xc0ejJwa\x06\x14\x1a\x0e\xc7k\xdd\x87\x87u\x84X\x1f\xba\x17\xc0'
 b"\xd2?h\x00\x14\xd2\xed@\xe8\xbf\xb8\x19'\xbc\xfe\xac\x1e\x97DoI\xb4\xa1^"
 b'Sv\xbaF\xbf\xe5K')

{'A1': -913877238,
 'A2': -3152172885137945900,
 'A3': 2399959248034150189,
 'A4': 149,
 'A5': 'bprlgfjm',
 'A6': {'B1': [{'C1': -409580086821051832,
                'C2': 2242510989,
                'C3': 71,
                'C4': [39446, 55582, 19172, 28033, 49121, 7715, 57800],
                'C5': 15336144859725200754,
                'C6': 27380},
               {'C1': -8758343440651291225,
                'C2': 1078962501,
                'C3': 38,
                'C4': [64725, 18919, 50925, 13918, 7097, 26048, 19050],
                'C5': 7766191587591610743,
                'C6': 34781}],
        'B2': 13841736623538337159,
        'B3': {'D1': [210, 63],
               'D2': -0.7579259017075062,
               'D3': 184,
               'D4': 10009,
               'D5': 5291523503029026492},
        'B4': 41396,
        'B5': 21342,
        'B6': -0.7762826681137085,
        'B7': 19429}}

(b'<GRVC\xfbMs\xd4\x1e\xd4\xd75\x94\x939Kr\xb9\x9e\xca\x88(\xf8Y\x85nkxrzz'
 b'ggg\xd2\x98-/-\x94U\x8cn\x19\xc4\xb1\xb0\x0f1\x8c\x104\xa4\xecw\xa2\xafL\xb6'
 b'\x99HN6.\x16\x99}\xf4\x8c"D\xbe0,\x997\x9eH\x01\xd0\xf0\xa6\xcfl\x19\x19\xc5'
 b'\x03\xd0\x0c\xec\xff\xb8\x0e\x81SqP\x07_n\xd7\x02\xe4\xe6\xa2\x97'
 b'\xff\x02\xb6.\xa1X\x9c$\xf3@\x10LBb\xf7p\xd2?\x84B\xfaU^\r\x82{\x8e\xf9'
 b'\x84~\xdb\xa4\xca;N\x10?\x9c\xbb')

{'A1': -730640901,
 'A2': 5420525891284882462,
 'A3': 6482976231579892082,
 'A4': 133,
 'A5': 'nkxrzzgg',
 'A6': {'B1': [{'C1': 6166603470428754535,
                'C2': 3290001036,
                'C3': 177,
                'C4': [4016, 35889, 13328, 60580, 41591, 19631, 39350],
                'C5': 17617405637886889544,
                'C6': 8844},
               {'C1': 5232680948062010948,
                'C2': 2800799745,
                'C3': 207,
                'C4': [6508, 50457, 53251, 60428, 47359, 33038, 29011],
                'C5': 16637426047706400592,
                'C6': 38818}],
        'B2': 2638080931028927231,
        'B3': {'D1': [243, 64],
               'D2': 0.2881449183998379,
               'D3': 132,
               'D4': -1470,
               'D5': 9581846343321476693},
        'B4': 56190,
        'B5': -13660,
        'B6': 0.5636937022209167,
        'B7': 48028}}

Вариант №24

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

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

(b'GJQR,.\r/\xc3\x0b\xdeI\x00\x00\x00\x02\x00\x00\x00fR?\x12\x13\xaf\xbf4\x0b'
 b'w\xbf\x1a3r\xbf\x19\xbc\x94>\x81\x85Om\xdb\xc7\x0f\xdf\x00ni\x00\x00\x00'
 b'\x02\x00\x00\x00\x8a\xe2>\xe9\xe5\x08=*\xb2\xd4\xbd\x9d+\xaf=\xa9'
 b'\xe0.\xbd\xcf\x9d\xdb\xba\xd7\x12_\x16\x00\x92\xcaN\xc6\xc2av\xd4'
 b'\xe3\x08\x84\x0b"d\xa2\x11\xfa-\x00\x00\x00Z\x00\x00\x00`?\xbf\x1df <'
 b"\xc0\x9e<\xe2S\x96>^\x06'v\xce#\xb4so\xb8\xc8P\x99&\x88\x00\x00\x00~\x00\x00"
 b'\x00\x843bJ\xdd\xc3-y\xaa6\xb6bz>\x93b\x9a')

{'A1': 3183496485384478281,
 'A2': [{'B1': [{'C1': 118, 'C2': 212, 'C3': 3808986123},
                {'C1': 34, 'C2': 100, 'C3': 2719087149}],
         'B2': 82,
         'B3': [0.5706128478050232,
                -0.7032999396324158,
                -0.6023474931716919,
                -0.6005337238311768,
                0.2529701888561249],
         'B4': 109,
         'B5': -607711265,
         'B6': {'D1': [16319, 7526],
                'D2': 8252,
                'D3': [192, 158, 60, 226],
                'D4': 21398,
                'D5': 0.2168203443288803},
         'B7': 105},
        {'B1': [{'C1': 118, 'C2': 206, 'C3': 599028591},
                {'C1': 184, 'C2': 200, 'C3': 1352214152}],
         'B2': 226,
         'B3': [0.45682549476623535,
                0.041674450039863586,
                -0.0767434760928154,
                0.08294712007045746,
                -0.10137530416250229],
         'B4': -70,
         'B5': -686661866,
         'B6': {'D1': [13154, 19165],
                'D2': -15571,
                'D3': [121, 170, 54, 182],
                'D4': 25210,
                'D5': 0.2878616452217102},
         'B7': -54}],
 'A3': 1321648737}

(b'GJQR\x91u\x1f\xf3\n\x87\xe6\t\x00\x00\x00\x02\x00\x00\x00f\x9d\xbe\xa1\xe4'
 b'C\xbe\xdd\xaa=\xbe\xa8\xdes\xbd\xf0_\xb8\xbf\x0f\x12\x02\xe3\xbd\x92'
 b'\x9a\xf8\x00n\xef\x00\x00\x00\x02\x00\x00\x00\x8a\x08\xbd\xb3P\xfb?\x18'
 b'\xf7\xd4>\x8b\xd3\xcb\xbe\xb9*\x81>\x854wv"\xd2\x1f\x9f\x00\x92\x104\xbb'
 b'\xf7HL>L\x8f1\x1e\xbc\xc8S\xed\xbd\xef\x00\x00\x00Z\x00\x00\x00`$\xc4'
 b'(\xbb\xae\xe8\xefI\x10%\xfa?>\xa4\xb9\xe7;\xec\xe7h_\x12`\xd4\xceaDB\x00\x00'
 b'\x00~\x00\x00\x00\x84\xfb\xfb\x14\xe9\x1fR\t\xa2e\x1e\xbb\x85\xbf\x17'
 b'\xa8\xb2')

{'A1': 10481318836488889865,
 'A2': [{'B1': [{'C1': 76, 'C2': 62, 'C3': 1284452638},
                {'C1': 188, 'C2': 200, 'C3': 1408089583}],
         'B2': 157,
         'B3': [-0.316194623708725,
                -0.43293944001197815,
                -0.3298221528530121,
                -0.11737006902694702,
                -0.5588685274124146],
         'B4': -29,
         'B5': -1114465544,
         'B6': {'D1': [9412, 10427],
                'D2': -20760,
                'D3': [239, 73, 16, 37],
                'D4': 64063,
                'D5': 0.3217308223247528},
         'B7': -17},
        {'B1': [{'C1': 59, 'C2': 236, 'C3': 3882376978},
                {'C1': 96, 'C2': 212, 'C3': 3462480962}],
         'B2': 8,
         'B3': [-0.08755680173635483,
                0.5975315570831299,
                0.27310022711753845,
                -0.3616524040699005,
                0.26016589999198914],
         'B4': 118,
         'B5': 584195999,
         'B6': {'D1': [-1029, 5353],
                'D2': 8018,
                'D3': [9, 162, 101, 30],
                'D4': 48005,
                'D5': -0.59241783618927},
         'B7': 16}],
 'A3': 884733768}

Вариант №25

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

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

(b'TFBNm\xc6b\xa2s\xc4\x1b\x96\xbb\x10\xd7p\xaa\xf5\x9e2\x05\xcd\xa1\x02L0H\x17'
 b'.BP(2h\xd3\xa8\x9a\x15\xd8\x14\xd2\x14\xfc\xb2O\x06\xa8\xc0J\xea^gybllkqck'
 b'I\x00\x00\x00\xa1O\xdf/\xa4\x03\xc4\x18\x8e\xf0=S\x0f\xb0-\xb1\xbf|z\\'
 b'.Xi\xee\xa8K\x7f\xef\x93\\s\xce`Dxd\xfaM\xc0\xed\\uS<\xb5Ma\x96.\xc2\xb4\xb6'
 b'}*\xf6\xba<\xf9Q\xc0')

{'A1': 10816454930985043565,
 'A2': [{'B1': 1893142715, 'B2': 849278378, 'B3': -13051},
        {'B1': 810287777, 'B2': 1110316872, 'B3': 10320},
        {'B1': -1462540238, 'B2': 349705626, 'B3': 5330},
        {'B1': 105886460, 'B2': -364199768, 'B3': 26462}],
 'A3': 'ybllkqck',
 'A4': {'C1': -0.06710338949346073,
        'C2': {'D1': 124,
               'D2': [122, 92, 46, 88],
               'D3': 105,
               'D4': 238,
               'D5': 168,
               'D6': [2481946443, 1624142684, 4200888388]},
        'C3': 77,
        'C4': 1969024448,
        'C5': 13992286436946426963,
        'C6': -487309093225253196,
        'C7': 81,
        'C8': 192},
 'A5': [20385, 12255],
 'A6': 932,
 'A7': 6340,
 'A8': 142}

(b'TFBNH\xb6.|k\x18\xd4\xd2\xf0\x9aM\x9f\x90\xe5\xd4\xd4-\xb1\x89\x9f'
 b'.\x1b\x97\x92\xb7\x87\xe6\xe7\xf6Z\x97\xc5/\x0bX\x8d\xd4\xf7\xd4\x1a'
 b'L\xb4\r\n\x9dX\xe99uudlimotI\x00\x00\x006d\x9a\xa9\xe1t=\xe0RT3\xe7'
 b'\x92\xc7\x08\xde?\xab\x8e\xd0.\xe3\xd7\xfa"\x94\x7fe\xb7\n\xb5\x9d'
 b'\x03\x1f\x07\xafc\x89j\xb0\xa6\xe6\xe9\x16\xba$\xdfp\x07\x10\x1b\xab'
 b'\xb9\xa9zV\x1f\xee\xbd\xb2')

{'A1': 15191794292951529032,
 'A2': [{'B1': -1622304016, 'B2': -724245104, 'B3': -20179},
        {'B1': 456040329, 'B2': -2018012521, 'B3': -6170},
        {'B1': -979936522, 'B2': -1923609809, 'B3': -2092},
        {'B1': -1270080812, 'B2': 1486686733, 'B3': 14825}],
 'A3': 'uudlimot',
 'A4': {'C1': 0.4692858633614396,
        'C2': {'D1': 171,
               'D2': [-114, -48, 46, -29],
               'D3': -41,
               'D4': 250,
               'D5': 34,
               'D6': [3076882324, 60667146, 1672415007]},
        'C3': 137,
        'C4': 3869683818,
        'C5': 1155015933140014825,
        'C6': -1288215883571156197,
        'C7': 189,
        'C8': 178},
 'A5': [25654, -22118],
 'A6': 29921,
 'A7': 57405,
 'A8': 82}

Вариант №26

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

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

(b'\x9aQUAH\x04\x00L\x00p\x89H`\xc1\x8f\xca?\xe4\xcf\x0c\xbe\xb0D\x9a'
 b'\xa0j\x00\x00\x00\xces\xd7\xaa\xf7:\x83m\x0f)\xd7\x9a\xde\x07Y(\xf7\xe1?'
 b'-\xd5%r7\x0f\xf1/jF6\xe1\x9a\xc1\xbfs\xff3\x03?\xc3\xf8\xae\xaa'
 b'\xfb\xf4\xd7\xe1\xfb\xcb\x11&\xb5Bt\xd9\xbe\x9c\x03\x00bGN]P\x00V\x00'
 b'\xc1\xf6hIQP\xffZ}\xda\x02\x00\x00\x00\\\x00\x00\x00\x05\x00`\x00\x00\x00'
 b'\xbc\xaa\x8e\x05p\xdc')

{'A1': [-5, -53, 17, 38],
 'A2': 0.20751206590018567,
 'A3': 11572637718375354340,
 'A4': {'B1': [{'C1': 3648275125, 'C2': -25410},
               {'C1': 1197604867, 'C2': 23886}],
        'B2': [63169, 18792, 20561, 23295, 55933],
        'B3': -21828,
        'B4': 1422,
        'B5': -9104},
 'A5': {'D1': 29646,
        'D2': 215,
        'D3': 15503940155227174826,
        'D4': 0.5614206065065048,
        'D5': [45, 213, 37, 114, 55, 15, 241, 47],
        'D6': 8340597905861002858,
        'D7': 0.5125121474266052},
 'A6': 16273745140264138947}

(b'\x9aQUAH\x05\x00L\x00|\x17(~J\xb1\xe3\xbf\xca\x97R\x9f6\xc5\xa4\xd8{\x00\x00'
 b'\x00\xcbH)\xfe\xbc\xc3)\xb6\xbf]V\xd2Sr4/l\xed\xbfR\xc2\x80O\xa4\xe7\x8b\x83'
 b'\xf5u\xae\xe6\xd7l\x8b\xcd\x86g\x10?\x02\x93\xdaQyEK\xf8>O\xc1$`\xb4\xc7\xab'
 b'\xbf\xfe`N\xb9\xe7\x85!6\x81\x8f*K\xb6\xa9\x8cs\xae\xbfEIQ\x00W\x00]\x00c'
 b'\x00c\xa3&z\xc7\x05\x11\xbe\x06$\x04\x00\x00\x00i\x00\x00\x00\x05'
 b'\x00q\x00\x00\x00\xff\xcdvg\xa0\x83')

{'A1': [62, 79, -63, 36, 96],
 'A2': -0.6153919662472016,
 'A3': 15610819046764877770,
 'A4': {'B1': [{'C1': 3215706036, 'C2': 24830},
               {'C1': 2246555982, 'C2': 13857},
               {'C1': 1261080449, 'C2': -22090},
               {'C1': 3215881100, 'C2': 18757}],
        'B2': [41827, 31270, 1479, 48657, 9222],
        'B3': -12801,
        'B4': 26486,
        'B5': -31840},
 'A5': {'D1': 18635,
        'D2': 41,
        'D3': 6223341049201540350,
        'D4': -0.9194561027858248,
        'D5': [82, 194, 128, 79, 164, 231, 139, 131],
        'D6': -3635692599627581963,
        'D7': 0.5640796422958374},
 'A6': 17891470332026065666}

Вариант №27

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

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

(b'\x1dWJN\xeap\x83T\x00Z\x00h\x00w\x00\x85\x00\x93t~\xe1\xb3\xd8\xc9'
 b'\xc7\x9eM\xe0 \xacY\xf3_\x17\xb2]y\rf\x11C\nbh~&\xbeB[\xff>\xa3'
 b'\x91\xc4\x86\x11\xbc\xf3\xdb\x9d\xed\xe0\xeb\xd0\xf3\xc2\x9cZ'
 b'\x00\x00\x00\xa7>\xd8S\x0b\x97\xa0\x88M\x88\xf3\x19X\xce\x96\xd4\xd3qa4\x0f'
 b'\x00\x02\x00\x00\x00X\x1a\x81\xaf\xf4um!\x02\x00\x02\x00\x00\x00f'
 b'\x98\x11 \xccfoa@\x88\x00\x03\x00\x00\x00t\xeb\xb8\x9f\x19cr\xd9r\x00'
 b'\x02\x00\x00\x00\x83\x89f\xe2\xcddpz\xb5\x00\x02\x00\x00\x00\x91\x94'
 b'\xaf\xefS\xf0\xd4\xd2\xb74\xa6/\xed\x00\x00\x00\x04\x00\x9fO\x1a*\xd7')

{'A1': -361725100,
 'A2': [{'B1': 13327, 'B2': 'qa', 'B3': 444706804},
        {'B1': 8450, 'B2': 'um', 'B3': -1743707956},
        {'B1': 16520, 'B2': 'foa', 'B3': -340222183},
        {'B1': -9870, 'B2': 'cr', 'B3': -1989745971},
        {'B1': 31413, 'B2': 'dp', 'B3': -1800409261}],
 'A3': {'C1': [1954472371,
               3637102494,
               1306534060,
               1509121815,
               2992470285,
               1712407306,
               1651015206],
        'C2': {'D1': [-0.1898040622472763, 0.31947147846221924],
               'D2': 34321,
               'D3': -4831276503891121200},
        'C3': 62402,
        'C4': -100,
        'C5': 90,
        'C6': {'E1': [-3884, -11593, 13478, 12269], 'E2': 1327114967},
        'C7': 0.42250856757164},
 'A4': -1751087027,
 'A5': -8578484995996855085}

(b'\x1dWJN\x91=\x81\xe4\x00[\x00i\x00x\x00\x87\x00\x95V\xdb?\xa7j7\x91C\x1dX'
 b'?E>\xae\xf6\x04tj\x00\x15\xc1\xfc\xc3r\xd8\xc4$\x05?;\xdec\xbfRu\xd7\x02\xfd'
 b'\xbb6\xce\xe3\x89\xf0\xbd\xe3\x1a,\x10\xab\x00\x00\x00\xa9\xbe\x83\x97\xb6'
 b'\x8f\xd8\xe1\x8b\xc5\xed\xba\x1aI\xc7\x84zkpxCU\x00\x03\x00\x00\x00X\x83'
 b'\xca1Lfb1\xd5\x00\x02\x00\x00\x00gW\xc5\xd1\x11tiw\xf2\xa7\x00\x03'
 b'\x00\x00\x00u\xbePz\xd2aou\x8d%\x00\x03\x00\x00\x00\x84Cq*mmx\xb32\x00'
 b'\x02\x00\x00\x00\x93\xea&\x8a\x86\xf4.\x18\xfa\x98\xdb\xe3\xd5\x00\x00\x00'
 b'\x04\x00\xa1\xb1\x82$\x97')

{'A1': -1858240028,
 'A2': [{'B1': 17237, 'B2': 'kpx', 'B3': -2083901108},
        {'B1': 12757, 'B2': 'fb', 'B3': 1472581905},
        {'B1': -3417, 'B2': 'tiw', 'B3': -1102021934},
        {'B1': -29403, 'B2': 'aou', 'B3': 1131489901},
        {'B1': -19662, 'B2': 'mx', 'B3': -366572922}],
 'A3': {'C1': [1457209255,
               1782026563,
               492322629,
               1051653636,
               1953103893,
               3254567794,
               3636732933],
        'C2': {'D1': [0.7338621020317078, -0.8221105933189392],
               'D2': 765,
               'D3': -4956546863207498269},
        'C3': 6700,
        'C4': 16,
        'C5': -85,
        'C6': {'E1': [-3026, 6394, -26405, -7211], 'E2': 2978096279},
        'C7': -0.2570168375968933},
 'A4': -1881611893,
 'A5': -4184483856687594374}

Вариант №28

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

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

(b'FHQE\xa8\x02\x8f\x02\xed\xf5|\x17\xe4`\x15.h\xbf\xd4\x03\x00\x00\x00I'
 b'\x00\x00\x00\xc7\xf3\xb9\xfb\x82\xe1\x02\x0ca\xce\xdfpO\x83\x07\xab\x8f'
 b'\xcf\xf2<\xbe\x03\x00L\x00\x00\x00\x06\x00\x00\x00s\x00\x00\x00\x9c\xe3'
 b'i\xdf\xb3\x1b(\xc6\x1a\x81\x00ghd\xf1\xa9\xd5\x1b\xf0\x01\xe8\x12\xdb0\xf4c'
 b'\xb4N\xc0\xe6\x1c$\xdc\xd9\xab\xa7u\x0c\x08Y\x82\x88\x9a\x15\x13\xb9'
 b'\xd2\xc9\xd6\x8cg\x99\xbfBY\xc6\x9f\x0f\xff<\xedv\x0b\n\xd1\x9b\xccF\x7f\xa0'
 b'H=\x08T\x1a\xc4\x90\x0c:`{0\xfe^\xc5\x916\xd1\x9cjR\x02\x00\x00'
 b'\x00\x7f\x00\x1e\xecoQ\xe4\xd5\xb2\xdcNC')

{'A1': {'B1': -2011001312912437502, 'B2': 96, 'B3': -0.9069531559944153},
 'A2': -44,
 'A3': {'C1': 'ghd',
        'C2': 865502031093822407,
        'C3': 12323963282542022241,
        'C4': 143,
        'C5': -0.18451999127864838},
 'A4': {'D1': [{'E1': 241, 'E2': -2660809334801574487, 'E3': 3026449456},
               {'E1': 78, 'E2': -6364754108836157760, 'E3': 1493699701},
               {'E1': 130, 'E2': -2969610786943165816, 'E3': 3214501772}],
        'D2': [22850, -24634, -241, -4804, 2934, -12022],
        'D3': -100},
 'A5': 1929273589821827555,
 'A6': {'F1': [1218477894,
               441714749,
               973902020,
               4264590176,
               915522910,
               1382718673],
        'F2': [155, 204],
        'F3': -5090,
        'F4': 4850056509375402351}}

(b'FHQE\xa8SX\xc5\xce\xef\xd5?#z\xd2\xc4+?\xec\x03\x00\x00\x00I\x00\x00\x00\xf3'
 b'\x93h\x1c\xdf\x0fj\x8e\xe4\x10\xa08\xbe$\xa2P-\xe0\xf3\xff=\x02\x00L\x00'
 b'\x00\x00\x05\x00\x00\x00f\x00\x00\x00\xea[\x93\xca\x82\xaf\xdfG\xf4r\x00pct'
 b'\x0c$\xb5\x906!AfC\xae\xfb~K\xe4\xb8\x87\x89\x18\x1d\xd0\x0b1HA\xbfp\x86\x8c'
 b'_{\xfe\x94#\r\x7ft\xa0\x8b\x9a\x05\x07\xcep2\x9b\xc3>f\xc5\xc0\x18{'
 b'e\xe5\x88\xbdyI\xb1\x92\xdd3\x02\x00\x00\x00p\x00\xaf\xce_O_\xd0_\xe3'
 b'\xfe\xb4')

{'A1': {'B1': 2539983940803188819, 'B2': 122, 'B3': 0.6709719896316528},
 'A2': -20,
 'A3': {'C1': 'pct',
        'C2': -8184711921863715853,
        'C3': 5810246868673761508,
        'C4': 45,
        'C5': 0.12497687339782715},
 'A4': {'D1': [{'E1': 12, 'E2': 4856640859070838052, 'E3': 1266613166},
               {'E1': 228, 'E2': 3534147155986581432, 'E3': 1891582280}],
        'D2': [-29562, 31583, -27394, 3363, 29823],
        'D3': -22},
 'A5': 17602283613507457883,
 'A6': {'F1': [3456566682,
               3281728112,
               3234162238,
               3848633112,
               1232715144,
               870159025],
        'F2': [160, 139],
        'F3': -12625,
        'F4': 13042111571568840543}}

Вариант №29

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

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

(b"VQI`\xe8\xa9V\n\n\xa8\xed'\x00\x00\x00\x80*K\xdf]\xf0\xe6\xbf\x81"
 b'\xe9\xd1\xe6\xcb\x0fO\x0by\x00vvknsr$>ri\xfe\xc4,j\x06\x00!\x00!'
 b'\xc4\x82>\xa7\xbeaD2\x15\xe8c\x7fk\x85\x87\xd1\xaa\x02\xc3\xe1@\x8f\xa3\xc3'
 b';;\xae\x19|\xed\x10\x8d\x9f\x9f\xc0\xe5<I\x947\x00@\x00I\x00R\x00\xaf'
 b'\x82\xe4\xb8\x8c\xc0\x0e\x07\xf8\x04\x80\x05H\x8e\xd5v\xd8\xa0\xa0t\xca'
 b'p\x04\x00\x00\x00[\x00\x00\x00ra\xb6-Y7\xcf\x18\x8c\x93\x0e\x9b\x12\xba\xfb'
 b'\xc98\xc4m\xee?\x05\x00\x00\x00c\x00\x00\x00\x02\x00\x00\x00w\x00\x00\x00')

{'A1': -1321795451113314208,
 'A2': {'B1': 7650706463965462052, 'B2': 'vvknsr', 'B3': 0.2554025948047638},
 'A3': -0.7168416367724859,
 'A4': 814887426002643329,
 'A5': {'C1': [{'D1': 7199027309991542439, 'D2': 127},
               {'D1': -2178894862034172565, 'D2': 64},
               {'D1': 8942370104549811087, 'D2': 237},
               {'D1': 5277345478845893904, 'D2': 148}],
        'C2': 24946,
        'C3': {'E1': -74,
               'E2': 22829,
               'E3': 1340681340946272055,
               'E4': 0.9508992299232581,
               'E5': [-1192983889, 118407308, 92275960, 1993707080, 1956683992],
               'E6': [202, 112]}}}

(b'VQI\xb1\xddM\x0f\xea]\xcb &\x00\x00\x00\x80\x16\x90^\xbb\xa6\xbc\xbf\xf3'
 b'\xdfz\xf8\xc3\x8c)\xef|\x00ttmvb"\xe9\x10\x03\x0e(&\xeb\x05\x00!\x00\xc6\xc6'
 b'@?\x1ab)\x9a<\xf8\xbb\xc8<0`\xae|L\xb7}\x9adP\xfaH\x8a\xe8};z\n\xf6zN'
 b'\x0e4\xae\xb96\xffi\xfa\xd8t%\x8f\x1d!w6\x00?\x00H\x00Q\x00Z\x00~:\x8d'
 b'\x18^\xbd\xf7\xb0\x0e^\xdd,\x8a\xb2\x0b\x05\x00\x00\x00c\x00\x00\x00'
 b'\xa3\xc1\xc4\xd0\xd7\x1c\xeb;\xfb\x97\x1ak}D\xacZ:h}\xe7\xbf\x03\x00\x00'
 b'\x00m\x00\x00\x00\x03\x00\x00\x00y\x00\x00\x00')

{'A1': 2363085689346448817,
 'A2': {'B1': 16944274688674162978, 'B2': 'ttmvb', 'B3': 0.7530330419540405},
 'A3': -0.11191912707007567,
 'A4': -1213283851284324365,
 'A5': {'C1': [{'D1': -3982316506310942182, 'D2': 60},
               {'D1': -7314488680642617296, 'D2': 100},
               {'D1': 8807771933959060048, 'D2': 10},
               {'D1': 3943374487341136630, 'D2': 255},
               {'D1': 2386220768613169769, 'D2': 119}],
        'C2': 49571,
        'C3': {'E1': -60,
               'E2': -10288,
               'E3': 9037346317306424092,
               'E4': -0.734058488820104,
               'E5': [411908734, -1325941410, 752705038],
               'E6': [138, 178, 11]}}}

Вариант №30

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

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

(b'YWB\xe2b?\xed\x96\x054p\xbe\xc6\x81\x00u\x9eX\xa9\x00\x02\x00\x96\xbf'
 b"\xe2\xc8I\xd3\x1c\xde\xe4Ow\xf3'\xd926\x06\xc7\x18\x8c\xda\xea\x08\xbf\x0bj"
 b'-\xbfN+\xfc?\ri\xde\xd3\xe5!\xe1J+W=?\x03\x04\x9e?q\xa0P\xbfN?'
 b'\xd6\x00\x00\x00%\x00\x00\x009?\xda<\x07\x8ew\x82\x88\xbf\xd8Y\t\xd7\xb7C'
 b'd\xbf\xe6\xaa\xda\xd5)e\\\xbfLl\xdb\x00\x03\x00U\x87odoio^\xd1p\xc4\x00'
 b'\x02\x00MZM\xfe\xbc\xfc\xa5\xc5\x8e\xbd\xf4i\xffG\x00m\x10\xfe\xc9\xa4cE')

{'A1': -7582,
 'A2': 0.9245630287386681,
 'A3': -127,
 'A4': {'B1': 135,
        'B2': 'odoio',
        'B3': 1590784196,
        'B4': [{'C1': 906413848,
                'C2': -1931810296,
                'C3': -0.5445888638496399,
                'C4': [-0.8053586483001709, 0.5523966550827026]},
               {'C1': 3555008993,
                'C2': 1244354365,
                'C3': 0.5117892026901245,
                'C4': [0.943852424621582, -0.8056615591049194]}],
        'B5': {'D1': 6507137124266263950, 'D2': -0.11934279650449753},
        'B6': 71,
        'B7': {'E1': -0.7985360026359558,
               'E2': [0.40991391098763375,
                      -0.38043447557452326,
                      -0.7083563006701001]},
        'B8': 285133220},
 'A5': {'F1': 40536, 'F2': 169, 'F3': [99, 69]},
 'A6': -0.5869492648407371,
 'A7': 20343,
 'A8': 4079474994}

(b'YWB\xf3\x93\xbf\xe3\xd3\xdd\xf2\xac\xfbZL\x00\x85s\xc3\xf2\x00'
 b"\x02\x00\xa6\xbf\xdd\xe9]\xf9\xf9\x8d\\\x1d\xe4nB'\xa8\xd7\xe8\xa4\xbd2h\x99"
 b"E\xbfSv\x94?cC\xc9?e;\xdf\xdcs'\xae\x8eH^u\xbe\xef\xe3\xcc\xbf\x12\xc1"
 b'\xc6?U]\xcdHr\xd0\x9f\xc9T\x1b\xd2\xbfu\x8a\x8e>\n\x1en\xbf;8'
 b'\xae\x00\x00\x00%\x00\x00\x009\x00\x00\x00M?\xcd\x0c\xc6\xebP\xa8\xa8?\xddj'
 b'\xf7\xefz\x9d\xc0\xbeK\x8bh\x00\x02\x00m\novdek\x8a|\xae\x8c\x00'
 b'\x03\x00a\x8b\xed\xf1\xe9\xf0\ni\xef?\x1c\xceq{\x00}\x8e\xa7\xde*\x91O')

{'A1': -3181,
 'A2': -0.6196126689681976,
 'A3': 76,
 'A4': {'B1': 10,
        'B2': 'ovdek',
        'B3': 2323426956,
        'B4': [{'C1': 3622347965,
                'C2': 845715781,
                'C3': -0.8260281085968018,
                'C4': [0.8877530694007874, 0.8954448103904724]},
               {'C1': 3698534318,
                'C2': -1907859851,
                'C3': -0.46853482723236084,
                'C4': [-0.573269248008728, 0.8334625363349915]},
               {'C1': 1215484063,
                'C2': -917234734,
                'C3': -0.9591454267501831,
                'C4': [0.13488170504570007, -0.7313336133956909]}],
        'B5': {'D1': 10082981127809296879, 'D2': 0.6125250458717346},
        'B6': 123,
        'B7': {'E1': -0.19877398014068604,
               'E2': [0.2269524239539511, 0.4596538389837086]},
        'B8': 2393366058},
 'A5': {'F1': 29635, 'F2': 242, 'F3': [145, 79]},
 'A6': -0.4673685971412931,
 'A7': 7652,
 'A8': 1849829288}

Вариант №31

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

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

(b'2VNQD\xcf{\x81\xb3\x11\x00\x07\x00\x00\x00;\x00\x02\x00P\x00fnr\xc8\x05\xfb|'
 b'`e\x04\xe98j\x91qJt\xef*\xc7\x89u\x00\x00\x00\x02\x00w\x10\xa9\xbd'
 b'\x99\xda\xe2\x84|qGi{O.\x88\xc0e\xddfS\x8bAY\xeb\xa3\xdb\xcc\xb4\xcbQ\xba'
 b'zv>\x8c\x9b\x08\xbf\x0e\x81\x88\xbe\xaa\x809>\x9f\xb6?\xbe\x9duM\x00\x00'
 b'\x00\x05\x00\x00\x00R\xeb\xbf\xe2\xcf\x02Mz\rlVE8\xc9')

{'A1': 53115,
 'A2': {'B1': -127,
        'B2': 45841,
        'B3': [{'C1': 27003, 'C2': 79},
               {'C1': 11912, 'C2': 192},
               {'C1': 26077, 'C2': 102},
               {'C1': 21387, 'C2': 65},
               {'C1': 23019, 'C2': 163},
               {'C1': 56268, 'C2': 180},
               {'C1': 52049, 'C2': 186}],
        'B4': 'zv',
        'B5': {'D1': [0.27462029457092285,
                      -0.556663990020752,
                      -0.3330095112323761,
                      0.3119373023509979,
                      -0.3075355589389801],
               'D2': 235,
               'D3': -0.5877696526735412}},
 'A3': [1853016069, 4219232357, 82393194, 2440120948, 4012558217],
 'A4': 117,
 'A5': [22085, 14537],
 'A6': 1200699244170871932,
 'A7': 113,
 'A8': 71}

(b'2VNQD\xb4\x0e\xb42\xaf\x00\x04\x00\x00\x00;\x00\x02\x00G\x00U\xaet'
 b'\x07\x0b\xba\xbc\x99aZ\xa9\x80RRL\xaa<\xeaR\x83\xa9{\x00\x00\x00\x02\x00'
 b'f\x89\xd5Y%!I\xa0\xea\x19\xb1\xdd\x15\xaa%K\xcbt\\\xb0\xda\x8c\x19y'
 b'n\xbev\xd4\x8d>\x00g+\xbf.\xf9\x87\x00\x00\x00\x03\x00\x00\x00I\xb4?\xed'
 b'\xf6\x15J\x15^8mJ\xdcP')

{'A1': 46094,
 'A2': {'B1': -76,
        'B2': 12975,
        'B3': [{'C1': 56597, 'C2': 170},
               {'C1': 9547, 'C2': 203},
               {'C1': 29788, 'C2': 176},
               {'C1': 55948, 'C2': 25}],
        'B4': 'yn',
        'B5': {'D1': [-0.24104519188404083,
                      0.1253935545682907,
                      -0.6834949851036072],
               'D2': 180,
               'D3': 0.9362894484465363}},
 'A3': [2926839563, 3132922209, 1521057874, 1380756028, 3931276201],
 'A4': 123,
 'A5': [27978, -9136],
 'A6': -8514801504466919190,
 'A7': 25,
 'A8': -79}

Вариант №32

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

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

(b'LVK\xb6=\xffK\xd7\x91Y\n\xb0\xa4\r\x16*\xda\xfa{\xa3\xa6\xd2\xee\xd1'
 b'\x11\xfd=\xbav\x0c\xdbl\xcd\xb2\xc2\xb8\xa1\x00tB$W\xd2\x82\xbb\xf3\x7f8'
 b'\xc6\xbb\xb6\x89\xee\xb3\xdd\xa9ud\xe3\xc8*\xbe\xa5\x08\xb5\r\xb7O'
 b'\x0e;\x02\x00\x00\x00p\x00\xf4\x93\xe5\xc1\xd9\xbe:\xe8\xb9\xed\xbe\xe4'
 b'=\x9d\xe7\x84\x14\x04\xee\x81A<\n\xdc\x02\x00\x00\x00x\x00\xe6g'
 b'\xa9\xc4\x05\x8aJ\x0fP?pM#\xbe<l\xe4\xfe\xef\xf0\xd8\xbf\xce\x1cx\xed'
 b'\xaf\xc1\xe0\xbf')

{'A1': 15798,
 'A2': {'B1': 19455,
        'B2': [{'C1': [215, 145], 'C2': 89, 'C3': -370937745098100726},
               {'C1': [123, 163], 'C2': -90, 'C3': 8555218599278669522},
               {'C1': [12, 219], 'C2': 108, 'C3': 4788452998391182029},
               {'C1': [36, 87], 'C2': -46, 'C3': -5279408192194626686},
               {'C1': [137, 238], 'C2': -77, 'C3': -4743758378512832035}],
        'B3': 4255426345539274917,
        'B4': {'D1': [0.8127332925796509, -0.15947508811950684],
               'D2': -27660,
               'D3': -0.42530742287635803,
               'D4': 11330463746217338938,
               'D5': 34023,
               'D6': -2591192383547898860,
               'D7': [-0.3897056569273365, -0.5236434591360195]}},
 'A3': 3299436518,
 'A4': -30203}

(b'LVK\xe3\x87\xe1q\xa8\x12\xd2\x83\xa2\x17\xb0\x1es\xac\xea&Xc\xb9\xfeC'
 b'\x07\xfe\x0b\x12-W7\xb0W6\xae\xdb4\x0b\xda\x96S\xa9\xa1\xa2v\x91\xe0k'
 b'\xdb\xf9\xc1\x0c\x0b\x8f\xda\x15\xaa\x90T\x8b\x97\xde\x08@9\xb75-'
 b'\xff\x99\x02\x00\x00\x00p\x00\\\x93W`\x15<\xe6\xd8\xed\x87\x8dn\xdd;\xd8\xf0'
 b'\x10\xac\x13uYe5\\\x02\x00\x00\x00x\x00^\x99\xa7\x82\xe1\xfc\x1bg\x0e\xbe'
 b'\x88\x87y?\xa8\x9d+\xbe\xe8|\xdd\xbf\x1c5\xf9\x1e\x92n\xd0?')

{'A1': 34787,
 'A2': {'B1': 29153,
        'B2': [{'C1': [168, 18], 'C2': -46, 'C3': -1536726797199629693},
               {'C1': [38, 88], 'C2': 99, 'C3': 3247671466959044281},
               {'C1': [87, 55], 'C2': -80, 'C3': -7576731101445605801},
               {'C1': [83, 169], 'C2': -95, 'C3': -4469299898812893534},
               {'C1': [12, 11], 'C2': -113, 'C3': -2407302280485661222}],
        'B3': -7350106358114861048,
        'B4': {'D1': [-0.1390651911497116, 0.974724292755127],
               'D2': -27812,
               'D3': 0.009117207489907742,
               'D4': 4313725572240759014,
               'D5': 61656,
               'D6': 6644328260145753104,
               'D7': [-0.46074884959531426, 0.2567487051463375]}},
 'A3': 2192021854,
 'A4': -799}

Вариант №33

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

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

(b'RPWL+\x05\x00\x00\x00.\x00\x00\x00B\x00%\x01\xd8>n\x00\xc8D\x9f\x9bMTv'
 b'\x85\x94L}\xf1\tq\x80\xf8\xa2o/u\xc80\x18o\xcb\x15\x00\x00\x00\x1a\x00'
 b"\x00\x00\x1f\x00\x00\x00$\x00\x00\x00)\x00\x00\x00\xe4'\xce\xbd\x1f\xd8"
 b'\xdb?\x80\x9c+\x89Z\xd3\xb3\xbf\xa0\xc4`H\xfe\x8f\xb4\xbf\x16T\x9d4CQ'
 b'\xeb\xbf\x1aeh\x98$\xa8\x0c\xcb~\xbe\xcd\x1d\xb3\xf0C\x87.\x97`\x1an0'
 b'\x10\xde\xc75tI,Fhv\xb5\x94G\xd2\x8bFOR\x02\x00\x00\x00j\x00\x83[\xe4\xee'
 b'\x1c_\x0f\x9f\xed\xdf}\xcd\xd0\x9cO/\xa2r9\x1b=\xbcz')

{'A1': [{'B1': -56, 'B2': 1302044484},
        {'B1': 84, 'B2': 1284801910},
        {'B1': 125, 'B2': 2154891761},
        {'B1': -8, 'B2': 1966043042},
        {'B1': -56, 'B2': 3413055536}],
 'A2': {'C1': [0.43506616149590926,
               -0.07744375084767974,
               -0.08032216326752684,
               -0.8536697414043626],
        'C2': -1737988838,
        'C3': -888362972},
 'A3': 0.4218837320804596,
 'A4': {'D1': 1900685268844015795,
        'D2': [3725602926, 1232352711, 1986545196, 3527906485, 1380927115],
        'D3': {'E1': [48766, 7629], 'E2': -125, 'E3': 58459},
        'D4': [257891566, 2111827359, 1335677133, 963813935, 2059156763]}}

(b'RPWL+\x06\x00\x00\x003\x00\x00\x00K\x00k\x04\x00\xbey\x00\xab\xce$'
 b'\xbff\xa5\x12\x80;\xf8m\xf1<\xc2^\x8ec\xf8\xd9\x0c\x1e%t7\xc2\xf4Z'
 b'\xc2R\xce\x15\x00\x00\x00\x1a\x00\x00\x00\x1f\x00\x00\x00$\x00\x00\x00)'
 b'\x00\x00\x00.\x00\x00\x00x\x1e@\xecR\xeb\xe7?\xae7\x82E\xaam\xe1?\xc0'
 b'\xfa/F\xfc\xd2\xeb\xbf\x10R\xab\xe1\x8eM\xe2\xbfY\x9b\xac m89@\x94\x91p\xe0K'
 b'\xb4\x15$g\xa5\t\xb9\xa7\xe27\xd5Z\x8c\xff\xb81~\xb8\xcdld\xbb\x18\xb9'
 b'\xd6\xbe\x10\xea\x96\x03\x00\x00\x00s\x00T\x7f\xe2fs\xc5[\xf1\xect[\xfa^'
 b'\x1d|\xe6\x12\t\xaf-\xfaeS')

{'A1': [{'B1': -85, 'B2': 1723802830},
        {'B1': -91, 'B2': 4164648978},
        {'B1': 109, 'B2': 1589787889},
        {'B1': -114, 'B2': 215611491},
        {'B1': 30, 'B2': 3258414117},
        {'B1': -12, 'B2': 3461530202}],
 'A2': {'C1': [0.7474760641352551,
               0.5446368558493668,
               -0.8695050593231244,
               -0.5719675452806445],
        'C2': 548182873,
        'C3': 1077491821},
 'A3': -0.12501685321331024,
 'A4': {'D1': -2114518048946314219,
        'D2': [2354763063, 2117187839, 1684852152, 3602454715, 2531922110],
        'D3': {'E1': [37268, 57456, 46155], 'E2': 84, 'E3': 57983},
        'D4': [1539666790, 1534389489, 2082299642, -1358359834, 1399192109]}}

Вариант №34

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

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

(b'kVRZ*\x00\x00\x00\x90ua\xb1*\r\xc3\xbf\x9f\x00\x00\x00\x02\x00\x00\x00'
 b'\xa9\x00O\xb5\x1b\x85\x94\xb4\x1d\x95\xa6DA\x05`,pc\x07\x00\x00\x00\x1a\x00'
 b'\x02\x00\x00\x00(\x00\x00\x00p\x9b\x8a\xac4\x9d\xc8?\\\x16\xf7<\x86=\xd7u'
 b'V\xd2\x95\xbeJ>\xf3\xf0<S++\xbe9\xd1>\x11\x7f\t\xbf\xad\xc6\x9b\xbe'
 b'\x03\x00\x00\x00T\x00\x00\x00`\xaek\xdc\xc2\xd8\xa6\xbf\x08\xaa\xd4\x9d'
 b'\xff\xd5\xc0?\x16\x1d\xda\x86`\x16\xe7\xbf\x90R4v\x10\xda\xdc?\x90C~/'
 b'5i\xec\xbfI\x1a\x05ST\xe4\x15Wq\x8d\xbdK]\xf7\xbd\xdc*\xdc\xf3x?`\x00\x00'
 b'\x00>\x80\x19\xbe*/<?')

{'A1': {'B1': [{'C1': 79, 'C2': 181},
               {'C1': 27, 'C2': 133},
               {'C1': -108, 'C2': 180},
               {'C1': 29, 'C2': 149},
               {'C1': -90, 'C2': 68},
               {'C1': 65, 'C2': 5},
               {'C1': 96, 'C2': 44}],
        'B2': 'pc',
        'B3': 0.19229753899454805,
        'B4': 8491323269188097628,
        'B5': -0.29262036085128784,
        'B6': 3110671488835075658},
 'A2': -0.1488393179051113,
 'A3': {'D1': 10972,
        'D2': 0.9724709987640381,
        'D3': {'E1': [0.4086436629295349,
                      -0.5370951294898987,
                      -0.30425015091896057],
               'E2': [-0.044622506529631734,
                      0.13153071600511645,
                      -0.7214815744236229,
                      0.4508095888461776,
                      -0.8878427436448977],
               'E3': 6729,
               'E4': 5,
               'E5': 367285331,
               'E6': -0.06906383484601974,
               'E7': -0.12078341096639633}},
 'A4': [-0.14990326762199402, 0.7350946664810181]}

(b'kVRZ+\x00\x00\x006P\xe7\xb1\x8dN\xe9\xbf\xa0\x00\x00\x00\x02\x00\x00\x00'
 b'\xaa\x00\x04\x8cb\xcd\xabc$\x81\xf4j\x12\xb0\xc4\x81wyr\x07\x00\x00\x00\x1a'
 b'\x00\x03\x00\x00\x00(\x00\x00\x00\xa4\xda\x90\t\xd6\x9d\xe8\xbf\xfb\xc9\n'
 b'\xde\x1a/\xab,\xb9\xfdp\xbf$\x06U\xd3U\x8e\xc2\x86\xb8\x8f\xae>\xcd\xca*'
 b'?f\n\xf0\xbe\x03\x00\x00\x00U\x00\x00\x00.\x87\x12\\\xea/\xe8?\xd8\xbd\xb1'
 b'sWN\xc0?\xfe\xd9\xa7E\xa9\xb5\xe8\xbf\x84\x0b\xa7F\xf2\xd9\xe8'
 b'\xbf\xb2\xb4\xc8\xf4h\x8f\xef\xbf\x95 \xf1\xa9j\x05\xd5OX\xd4\xbeI%S?'
 b'\xa3a\xa7\x97\x1f=a\x00\x00\x00\tY\x87\xbe\xc9\xcf\xf7\xbe')

{'A1': {'B1': [{'C1': 4, 'C2': 140},
               {'C1': 98, 'C2': 205},
               {'C1': -85, 'C2': 99},
               {'C1': 36, 'C2': 129},
               {'C1': -12, 'C2': 106},
               {'C1': 18, 'C2': 176},
               {'C1': -60, 'C2': 129}],
        'B2': 'wyr',
        'B3': -0.7692671000321138,
        'B4': 3218718151127255547,
        'B5': -0.941371500492096,
        'B6': -8736263827876411868},
 'A2': -0.790839049785524,
 'A3': {'D1': 24995,
        'D2': 0.03896298632025719,
        'D3': {'E1': [0.3409402370452881,
                      0.667156994342804,
                      -0.46882933378219604],
               'E2': [0.7558490560806825,
                      0.127390796176299,
                      -0.7721754417860323,
                      -0.7766047840053578,
                      -0.9862561016976967],
               'E3': 8341,
               'E4': 241,
               'E5': 3573901993,
               'E6': -0.41473624110221863,
               'E7': 0.8247876763343811}},
 'A4': [-0.26435115933418274, -0.4840071499347687]}

Вариант №35

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

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

(b'\x1bTTHC\x00^\xbf\xa6\xe7m\xc0\xd2\xd7@\xb8\xa8\x88\xd9\x00\x02\x00\x88\xcd'
 b'\xcdbc<\xc0|\xf2\x94\xa6\xc7\x99\xdd^N\xfe\xc3\x9b\xeb\x07\xb1'
 b'\xd6\xe5\x1b\xce\xbf\xc6A\xa0\xe4y\xf1\xa86\x9f\x14iS\xfb\xd0\xaf'
 b'\xa9\xc9\xe3f\x051\x92\xf3\xeail\xdb\xac3\x8c\xa7\xa3v\xdd\xd8\xb1\x19vp'
 b'K\x86\x14\x16\x99welzyhic\xf2\x1f4\xcd\x0e\x02\xa4#9\x04\x1e\x0c4\xeb\xe9'
 b'"\x01\x848\xb6r\x8fH`\r\xc1+\x16\x0eR\x1f\xe3\xd7\\\xf6hs')

{'A1': {'B1': 101,
        'B2': 'lzyhi',
        'B3': [{'C1': 25586, 'C2': 523554062},
               {'C1': 676, 'C2': 590939166},
               {'C1': 3124, 'C2': 3957924353},
               {'C1': -31688, 'C2': 3060961096},
               {'C1': 24589, 'C2': 3240826382},
               {'C1': 21023, 'C2': 3822542070}]},
 'A2': -0.044734411037480104,
 'A3': -1196914471,
 'A4': 'hs',
 'A5': -842177949,
 'A6': 0.0234970785677433,
 'A7': {'D1': 10711468227405172478,
        'D2': 195,
        'D3': 11235082155801779150,
        'D4': -0.17387782245704142,
        'D5': 916395113,
        'D6': 1409011887,
        'D7': [-1446386842, 87134963, -362189605, -1405907801, -1552491048],
        'D8': 12761361243806503958},
 'A8': -26249}

(b'\x1bTTHC\x00^?\xe76\xaco\x11\xb9\xaali\xfd\xcc\x00\x02\x00\x88nqw\xba='
 b'\xa1\x16\xcee_\xc9@@#"\xeekq9\xfe\xd3D\xbc^r\xbf\xe9\xfb\xa1\x13\xbd\xd4\xf4'
 b'\xa0\xe0\xb5f\xa3\xfb\xd4\xb6\xaf\x16\xfc\xf9\x83\xfb=el\x94\xd8\x1f.*]3'
 b'9\xad\x03\xc9\xf9\xfc\x19\xda>MU\xd5om2yngur\x87\xeb\xc8h\x89g8\x02'
 b'\x93\xfa\xc6I3\x894\x8d|T/\xa2\xad\x8e_\xd2\xc0~\xfb\xb3<\xf8?1\xd7\x17x_tb')

{'A1': {'B1': 50,
        'B2': 'yngur',
        'B3': [{'C1': -30741, 'C2': 3362294119},
               {'C1': 14338, 'C2': 2482685513},
               {'C1': 13193, 'C2': 881687636},
               {'C1': 12194, 'C2': 2911789010},
               {'C1': -16258, 'C2': 4222827768},
               {'C1': 16177, 'C2': 3608639583}]},
 'A2': 0.7254240197487907,
 'A3': 1818885580,
 'A4': 'tb',
 'A5': 1852929978,
 'A6': 0.07865677773952484,
 'A7': {'D1': 7304778398409368302,
        'D2': 107,
        'D3': 8158832383303114354,
        'D4': -0.811966455991437,
        'D5': 2699081062,
        'D6': -1543777098,
        'D7': [-1357447943, -2080686747, 1821693983, 774528307, 967640009],
        'D8': 18013301034713961941},
 'A8': 28525}

Вариант №36

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

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

(b'\x87AXN\xb3\x06\x94\x14[\xde\xfb\xcfx\x07\x84R\xdd\xf9\x00D\x00\x03\x00\x82'
 b'd\x1e\xab\xa4f\xffpqG\xca&\xbe\x83\xd1\x0e\xbf\xee\xff\x07\xaa'
 b'\xba\xf7\x9d\xbf\x90~\xb7\t\x97\x1fR\xf3\x00\x00\x00,\x00\x00\x000'
 b'\x00\x00\x004\x04\xa4suwfguc\xcb\xb4$\x05\xc3\x93\xec0(a\x0e\x82\x1c\x00\x03'
 b'\x00\x00\x008fk\xbf\xd1\xe6\x00\xec%\xcb\xfc?\xea\xabJ\x1e\xa2\xc6p?\xd2'
 b'\xe6\xbe]\xffc\xac\xbf\xee\xcb)3\x1e\xdf6\xdc|}\x12\x01\x92')

{'A1': -5546583075898590257,
 'A2': 30727,
 'A3': -2074944007,
 'A4': {'B1': 1188,
        'B2': {'C1': 115, 'C2': 'uwfgu', 'C3': 7191039296835654636},
        'B3': 807952654,
        'B4': 33308,
        'B5': [{'D1': 186, 'D2': -9, 'D3': -25153},
               {'D1': 144, 'D2': 126, 'D3': -18679},
               {'D1': 151, 'D2': 31, 'D3': 21235}],
        'B6': 26219,
        'B7': [-0.2796633058671316,
               0.8334093664509066,
               0.29533347300962975,
               -0.9622999189805117]},
 'A5': {'E1': [56444, 32018, 402], 'E2': 100, 'E3': [30, -85, -92, 102, -1]},
 'A6': 8102336138175218641,
 'A7': 247459583,
 'A8': 1962}

(b'\x87AXN\x17\x1b\xf7{\xd8\x91\x9a%\xe7\x96\xd3sF\x98\x00<\x00\x02\x00z'
 b'=\xfa\xdfcE9\x94z\x0f\x12gb,\x89\x15\x02\xca`\x05\xfdz\x03\xe8\x84\x86X5\xe8'
 b'\x00\x00\x00,\x00\x00\x000\x1f}&frxfy\xdd\x93eC\xe3X\x80\xe7/<\xd46'
 b'\xebt\x00\x02\x00\x00\x004\xb0\xb6?\x9f\xb9\xd4}\xe0!\x00\xbf\xde\xaf\xd9-('
 b'\xa7\xd4\xbf\xcd\xb5\xff\x19X\xe2\xf0?\xe9\xd5\xf5i\xf6{\xc8\xd1t\x8d\x12')

{'A1': 1665196598529989157,
 'A2': -6250,
 'A3': -747420008,
 'A4': {'B1': 8061,
        'B2': {'C1': 38, 'C2': 'frxfy', 'C3': -2480527627499568921},
        'B3': 792515638,
        'B4': 60276,
        'B5': [{'D1': 122, 'D2': 3, 'D3': -6012},
               {'D1': 134, 'D2': 88, 'D3': 13800}],
        'B6': 45238,
        'B7': [0.030982322867232348,
               -0.47948293123283503,
               -0.2321165918126762,
               0.8073679990374041]},
 'A5': {'E1': [53620, 36114], 'E2': 61, 'E3': [-6, -33, 99, 69, 57]},
 'A6': 10698880436490349705,
 'A7': 352504416,
 'A8': 1533}

Вариант №37

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

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

(b'HCI@\x00\x07\x00\x00\x00L?^\x90\x9f\xd3m\x81D\x8d;\xfb1\x83$2\xaf\x9b0'
 b'\x00\x00\x00W\x06ds\xb1\xd8N\x00\x00\x00n\xa6\xaa}6o@\x00\x00\x00\x84'
 b'\xb8\xcf\x1f\x08oE\x00\x00\x00\x9a\x123\x00\x04\x00\x00\x00\xae\x03d'
 b'\xb0\x15\xf7Wsqpdzod\xdb8@G\xb9\x94\x88(\x0c\xf9\xa2\xd8\x00\x04\x00S?'
 b'\xd6\xf0\x9dRLT\xf0\x1c\xa3\xd6\x81e\\\x83\xb1\x9a\xf2\x92\x00\x03'
 b'\x00k\xbf\xe9\xf8\x93\xd1\xe3"z\x06\xf4\xe6\xa4C\xd3h\xb3@x\x00\x02\x00\x82'
 b'?\xe2\xafUx\xc5\xa9D"\x1b\xca[\xd6\xfexS\x00U\x00\x02\x00\x98\xbf\xd5'
 b'\xf9\x84\x06J\xa3\x10\xd5\xfb-\xa1\x15B\x15\xdd')

{'A1': 'sqpdzod',
 'A2': 0.8693942427635193,
 'A3': -3211768827818017999,
 'A4': -125,
 'A5': [{'B1': 607301531,
         'B2': 48,
         'B3': {'C1': 13372462899167601368,
                'C2': [219, 56, 64, 71],
                'C3': 0.3584359458630635},
         'B4': 6},
        {'B1': 1685303768,
         'B2': 78,
         'B3': {'C1': 9323960324230673042,
                'C2': [28, 163, 214],
                'C3': -0.8115939235077143},
         'B4': -90},
        {'B1': -1434634641,
         'B2': 64,
         'B3': {'C1': 16619483100177711224,
                'C2': [6, 244],
                'C3': 0.5839030608015396},
         'B4': -72},
        {'B1': -820049809,
         'B2': 69,
         'B3': {'C1': 14581484606970855509,
                'C2': [34, 27],
                'C3': -0.34335423101815454},
         'B4': 18}],
 'A6': {'D1': 51, 'D2': [54779, 11681, 5442, 5597]},
 'A7': 868,
 'A8': -1340737705}

(b'HCI@\x00\x05\x00\x00\x00L\xbfL"\xac:\x07\x94\x16\xf1\xba\xda\x1d\xb3\xfdJlB^'
 b'\x00\x00\x00S\x14\x91\xdc\x12M\xf4\x00\x00\x00kSY i^\xd2\x00\x00\x00\x83'
 b'i\x84\xdf\xbd\xcb\xd4\x00\x00\x00\x9a\xb6\xc1\x00\x03\x00\x00'
 b'\x00\xae\xaf\x8d\x9f\x8d\x89\x95iwuhx\xc8O\xc9%q\xa0fW!\xef\x00\x02\x00Q?'
 b'\xe5\xd3L8\x85\x9d\xe0\xa7\x97\xc9y\x9e\xb5kH\xdd#\xb1\xfa\x00\x04\x00g?'
 b'\xecOCM\x90v\xaa\x9e#\xad\xd1\x94(WB\xb1H\xda\xa5\x00\x04\x00\x7f\xbf'
 b"\xeb\x95\xffb\xb2b\xce\x90\xeey\xc7\xb0\x90C'\xf5\x00\xf1\x00\x03"
 b'\x00\x97\xbf\xe3\xc7{i\xfa\xe1\xcaN\xb8\x10\x14\x1bT')

{'A1': 'iwuhx',
 'A2': -0.7974040508270264,
 'A3': 4181473605302540829,
 'A4': -77,
 'A5': [{'B1': -45454270,
         'B2': 94,
         'B3': {'C1': 14494115909487501807,
                'C2': [200, 79],
                'C3': 0.6820431808418412},
         'B4': 20},
        {'B1': -1847848371,
         'B2': -12,
         'B3': {'C1': 11436164789469164026,
                'C2': [167, 151, 201, 121],
                'C3': 0.8846756472518866},
         'B4': 83},
        {'B1': 1495296350,
         'B2': -46,
         'B3': {'C1': 10675878860635560613,
                'C2': [158, 35, 173, 209],
                'C3': -0.8620602538749951},
         'B4': 105},
        {'B1': -2065711669,
         'B2': -44,
         'B3': {'C1': 14389159427556311281,
                'C2': [144, 238, 121],
                'C3': -0.6181008405611064},
         'B4': -74}],
 'A6': {'D1': 193, 'D2': [20152, 4116, 6996]},
 'A7': -20595,
 'A8': -1618114155}

Вариант №38

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

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

(b'IIZ\x98`\xfd\xa2}M9\x96\xc4\x00\x00\x00]hztusR6\xbf6\xc9\xe7\xfa\x92>\x7fe'
 b'\xdel}\xbe\xbe[\xad\xb1\x8f=\xed\xe2S\x11G?\x07\xbaq\x14\xb4\x12\x013'
 b'\xbfz\xeep\xbfN\xae\xff\xbf\x1a\x02\x90=O\x9c\x1d>\xdf+(\xbfc\xc9\xd2'
 b"?\x03\xde\x0b'\x1a\xd8\xa0Bs\r\xa5u\xbf\xdcT\xd9\xd6\xf76\xe8\xbf\xe4\x84"
 b'\xa6\xa3\xe2\xceT\xdf]\xcaN')

{'A1': {'B1': -26528, 'B2': -3, 'B3': 41597},
 'A2': 1295619780,
 'A3': {'C1': -0.44267889015905704,
        'C2': -0.6411927414796517,
        'C3': -547501490},
 'A4': {'D1': 'hztus',
        'D2': [{'E1': 21046, 'E2': -0.7140182852745056},
               {'E1': 64146, 'E2': 0.24941202998161316},
               {'E1': 27773, 'E2': -0.3717931807041168},
               {'E1': 45455, 'E2': 0.11615433543920517},
               {'E1': 4423, 'E2': 0.5301886200904846}],
        'D3': 347345409,
        'D4': 51},
 'A5': {'F1': [-0.9802007675170898,
               -0.8073577284812927,
               -0.6016016006469727,
               0.05068599060177803,
               0.43587613105773926,
               -0.8897982835769653,
               0.5151068568229675],
        'F2': 39},
 'A6': 450404418,
 'A7': [29453, 42357]}

(b'IIZ|\xe2\x8b/\xf5\xc9\x82H\xc1\x00\x00\x00]oqlow1\x1e?T8\xe9\x87'
 b'\x7f?\x04\x82\xf7=K\xbd\xbeE=W\x85\xbd\xe7\x0f~\xb0>?.\x918k\x0f\xa8\xd4\x17'
 b'\xbex\x84\xa1\xbc\xfb\xd17\xbf\x06\xe0\x10\xbfdP&\xbd\x97\x10\xcb>Q9a'
 b'?`\xa2\xb5\xa7/\xb9e^)?l-?\xd7\xc6\xd4\x8c.\xae\xd4?\xeb\x1fwy}\xf4'
 b'\x1a\x03\xd3\xfa\x84')

{'A1': {'B1': 31970, 'B2': -117, 'B3': 12277},
 'A2': -914208575,
 'A3': {'C1': 0.37151063623126146, 'C2': 0.8475911496058217, 'C3': 64223876},
 'A4': {'D1': 'oqlow',
        'D2': [{'E1': 12574, 'E2': 0.8289933800697327},
               {'E1': 34687, 'E2': 0.5176233649253845},
               {'E1': 15691, 'E2': -0.09290549904108047},
               {'E1': 22405, 'E2': -0.1128225177526474},
               {'E1': 45118, 'E2': 0.6819033622741699}],
        'D3': 1796188372,
        'D4': 23},
 'A5': {'F1': [-0.2426934391260147,
               -0.03073940984904766,
               -0.5268564224243164,
               -0.8918479681015015,
               -0.07376249879598618,
               0.20432044565677643,
               0.8774827122688293],
        'F2': -89},
 'A6': 800679262,
 'A7': [10559, 27693]}

Вариант №39

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

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

(b'KJZA\xcb\xfe\xc8`RYu<\xbf\xcb"G\xbe\x96y\xcb1\x05h\xe6\x89,\x02\x00'
 b'\x00\x00\x7f\x00\x00\x00\xce\xff\xfc\x8bv\xf4\xa8\x05\x93$ojwqthvw\xab%/\xa8'
 b'\xa9\xdds?e\xfd\xb3o\x16\xd0"L\x82\xe2\xecB\xa9\x06\x00\x83\x00\x00\x00\x0f'
 b',\x90>(Ih\xbfL\xc7R\xbf\x03\x00\x00\x00O\x00\x88\xaf\xfbn\xa5\x12\x85'
 b'$+\xbf\x00\xb0\xf1\xbe\x90aR\xbf\x03\x00\x00\x00g\x00\xf0\xdb_\xe8x\xc1['
 b'\x00s\x00L5v\xbf*\xae1\xbe\xc0(\t\xbf\xa1\xa0\xac>\x89\xe6F?.\x15#\xbf')

{'A1': {'B1': -14082, 'B2': 21088, 'B3': -0.7361655831336975},
 'A2': {'C1': -0.1944686621427536,
        'C2': -106,
        'C3': 3209349543916325753,
        'C4': [{'D1': [0.2815861403942108,
                       -0.9073662757873535,
                       -0.8233535289764404],
                'D2': 44936,
                'D3': 312831739},
               {'D1': [-0.6685259938240051,
                       -0.4720458984375,
                       -0.8218011856079102],
                'D2': 56304,
                'D3': -1049040801}],
        'C5': -50,
        'C6': -7852684607336219393,
        'C7': 36},
 'A3': 'ojwqthvw',
 'A4': 9643,
 'A5': {'E1': 43055,
        'E2': 0.9526010155677795,
        'E3': 5486176090872610149,
        'E4': 1122820738},
 'A6': -87,
 'A7': [-0.9617507457733154,
        -0.1735159456729889,
        -0.5357780456542969,
        0.3371630012989044,
        0.7769551873207092,
        -0.6370419263839722]}

(b'KJZA\xcb\xe5\x8d\xa9\xb42\xb3\x0b?|\x9d\xa8\xbe\xc7\xdf(fD\xbc\x92'
 b'\xdc\xf4\x02\x00\x00\x00{\x00\x00\x00\x86\xbb\xab\xf0<\x1eO\\e\x81wpxhyinm'
 b'\x01\xfaP\xc9`;{\xbf\xe6\x0c`)XR\xa6\xf10\xc6~\x8eO\x02\x00\x7f\x00\x00\x00Q'
 b'T\xa2\xbe\xc7uy\xbf\xcb\xf8\x0e\xbf\x03\x00\x00\x00O\x00I\x0b\xf8\x8f\x98 g'
 b'f\x1c?[\xb7\x08>\x02\x00\x00\x00g\x00\x10\x93\xe35l\x85[\x00o\x00\xccjp\xbfT'
 b'\xabN>')

{'A1': {'B1': -29211, 'B2': -19287, 'B3': 0.5457030534744263},
 'A2': {'C1': -0.3293265104293823,
        'C2': -57,
        'C3': -802605296279738145,
        'C4': [{'D1': [-0.3170495331287384,
                       -0.9744533896446228,
                       -0.5584837794303894],
                'D2': 2889,
                'D3': 546869240},
               {'D1': [0.6109375357627869, 0.13351194560527802],
                'D2': 37648,
                'D3': -2056505885}],
        'C5': -122,
        'C6': 7303799686978120635,
        'C7': 129},
 'A3': 'wpxhyinm',
 'A4': 64001,
 'A5': {'E1': 51536,
        'E2': -0.9813747406005859,
        'E3': 17412695547879361766,
        'E4': 2390672944},
 'A6': 79,
 'A7': [-0.9391295909881592, 0.20182543992996216]}

Вариант №40

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

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

(b'IKQ\x03\x00\x00\x00,\x00\x00\x00$|\xfd0T1\xbd/c\x00\x00\x00T\x10j\x867'
 b'}\x18\xa8\x0cfgwhlrveavni\x97\xaa\x94\xbe\x02\x05\x00\x00\x00 \x00\x90'
 b'\xa4\xda\x9c2\x05\x00\x00\x00%\x00\x07P\xbf\xc4\xbb\x02\x00\x00\x00*'
 b"\x00\x8c\x13\xb3'\x92\xd2\x1e^\x07\xc9\xc6)\xeb\xbflp\xd8\x9cv\xad\xd7?\xbe"
 b'H\x19`\x1d\x89\xfb\xbd>\xce/\x03\x00M\x00\x00\x00\x02\x00S\x00\xf9\xd0^\xf7'
 b'P\xd0\x1f\x8a\x19\xb8\x83')

{'A1': [{'B1': -105, 'B2': 46044330, 'B3': 'fgwhl'},
        {'B1': -112, 'B2': 849140388, 'B3': 'rveav'},
        {'B1': 7, 'B2': 3150233424, 'B3': 'ni'}],
 'A2': 3439959928049859620,
 'A3': {'C1': 1612269758,
        'C2': 29,
        'C3': 0.37105968594551086,
        'C4': 12238,
        'C5': [5004, 10163, -11630],
        'C6': [-0.8488496710151059, 0.36996236149730666],
        'C7': 9952902747678232825,
        'C8': {'D1': 25, 'D2': -31816}},
 'A4': 84,
 'A5': 27152,
 'A6': -122,
 'A7': [55, 125, 24, -88, 12]}

(b'IKQ\x04\x00\x00\x000\x00\x00\x00\xa3d\xb4\x90\xe4!O\xf2p\x00\x00\x00\xfb'
 b'8\xdcM\x1eNI\xf6\xa7inkyjaohdnzyliwo\x18\x1b,@\x8e\x05\x00\x00\x00 \x00G'
 b'Cq\x1a\xaa\x05\x00\x00\x00%\x00\x1c\x8a\x80u\x85\x03\x00\x00\x00*'
 b'\x00\xff(\xd0#\x88\x03\x00\x00\x00-\x00\x81\x91\xb2\xdc\x10e#\xed'
 b'\x03\xd9\xb9?^D\xf2\xacG\xc9\xe8?EJ$2|\x83\xbbd?\x1a\x84\x02\x00\\\x00\x00'
 b'\x00\x02\x00`\x00\xe0\x87w \xe6\xa4\xc2\x9e\xa0\xd9 ')

{'A1': [{'B1': 24, 'B2': 2386570267, 'B3': 'inkyj'},
        {'B1': 71, 'B2': 2853859651, 'B3': 'aohdn'},
        {'B1': 28, 'B2': 2239070346, 'B3': 'zyl'},
        {'B1': -1, 'B2': 2284048424, 'B3': 'iwo'}],
 'A2': -986532527806847837,
 'A3': {'C1': 841239109,
        'C2': 124,
        'C3': 0.8934862017631531,
        'C4': -31718,
        'C5': [-28287, -9038],
        'C6': [0.10096764125355073, 0.774570310388423],
        'C7': 11439887311768618976,
        'C8': {'D1': -96, 'D2': 8409}},
 'A4': -5,
 'A5': 56376,
 'A6': 77,
 'A7': [30, 78, 73, -10, -89]}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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