ИКБО-27-22

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

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

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

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

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

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

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

(b'MAWPP\x00E}/\x1cp\xea)C\xcb\x00\x00\x00\x80jpcyR\xb2\xfb5\x9e\x8e\xd5-c'
 b'\xbd?\xdc\x83\xe8\x87\xdcr\x08B\x00v8o\x0e\xef\xbah#\xab\xbf\xc8\xd0\xd1'
 b'#\x07j\xe0\xf5pJ\xcd\x93\xfbr^\xfd\x00\x04\x00\x00\x00\x13\x00\x02\x00\x179'
 b'8\x86\xfc\x0cd\xbbl\xf9\xd6 \x83\xa9S\xc52\x00\x00\x00\x02\x00=\xd1\xfa\x9d'
 b'\x7fP\xb7c`\xa2!n)Q6\xf8&\xfe\xa6\xcf\xc6`\xb7\xe36$Z!\xf0W\x08\xf7'
 b'\x00\x00\x00\x03\x00\x00\x00}\xe6\xbd')

{'A1': {'B1': 'jpcy',
        'B2': [{'C1': 21170,
                'C2': 4214595214,
                'C3': 3576521661,
                'C4': 0.44555104510962495,
                'C5': 66},
               {'C1': 118,
                'C2': 946802415,
                'C3': 3127387051,
                'C4': -0.1938725873031535,
                'C5': -11}],
        'B3': 960005884,
        'B4': 3172,
        'B5': {'D1': 47980,
               'D2': -444131763395771086,
               'D3': [1883950483, 4218576637],
               'D4': 209,
               'D5': 250,
               'D6': [40319, 20663, 25440, 41505, 28201, 20790, 63526]},
        'B6': 18349582182700802870},
 'A2': 9020459849936880587,
 'A3': {'E1': -262731529, 'E2': [36, 90, 33], 'E3': 59069}}

(b'MAWPP\x00iN\x94\x7fwb\xeb\xaf\xe5\x00\x00\x00\xa3xe1\xcf\xb3\xd83<\xa6'
 b'\xd5\xf3.?\xc8\xe6\x15Mt\xb5\xb8b_\x98@\xa5\x0c\x92\xde\xafo\xf6\xbf\xd7'
 b'}j\x83~\xb2\xb4\x9aC\xbe\x1d\xa7\x10hh\x12\xde\xb6?\xc71\xf3TR\x9f'
 b'\xd0\xabt\xaa\xcb}\x9d\xf8s\xde\x0fr?\xcb\xe2\xc9>2\xa4\x18]\xec\xd5\xc1'
 b'{E\x85\r\xb6\x00\x02\x00\x00\x00\x13\x00\x04\x00\x15\xabm8(\r\x1aF\xc4\x8a'
 b'\xeb}\xd9\x0e\xfa\x98\xfe\x00\x00\x00\x02\x00a\xdb"<A\xc3\xee\xaa'
 b'\x8d\xdeG\xda\xc4C\xb3f\xf1\x02k\xd2WX\xbb\xe6h\x1c\x1e\xac\xfc\xaa\xca\x00'
 b'\x00\x00\x02\x00\x00\x00\xa1\x98 ')

{'A1': {'B1': 'xe',
        'B2': [{'C1': 12751,
                'C2': 3017290556,
                'C3': 2799039278,
                'C4': 0.19452158243204365,
                'C5': 98},
               {'C1': 24472,
                'C2': 1084558482,
                'C3': 3736039414,
                'C4': -0.3670297893648169,
                'C5': -102},
               {'C1': 17342,
                'C2': 497487976,
                'C3': 1746067126,
                'C4': 0.18121186845132664,
                'C5': -85},
               {'C1': 29866,
                'C2': 3414007288,
                'C3': 1943932786,
                'C4': 0.21785846268656495,
                'C5': 93}],
        'B3': 2876061736,
        'B4': 3354,
        'B5': {'D1': 18116,
               'D2': -8436511105735812866,
               'D3': [3973431675, 1166347702],
               'D4': 219,
               'D5': 34,
               'D6': [15425, 50158, 43661, 56903, 56004, 17331, 26353]},
        'B6': 174464283176593000},
 'A2': 5662290782249005029,
 'A3': {'E1': -1392727350, 'E2': [28, 30], 'E3': 38944}}

Вариант №2

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

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

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

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

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

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

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

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

(b'GSM\xcb4\xb2sB\x88\xbd\x11\x00\x02\x00\x00\x00-\x1e\xc2K\x10\xfe\xba\x90'
 b'\xe5\x005\x00E\x00\x00\x00\x02\x00g\xfd{ \x85\xf3\x86~7\xa3\xf4\x00\x00\x00'
 b'#\x00\x00\x00(\x18\xab,\xe9g \xf9\x0c?\xc0\xbe\xf5m\x88\x87\xa8\xbf\xede'
 b'\x85\xf1.\xbf\x18?\xe6\xaf\n\xff\xef\xda\x02EQ<~?\xd9Y\x8d\xa6\x12eHT_\xb2'
 b'\xb7\x97?\xbf\xddT\xbe\x16\xe9\xbf\x88?\xe6\xfd\x0e\x85@\x822')

{'A1': -3804219577113985775,
 'A2': [{'B1': -3, 'B2': 2065729011}, {'B1': -122, 'B2': 2117575668}],
 'A3': 2216416502984904933,
 'A4': {'C1': 1777563858897008908, 'C2': 0.1308275971251167},
 'A5': {'D1': {'E1': -0.9186429701421472,
               'E2': {'F1': 0.7088675497787451, 'F2': [69, 81]},
               'E3': 60,
               'E4': [126, 63, -39, 89, -115, -90, 18],
               'E5': 7298175966150891327},
        'D2': [-0.4582972739944968, 0.7183907129838814]}}

(b'GSM\xf5\xcd\xf8\xc6\x81+\xa0P\x00\x02\x00\x00\x00-mC\xc3\xb5\xd5\x1b\xd5'
 b'\x91\x005\x00E\x00\x00\x00\x02\x00g\xd4\xac\xc9\xbb\xcf\xee>\xd40'
 b'\x0e\x00\x00\x00#\x00\x00\x00(\xc1D\x87\n^\xe4\x04\xd6\xbf\xb0\xa0'
 b'\xd6\xeb|\x98\x10?\xdd\xd3B>\x17\xb9\xf4?\xc2\xa5f\x1f\x1b^\xf8\xc0F\xfc'
 b'\x80\xf9\xda\x05\x87\xec\x8d0\x0b\xd5\xd9\xbaK+\x92\xbf\xec\xc8D\xe8<\x0eB?'
 b'\xc1f\xfa\xae_H@')

{'A1': -734657632737189808,
 'A2': [{'B1': -44, 'B2': 2898901967}, {'B1': -18, 'B2': 1054093326}],
 'A3': 7873351759305627025,
 'A4': {'C1': 13926404426347840726, 'C2': -0.06495421647250077},
 'A5': {'D1': {'E1': 0.4660192114232864,
               'E2': {'F1': 0.1456725742234466, 'F2': [192, 70]},
               'E3': 252,
               'E4': [-128, -7, -38, 5, -121, -20, -115],
               'E5': 3462095869674466194},
        'D2': [-0.8994469199973951, 0.13595517648951905]}}

Вариант №3

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

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

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

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

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

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

(b'\xa2OQE\x00\x00\x00I\x00\x00\x00X\x00\x00\x00g\x00\x00\x00v\xd1?\xe9\x03'
 b'L\x90\x92\xfe\x1c?\xe3\xa6\xe1M\xe1\x0e\x1c\xbf\xe96\xee\r\x18\xa8d?\xef\xe0'
 b'\x8a\xdaE\x18z?\xe3\x18c\n\x194T\xbf\xd8\xd4\xa8f\xa7\xc4\xcc\t\xe2\xe6'
 b'\xd2?\xef@2UD\xe7\x12Jxoct^\xcf?\xe4\xc4\x8c\x16\x19\x81\xc6@wdozx$\xbf'
 b'\xac-\xd5}}\xcb\x80\x82|jgk^\xff\xcf\x17\x12\xd5K[\x99y\x8dR\x14v\xf0b'
 b'K\x1aj(^\xec\xf0Z\xa2ebU\x9d\xb6\x7f\x10\xc1\xe8\x86\x98\xa3')

{'A1': [{'B1': 0.9765865006840804, 'B2': 19064, 'B3': 'oct', 'B4': 24271},
        {'B1': 0.648992579615929, 'B2': 16503, 'B3': 'doz', 'B4': 30756},
        {'B1': -0.055037185257694965, 'B2': 33404, 'B3': 'jgk', 'B4': 24319}],
 'A2': {'C1': 14922416597617056121,
        'C2': 141,
        'C3': {'D1': 21012,
               'D2': [8570458165591287902,
                      -1373498232815856227,
                      -5296496211748546397]}},
 'A3': 209,
 'A4': [0.781652719851937,
        0.6141211052967637,
        -0.7879553085124482,
        0.9961599600872113],
 'A5': [0.5967269131884998, -0.3879796030515308],
 'A6': 2530,
 'A7': 59090}

(b'\xa2OQE\x00\x00\x00I\x00\x00\x00X\x00\x00\x00g\x00\x00\x00v\xbf?\xec\xaa'
 b' \xf0n\x98\x08?\xd5\xb9\n{\x92\x82h?\xdbT!(\xac98?\xe0\xe2\xa6\xf6\xdc\x80'
 b'\xb8\xbf\xeaS\n\x99\x83R\xfe?\xc4l\x0c\x06\xcc*\x98W\xc1\x88\xde?\xe5\xfe'
 b'\xa4\xa5*\xd5\x08\xa0<ympbA?\xb3\xd8\x11)\xeb\xba\x90\xad\x19tloc\xbc\xbf'
 b'\xea)q\xbd\xaa\x8e\xf8\x02\x9cxphRP\xdf\x11ps"\x9be\xb7\xad`\xba\x9b\xa3\xbf'
 b'-\x00\xe1>\xf3\x1b\xdc\xe9\x01\xd9eg\x19\xc4\xa7\x16\xb0+\x96\xdd&')

{'A1': [{'B1': 0.6873343683170399, 'B2': 41020, 'B3': 'ymp', 'B4': 25153},
        {'B1': 0.07751567147691163, 'B2': 44313, 'B3': 'tlo', 'B4': 25532},
        {'B1': -0.8175591186922864, 'B2': 668, 'B3': 'xph', 'B4': 21072}],
 'A2': {'C1': 16073752184866170295,
        'C2': 173,
        'C3': {'D1': 24762,
               'D2': [-7231726376617689357,
                      2007735728051939097,
                      -4276424375263634138]}},
 'A3': 191,
 'A4': [0.8957676597535746,
        0.3394190031777158,
        0.4270098588175588,
        0.5276675054083375],
 'A5': [-0.8226368902492991, 0.15954733211431882],
 'A6': 22465,
 'A7': 35038}

Вариант №4

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

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

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

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

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

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

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

(b'RIIM\xa0l\r\xd2N\xae\xb7\xbf\x02\x00\x1f\x00T\x00\x00\x00bwzvnhtqbqk\x05'
 b'\x00\x14\x00\xad\xf2\x9f8\xb3Sc\xe3?\x82\xbe\xb9!F\xbb\xe7\xbf'
 b"\x06\x00\x19\x00'pc\xc7\x84\xda\x16\xb2\xbf\x00\xdd;+\xf3\xd5\x84?p\t\x8f"
 b'\x89\xf3l\xe5\xff\xfd\x9e\xc5I\x00\xc8\xe5y\xbe\x85\xe28A\x01\x89t?\xb2\xe5'
 b'{\xe6\nT@<\x9a')

{'A1': -0.09250347736581199,
 'A2': [{'B1': 'bwzvn',
         'B2': 173,
         'B3': 0.6058748722471121,
         'B4': -0.7416105898573309},
        {'B1': 'htqbqk',
         'B2': 39,
         'B3': -0.07066121808692372,
         'B4': 0.010173702008144492}],
 'A3': {'C1': {'D1': [2416, 35215, 27891, 65509, 40701], 'D2': -59},
        'C2': -0.2440406084060669,
        'C3': 1094247045,
        'C4': {'E1': 0.9552155137062073, 'E2': -428087886, 'E3': 10},
        'C5': [84, 64, 60, 154]}}

(b'RIIMRn\xf2\x89N\x8f\xe3\xbf\x02\x00"\x00W\x00\x00\x00rwgzksbxxqxtkk\x07\x00'
 b'\x14\x00\xd0Ho\x8f\xe7g\xa7\xc9?\x86\x10p37f\xe0\xbf\x07\x00\x1b\x00\xf4'
 b'\xe4\x8a\xcf\x9dR\xaa\xef\xbf\xc6\x14 j\xda\x1d\xeb?\xa5b\x9b\xfd0to\xb0'
 b'\x10\xc2\x95L\x00O$?\xbe\xb0\xce\x91\xdb$]\x90\xbd\x94I\xb0\xdfn\x0f\xb7'
 b'\xc4\xa4')

{'A1': -0.6112435049321425,
 'A2': [{'B1': 'rwgzksb',
         'B2': 208,
         'B3': 0.20042132193236228,
         'B4': -0.5124774937289807},
        {'B1': 'xxqxtkk',
         'B2': 244,
         'B3': -0.9895413477173318,
         'B4': 0.8473941872367952}],
 'A3': {'C1': {'D1': [25253, 64923, 29744, 45167, 49680], 'D2': -107},
        'C2': -0.18666194379329681,
        'C3': -611201360,
        'C4': {'E1': -0.07049015164375305, 'E2': -542094956, 'E3': 110},
        'C5': [15, 183, 196, 164]}}

Вариант №5

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

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

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

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

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

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

(b'\xc4FSA:6G\xd2"\x08\xef\xfc~\xd6\xe5\x13\xc9\xb4\x1d\xf7\x00\x02\x00L'
 b'\x00\x00\x00\x02\x00r\xc8\x8e\x11\xf4\x0f\xa4\xe4\x82?\x8513\x01\x9b'
 b'W\xf6z\xee\xe8\xbd\x9e\x7f\xe9\x1fI\xbc\xbd\xbf\xe4\xa8\xa5\x1b\xd6>'
 b'\xf4te\x861trsfeW\xc5#\x00\x02\x00\x00\x00Aj\x8b?s^>\x00\x02\x00Cq\x90u'
 b'\x00\x05\x00\x00\x00Ei\xc4?\x11\x1fh\x00\x02\x00J(2\xce\xca99\x17\xa7'
 b'\x11\xce')

{'A1': 976635858,
 'A2': 571011068,
 'A3': 2128012563,
 'A4': 3384024567,
 'A5': [{'B1': 35,
         'B2': 'te',
         'B3': {'C1': 27275, 'C2': 0.9506567716598511, 'C3': [134, 49]},
         'B4': 29072},
        {'B1': 117,
         'B2': 'trsfe',
         'B3': {'C1': 27076, 'C2': 0.5668854713439941, 'C3': [87, 197]},
         'B4': 10290}],
 'A6': {'D1': [3469359417, 396825038],
        'D2': [14451507994210657410, 4577118691432028150, 8858273418189990175],
        'D3': 73,
        'D4': 48317,
        'D5': -0.6455865424813667}}

(b'\xc4FSA}9N\xb7!\xc7\x0f\xdeA\xbe\xb1\xb8EQ\xf4\x1b\x00\x02\x00L'
 b'\x00\x00\x00\x06\x00r\x07\xa1\xe42\xfcI>\xeb\xd0\xbf\xd9\x12\x92i\xc8\x80B+'
 b'0\xf5\xea2\x87\x9b\x03\x0c\xc6?\xcb\x9f\x98\xf9\n\xeb\xa0lnX\xaf3gnr\x8eT`'
 b'\x1c\x00\x02\x00\x00\x00A\xc1C\xbfX\x12I\x00\x03\x00C\xa0\xccH'
 b"\x00\x03\x00\x00\x00F\xf0L?\x14lr\x00\x03\x00I\xf1\xab\xb4\xfa\xe0'\xd3\xda"
 b'3\x14\xf6\x83\xf2\x03g\x86\x1al\x92~\xfa\xceNm\xba\x0c')

{'A1': 2100907703,
 'A2': 566693854,
 'A3': 1103016376,
 'A4': 1162998811,
 'A5': [{'B1': 28,
         'B2': 'ln',
         'B3': {'C1': -16061, 'C2': -0.8440290093421936, 'C3': [88, 175, 51]},
         'B4': -24372},
        {'B1': 72,
         'B2': 'gnr',
         'B3': {'C1': -4020, 'C2': 0.5797797441482544, 'C3': [142, 84, 96]},
         'B4': -3669}],
 'A6': {'D1': [3036340263,
               3554292500,
               4135842307,
               1736841836,
               2457795278,
               1315813900],
        'D2': [549971537148067563, 15041979954229790848, 4767958463256102811],
        'D3': 3,
        'D4': 3270,
        'D5': 0.21580803070341137}}

Вариант №6

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

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

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

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

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

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

(b'KGWYB\x00\x00\x00\xd1\x02\xab\x93O?\x06\x00\x00\x00\x91\x00\x00\x00c\xd1'
 b'<\xbftO\xc4=P\x1a0>\xbd\xe5]?\xe9m\xa3=\xd3\xbe\xc1\xc3fQ\xbe\xbc\x92V'
 b'\x0c\xb1\x15]\xe1\x89v\x16A\xf7\\>ftK[\xcf\xfc\x8aAv\x02\xaf\x80'
 b'\xb9\xcb\xc5wK[\xb1\xa3N\xcfIpU\xc3\xd9y\xbb\xa1\x8f\xa8\xf6\xab\x19z'
 b'I\xd0\x92:Tdy\xa9\xf3 \x8b\xf4=\xbc\x8b\xaba\xa2\x91\xb6\xb9\xc9+\x11'
 b"f\xb0\xe3{'\x99w\xa0\xd2\xfd\xc6\xf1\x80{\x02\x00@\x00\x00\x00\x83f*:"
 b'\xaa\xdbw\xdf\xa0V1\xe8\xb06\xc4\xf3\xc2\t\x8f\xcd\xce\x0f\x0c#\xba')

{'A1': {'B1': 177401300530453323,
        'B2': [{'C1': 6578483372114935983,
                'C2': 3478037425,
                'C3': -6792701636766240695},
               {'C1': -3438082589842823025,
                'C2': 1683241618,
                'C3': -4882477542609278599},
               {'C1': -3910894064783742069,
                'C2': 2959479083,
                'C3': -156886601473491997}],
        'B3': -3642,
        'B4': 31616,
        'B5': 'ft',
        'B6': -125},
 'A2': {'D1': 721,
        'D2': 0.8108469843864441,
        'D3': [2855938662,
               2698999771,
               2968006998,
               3270755382,
               3469577993,
               3122859023],
        'D4': [-0.7375699877738953,
               0.09585466980934143,
               0.17197537422180176,
               0.866786777973175,
               0.07979948073625565],
        'D5': -16685,
        'D6': 6238255959457055681,
        'D7': 1618632717108621580,
        'D8': 0.21578694880008698}}

(b'KGWYB\x00\x00\x00\x1b\xfcQ\xd8\xf6>\x07\x00\x00\x00\x91\x00\x00\x00\xb7M'
 b'\x1c\xbf\x99\xd6\x0b\xbf\xbe\x93z?\x86\x11\x9f\xbd\x1f\x03\x88>VY/\x865d'
 b'\xc5\x89\xd9S\x8c\xd0\x88D\xde\xe6\x83\xaex\xa4[?oh\x18d:5\xf1\xa4\xe2ooD'
 b"\xfd@'\x93\xc3\xf6\xf7\xaf1t\xaa3\x1dF!L\xaadL\xa5,\xe2\xd4\xe0\xb0\xb0\xf6o"
 b'\xaa+#\x96\x02i7\xc9\xf80\x95v\xe1@\x82Dm\x91W\x17\x1c\xb7{\xa5\xdbEz\xeb'
 b':G\xdf/\x9a\xe0\x02\x00@\x00\x00\x00\t\xd4\xe7\x9aE\xaeTy\xd4b\x9ah'
 b'\x92\x19m\x0c\x8c*\x0fH4\xae\xffUc\xb0\x0e\x1c\xe8')

{'A1': {'B1': 8062187638833701912,
        'B2': [{'C1': -665526523117353873,
                'C2': 1949413367,
                'C3': 7253693855627555754},
               {'C1': -5714820722200894132,
                'C2': 732590070,
                'C3': 3528791547866945059},
               {'C1': -7967636839523584363,
                'C2': 3072071511,
                'C3': 5132673635732661627}],
        'B3': 12255,
        'B4': -8038,
        'B5': 'oh',
        'B6': 9},
 'A2': {'D1': 64539,
        'D2': 0.4821191132068634,
        'D3': [1167779796,
               3564721326,
               2456328802,
               2349624601,
               877137706,
               1666580398,
               3894152880],
        'D4': [-0.6105608344078064,
               -0.5462432503700256,
               0.9788168668746948,
               -0.0776701420545578,
               0.26564881205558777],
        'D5': 22870,
        'D6': 6042011855977023023,
        'D7': -5871595646854049652,
        'D8': 0.857978343963623}}

Вариант №7

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

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

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

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

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

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

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

(b'YIEH\x00\n\x00t\x1bu4\x8d\xf1\x15tXn\x92q\x94\x89\xec\xd1\xa2\x18Jt\x1d'
 b'\x7f^\xa1>\xacq,\xe8RW\x89\x077\xed"\x89\x8a\x1b\xa3\x19$\xf2n\xac'
 b"\x9c\x1b\xa7\xb2z\xba\x06}S\xe6\xa7J\xa9\xe7K\xc4VA\xef,'\xe5\x9c\xf1"
 b'\xdf\xf0\x96*\xf6 \xff\xefS\xfbL\xbf>J\xa6\xa6w\x97\xd1\xd5\xd0\xa0\x91{'
 b'?\x19\xc0h\xfb\x18\xc6\xede\x0f\x118\xbfq\x9d\xe3\xde\xba\x00\x00'
 b'\x00\x06\x00\x00\x00\x14!2\xbcZ\x00\x04\x00\\\x00\x00\x00d')

{'A1': {'B1': 3786947936137014930, 'B2': 29076},
 'A2': {'C1': -8518,
        'C2': [{'D1': 2313998754,
                'D2': 24,
                'D3': 1249123711,
                'D4': [94, 161, 62]},
               {'D1': 2893098216,
                'D2': 82,
                'D3': 1468598071,
                'D4': [237, 34, 137]},
               {'D1': 2317067033,
                'D2': 36,
                'D3': -227627876,
                'D4': [27, 167, 178]},
               {'D1': 2059011709,
                'D2': 83,
                'D3': -425243991,
                'D4': [231, 75, 196]},
               {'D1': 1447161644,
                'D2': 39,
                'D3': -442699297,
                'D4': [240, 150, 42]},
               {'D1': 4129357807,
                'D2': 83,
                'D3': -78856386,
                'D4': [74, 166, 166]}],
        'C3': 556973146,
        'C4': [30615, 53717, 53408, 37243],
        'C5': {'E1': 0.6005921363830566,
               'E2': [4212705005, 1695486264],
               'E3': -0.9438154101371765}},
 'A3': 7029}

(b'YIEH\x00\n\x00|\xd1\xe0_"\x89\x96\xab\x9b\xce\x92\xa3\xcbb\x99\xef\x1a'
 b'\xad\xb1>\xce*\x01\x18O\xa3$\x02}~4Xe\x84\xad\x11\xebv\xd4\xbe<\x9c\x11m('
 b'yz\x06\xfdj7\\,kO+\x8e\xd0\x0ff\xc3]w\xcdy\x08s\x83\xa2d9\xa6\x99'
 b'\xf9\x95>\x9a\xe7\xac\x92\xe9\t.8\x85\xd0\xedn\xda\xf6\x8b\xb0\x13\x1e\x8abH'
 b'gh\xa8\xd6\xbf\x0c\x15\x8btm\xaeq\x17\xa0]\x9e\xbe\x80\xb0F\xfaD\x00\x00'
 b'\x00\x07\x00\x00\x00\x14\xb6X\xaa\x9f\x00\x02\x00h\x00\x00\x00l')

{'A1': {'B1': 6855192863028530834, 'B2': 41931},
 'A2': {'C1': -1468,
        'C2': [{'D1': 1654255386,
                'D2': 173,
                'D3': -1321284054,
                'D4': [1, 24, 79]},
               {'D1': 2737046141,
                'D2': 126,
                'D3': 878208388,
                'D4': [173, 17, 235]},
               {'D1': 1993653820,
                'D2': 156,
                'D3': 292366457,
                'D4': [122, 6, 253]},
               {'D1': 1782012972,
                'D2': 107,
                'D3': 1328254672,
                'D4': [15, 102, 195]},
               {'D1': 1568132473,
                'D2': 8,
                'D3': 1938006628,
                'D4': [57, 166, 153]},
               {'D1': 4187307674,
                'D2': 231,
                'D3': -1399658231,
                'D4': [46, 56, 133]},
               {'D1': 3505221338,
                'D2': 246,
                'D3': -1951395042,
                'D4': [138, 98, 72]}],
        'C3': 3059264159,
        'C4': [26472, 43222],
        'C5': {'E1': -0.5472037196159363,
               'E2': [1953345137, 396385694],
               'E3': -0.25134485960006714}},
 'A3': -11808}

Вариант №8

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

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

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

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

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

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

(b"XRJ\x06\x00\x00\x00P\x00h\x88\xf7;>\xb64'\x1e\x80\x00\x00\x82\x1508P&t"
 b'\xa7\xab\xc4\x0c\xe3?h\xfa\xd3\xb2\x0f\xd5\x95\xe3\xbfO\x0e`\xcc3'
 b"\xf0\x0b\xea\xbfR\xec'nE'\xf7\xed?\x88\xf0.P\x88\xa2\n\xe1?z\xd6iT\xb9\xbb"
 b'\xa3\xe4\xbf\xe8\x1a\x00\x00\x00#\x00\x00\x00,\x00\x00\x005\x00\x00\x00'
 b'>\x00\x00\x00G\x00\x00\x00\x053\x85\x06\xf2\xc5\xb8\xa1:\xfc\xcc\xa7'
 b'\x82\x08s\xd2\xcbX\xdf\x87\xb8\x08\xb7H\x01\xa0\x02\x00\x00\x00h\x00'
 b'\xc8i\x85\x00\xfd\xef\x0c\x8dY\xcb\n\xa1/\xef0]\x08\x00\x00\x00p\x00\x00\x00'
 b'\x19\x08\xc2\xdc\xad\xea\x10\xe5\xa4\xa4B]\x1d\xcc\xea?\xb8\x82\x85ME\xec2v'
 b'\xee')

{'A1': [{'B1': 0.5953086235637144, 'B2': 104},
        {'B1': -0.6120400721180197, 'B2': 79},
        {'B1': -0.8139573108373968, 'B2': 82},
        {'B1': 0.9364200931606752, 'B2': 136},
        {'B1': 0.5325482046477799, 'B2': 122},
        {'B1': -0.6449869746896251, 'B2': 232}],
 'A2': 2825083244678449256,
 'A3': 30,
 'A4': {'C1': -24575,
        'C2': {'D1': [109392645, 2713241074],
               'D2': 10163762328982874568,
               'D3': 6715130032253750105,
               'D4': [-966, -22580, 2178, -11661, 22731, -30753, 2232, 18615],
               'D5': -1940793406942738407},
        'C3': 0.8374163457384793,
        'C4': -72,
        'C5': -1263766655074466430},
 'A5': [0, -126, 21, 48],
 'A6': 20536}

(b'XRJ\x03\x00\x00\x005\x00X\xd3)\xe8\x97B\xdc\xb81e\x00\x93\x11y\x05'
 b'\xd2\x9c\xc8n\x00\x00\xf2\xa1\xcc\xbf\xf3\xfc+>O\x81I\xdc\xbf\r\\\xab+\x81'
 b'\xb6\xda\xd4\xbf\xb9\x1a\x00\x00\x00#\x00\x00\x00,\x00\x00\x00\xe0\xab\xcf'
 b'\xcd(0)\xce\xb7\x02\xa4?Q\x87\xdd\x88\xf6z<>`\xb5\x9b\xc2fH,\xd0\xe9\xdaj'
 b" jp\xb5\x81\xa1\xd8\x05\x00\x00\x00A\x00' \x8b\x96\x87 6\x112\xa2\xb7"
 b'Y\x02<\x9ad\x08\x00\x00\x00U\x00\x00\x00l;Ghg@\x8aF\xbc\x8f\xf9#\xf5t\xee'
 b'\xbf0\xb0\xf8AY\x1b\x16\xdd`')

{'A1': [{'B1': -0.22369217872698344, 'B2': 243},
        {'B1': -0.44198639620361724, 'B2': 13},
        {'B1': -0.32584917654337686, 'B2': 185}],
 'A2': -5126149055651916968,
 'A3': 49,
 'A4': {'C1': -10079,
        'C2': {'D1': [3452939232,
                      3458805800,
                      1067713207,
                      2296219473,
                      1044151030],
               'D2': 1240214514105524263,
               'D3': 7249172530999042610,
               'D4': [-19104,
                      -15717,
                      18534,
                      -12244,
                      -9495,
                      8298,
                      28778,
                      -32331],
               'D5': 5082945942316333932},
        'C3': -0.9517770483621386,
        'C4': 48,
        'C5': 6979759304211560624},
 'A5': [-109, 17, 121, 5],
 'A6': -25390}

Вариант №9

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

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

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

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

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

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

(b'CEUSL\x03\x00\x00\x00E\x00|\x00\x00\x00k]*\x82\x86E\x92\x90\x87b\xbb\xf4\x99'
 b'B(\xe7\xd1\xd6\xf6\xb5\xf5\x0cS\xae\xa4\r+D\x0e\xf3\xb9\xe0a\xc6\xdef\x1a'
 b'\x08\xbc\x17\t\x17$Z\x83\xcc\xcb\xea\x0e\xe1\xbf\x81\x06\xebycyg\xe5%|'
 b'\xc7\r\xa7Fo\xd3\xee\x00\x90\xbc\xee\xbb\x02\x00H\x00\x00\x00\x07\xec'
 b'_\xa4!\x03\x10\x92s\xec\xfb\xf9\xd0-o\xdeS\xf9\xc64\x02\x00b\x00\x00\x00'
 b'\x0cZ\x18"\xb4\x99#\xd4\xde\xbeX\x00r\x00')

{'A1': 'ycy',
 'A2': {'B1': -26188,
        'B2': -0.43521222472190857,
        'B3': [{'C1': [5091053054198146407, -4904775617482927249],
                'C2': 2757749767},
               {'C1': [-433492957995203807, 3803001073970392528],
                'C2': 572021260}]},
 'A3': 107,
 'A4': {'D1': 10845,
        'D2': 13502503687809238658,
        'D3': [675453428, -153693721, 1393358261, 722314414],
        'D4': 68,
        'D5': 14,
        'D6': 1902452836237621747,
        'D7': 48136},
 'A5': 605489431,
 'A6': -0.5330709438750134,
 'A7': -127,
 'A8': 60166}

(b'CEUSL\x02\x00\x00\x00E\x00{\x00\x00\x00\x8d\xcb\xbf\x9c\x12\x04J\xb1\x8d'
 b"\xa2\x11K\x04`\xe3\xfb9\xa9+\xa6\xe5}\xb0\x95\x90+\xc6'\xc9\xe1\xbe\x87\x1e"
 b'\xb0J\x10\x06J\xc4\x8d\xbe\x86\rH\x9e\x0b\xc1\xde\x0f\xe2\xbfww\xe2rt&'
 b'\t\xa8\x82\xff\tO\x07Bv\xb3\xd0\x19\xbd\xa5\xd7\x02\x00G\x00\x00'
 b'\x00\x02*\xdc\x0b\xd1\x89]n\x11&\xce-\xa8\xd4\nh\x99d\xb4\xc3\x02\x00a'
 b'\x00\x00\x00ne\x08t\xe8\x98O\xe0\xb9>W\x00q\x00')

{'A1': 'rt',
 'A2': {'B1': -26392,
        'B2': 0.36303946375846863,
        'B3': [{'C1': [526650674438998310, -2907710065824532926],
                'C2': 198978050},
               {'C1': [3300617433217075665, -4344737130467371864],
                'C2': 1946707310}]},
 'A3': -115,
 'A4': {'D1': 49099,
        'D2': 1270733837462409884,
        'D3': [-480246709, 732510715, -1333926490, -970223467],
        'D4': 39,
        'D5': 201,
        'D6': 436931284141850337,
        'D7': 50250},
 'A5': 226934413,
 'A6': -0.564437272111669,
 'A7': 119,
 'A8': 57975}

Вариант №10

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

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

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

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

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

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

(b"\x08LZLVI\xbc\x00H4{)X:/\x8c\x7f^\xbcv\xdc\xc0\xdf\x91\x9f\x14'\xed"
 b'\xa7g\xe9\xa8\xd7~>\xbf\xe4\x8bF\xe4C\xf1\x1d\xa3\x07\xbfr`,\x08\x99\xeb'
 b'A\xfe\x9e2?\xe5\xa8\xab\xe3A0v\xbf\xe1\xee\xc7o\xd9S\xc2\xd23f\xd6'
 b'\x81\xd8\xbfp\x8d\x1b\xc8\xe6\x1b\xba\x16\x0b\x00\x00\x00"\x00\x00\x00-'
 b'\x14?\xdcf\xaa\x9a\xd2\xb7`\x00\x02\x008\x1eH\xc48l1\x0b\x1f%/\xa5tM\xc5\x1c'
 b'{\xa6\xf7y[#\xe1\x92\xbe\xdb\xd0\xa2G\xa0\xf1\xe8b\xa4\xd7vb\xed\xe2\xb5'
 b'!\x7f\xbb"n\x19z\x006@=\x8f\x1c;B\xa0m\xdb\x98P\xf8yq\xa2&\xad\x1b\x93'
 b'\x17\xa2')

{'A1': 18876,
 'A2': {'B1': -3300181030444941456,
        'B2': -8278802599357311477,
        'B3': {'C1': [{'D1': 0.3747905194759369,
                       'D2': 70,
                       'D3': -7101,
                       'D4': 4045251335},
                      {'D1': -0.9467799663543701,
                       'D2': 8,
                       'D3': -26133,
                       'D4': 1107205682}],
               'C2': 20,
               'C3': 0.4437662612862052,
               'C4': [0.6768397749488162, -0.5603978333043573],
               'C5': [508085304,
                      1815153439,
                      623879540,
                      1304763515,
                      2801236315,
                      601985726],
               'C6': 219,
               'C7': 15033657262695015076},
        'B4': [-680107283,
               -491445889,
               -1155371495,
               2046834240,
               1032789051,
               1117810139,
               -1739523975],
        'B5': 8188149597446805410},
 'A3': [52, 123, 41, 88, 58, 47, 140, 127],
 'A4': 1589409500,
 'A5': 192,
 'A6': -2336911822710528153,
 'A7': -374810754}

(b'\x08LZLV\xc4\xf6\x00H/\n\x18\x01j\xfe\x0b$X\x8c\xbb\x9c\xd1p\xdb'
 b'y\xf8\xb4\xe8\xf2;T\xc4\xc2\n\xbfpx\xf7M#\x96\x88\x83L\xd1\xbe\xc1U'
 b'hA\x0f\xdf\xdd}S#\xbf\xd2\xca_2bB\x08\xbf\xee\x1a^\x918\xf8\x92ezOp'
 b'\x8cf\x84\xb1\x86\xd3M\xb3P\xac\xd9l\x00\x00\x00"\x00\x00\x00-\xde?\xea\xe3'
 b"\xf9+d'\x82\x00\x02\x008\x1b]\xe3\xf2\x10\xe4\x06A\xf3LFG\xc3\x04A-\xf6`\xa4"
 b'zp\xf7bI\x18\xbf\xfejG1\xf1\xb1\x97\x9a\xa4\x8d\x9e\x8c\x10\xe1-d\x86'
 b'\x02p-\xdf\xdf\xfb$n\x81\xe8\x1a\x13\x15\n\x9c\xeb%P\x9e\x13\xcd=\x9f{o\xbb')

{'A1': 50422,
 'A2': {'B1': 7312244289799881905,
        'B2': -8731549819993269908,
        'B3': {'C1': [{'D1': -0.9393457770347595,
                       'D2': 77,
                       'D3': 9110,
                       'D4': 2290306257},
                      {'D1': -0.37760472297668457,
                       'D2': 65,
                       'D3': 4063,
                       'D4': 3715978019}],
               'C2': 222,
               'C3': 0.8403287742123526,
               'C4': [-0.29360179825110366, -0.9407189213159362],
               'C5': [459138034,
                      283379265,
                      4081862215,
                      3271835949,
                      4133528698,
                      1895260745],
               'C6': 24,
               'C7': 13834611959341887895},
        'B4': [-1700491874,
               -1945050835,
               1686504048,
               769646587,
               611221992,
               437458186,
               -1662311088],
        'B5': 11390673547102482363},
 'A3': [47, 10, 24, 1, 106, 254, 11, 36],
 'A4': 1485618076,
 'A5': 209,
 'A6': 8132227661241578043,
 'A7': 1422180874}

Вариант №11

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

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

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

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

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

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

(b'NWVCK\\\xda\x81&s\x00\x00\x00\x07\x00P\x02\x84\x81QR2nk\xe3\n$g'
 b'\x84\xa5\x1d\xee\x8d\x88\x97\x19\xb2\x9b\xf8%\xee\x024j\xc7\x97\xc0\xd0'
 b'\x19\x1af\xab\x00\xa0\xbf/\xe4.\xb7,\xa0B\xb3\xca\xc4\x1f\x8c\xb6'
 b'\xff\xee\x00v\xb3$\x107\x1d\xcdt\x07zwynjks\xbf5e\x99>\xbaK\xb2\xe5'
 b'V\xdb\xd49\x88\x99<\x00\x02\x00W\xa9f\xa1\xfe0\xec\xe5`\xae\xd5\xd8\xbf\xe3'
 b'D\xe6\x8dy\x92X=\xeb\x00_\xff\xa8\xf1R\xc6\xc0\xff\x96\xc6\x86Z\xf4\xd9$'
 b'F\xa6\xd5\x0e\x95\x19.')

{'A1': 1264376449,
 'A2': 9843,
 'A3': 'zwynjks',
 'A4': [{'B1': 181412071273033323, 'B2': -2086815450307158546, 'B3': 36232},
        {'B1': -7558814116611756542, 'B2': 3777050692092434714, 'B3': 26283},
        {'B1': 45246208686339884, 'B2': -6898753995723010890, 'B3': 65518}],
 'A5': {'C1': -0.602160717313903,
        'C2': 15851,
        'C3': {'D1': 16525637587227416892,
               'D2': [-0.7085815072059631, 0.36385875940322876],
               'D3': -1452891650,
               'D4': 12524,
               'D5': 229,
               'D6': 1622070744},
        'C4': -5705390,
        'C5': 14321727838079048436,
        'C6': 217,
        'C7': 2613960067738048814},
 'A6': [-1289482185, 500003847]}

(b'NWVC\xbe)\xc0\xf71\xde\x00\x00\x00\x03\x00P\xaf\xd6|\xf1\xd3\xe4\xfe9'
 b'v\x90\x9czG]H\xe0)\xfb\xcc\x1e\x87>\x9d\xabl\x19\x94^C+aVf\x00F\x9e'
 b'\x97\x8c\xe44\xb4\x86\\\xc1\xdd\x97^Tn64\x9a\xa3\x82\x00zy\xc0g!\\\x92,5'
 b'oox\xbf8\x8d1\xbe@\x92\xdd\xbf*\x03V\xbfE\xc7\x94Lp\xe8h\\\t\xd2:\x00'
 b'\x04\x00SI\xaf_-:\x92ZG\xce\x07\xee\xbf\xef\n\xba.o\x8b\xb6\x8d\x0e'
 b'\x00c\xb8\xd9]\xda\xe6\xae\xb7\x82\x90S\xf0\xd5X$\xb0\xff$\xd1\xd3\x8e\x10')

{'A1': -1104559881,
 'A2': 12766,
 'A3': 'oox',
 'A4': [{'B1': -5776292093972120007, 'B2': 8543500542119069920, 'B3': 10747},
        {'B1': -3738401937667953639, 'B2': -7755687654689708544, 'B3': 18078},
        {'B1': -7526389962224804671, 'B2': -2479409353124858726, 'B3': 41858}],
 'A5': {'C1': -0.9700594813297048,
        'C2': 36110,
        'C3': {'D1': 5508157879192506938,
               'D2': [-0.7209044098854065,
                      -0.1880602389574051,
                      -0.6641134023666382,
                      -0.7725765705108643],
               'D3': 1236229933,
               'D4': 14994,
               'D5': 90,
               'D6': 1204684782},
        'C4': -1193714214,
        'C5': 16622425046066131157,
        'C6': 88,
        'C7': 2643893514870689296},
 'A6': [2042652449, 1553083445]}

Вариант №12

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

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

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

(b'YROD\x00,n\xfe\xe3\x8e\xfe\x10\xbf\xd5<\x8f\x1fE\x00\x00\x00A\x00W'
 b'\x00y\x00\x9b?!{Z\xbf$(\x9b\xbce\x8d6\xbfu\xf3\xe1\xbf\xe7[\xe1C\xbc\xe58'
 b'epihhlp\x00\x00\x00\x04\x00\x1c\x8e?\xc4\x13\x8e+\x89\x92\xf0\xd8\xb5'
 b'\xf4\x91!4\xacq\xfb\xe9\xcc\x87\xcf\xf8\xee\x00\x00\x00\x03\x00K='
 b'\x9f\x83Z\xa5\xc2\x0bo\rm\x8f\xe5n\x90\xa8\xd9*\x15\xdel\xdd"\xf5TF'
 b'\x93\xd0?\x00\x00\x00\x04\x00i\x86\xbf30$=l\x9e\xf5\xf5\x85b\xda\xed\x9d'
 b'\xf2\x94\x1a3\x838m[g\xb7\xf2\x92n\x00\x00\x00\x04\x00\x8b\xb3\x8daHC'
 b'm\xef\xf2\x96\x9f')

{'A1': {'B1': {'C1': -0.7299658129697155,
               'C2': 'epihhlp',
               'C3': [0.6307884454727173,
                      -0.6412445902824402,
                      -0.01401071809232235,
                      -0.960752546787262]},
        'B2': 1862198158},
 'A2': -139400665883533499,
 'A3': {'D1': 142, 'D2': 0.15684678197717217, 'D3': 216},
 'A4': [{'E1': 63726,
         'E2': [3052704033, 883716603, 3922495439],
         'E3': 1033864026,
         'E4': -23102,
         'E5': 191827309},
        {'E1': 53311,
         'E2': [2414177936, 2832804373, 3731676450, 4115941011],
         'E3': 2260677424,
         'E4': 9277,
         'E5': 1822356981},
        {'E1': 37486,
         'E2': [2237848301, 2649920538, 864237677, 1533523954],
         'E3': 3012387144,
         'E4': 17261,
         'E5': -269314401}]}

(b'YROD\x00$j\x01Y\x8d\xe1\xaa\x9e\x17\xa6\xd3\x94\x97\x00\x00\x009\x00K'
 b'\x00m\x00\x87\xbf}\xbe\xd1\xbe\x88mT?\xe1a/\x0f\x19O\xbaayqymkh\x00'
 b'\x00\x00\x02\x00\x1c\xdf?\xe9o\x88e\x92\x9784\xc6\x18V\xd8\x8b\x99\xe7x\xf8'
 b'!\x00\x00\x00\x02\x00CL \xd6\x1e\xa5W\x94a\xf2\x1e\x96\xc4\xcb\x1f>\x86\xf1'
 b'\xcd\xb6\xed\x0b\xbe\x94\xa8p\xba\x9f\x91\x00\x00\x00\x04\x00]yizk\xed\xfd~'
 b'..\x15;\xfd\x90\xc0\xc2\x1a\xb4M\x1e\x17\x00\x00\x00\x02\x00\x7f\x83'
 b'\xcc\xaa=\xf6\x0eE\x1b\x07Q')

{'A1': {'B1': {'C1': 0.5431132597827777,
               'C2': 'ayqymkh',
               'C3': [-0.9911928772926331, -0.2664591073989868]},
        'B2': 1778473357},
 'A2': -2185760844714634089,
 'A3': {'D1': 223, 'D2': 0.7948648437347634, 'D3': 52},
 'A4': [{'E1': 63521,
         'E2': [3323483864, 2342119288],
         'E3': 1277220382,
         'E4': -23209,
         'E5': -1805520354},
        {'E1': 40849,
         'E2': [2529479455, 1049031117, 3068988350, 2494066874],
         'E3': 2036955755,
         'E4': -4611,
         'E5': 2116955669},
        {'E1': 7703,
         'E2': [1006473408, 3256529997],
         'E3': 2211228221,
         'E4': -2546,
         'E5': 1159399249}]}

Вариант №13

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

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

(b'\x0fJCJR\x00L\xa5[\xbe\x97U\xb1\x03z\x03N\xc3\xaf|\x02\x00\x00\x00'
 b'\n\x00\x00\x00n\x81\xa0M\x02\x00\x00\x00\x0c\x00\x00\x00\x1e\xcf\xf8\x84'
 b'\x02\x00\x00\x00\x0e\x00\x00\x00gt\x1d\x9d\x02\x00\x00\x00\x10\x00\x00\x00'
 b'r\x0fs\xb5\x02\x00\x00\x00\x12\x00\x00\x00\xc6\x97wx\xdb\x1c\xeb\xf1'
 b'_w\x81\x08\x08P\xe0,\xe6\x1fa>\x83\x05\x00\x00\x00\x14\x0028p\xc2B'
 b'<\x95\xfd\xd0\x12(\xc6\x1e\xe50(\xe3r\xbfg\x82\xe2\x99<\xaf\xd9\x05|\xa4'
 b'\x04|\xc3o*\xe3k\xe9U6\x93M\x98j\xedeJ\xfb\x02\x00\x00\x00P\x00\x00\x00\x19V'
 b'\x99)\xbfr\xa1Y\xbf')

{'A1': {'B1': 2002776555,
        'B2': 2298574001746217089,
        'B3': 15969,
        'B4': {'C1': 131,
               'C2': [{'D1': [-105, 85], 'D2': 1302364526},
                      {'D1': [-79, 3], 'D2': -2064068834},
                      {'D1': [122, 3], 'D2': -1659014041},
                      {'D1': [78, -61], 'D2': -1250750606},
                      {'D1': [-81, 124], 'D2': 2021103558}],
               'C3': {'E1': -1032832974, 'E2': 14278683307395071042},
               'C4': 7475820226415748382,
               'C5': 57986,
               'C6': {'F1': [-642827111,
                             77888517,
                             711967612,
                             1441360867,
                             -1739746506,
                             1248193898],
                      'F2': 251,
                      'F3': [219, 28]},
               'C7': 25},
        'B5': -0.6624959707260132,
        'B6': -0.8501197099685669},
 'A2': -0.21449774503707886}

(b'\x0fJCJ8\x000\xa2\x0c=\x9a3$w\xb5\x1a\x02\x00\x00\x00\n\x00\x00\x00'
 b'\xbb\x9e\xac\xdb\x02\x00\x00\x00\x0c\x00\x00\x00\x0b\xa8\xca\x1f'
 b'\x02\x00\x00\x00\x0e\x00\x00\x00$\x83\x8bR\xa0\xa9@\xea\x08\xcf\x99M'
 b'I\xca\xfe\x08\xf6I\xc4#\xdf\x93\xc4\x03\x00\x00\x00\x10\x00\xa4\xdc|'
 b'M}\xc0\x0e\x99}!F\x92*\xf6\xf7\xceA3\xdd\x0f\x98\xb5\xd4\xec\xec\xf1\xfd'
 b'\x19\x88\xcevs\xf9F\xebf\xe0;G\xfe\x1f\x18B8\xeb\xfe\x9e\x04\x00\x00\x00'
 b'4\x00\x00\x00\xde\x88\xbe\xb0>x\xa3\n?')

{'A1': {'B1': 1301925640,
        'B2': 2577266207824464457,
        'B3': -27681,
        'B4': {'C1': 196,
               'C2': [{'D1': [-102, 51], 'D2': -609444165},
                      {'D1': [36, 119], 'D2': 533374987},
                      {'D1': [-75, 26], 'D2': 1384874788}],
               'C3': {'E1': 1300028580, 'E2': 10540148801229734013},
               'C4': 1143126238160221738,
               'C5': 46488,
               'C6': {'F1': [-236131116,
                             -829941251,
                             1190753142,
                             1004562155,
                             404749895,
                             -18139070],
                      'F2': 158,
                      'F3': [160, 169, 64, 234]},
               'C7': -34},
        'B5': 0.3452036380767822,
        'B6': 0.5415568351745605},
 'A2': 0.03433436155319214}

Вариант №14

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

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

(b'\xa7KBSL\x03\x000\x00\x00\x00|{#\xd6\x93\xfa\xe9?\xd23\x00\x00\x00'
 b'8\x00\x00\x00=\x00\x00\x00J\x00\x00\x00I\xb8\x18\xbf\xb4\x04\x05\xa8'
 b'm\x8c\xbc\xbaval\xbe\x91\x90E\xb3\x17p\xd7\xd5m\xbbi\xd7\x1bL\x9d#'
 b'\xa6\xf6\xf2\xa19\xe9\x04\x00\x00\x00B\x00\x83Z\xa7YzW\x86\xfd\xde\xe3z9'
 b"'\xe1\x1d\xa9\x9e\xdb\xe3!\xa3W{?")

{'A1': 'val',
 'A2': 0.811838072051486,
 'A3': -46,
 'A4': {'B1': [{'C1': 37310, 'C2': 144, 'C3': -19643},
               {'C1': 28695, 'C2': 215, 'C3': 28117},
               {'C1': 27067, 'C2': 215, 'C3': 19483}],
        'B2': {'D1': [9117, -2394, -24078, -5831],
               'D2': [-178358952232789373, -6260600348390792226],
               'D3': -9314,
               'D4': 227,
               'D5': 33,
               'D6': 0.9818059802055359},
        'B3': -0.5965619683265686,
        'B4': -4990959884435127116}}

(b'\xa7KBSL\x04\x000\x00\x00\x00\x8c~}\x998\xc9\xd0\xbf\xb74\x00\x00\x00'
 b'9\x00\x00\x00>\x00\x00\x00G\x00\x00\x00\x17\xff\x94>K\xb5\xe3e'
 b'\xdb\xb6\xc8\xf1kqvp\xc0\xc3\xdb\xf7/\x8a\xde\xd8\x15h\x17\x17\x14NL\xca'
 b'\x16t\xdd\x02\x00\x00\x00C\x00+\xb6sg\xf2\x9c\xcb\xb5\xd84\xef\x0fh\x8c='
 b';t\x94\xd4\x84\xc2e,>')

{'A1': 'kqvp',
 'A2': -0.2622815607955793,
 'A3': -73,
 'A4': {'B1': [{'C1': 50112, 'C2': 219, 'C3': 12279},
               {'C1': 56970, 'C2': 216, 'C3': 26645},
               {'C1': 5911, 'C2': 20, 'C3': 19534}],
        'B2': {'D1': [5834, -8844],
               'D2': [-5347007567640676821, 4268722400388920536],
               'D3': -27532,
               'D4': 212,
               'D5': 132,
               'D6': 0.16835692524909973},
        'B3': 0.29100868105888367,
        'B4': -1024367861803272885}}

Вариант №15

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

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

(b'WDA\x1c\xa6\xd5\x01]!\xb1\x99\xf6\x04\x17^\xcf;<>\x8d\xaa\x00\x02\x00'
 b's\x00\x02\x00\x00\x00{\xae\xf5\x98\xed\x81b\x98\xe5\xd6\xcc\x8c\xbe\xc6'
 b"9\x00w8\xf6\x10Y\x9bY.C1U\x12'\x82w\xdc!\x00\x03\x00\x00\x00\x838j\xe7"
 b'<\xafIK\xad\xa9\x01\xeb\x02\x0c\x00\x00\x00\x02\x00Ix\x02L\xda'
 b'\xf0\x03\x17\x99v\x06\xed\xef-\xf6\xe4\x00\x00\x00\x02\x00^(t9n\xa1\xe3\x00'
 b'\x00\x00M\x00\x00\x00boxpE\xba\xd7\xe6a\xdb2M\x9e+\xd0')

{'A1': 2064571681030123929,
 'A2': -719424344501306306,
 'A3': 36266,
 'A4': {'B1': [{'C1': 2835475202,
                'C2': 12,
                'C3': [-20663, 19373],
                'C4': 2013416666,
                'C5': 240,
                'C6': 3},
               {'C1': 3991875062,
                'C2': 228,
                'C3': [6041, 30214],
                'C4': 678705518,
                'C5': 161,
                'C6': 227}],
        'B2': {'D1': [1870164037, -1160255903],
               'D2': -1359636243,
               'D3': -32414,
               'D4': -1729767732,
               'D5': 140,
               'D6': -0.38715362548828125},
        'B3': 2000221712,
        'B4': 1503353134,
        'B5': 1127306514},
 'A5': 662861788,
 'A6': 33,
 'A7': [-9422, 19870, 11216],
 'A8': 946530108}

(b"WDA\xe01[oO\xa4\x96\xd1\x88\xf8}y\xdd\xf8\x9aq'\x0e\x00\x02\x00s\x00\x02\x00"
 b"\x00\x00{\xda\xe0\xdf\x7f\x08'{\xf6G\xa4\xe3\xbe\xbd\x96\x83\xa2\x96"
 b'9\x9c\xb9\xa6c\xef\x8f\xbdt\x84\xf2\x04\t\x83h\x00\x07\x00\x00\x00\x83#3\xf1'
 b'\xda\xce\xff\x066i\xd7]\xe6\x1d\x00\x00\x00\x02\x00I\x0f8;\r\x16\x04s\x8c'
 b'8\xa5\xdf\x17{\xd2\xa9\x00\x00\x00\x02\x00^\x07\xec\x8e&\xe9\x91\x00'
 b'\x00\x00M\x00\x00\x00b\x97zYt\x1c\xe6\x9f\x0c\xa1\x9c\xa9\xd1V'
 b'\xe7\xc5\xd1\xff\xe0\x93\xf9\x14/')

{'A1': -2291950201719187759,
 'A2': -8576967527958537615,
 'A3': 9998,
 'A4': {'B1': [{'C1': 1775721958,
                'C2': 29,
                'C3': [-12545, 1590],
                'C4': 255343373,
                'C5': 22,
                'C6': 4},
               {'C1': 3742858194,
                'C2': 169,
                'C3': [29580, 14501],
                'C4': 132943398,
                'C5': 233,
                'C6': 145}],
        'B2': {'D1': [-1753589388, 484876044],
               'D2': -622796929,
               'D3': 2087,
               'D4': 2079737764,
               'D5': 227,
               'D6': -0.3702889382839203},
        'B3': 2727754140,
        'B4': 3114689519,
        'B5': 2411558020},
 'A5': 4060350851,
 'A6': 104,
 'A7': [-24164, -22063, 22247, -14895, -32, -27655, 5167],
 'A8': 590606810}

Вариант №16

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

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

(b"UZH\x80\xd7\xa1?\x91\xe3\x1fK?\x00\x00\x00e\x00\x08O'\xee\xf4\x88\xe1"
 b'&\x81\x00\x00\x00xZ\xb8v?\xee<\xa2\x8eY\xfd\x84\xef\x03k\xca\xb3>t\xf0=]v'
 b'r\x99\xa1\x1d\x00\x00\x00*\x00\x00\x00\xf9*#Z\xdd\x81\xbdiO\x07K\x9c^'
 b'\xb9\xdeO\x02\x00\x00\x007\x00\x00\x00J\xa6\x85\x92,G\x01h\xb7\xddxr)'
 b'\xea\x92"\xb2\x08\xc9\xea7J\xcc9\xe5\xb9>\x0f\xe4\xbf\xf8\xb5\xf5'
 b'\x1d\xaa`\x15\x9d;\x06(\x1d\x8b\x98\t\xde\x97\xbd\xe0\xf5\x03\x00\x00'
 b'\x00~\x00\x00\x009\x8f\x9a\x9e')

{'A1': 1067571072,
 'A2': 1260381073,
 'A3': {'B1': 7619388932280756985,
        'B2': 5755241189826299727,
        'B3': [{'C1': 120,
                'C2': 0.9637504816055298,
                'C3': -1901970194,
                'C4': [89, 253, 132, 239]},
               {'C1': 3,
                'C2': 0.351153701543808,
                'C3': 1564340340,
                'C4': [118, 114, 153, 161]}],
        'B4': -1836734902,
        'B5': 1744914220,
        'B6': -8777,
        'B7': 3928584824},
 'A4': {'D1': {'E1': 5348001231680971410, 'E2': -0.6268609648484982, 'E3': 248},
        'D2': 4295613124496455093},
 'A5': 2801671028750110472,
 'A6': {'F1': -26485,
        'F2': [9, -34, -105, -67, -32, -11],
        'F3': [6, 40, 29],
        'F4': 2660929337}}

(b'UZH]\xd92\x92\xb5Fa\xd1P\x00\x00\x00v\x00\xe4\xbd\xc0@\x04\xd4\xb5'
 b'8\x92\x00\x00\x00\xd2\xac9\x8e\xbeL\xf2\xbc\xdf\xbe\xb4\xccG\xd1\xa5'
 b'\r\xd6>\xa7{\x0b/\xf7\x93\xa5\x18F\xa2\xf5\x8c\xbeC\x18\x8ejI2n\xa8'
 b'\x1d\x00\x00\x00*\x00\x00\x007\x00\x00\x00<4{6\xbe\x00]\xfe\xf4\xfc\xf0\xbe'
 b'\x89,\x93\x8c\x03\x00\x00\x00D\x00\x00\x00\x12]\xf3E\x1b\x9f\x1a"L\xc1(\x82'
 b'\xce\x85\x82:\xf7G:\xd4\xc3\x01\xce\x08\x86\x1e\xe7\xf8\xe2?\xf6\x16'
 b'\x15K\x98\xd8\xb4\xed\x00\xb9\x90\x1aE=b\x842M\x8f\xc5\x03\x00'
 b'\x00\x00\x8f\x00\x00\x008\xf0\xa2\x14')

{'A1': -1842161315,
 'A2': 3512813237,
 'A3': {'B1': -117937198283934660,
        'B2': 10129488957011983604,
        'B3': [{'C1': -46,
                'C2': -0.27778375148773193,
                'C3': -541265332,
                'C4': [190, 180, 204, 71]},
               {'C1': -47,
                'C2': 0.4180728495121002,
                'C3': 789281703,
                'C4': [247, 147, 165, 24]},
               {'C1': 70,
                'C2': -0.27531152963638306,
                'C3': 1787697219,
                'C4': [73, 50, 110, 168]}],
        'B4': 1173576978,
        'B5': 572170011,
        'B6': -16052,
        'B7': 2244903464},
 'A4': {'D1': {'E1': 127178561277082242, 'E2': 0.592883643738128, 'E3': 246},
        'D2': 66908411841418518},
 'A5': 4086405351639924196,
 'A6': {'F1': 15685,
        'F2': [98, -124, 50, 77, -113, -59],
        'F3': [185, 144, 26],
        'F4': 346222648}}

Вариант №17

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

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

(b'OQQ`\xbeq?Fl\xce\x00\x00\x00\x03\x00C{\xe0\xfd\xd2Nw\xa2`\xf1zz\xcd'
 b'\xc7\xf3\xbe\x17\xf4\xa5\x90\xfe)\x80\xd7*\x0f\x00I\x00R\x00[\x00d\x00m\x00'
 b'v\x00\x7f\x00\x88\x00\x00\x00\x99\xbfi\xc1{Qc\x066T\x0e\xf8\x1bG\xe6\xf3'
 b'm\xc5\xca\xcf\x7fNA\x88\xca@+OS\x1d\x08\xe5i\x01c\xac\x1d\xd8\x18xN\x87Rt'
 b'\t\xfb\x80SL\xabhD\x1b\xb2R\x1e\x83\x0b\x94\xbf\x8dT\xbeN\xbcl\xc9O'
 b'|\x96\x07C\xb8!G\xf2\xbd\x0b\x81\xbf\xcc\x14d\xa5\xa5\xec\xc3\x96'
 b'\x0b\x07\xcf\xc4\xea\x1f\x1e\x00\x00\x00\x03\x00\x91Y\x06\x8a<\x1f\x80\xdf'
 b'\xd9\xb7|\x00\x02\x00\x97')

{'A1': 96,
 'A2': {'B1': {'C1': 190,
               'C2': {'D1': 113,
                      'D2': 0.7750977277755737,
                      'D3': [1590, 21518, 63515],
                      'D4': 2078342610},
               'C3': 5654166394438843085,
               'C4': -4038675430723186434,
               'C5': 10624},
        'B2': 55082,
        'B3': 15},
 'A3': [{'E1': 5181096074131722111, 'E2': 78},
        {'E1': 4722246586251301661, 'E2': 8},
        {'E1': -1915998638868408296, 'E2': 120},
        {'E1': 5658582115151478867, 'E2': 76},
        {'E1': -6095547209899434365, 'E2': 11},
        {'E1': -7728303040434881428, 'E2': -55},
        {'E1': 5727617784053506375, 'E2': -14},
        {'E1': -4824619915034729307, 'E2': -91}],
 'A4': {'F1': 7966,
        'F2': [60611, 38411, 1999],
        'F3': 1493600828,
        'F4': 8064,
        'F5': -8231,
        'F6': 46972,
        'F7': [196, 234]},
 'A5': -0.9131085276603699,
 'A6': 20835}

(b'OQQ3\xb2\x96=\xd9\x05\x18\x00\x00\x00\x03\x00C\xb3E\xd9\x92\xf7f\xee\xde'
 b'w\x93\xab\xa8\xfe9v\xd7A\x87\xca\x08\xafa]\x97\x8c\x00I\x00R\x00[\x00'
 b'd\x00m\x00v\x00\x7f\x00\x88\x00\x00\x00\x9b?i\xb9%\tj\xd7\xee\xa7\xd4{'
 b'1\x0b\xea\xce\x93X\xb0\x06\xe7\x80\xbfe\xcd\xb4\xb0M\xe0\x88\x9e\xff'
 b'\xa1\x1d\x81Z\xa0"$\xe3\xf9,\x87][\xa2\x80\x99\x04p\x87\xc4>\x91\xb3\xa9'
 b"\xa3jh'\xc9-0\x05\xa2\t\xaat \x9bv\xa7\xf0H\x1dj\x06B^\xf2\xc1#\x1a\xe1"
 b'\xe2\xb6\xe7\\\x88\x1a\x0b4\xff\x90\xc2*\xae\x00\x00\x00\x02\x00\x91y'
 b'\xd6\x9b\xcf\r\xe1\xcfd\x88p\x00\x06\x00\x95')

{'A1': 51,
 'A2': {'B1': {'C1': 178,
               'C2': {'D1': -106,
                      'D2': 0.10596674680709839,
                      'D3': [55278, 42964, 31537],
                      'D4': -1287267950},
               'C3': 17827198814249003944,
               'C4': -127940447513884152,
               'C5': -20639},
        'B2': 23959,
        'B3': -116},
 'A3': [{'E1': 858725811210946279, 'E2': -128},
        {'E1': -4655088463881838456, 'E2': -98},
        {'E1': -26707681379081692, 'E2': -29},
        {'E1': -491869424251141991, 'E2': 4},
        {'E1': 8108665427115354531, 'E2': 106},
        {'E1': 7505188499952607753, 'E2': -86},
        {'E1': 8367859041580369949, 'E2': 106},
        {'E1': 451027309405870817, 'E2': -30}],
 'A4': {'F1': 10926,
        'F2': [46823, 23688],
        'F3': 2044107727,
        'F4': 3553,
        'F5': -12444,
        'F6': 34928,
        'F7': [26, 11, 52, 255, 144, 194]},
 'A5': 0.9129813313484192,
 'A6': 2410}

Вариант №18

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

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

(b'VKHO\x00\x00\x00\x99\x0fIQ\t\xac\xfe\r\x02\x00\x00\x00^\x00|3\x12?i\xae\xba'
 b'>_\xfa\x8f\x00V\xb7\x9b8\xbdJ\xe6\x95\xa4\x97\x13\x06z\xc6\xc85Qu\xe7'
 b'x\xb6e\xe2_\xab\xc0\x05Pm\xf4\x81\x7fchb>\xa0\xea\x99%+\x1fz\xf6\x94\x00\xa4'
 b'\x81\xc4\x99V\xa0\x0c\x91N\xef~\xf3\xa3U\x8d\xbe\xb3\xbc\x0b4\xf6\xea?dt'
 b'N\xd2H\xab\xd9?\x87\xadAOagvlttfT\xa9\xcbp5\xc4\xec\xbfX\x9f\x97{\x10\r\xe3'
 b'?\x148\x1a\xd9efyhobu\xf7\xbb\xa9\xa6v7\xcf\xc7,X\x10\xc1\x19\xf1\x9d\xd2?')

{'A1': {'B1': -1715175004, 'B2': -24490, 'B3': 6171043640934043916, 'B4': -115},
 'A2': 1008432522595995545,
 'A3': [{'C1': 0.8425541142693118,
         'C2': 0.40107937371960234,
         'C3': 1329704327,
         'C4': 'agvlttf'},
        {'C1': -0.8989512637174735,
         'C2': 0.595344773665583,
         'C3': -652593132,
         'C4': 'efyhobu'}],
 'A4': 0.5710980892181396,
 'A5': 0.3646118938922882,
 'A6': 4079055467518622303,
 'A7': [{'D1': 19133,
         'D2': 2544145894,
         'D3': [1555, 50810, 13768, 30033, 30951, 26038],
         'D4': 24546},
        {'D1': 49323,
         'D2': 4100804613,
         'D3': [32641, 26723, 15970, 60064, 9625, 7979],
         'D4': 63098}],
 'A8': {'E1': -9, 'E2': 3226775495155034555, 'E3': 0.29089000239424}}

(b'VKHO\x00\x00\x00`\xaa\xd1\xe7\x99^il\x02\x00\x00\x00^\x00\xa8\xbe\xb1'
 b'\xbe\x92\xf5m\xbd\xa3r\xe2>\xc4\xf6"Hb\x91w\xe8d!\xd9\xde\xa8\n2c)uL'
 b'\x90\x02\x0e\xac.\xa6\xd6\xdc\xcc\xb3\xeb\xc1"\xb3i\x89\x08\xef\x88,\xb5OU.'
 b'g\x94\x00\xe4:\xee\xa9>\x8b\xd9m\xeeA!`\x02\xf7O\xbc\xf4\xda\xd2\xbdJ\xe8?lR'
 b'\xab;+\xbf\xd9\xbf\x1c\xed\xacbyuqomkp6\xb1o\xeeH\x12\xe7\xbf\x02XJ'
 b'\xeeK\x99\xea?\xa6\x87\xa24lalbnzy\x8f-\xd4\xee\xcbHa\x80\x1e\xe0(\xb8'
 b'\xb6\xdf\xeb\xe1?')

{'A1': {'B1': -1444005148, 'B2': -29890, 'B3': -647849700431598119, 'B4': 79},
 'A2': 7811879043763120736,
 'A3': [{'C1': 0.7591237180964963,
         'C2': -0.40229302241394893,
         'C3': 1655500060,
         'C4': 'yuqomkp'},
        {'C1': -0.7209820420226041,
         'C2': 0.831212964449833,
         'C3': 883066790,
         'C4': 'lalbnzy'}],
 'A4': -0.34715771675109863,
 'A5': -0.05809552222490311,
 'A6': 5197988242668024483,
 'A7': [{'D1': 37218,
         'D2': 560261239,
         'D3': [57049, 2728, 25394, 29993, 36940, 3586],
         'D4': 11948},
        {'D1': 54950,
         'D2': 3954429148,
         'D3': [8897, 27059, 2185, 35055, 46380, 21839],
         'D4': 26414}],
 'A8': {'E1': -113, 'E2': 2197863583443768365, 'E3': 0.5600431984651344}}

Вариант №19

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

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

(b'ZZMT\xbeZ\x00\x00\x00o\x00\x00\x00\xdb\x02\x00\x84\x00\x00\x00\x19V\xa2F'
 b'\x96\xbf.%\xd8R\xc8\x89\x9f\xf9\x19S\xc0imJ\xdd\x93"\x8ay\xedj6t8]\xda'
 b'\xd3\xc94gJ\x05\x8fqe\x00\x88\xa0\x8fQ\xdbhW\x8d^k\xe0\x00\xdbB'
 b'\xf5\xd8\xc5\xbf\xa2t}d\x7f\x1f\x8b\xcel\xd9Qh\xb7\xbelv\xf8\x06\xf8\xfb'
 b'>\xad\xe6\x06\x06"]\x80\xc5\xd6\x80\x1ad{?oq\xe1\x92S\x1b\xbf}\xc6'
 b'\xd86\x18\xff\xbf\x7f\xbd\xd5\x8aj\xec>\xad\xd5\xd0\xbe')

{'A1': [{'B1': -0.3582177460193634,
         'B2': 'lv',
         'B3': 248,
         'B4': 0.4921266436576843,
         'B5': {'C1': 14231477223202154157, 'C2': 32982}},
        {'B1': 0.9819961786270142,
         'B2': 'oq',
         'B3': 225,
         'B4': -0.6067439317703247,
         'B5': {'C1': 9205356642833057405, 'C2': 54717}}],
 'A2': -37,
 'A3': {'D1': [0.461750328540802, -0.4078802168369293], 'D2': 25},
 'A4': {'E1': [15574906286725571158,
               13858449038263306322,
               8757850443843530089,
               15265616383974992621,
               7309780923084911817,
               6298525222226135040],
        'E2': -115,
        'E3': 27486},
 'A5': -0.1706835342829498,
 'A6': 29858,
 'A7': -2779619773070220163}

(b'ZZMT\xbeZ\x00\x00\x00o\x00\x00\x00\x95\x04\x00\x84\x00\x00\x00'
 b'\x9f\xb8\xf0\x15U\xe6\x9b\xd22\xea\xef\xc3\x02\xb8\xd6\x02\x92>\x7f\xfe'
 b'\x9f\x96c\x00\x13\xa7\xca\xa0\xbc\xd8HY\xe9\xd3\xa9\x98j\xe1\x81\x92'
 b"4\x14L\xc4{ET\x0e\xf5\x1a\x19\xfd`\xa6o\x86\x13\xff\xe0\xbf\xbd\x93]'"
 b'\xd7\x8d\t1\x8fh\x01\x8a\x17\xbfwm.@\xf3{\xbdf\xb0\x0b\x8b\x90T,'
 b"\xb5\xed\xab\x99]\x1b\xbfaq'\x94\xedv\xbf$\xd0\xcf>\x01^\x86\xb5\xfc\xe7"
 b"\xe7q'\xbf,V\x11\xbf\xd6=1;d\x11N\xbe")

{'A1': [{'B1': -0.5919495224952698,
         'B2': 'wm',
         'B3': 46,
         'B4': -0.06151127815246582,
         'B5': {'C1': 13054902399625048166, 'C2': 44013}},
        {'B1': -0.6068969368934631,
         'B2': 'aq',
         'B3': 39,
         'B4': -0.9645626544952393,
         'B5': {'C1': 13080245527185969188, 'C2': 59388}}],
 'A2': -107,
 'A3': {'D1': [-0.6540817618370056,
               -0.5677211284637451,
               0.0027044913731515408,
               -0.201238214969635],
        'D2': -97},
 'A4': {'E1': [3662160860577919160,
               10521207765299621866,
               1369203785301131070,
               16814550779479247527,
               3788233041728022995,
               17658143846372232212],
        'E2': 26,
        'E3': -743},
 'A5': -0.5311372400003158,
 'A6': -27715,
 'A7': 7534294618718283613}

Вариант №20

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

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

(b'\xc5PTCM\xde6\xe7\xa9\x03\x00\x00\x00\x85\x00\x00\x00\x03\x00\x8b\x00s\x7fc'
 b'@\x93-,\xbc\x95H\xa8\xbb(\xd0\xbf\rW\xda\xcca\x85s\x8a\xba\x06\x14_'
 b'qd\x9d\xa7\x95\xe5\x01h\x89\x01\xe3M\x07\xc2\xa9\x84\xe62\xc8\xdb){\xc7\xdb'
 b'\xc2\n\x81\xbc\xd6\x19\x87\xe9\x94\xfd|<D\xb7\xa95\xc6\x15,6\x01:\xff\xff'
 b"\xe6\r\x8fi'\xfd\xb5]F\x85|r\x00LQgI4r\xc5%D\xc6\x8e6\xe0\xc4\xcf"
 b'\xef\xf3\xf3\xb5\x9a\x9ei`\xf1U\x00e\x00u\x00zwm')

{'A1': 2850502366,
 'A2': {'B1': [{'C1': 87305714811644343, 'C2': 2839958329906691898},
               {'C1': 32225059198055933, 'C2': 2721707118710706508},
               {'C1': -1166497311198624188, 'C2': -1053726182883331085}],
        'B2': 'zwm',
        'B3': {'D1': [115, 127, 99, 64, -109, 45, 44],
               'D2': -0.25248614725054686},
        'B4': -8470279819058587891,
        'B5': [1595147962,
               2812109937,
               1744954773,
               1306722697,
               2225717767,
               3687330534,
               3687283497,
               3162573506],
        'B6': 214},
 'A3': 4916942321748641561}

(b'\xc5PTCM\xabg\x80\x02\x04\x00\x00\x00\x95\x00\x00\x00\x03\x00\x9d'
 b'\x00\xfd\xa6\xb2:\xf7@#X\x9fc\xe8\x05z\xd3?\xec\x13x\xd6\xa0r\x98\x83'
 b'\x89R=\xf6\xd8\x89K\xc0\x9a\n\x1c\xb3GD\xf4Dc\x9e\xde\xf5\xc28\xb2q'
 b'"\xb8\x0f\x0e\x8c\xe9\xbe\x98\xa1\r}\xae}\xb2\xf9\x9e\xf8AEV\xda\x13\xf6\x8b'
 b'.g\xfd\x8c\xc79{\xbe#~n\xc8\x898\x94\xffY\x01\xa4q\xac\xac$\xe6\xc50\x0b|'
 b"\xb6\\y\xfe\n\xbd\x8e\x98\xa9\xa5x\xfc'H\x8d\x1d\xbcx\xde\x00z\xd8H*"
 b'\x93l\xf5\xbe\xedU\x00e\x00u\x00\x85\x00iqq')

{'A1': 41969579,
 'A2': {'B1': [{'C1': 3354044912635364673, 'C2': 2575631524993760615},
               {'C1': 6485064958987497086, 'C2': -4186618479548193791},
               {'C1': 792204023569320752, 'C2': 2881310514520559293},
               {'C1': 8791271082760703304, 'C2': -1315344194471311144}],
        'B2': 'iqq',
        'B3': {'D1': [-3, -90, -78, 58, -9, 64, 35], 'D2': 0.30432269758465713},
        'B4': -8964289023162444820,
        'B5': [4131213961,
               3226175960,
               3004959386,
               1156858951,
               4125007459,
               1907505346,
               235911202,
               2562648460],
        'B6': 161},
 'A3': -531713160975057651}

Вариант №21

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

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

(b'USFP\x9c.q\xa5n\x00\x00\x00|\xb9\x03\x00\x00\x00\x85\x00\x02\x00\x8b\x00'
 b'\x00\x00{\x145\x1f\x8ck\x05\xe0\xca\xa3\x13\xfdxm"T\xae\xe5\x98r>P'
 b'\x02\x00\x00\x00&\x00\x00\x001\xf1\x1a\xbcp\x90\x1f\xad \xda\xc8\xd5?RV\x8a'
 b"\x10F,fHk\x11\xa9'j$\x05\x9a&\x1b\xfc\xbb\xf5o\xad\x0bE_\xf83|\xb1\xb0"
 b'\xdc\xd5h\x1a\n\x1a\xda&\xed\xbe(\x00\x00\x00Q\x00\x00\x00\xb4\xb3'
 b'^\xe5\xac\x12\x82\xf1N\x0b\x0fn*&#v\x00{\x00\x80\x00\x9dG\x1e\xaf\xb8'
 b'+\xa4\x1b')

{'A1': 2775658140,
 'A2': {'B1': {'C1': -441560030,
               'C2': 1346269848,
               'C3': 'xm',
               'C4': -0.009456918574869633,
               'C5': 112,
               'C6': 0.3403840369323854,
               'C7': 5216905897792132690,
               'C8': [4459, 10153]},
        'B2': {'D1': 106,
               'D2': -739720520230370012,
               'D3': 1158393199,
               'D4': 2083780703,
               'D5': 1876341232320164017,
               'D6': -0.463187038898468}},
 'A3': 47484,
 'A4': [{'E1': -76, 'E2': 24243, 'E3': -21275},
        {'E1': 18, 'E2': -3710, 'E3': 2894},
        {'E1': 15, 'E2': 10862, 'E3': 8998}],
 'A5': [-1356970083, 463743928],
 'A6': 5243,
 'A7': [7989, 27532, 57349, 41930, 64787]}

(b'USFP\xd5\x1a2\ns\x00\x00\x00c\xa2\x03\x00\x00\x00\x8a\x00\x04\x00\x90\x00'
 b'\x00\x00x\xb0U\x9c\xc3\x95\xaaY\x8e\xe8R\x7fhpixrij\xac\x84k\xabHv\xcd'
 b'\x8f\x07\x00\x00\x00&\x00\x00\x00\xbdw\x17\xbflh\x80\x18|\xb9x\xc3\xbfW\x08'
 b'\x91`\xe3\r>\xa8f\xf8\xcb1\x17\xd7R\x02\xe4L[\x97#P\x8fK\x0f&\xbcR\x8c\xb8'
 b'\x90Yy\x1bv\xc3*H\xf9\x8a>-\x00\x00\x00V\x00\x00\x00\x805\xdbl\x04\xe8\x9f<d'
 b'\x92\x05\x89\xc0\xb8\xf3{\x00\x80\x00\x85\x00\x97B\xcf\xfa\x0f\x16\x86\xea'
 b'>1\xf1!0F\x19\x90')

{'A1': 171055829,
 'A2': {'B1': {'C1': -1419017044,
               'C2': -1882360248,
               'C3': 'hpixrij',
               'C4': -0.5916708111763,
               'C5': 108,
               'C6': -0.15212172088013465,
               'C7': 12123142517156808791,
               'C8': [63590, 12747]},
        'B2': {'D1': 23,
               'D2': 2564618898611786455,
               'D3': 256610128,
               'D4': 2354232358,
               'D5': 3081436430423658680,
               'D6': 0.27143311500549316}},
 'A3': 41571,
 'A4': [{'E1': -128, 'E2': -9419, 'E3': 1132},
        {'E1': -24, 'E2': 15519, 'E3': -28060},
        {'E1': 5, 'E2': -16247, 'E3': -3144}],
 'A5': [-87080297, -360311281, 569454910, -1877391824],
 'A6': 45176,
 'A7': [40021, 38339, 22954, 59534, 32594]}

Вариант №22

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

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

(b'KBC\xd7\x00\x00\x00\x02\x00\x00\x00KRon\x01b\x00]\xb4\xa5\xca^@\xd3\xb7r1'
 b'\xda;\x9c\xc3\x1ab\xb9\xae%\xab\xb7\x00\x03\x00\x13>\xda\x97\x89\x15'
 b'\x0eo\xa2\xfe_I\xf1Oz|\x17<O\xe6L3p\xa21\x00\x03\x00/=\xd9\x02p\x00'
 b'\x00\x00\x1f\x00\x00\x00;\x0bW\xd9Io+y\xdfj`\xd0\xc0\xe2\xbb\xfa}\xb8'
 b'\xa0\xdat\xbe\xfb\xdaQ7/\xb4z\xde5F\xa3\xf1??\xc1?\xcdch\xbc\x88\x05\x13\x86'
 b'{]\xbd\xc6p\xa1\t\x02OSB\xda\tl\x00\x00\x00\x05\x00\x00\x00SCs')

{'A1': [{'B1': -1021680967,
         'B2': -1373262921,
         'B3': [3030764126, 1087616882, 836385692],
         'B4': 0.42693737149238586},
        {'B1': 1011869260,
         'B2': 863019569,
         'B3': [353267618, 4267657713, 1333427223],
         'B4': 0.10596168041229248}],
 'A2': 82,
 'A3': 1869480290,
 'A4': {'C1': {'D1': [-792665413, -92424032, -629883141, -632211665],
               'D2': [3027951157, 1185149247],
               'D3': 0.13475959161721485,
               'D4': 365783859158959728,
               'D5': 161,
               'D6': 151146323},
        'C2': 1121585516,
        'C3': [2903, 55625, 28459, 31199, 27232],
        'C4': 17267}}

(b'KBC\xd7\x00\x00\x00\x02\x00\x00\x00GP4\xf85\xff\x00W\x8e\x94T.2)#h7'
 b'\xcc\x08\xf9\x9a\xf1\x7f\x99Q\xc7\xcd\x9a\x00\x03\x00\x13?$\x8b u'
 b'\xc6\xdc\x88\xb7d{~iM"\x17,UMX\x00\x02\x00/=\xadl\x05\x00\x00\x00\x1f\x00'
 b"\x00\x007waZ\xfd\xff\xef\xc5\x93\x94\xda\x89\xff'\x89\xd3\x8b8"
 b'\xde\xbd\xd8\xafu\x8at\x100\xc7\xd0\x9d\xb7\x8e\xab?\xb9\xe8?\x93'
 b'\xffy\xe0\x86\x90\xad\xac\xc7\xdeG\xe6k\x90\xec\xfbw\x00\xe6\xa9\x1d'
 b'\x00\x00\x00\x04\x00\x00\x00O4&')

{'A1': [{'B1': -1695449191,
         'B2': 1372048794,
         'B3': [2392085550, 841556840, 936118521],
         'B4': 0.6427478790283203},
        {'B1': 1766662679,
         'B2': 743787864,
         'B3': [1975966856, 3076815742],
         'B4': 0.08467868715524673}],
 'A2': 80,
 'A3': 888681983,
 'A4': {'C1': {'D1': [-1797617153, 663344011, 954121688, -1351251340],
               'D2': [271632336, 2646052523],
               'D3': 0.1012000786135796,
               'D4': 9696440955327891430,
               'D5': 107,
               'D6': -1863517321},
        'C2': 15116573,
        'C3': [30561, 23293, 65519, 50579],
        'C4': 13350}}

Вариант №23

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

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

(b'WCBD\x8e5\x00F\x00\x00\x00\x03\x00P\x00s\xc8\xe7\xc1\xd6\x16\xa0j\n'
 b'!\xf3(\xf6Qf\x00z\xc4\xbb\x14bN\xd9\xcdlX\x12:}\xda\xd6X\xe9\x04\xa2\xf87'
 b'\x89\xec\xacm).\xbbQ\xe9\xe8&\xe6og\xfa&\xc5Q\x00\x00\x00\x12\x00\x00'
 b'\x00,\x0ftgvj\xcd\x1c\n)\xfe\x18!\xa9\x1d\x8b\x00\xd5q\x83x\xbb\xdc'
 b'\xb1wn\x7f\xe8\x08w\xda\xac\xfa\xfb\x08W\x8d\xa3\xd2?\x96\x9e\xf3'
 b'\xf3\x84\xb2@\xbf\xe0\x15PU\x9e\x19\x9aJ\x9b\xbbJ\xf5\x07\xfd\t'
 b'\x00\x00\x00\x08\x00\x00\x00S')

{'A1': -29131,
 'A2': {'B1': [{'C1': 3252033184,
                'C2': 27146,
                'C3': 8691,
                'C4': 2951636104324498619,
                'C5': 5218,
                'C6': 5681798270122343037},
               {'C1': 3671480553,
                'C2': 1186,
                'C3': 63543,
                'C4': -8508236011167368367,
                'C5': -5656,
                'C6': 2803050310453871953}],
        'B2': 15,
        'B3': 116},
 'A3': 'gvj',
 'A4': {'D1': 210,
        'D2': [0.0220907323247721, -0.5026017830103229],
        'D3': 5376096510809734409,
        'D4': [-853800407,
               -31972951,
               495648981,
               1904441531,
               -592349330,
               2145912951,
               -626197765,
               139955619]},
 'A5': -14105}

(b'WCBD\xed\x98\x00F\x00\x00\x00\x04\x00P\x00\\f\xca%\x08\x06\xd3\n \xe8\x82uk'
 b'\x14^\xfa\xca\xb5\xbc-\x1b\xa5V\xf2,\x86\xe9\x0fp\x02G9<\xb8~#H\x8a\x13e\xcf'
 b'MsJ\xca \x85|J\xd0ZC+\xfa\xca\x00\x00\x00\x12\x00\x00\x00,\x17\xb5uvbz'
 b'^\xdc\xc3\xb3\x1cI\x90\xc8\xf8\xbf\x87\xba#s\x11,\x00\xbf\xde&\xb6\x97\\s'
 b'\\\xf4,VR\xa7<m\xd1\x00\x00\x00\x02\x00\x00\x00T')

{'A1': -4712,
 'A2': {'B1': [{'C1': 621283027,
                'C2': 2592,
                'C3': 59522,
                'C4': 8460878723112678844,
                'C5': 11547,
                'C6': 11913976137311129456},
               {'C1': 38222140,
                'C2': 47230,
                'C3': 9032,
                'C4': -8497336130885956918,
                'C5': 8325,
                'C6': 8956199895072242378}],
        'B2': 23,
        'B3': 181},
 'A3': 'uvbz',
 'A4': {'D1': 248,
        'D2': [-0.011585499714916736, -0.47111286908493866],
        'D3': -852211316486804015,
        'D4': [1591526323, 474583240]},
 'A5': 26314}

Вариант №24

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

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

(b'\x04SIH\x03\x00\x00\x00p\x00\x02\x00v\x00\x00\x00x\x00\x16\x80\xc1m\x88\xd5'
 b'\xea?\x96/\x0c+\x9f\xdf\xef?\x88\x96\xe6"\x9a\x18\xe9\xbfRe\xc2\xac\xe8\x86'
 b'\xe9?X\x7ftP\x11\x93\xd7?\xa2\xd4\xd1\x90YL\xe0\xbf\xf6\x95[\x06e\x88'
 b'\x00\x8ab{"m\xb2\xf2\xe5<\xed?f\x11,\x0f>\x0c/\xb4\xf1*k\xde\xbf\xa61)'
 b'\xc6\x01\xfa\xe0\xb3\xf9\xf9R\xe9?\xe0\x18I\x00V\x00c\x00ui\x9a\x1bTt'
 b'?\x9cE\x90Q\x8a\xa6\x03\x1d?\x08x\xc5:\x86\x93\x89}J\xaf\x88U\xeb\xbf'
 b'HX\x8d\xb0\x9ds\xf1\x10!\\\x8c\xfbI&\xadg\xb1\xb8\xbe\xbc\xe0')

{'A1': [{'B1': 138, 'B2': 31586, 'B3': 0.9136838665175768, 'B4': 4454},
        {'B1': 44, 'B2': 15887, 'B3': -0.4752910004033175, 'B4': 12710},
        {'B1': 41, 'B2': 454, 'B3': 0.7913789631848254, 'B4': 6368}],
 'A2': 'ui',
 'A3': {'C1': 154,
        'C2': 0.9544083476066589,
        'C3': {'D1': [156, 69, 144, 81, 138],
               'D2': 0.6133369207382202,
               'D3': 8,
               'D4': 120}},
 'A4': [0.8385660308522371,
        0.9960475769780597,
        -0.784253185430047,
        0.7977183698850843,
        0.3683512960142159,
        -0.5093200520047001],
 'A5': 106665462,
 'A6': 101,
 'A7': {'E1': -5815697938956535099,
        'E2': 136,
        'E3': [1220537173,
               -1649373864,
               554758515,
               1241222236,
               -1318605530,
               -524501320]}}

(b'\x04SIH\x03\x00\x00\x00p\x00\x02\x00v\x00\x00\x00x\x00X\xe1L\xf2=\xb4'
 b'\xec?\xd0\x85\xc6\x0e\xf7\xc7\xb2?\xa67\xf4\r\xb5\xe0\xe4\xbf\x1a\xf5'
 b'\xe5\xb5\xf2\xc2\xea?\x80bwjGB\xc9\xbf\xf0R|\xd4\xe6a\xb5\xbf\xde\xa2'
 b'=\x8a\xea\x88\x00\xae\xb1\x1f\x14#\x8c{\xafW\xdb\xbf\x02l\x15k2v\xb5-'
 b'\x16\xc22\xea?\x8f\xb3\xf1_\xac$\xd0=\xed\xf8\xb8\xd1?\xf0\xb9I\x00V\x00'
 b'c\x00maT\xc4\x1b8?A\xf9\x05\xf8\xc2-\x0e:\xbf=\x8e\xd6\xb7S\xf5\x96\x1bV\xb4'
 b'\xa98o\xe2(c\xef\xda\xc8\x0cP\x96\xaf\x1c\x19xTV\xbe\xdf\x91\x9d\xe6\x1d'
 b'\xde')

{'A1': [{'B1': 174, 'B2': 8113, 'B3': -0.427226896907585, 'B4': 27650},
        {'B1': 21, 'B2': 12907, 'B3': 0.8186960633444602, 'B4': -19569},
        {'B1': 241, 'B2': -21409, 'B3': 0.27691481750594193, 'B4': -17936}],
 'A2': 'ma',
 'A3': {'C1': 84,
        'C2': 0.7191736698150635,
        'C3': {'D1': [65, 249, 5, 248, 194],
               'D2': -0.7267788052558899,
               'D3': 61,
               'D4': -114}},
 'A4': [0.8970021946361539,
        0.07336372481088138,
        -0.652430083516937,
        0.8362973740292177,
        -0.19733517359306418,
        -0.08352511108052929],
 'A5': 2319295198,
 'A6': 234,
 'A7': {'E1': -5452139963710457898,
        'E2': 169,
        'E3': [685928248,
               -925175965,
               -1349103604,
               1417156892,
               -1847607722,
               -568465763]}}

Вариант №25

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

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

(b'ABMA\xd21\xd3#~[\xbf\xd5\x82\xfa[\x04\x002\x00\x00\x00\xcd6\x00'
 b'\x00\x00\x02\x00\x00\x00|\x00\x00\x00\x9a)\xbb\x1af\xcd,\xcb\x9c\xad\x90=6#'
 b'F$yfve\xd8\xd4m[9y$\x9d\xa2>\xd1\xf9J?\xba\xdb\t?SwB\xbfwPn\xbf\xdcr">'
 b'2Z\x04\xbf\xe2\xd8\xdf>\xb1R@?Y\xaf\x18?\x9f\x0c6?B\xa31?*\x1fc\xbf'
 b'\x82\x19\xf7>\x17A\xff\xbe\x8d@s\xbd<\x00\x00\x00\\\x00\x00\x00')

{'A1': 49,
 'A2': {'B1': 211,
        'B2': -0.8573934435844421,
        'B3': 1543144149,
        'B4': 'yfve',
        'B5': -51,
        'B6': {'C1': -11048, 'C2': 2033802093},
        'B7': [{'D1': 0.3176051378250122,
                'D2': [0.7928743958473206,
                       0.5385090112686157,
                       -0.7596332430839539,
                       -0.9309152960777283,
                       0.1586412787437439,
                       -0.5170012712478638,
                       0.4372015595436096]},
               {'D1': 0.7512617707252502,
                'D2': [0.5964255928993225,
                       0.7111300826072693,
                       0.6938973665237427,
                       -0.8871942758560181,
                       0.48261648416519165,
                       -0.49854347109794617,
                       -0.05938773229718208]}],
        'B8': 448473498},
 'A3': -886256282,
 'A4': [-21092, 15760, 9014, 9286]}

(b'ABMA\xd2\x85\x87\x12\x17\x91=\xe1F~\x16\x02\x002\x00\x00\x0064\x00'
 b'\x00\x00\x03\x00\x00\x00\x9a\x00\x00\x00\x0eh\x9eX\x84a\x9d\xd8>\x03'
 b'\xbdQv\x8d\x1f\x83jq\xd1\xc5\x05\xb7v\x9b\xedG\x93\xbe\xaeC\xcc>~+O?\xa7\xba'
 b'\x81=U\xa9&\xbf\xa6\x1e\xac\xbe\xcf\xb5\xef\xbe\xbc\xca\x99>\xc9Rk\xbf\xeaO'
 b'j\xbf\xefn*?\x9d\x8b\x8c\xbe.\x07\x11=6\xa5\xef\xbd\x12\x1bx>\xe0V'
 b'\n\xbfj\xa7H?\xaa\x00\xc2>?}\xb8>\xdec\x93=\xad3\xf5\xbe\x9a\x08O>\xaa\xb4'
 b'[?\xc0x\xd1>:\x00\x00\x00Z\x00\x00\x00z\x00\x00\x00')

{'A1': -123,
 'A2': {'B1': 135,
        'B2': 0.07084478437900543,
        'B3': 377374433,
        'B4': 'jq',
        'B5': 54,
        'B6': {'C1': -14895, 'C2': 2608248581},
        'B7': [{'D1': -0.28765812516212463,
                'D2': [0.3989538550376892,
                       0.8092573881149292,
                       0.06334429234266281,
                       -0.6510213017463684,
                       -0.33617132902145386,
                       -0.4681839644908905,
                       0.3003748655319214]},
               {'D1': -0.9192319512367249,
                'D2': [-0.9152818918228149,
                       0.6657552123069763,
                       -0.2745026648044586,
                       0.03540723770856857,
                       -0.1170143336057663,
                       0.24229076504707336,
                       -0.5403881072998047]},
               {'D1': 0.7838045358657837,
                'D2': [0.3789113163948059,
                       0.3603305518627167,
                       0.07196782529354095,
                       -0.4789098799228668,
                       0.20218124985694885,
                       0.8582254648208618,
                       0.40912437438964844]}],
        'B8': 1486776334},
 'A3': -660774524,
 'A4': [830, 20925, -29322, -31969]}

Вариант №26

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

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

(b'WGHO\x06\x00\x00\x00\x1b\x00\x00\x00&\xaf\x18r\x02\x00\x00\x003\x00\x00\x00'
 b'V\x00\x04\x81\xfe\x98\xfe\xad\x0f\x06\x80\xf0k^\xea\x8f\xad\xbf%\xa2'
 b'\x1c\xbf\xba\x01J\xee\xbf!\x00\x00\x00*\x00\x00\x00/\xeb,\xbfUm\xb5>\xac'
 b'\xc6\xdb2\xb9\xf4I~\xfa$\xd9\xb9\x04\x00\x00\x00C\x00\x8b\x02\x00;\x00\xc6G'
 b'\x00\xac\x04\xb7x\x97>\xed\xc0NI\x1c\x0e\xe1#\x9e\x9f\xd9\x14')

{'A1': [129, 254, 152, 254, 173, 15],
 'A2': 1914220326,
 'A3': [{'B1': 6, 'B2': -0.0577386131535329},
        {'B1': 37, 'B2': -0.9465340278046777}],
 'A4': {'C1': [-0.6754636168479919, 0.3543497622013092],
        'C2': -58,
        'C3': {'D1': -5054968448467471175,
               'D2': [-84, -58, -37, 50],
               'D3': 139},
        'C4': 1196,
        'C5': 0.29584285616874695,
        'C6': 2585363175739146477,
        'C7': 40862,
        'C8': 5337},
 'A5': 4}

(b'WGHO\x04\x00\x00\x00\x1b\x00\x00\x00O\x8bL\xea\x02\x00\x00\x001\x00\x00\x00'
 b'V\x00\xfeF\x83\x81\x8fX\x82\x90x\xce!\xf4\xe8\xbf\xd4\xf8\x0e,\x94\xb1F\xe6'
 b'?\x1f\x00\x00\x00(\x00\x00\x00\xcc\x94\x14?\xdf\xd9c\xbf\x80m\x89[\x0c\xcdn'
 b'\x02{\x0b?J\xe4\xd2\x06\x00\x00\x00A\x00+\x02\x009\x00jG\x006\xe5=\x80\xc1<p'
 b'\xa1\x80\xa5\x89\xda\xd7\x8d\x86%{W')

{'A1': [70, 131, 129, 143],
 'A2': 3930884943,
 'A3': [{'B1': 88, 'B2': -0.7798012764583435},
        {'B1': 212, 'B2': 0.6961295980440516}],
 'A4': {'C1': [0.5803954601287842, -0.8900431990623474],
        'C2': 106,
        'C3': {'D1': -3250391396418649490,
               'D2': [-128, 109, -119, 91, 12, -51],
               'D3': 43},
        'C4': -6858,
        'C5': 0.023620719090104103,
        'C6': -8225865909646876304,
        'C7': 9606,
        'C8': 22395},
 'A5': 254}

Вариант №27

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

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

(b'QRUH\xa5\x92\xf9\x00\x00\x00\x03\x00\x00\x00C6^\xa1\xfa\x8a\xd4\x83\xa2y'
 b'be\x91X\xcbp\x9c\x9f;\xc6\x00\x00\x00Fh\x93\x8b\xf1\r\xc3\x92$-\xea:,Yd'
 b'\x00\x00\x00[\x07\x00\x03\x00p\x87\xce\x00\x00\x00sayg\xbc\x9b\xd5#\x18T'
 b'M\xdbzm\x98;;\xae\xa5B:\xf0nK\x1b\x9d\x1a\x18\xad\x9b\x07\x00V\xf2\xed\x068T'
 b'<\x97J1\xce\x82\x85\xf5mvu\xa5\xcaw\xe1\x8d\x16;')

{'A1': 37625,
 'A2': 'ayg',
 'A3': 912171514,
 'A4': 35540,
 'A5': [{'B1': 2208463202,
         'B2': 7318728500244684603,
         'B3': 198,
         'B4': {'C1': -4856053426480198181,
                'C2': 2054002747,
                'C3': 15278,
                'C4': -1522386192,
                'C5': 28235,
                'C6': 27},
         'B5': 104},
        {'B1': 2475421965,
         'B2': -4354378110092039079,
         'B3': 100,
         'B4': {'C1': -7126356326451052458,
                'C2': 4075619896,
                'C3': 21564,
                'C4': -1756745266,
                'C5': 33413,
                'C6': -11},
         'B5': 7}],
 'A6': 'mvu',
 'A7': -30770,
 'A8': {'D1': -91, 'D2': [202, 119, 225, 141, 22, 59]}}

(b'QRUH\xa5x\xed\x00\x00\x00\x05\x00\x00\x00C\x85qc\xeb-\xb6O{\x81/B\xb4g'
 b'\x1e%\x84\x1d\xa2V\x00\x00\x00H*\x00P\xf4\xac\xe5\xef\xd1\xaeT7T\xe1\x8d'
 b'\x00\x00\x00]E\x00\x03\x00r\x83\x9d\x00\x00\x00uncqvx+\xbdr*\xa5\xf2*\xdc'
 b'\n\x06\x06f\xc3\x91\xd1\r\x13\xae.\xb8\x9d\xa4\xd9\xf9\x9a\x93\x87\x91'
 b'\x11"S\xb3\xbf\xa5\x9fC\xbf_N\xcc\x97\xb6gntL\x8f\xc5- ?\xab')

{'A1': 30957,
 'A2': 'ncqvx',
 'A3': -2056166421,
 'A4': 11702,
 'A5': [{'B1': 1333494063,
         'B2': 4806580081487256994,
         'B3': 86,
         'B4': {'C1': 3151800841727519452,
                'C2': 168167014,
                'C3': 50065,
                'C4': -787672146,
                'C5': 11960,
                'C6': -99},
         'B5': 42},
        {'B1': 5305516,
         'B2': -1878051972922780447,
         'B3': 141,
         'B4': {'C1': -6567944139247742703,
                'C2': 575910847,
                'C3': 42399,
                'C4': 1136615246,
                'C5': 52375,
                'C6': -74},
         'B5': 69}],
 'A6': 'gnt',
 'A7': -31843,
 'A8': {'D1': 76, 'D2': [143, 197, 45, 32, 63, 171]}}

Вариант №28

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

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

(b"|KAP\xbd\xc5:CT*a\x8f'Q\x00\x00\x00)\x00\x00\x00H\x00\x00\x00g\xa6clct\t"
 b'7o\xd6\x00\x98\x01\xf8\x0c]?\xe8D\x9a\x9a\xb5\x02\x12?\xcf\x06_\xbeI\x10'
 b'\xb8\xbf\xe7\xc1\xc3\xb5\xd1y0\xd0\xbe\t\xd3\x9b\x91\xe9\xbf\xdd\r\xe9'
 b'$Z\xf5\x14?\xd7\xe6\xa7\x9c\x9cK\xa4\xbf\xc5\x01G\xc2Tk\xc8J\xbfn\x1f'
 b'\x8f\xbf\x82\xbf\xee\xcdz\xec\x12\xd7(\xbf\xd6\xbb\xc6\xe0\x17\xb7\x14\xbf'
 b'\xe7\t\xe0=\x06\x89\x04 \xf0\xa6\xb45\xa4\xfaN\x05\x17\xe9\xe3\xd5'
 b'"\x07\x98\xcc5\xcc\x83\\\xfe\xdb\xf3&\x00\x00\x00\x03\x00\x86\xbf;'
 b'\xf9L\xbd\x8c\xe2\x8d\xe6\x00\x03\x00\x00\x00\x92\xa8')

{'A1': -4772344169279889009,
 'A2': 10065,
 'A3': [{'B1': 0.7583745023367234,
         'B2': 0.24238201895980693,
         'B3': -0.7424028922212411,
         'B4': 53438,
         'B5': 9,
         'B6': -744779287},
        {'B1': -0.4539740424186942,
         'B2': 0.3734530476951312,
         'B3': -0.16410157192953378,
         'B4': 19135,
         'B5': 110,
         'B6': 529514370},
        {'B1': -0.9625830279171383,
         'B2': -0.35521098979994403,
         'B3': -0.7199555580048416,
         'B4': 8432,
         'B5': -90,
         'B6': -1271552774}],
 'A4': -90,
 'A5': 'clct',
 'A6': 154628054,
 'A7': {'C1': {'D1': [1308956649, -472571385, -1731447348],
               'D2': -0.7342727184295654,
               'D3': -1114840435,
               'D4': -26,
               'D5': [-31908, -293, -3290],
               'D6': 168},
        'C2': 33033309}}

(b'|KAP\x86u}\xa0\x1c\xdd\xfb\xd0Y/\x00\x00\x00)\x00\x00\x00H\x00\x00\x00g`k'
 b'gyd\x84\xd5g]\x00\x92\t\xc1\x7fJ\xbf\xc2\xa6\x7f\xb2\xfd3\x08\xbf\xe4\xe5'
 b'\xe7\x14\x1e\x92\xc8\xbf\xe5\xebM\xd4*\x11\xee\xc2H\x1d\xe6\xed,Y'
 b'\xbf\xed\n\x86\xdd\xa9\xa38\xbf\xeb\xaf\x96\xe6\xd0\xeb\x80\xbf\xd4\x032'
 b'\xa5\xbe\x99\x9c\xe0\xcc\xba\x1dy\x14\xae\xbf\xa6\xf3\xb7\xb8\x06\x00\xe0?'
 b'\xd7oV"|z\xa8?\xde\xeb\xbf\xddQ\x86\x80\xc1B\x1e\xe1a8\xc15\x11\x90\x08u\x95'
 b'\x12l\xe5Jy\xc1\x00\x00\x00\x02\x00\x86>\xd9\xe5c\xb7j\x87\x1e'
 b'\xb6\x00\x02\x00\x00\x00\x8eh')

{'A1': -8757955773719512112,
 'A2': 22831,
 'A3': [{'B1': -0.145706140896799,
         'B2': -0.6530642884213984,
         'B3': -0.6849736350855531,
         'B4': 49736,
         'B5': 29,
         'B6': -420664231},
        {'B1': -0.907535012183053,
         'B2': -0.8651842601897073,
         'B3': -0.3126951807593288,
         'B4': 57548,
         'B5': -70,
         'B6': 494474414},
        {'B1': -0.04482816811923995,
         'B2': 0.3661704384593727,
         'B3': 0.48313900578623503,
         'B4': 49474,
         'B5': 30,
         'B6': -513722175}],
 'A4': 96,
 'A5': 'kgyd',
 'A6': -2066389155,
 'A7': {'C1': {'D1': [890343432, 1972703852],
               'D2': 0.42557820677757263,
               'D3': -1217755362,
               'D4': -74,
               'D5': [-6838, 31169],
               'D6': 104},
        'C2': 163675978}}

Вариант №29

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

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

(b'DMVENS\x00\x00\x00\xb0\x89\x8a\x00\x00\x00^U\x87\xa7\x95\x1b\n>\r'
 b'\x06\xe7\xfah\xb41\xc0\x0e\x9d]\xbd#\xc2\xd8\x8a\xc6\x08\xbc\xa0v\xa4yalzsv4'
 b'\xc5\xaaZ\xba\xe8\x05\x00\xa7RU\xcaj\xb0\xd9\x7f)4\x87\x0c\xa3\xb3,N0'
 b'I\xdb\xb7\x83\x9a\x16W~M\xa8|\xdf\x92\x03\x00\x00\x00\x0f\x00\x00'
 b'\x00\x06\x00-\x00\x8b\x02~\x9e\xc5\x03\xfc\xde\r\xb5\xfa\xe8S\x04\x003\x00on'
 b'9?\xea\xd7\x83=l;d\xbf\x9e\xcb\x13\xbfB\xf6c?\x10\x83\xc1\xadss')

{'A1': {'B1': 2091404670,
        'B2': 37599,
        'B3': [{'C1': 21854, 'C2': 436072952058193799},
               {'C1': -1305, 'C2': 13645235132682056808},
               {'C1': -15837, 'C2': 11850836198933564120}],
        'B4': 'yalzsv',
        'B5': 139,
        'B6': 999513260453428738,
        'B7': 64181,
        'B8': {'D1': [232, 83],
               'D2': [1663261966255412,
                      9212588485470671527,
                      5633074746804876329,
                      6275373021303359792],
               'D3': [0.7243413329124451,
                      0.06437666714191437,
                      -0.8915317058563232,
                      -0.577325701713562,
                      0.8904763460159302]}},
 'A2': 35248,
 'A3': {'E1': -31984, 'E2': 1936960961}}

(b'DMVENO\x00\x00\x00\xaei\x86\x00\x00\x00_\xea\xfbk\x90\xe5\xd0e\xa3'
 b'\x02\xa3\xa3\xaf H\x1a,\xadF\xbez\xf1\x9e\xd3f\xdf\xc7\xa9\xb1\xb4\x05\xb1U'
 b'\x98\x9e\xc2\xb5tfhtovehrju\xf7\x91\x91\xb3:N?\xb6\x01\xcf\xc2\xc4\xa1'
 b'\xc0\xd2\xed\x95\xae\x858A\x1e\x04\x00\x00\x00\x0f\x00\x00\x00\x08\x007'
 b'\x004\xa8\xea\xec\xdb?\xb1\xe0c\xb1\x1fE\xee\x02\x00?\x00\x9f/F>\x07\x00'
 b"+?=\xd3R?\x1c_\x81\xbe2\xdc\x84>'\x92\x89~\xba\x02")

{'A1': {'B1': 948285077,
        'B2': 7745,
        'B3': [{'C1': -5537, 'C2': 190107557158743035},
               {'C1': -23645, 'C2': 13710836520507154607},
               {'C1': -3718, 'C2': 13020374673616458654},
               {'C1': -20219, 'C2': 7522828551572068437}],
        'B4': 'tovehrju',
        'B5': 52,
        'B6': 7196947092368845480,
        'B7': 8113,
        'B8': {'D1': [69, 238],
               'D2': [13132301052463387127, 17136971333121527553],
               'D3': [0.1935410350561142,
                      0.6679691672325134,
                      0.8235357403755188,
                      -0.2526787519454956,
                      0.2594924569129944]}},
 'A2': 27054,
 'A3': {'E1': -28121, 'E2': 45776521}}

Вариант №30

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

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

(b'UKPSu\xca\n)\xa6\xba\xa9[:\xbe\xc1z?\xee-re>\x00\xe5\xbe\xb6\xbe\xc5'
 b'\xc1I\x9c\xbe\x94\xe6\xc2M\xbfF\x93j8\xbf\xb6\xa1EJ?\xcc\xbb\x8ax\xbf'
 b'\xe3\xdf\xee\xaa\xf1,\xae\x8f[\xd7M,b\xa1\xe2\xa0\xb1\x8b\xbf\x01g\x1e;\x12'
 b'?\xfaN5\x9f\xa2\xcb/\x9f\r\xd7\xdb\x00?\xd7\xe1\xb1>h$\x0b>\x02BB\xbf!')

{'A1': 117,
 'A2': {'B1': 4205141296197208778,
        'B2': {'C1': [{'D1': 0.9795187711715698, 'D2': 238},
                      {'D1': 0.22406835854053497, 'D2': 0},
                      {'D1': -0.3569251596927643, 'D2': 197},
                      {'D1': -0.3052501976490021, 'D2': 148},
                      {'D1': -0.8037551641464233, 'D2': 70},
                      {'D1': -0.720376193523407, 'D2': 182},
                      {'D1': 0.7901249527931213, 'D2': 204},
                      {'D1': -0.970866858959198, 'D2': 227}],
               'C2': 4054511327,
               'C3': 44,
               'C4': [-681865298, -1587401651],
               'C5': [-30, -96, -79, -117, -65]},
        'B3': 26369,
        'B4': 0.5712145566940308,
        'B5': [-6, 78, 53, -97, -94, -53, 47, -97]},
 'A3': 13,
 'A4': [0.5033544898033142,
        0.3474261462688446,
        0.13588106632232666,
        -0.7588196992874146],
 'A5': 33}

(b'UKPSD\x9c;J:"mW\x99\xe6\xa1\xd2=x\xfc\xb8U\xbf\xaft\x83B?S_iN\xbf,<\x8dF'
 b'>\x02U\xd4x\xbf\xcey#-\xbfC\xba\x83\xc8\xbey\xaa\xd4<\xe4\x01\xe8^'
 b'\x8d\x19\xff\xcf\xc1t\x12\xeb\xa6@VN\x82\x10\xac[>J\x15\xf0D\xd6\xc2\x0c'
 b'\x8dW}\xa8\xff>\x1f\x1b\xb3>\xc4\xf0\xcb\xbe\x16\x9f\xef\xbe3')

{'A1': 68,
 'A2': {'B1': -7397323869158491236,
        'B2': {'C1': [{'D1': 0.1028478592634201, 'D2': 120},
                      {'D1': -0.8348538875579834, 'D2': 175},
                      {'D1': 0.7598183155059814, 'D2': 83},
                      {'D1': -0.8062953352928162, 'D2': 44},
                      {'D1': 0.19389814138412476, 'D2': 2},
                      {'D1': -0.9719899296760559, 'D2': 206},
                      {'D1': -0.6763225197792053, 'D2': 67},
                      {'D1': -0.39162999391555786, 'D2': 121}],
               'C2': 3829191850,
               'C3': 1,
               'C4': [428695272, 1958858751],
               'C5': [18, -21, -90, 64, 86]},
        'B3': 33358,
        'B4': 0.2145235538482666,
        'B5': [74, 21, -16, 68, -42, -62, 12, -115]},
 'A3': 87,
 'A4': [0.49933233857154846,
        0.34981629252433777,
        -0.398321270942688,
        -0.4680106043815613],
 'A5': 51}

Вариант №31

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

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

(b'DNBH\xf9O\x00X\x00a\x00\xb2B\xeco\x06B\xec?/\xa1G\xbfwqvgcne\x92\x91'
 b'\x07\x96\x1e\x16$\xa0lG\xb0\xe9W/\xe2?\xc6\x03\x00j\x00\x00\x00\x04\x00\x00'
 b'\x00p\x00\x00\x00\xc1\x01\x11\x05\x96p\x97\xc5rl\x04\x00t\x00qg\x8b>\xf2'
 b"R$$\xf8\x1a\xb8\xec\xbf\\\xc8'H\xfeo\x80\xdd\xbfi\xc2\xce\xe0\x9e\xf3S"
 b'\xed\xbfX\xd3\xaf\xbc\\\xe1\xf5\xd2\x1b\x1d\xc0\x0b\xf0x\xa6\x81\xc3?'
 b"4\xba\xee\xab\x91L\xef\xbf@\xb1d\xd5\x99'\xbf\xbfz\xc1\x97}\n*\xee?")

{'A1': [{'B1': -14, 'B2': -0.897473797465077},
        {'B1': 92, 'B2': -0.460964201280714},
        {'B1': 105, 'B2': -0.9164980033005679}],
 'A2': 0.8830597101205824,
 'A3': -0.7798032164573669,
 'A4': 'wqvgcne',
 'A5': {'C1': 11539372465851961746,
        'C2': 0.5682792247991819,
        'C3': -58,
        'C4': [-11432, -17233, -7844],
        'C5': {'D1': [-11, -46, 27, 29],
               'D2': 449,
               'D3': 7814525557660845329,
               'D4': [0.15239411263618585,
                      -0.9780968053872301,
                      -0.12169801196859442,
                      0.9426319554313942]},
        'C6': 0.27227357029914856}}

(b'DNBH\xf9O\x00X\x00a\x0005W\xa4\x92\xbb\xb4?^\x04\x06\xbfdiljxxb\x92@'
 b'\n\xb8\tR\xc7Q\x88\x1d\x88;\xeb\xe9\xcd\xbf\xf8\x02\x00j\x00\x00'
 b'\x00\x02\x00\x00\x00n\x00\x00\x00\xa6\xc9$\x04=P^\xa0\xb2\xe9\x03\x00p\x00`'
 b'\xeeQ\xbf\xd6J\xabm\xbd\xf3\xf2\xe1\xbfu\xc8\xc60\xbf\x841\xde?i\n7'
 b'\xa6\x96\x03\x81\xe9?\x03m\xdf\x19w\x1a\xd0J\x8b\x8f#A\xd5?\x1eND\xda'
 b"\x16'\xe1\xbf\xf0d^\xb8\x15\x1c\xe2?")

{'A1': [{'B1': -42, 'B2': -0.5609072398923243},
        {'B1': 117, 'B2': 0.471772371968751},
        {'B1': 105, 'B2': 0.7969987814301203}],
 'A2': 0.08098713409636527,
 'A3': -0.5235041379928589,
 'A4': 'diljxxb',
 'A5': {'C1': 5892768839133446290,
        'C2': -0.23370113760777778,
        'C3': -8,
        'C4': [27907, 6623],
        'C5': {'D1': [119, 26],
               'D2': -13914,
               'D3': -1607045790084299740,
               'D4': [0.33210076349238893,
                      -0.5360216391586083,
                      0.5659283257438386]},
        'C6': -0.8200435638427734}}

Вариант №32

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

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

(b'\xceORXEa\x00\xe0$\x01a$/?\x91\x04\x00\x00\x00l\x00\x00\x00~\x00*g:'
 b"0\xc7>\xab]\x02\x00\x00\x00\x89\x00\x00\x00'\xcdS\xfc\xf5\x18clr\x9d]\xc2|V&"
 b'\x90\xd4f\xea1vPB\x08v\x02\xf2\xbd\xbf\xa7\xe2S\xcd\xfa\xe3+j<\xbc'
 b'&\xc4\xa6\xba\xec\xbf\x98\x1a\x8a\x02\x00\x00\x00\x91\x00\xe8'
 b'\x05\x9a\x02\x00_\x00\x8f\xbd)&\xe5\x18\x9d\xf1\x85=\xc7\xe5T\xbf\xb5\xd6G?'
 b'\xd6\x11\xe0>}5\r\x02\x00|\x00\xb5bd\xf6\xeb}\x8d\x1d\xe8=\xf6\xcc\x1e'
 b'\xbfqO1\xb4\x86\xb4/\xe3')

{'A1': {'B1': [{'C1': {'D1': 154,
                       'D2': [232, 5],
                       'D3': -113,
                       'D4': -67,
                       'D5': 417670697},
                'C2': 9440,
                'C3': 1,
                'C4': 97,
                'C5': 2436837156,
                'C6': [0.06540224701166153,
                       -0.8316311240196228,
                       0.7806199193000793,
                       0.4376360774040222]},
               {'C1': {'D1': 13,
                       'D2': [125, 53],
                       'D3': -75,
                       'D4': 98,
                       'D5': 2112616036},
                'C2': 26410,
                'C3': 58,
                'C4': 48,
                'C5': 1571503815,
                'C6': [0.11333761364221573, -0.6203149557113647]}],
        'B2': -61616857,
        'B3': 14005523530962376949,
        'B4': {'E1': 22140,
               'E2': 1725206566,
               'E3': -22,
               'E4': 30257,
               'E5': -0.11697402364394205,
               'E6': 7650459058345075367},
        'B5': -0.8977845984535473,
        'B6': -104,
        'B7': -30182},
 'A2': [-1271836815, -483412858]}

(b'\xceORXEa\x00{\x16\xbf\xd7\xacd\x7f\x97\x03\x00\x00\x00l\x00\x00\x00z'
 b"\x00A\xcc\xff\x93\x0c\x91'\xbe\x04\x00\x00\x00\x85\x00\x00\x00\xc8\x0b\xb0"
 b'\x84\xd7\xc3\xcb\xc9\xe0Q\xd7\xf1\x02\xf1\xf1\xfbI\x87\x05\xf5\x8f\x0e\xdc'
 b'\xf1\xb9o\xd8\xe8\xbfIm\xcf\xbf\xfc\x9c\x7f\xf1\x8c\x96|\xf1\xf9\xf7'
 b'\xe0?i\x0c>\x02\x00\x00\x00\x95\x00$\xed\r\x02\x00_\x00\x82+nR\x9bs'
 b'\x95\xc5\xea>\xdd\xdf<\xbf\x87\xeb,\xbe\x80U_\x02\x00x\x00~q\xc0\xda\x1f'
 b'\x07v\xc7\xf3>~\xdf_=_\xf1g?\xf8\x100\xbf\x13\x92\xcc\n\xef**\xcb')

{'A1': {'B1': [{'C1': {'D1': 13,
                       'D2': [36, 237],
                       'D3': -126,
                       'D4': 43,
                       'D5': 1939559022},
                'C2': 5755,
                'C3': -65,
                'C4': 215,
                'C5': 2541708460,
                'C6': [0.458538681268692,
                       -0.7377908825874329,
                       -0.16886721551418304]},
               {'C1': {'D1': 95,
                       'D2': [128, 85],
                       'D3': 126,
                       'D4': 113,
                       'D5': 119528128},
                'C2': -13247,
                'C3': -1,
                'C4': 147,
                'C5': 3190264076,
                'C6': [0.4761311411857605,
                       0.0546564981341362,
                       0.9060267806053162,
                       -0.6877589225769043]}],
        'B2': -2068837432,
        'B3': 17426487309033522135,
        'B4': {'E1': -3838,
               'E2': 2269772785,
               'E3': 5,
               'E4': -28683,
               'E5': -0.7764204627736733,
               'E6': 17401800094546619721},
        'B5': 0.5302705494438711,
        'B6': 105,
        'B7': 15884},
 'A2': [181178899, -886428945]}

Вариант №33

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

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

(b'JTM\x00\x08\x00)\x00\x00\x00g\x87\xd3\x0e\xd3p\x0b\xae\x12\xd9R\xaaC.'
 b'\xfc\x85P\x92\xab2U\x86\xc3\xd1\x8b\xdf\xd0I\xe2\x1c\xfcllvnezgw\x01\xbf\x97'
 b'\xf9\x92Bh\x91\xb7Jdg\x12\x97v/\x05\xb3\xf1\xc9\xc1g\xc3\x19\xc9O\x99'
 b'\xb8\xc4\x86\xb6\x10\xf0\xb8\xf2\xfe\x10i-8\x01s8l\xf3\x90\xcdC\xbc\xc4\xfa'
 b'\xb2\x14\xb9=qo\x1cE\xc6\xf0I\xe7\x0c/<\x04h\x18\xe0H\xb0);\xed\x001\x00:'
 b'\x00C\x00L\x00U\x00^Y{\x18U\xf4\x8e\\\x914\xe3\x10{\x03KT\xd0\x1a\x01>\x18'
 b"\x0b\xb9L\x03\xc4{\xa9\\0\xc3\xd9x?\xec\xf1'\xd17-,")

{'A1': 'llvnezgw',
 'A2': {'B1': 1030844188,
        'B2': 5027970234205351740,
        'B3': 4,
        'B4': 7500991782183320557,
        'B5': [{'C1': [1, -65], 'C2': 151, 'C3': 63890, 'C4': 1114149303},
               {'C1': [74, 100], 'C2': 103, 'C3': 4759, 'C4': 1982793139},
               {'C1': [-15, -55], 'C2': 193, 'C3': 26563, 'C4': 432623513},
               {'C1': [-72, -60], 'C2': 134, 'C3': 46608, 'C4': 4038652670},
               {'C1': [16, 105], 'C2': 45, 'C3': 14337, 'C4': 1933077747},
               {'C1': [-112, -51], 'C2': 67, 'C3': 48324, 'C4': 4205974713}],
        'B6': 22907,
        'B7': {'D1': 408286350,
               'D2': [1553020131, 276497227, 1422924289],
               'D3': 0.14848221838474274,
               'D4': 19459,
               'D5': 3296438620,
               'D6': 818141560,
               'D7': 0.9044379316559676}},
 'A3': 9787182716486921746,
 'A4': -648893885,
 'A5': 3385727600980341333,
 'A6': -122,
 'A7': -61,
 'A8': 15099408261375466748}

(b'JTM\x00\x05\x00)\x00\x00\x00d\xff\x89\x10\xe7\xc9\xd3\x13\xc0\x9e'
 b'\x14M\xca\xbe\xe3\xa2\xef\xba\xcdl\xc2\x8c\x81\xcd<\xfc\xa3\xaeV\xd1\xa5uvu'
 b'fh\xd6+\x17a;\xb3{\xac8y\xf93\x94e+\x05\x08.\xda\xf5\xe5X\xda\xb3U\xec'
 b'\x86\xadP\xd0\xf7c\xe5\xd6\xfe\x80\xe4\xde\xb4\xb2k\xcb*.\x80\xd0q\x96i\x94'
 b'\xebJ\xa0\xa7\x8b\x9c\x90a\xaa\xab\xbfA\xf8\x98\xcc%\n\x89\xd1h \x8f\xd3\xdc'
 b'\xa9\x00.\x007\x00@\x00I\x00R\x00[\xe1\xa5\xbc\x8cDB\xfe\xc3\xfc\xe2\xd9'
 b'\x81m\x9dq\n!!?#\x92\x81\x08\x94\x06\xcd\x9d\x82r\x99\xc0\xf0\xbf\xe7R'
 b'\xcb\xb1H\xf0\x98')

{'A1': 'uvufh',
 'A2': {'B1': 2342293601,
        'B2': 12298133497529814053,
        'B3': 10,
        'B4': -8515910931319628631,
        'B5': [{'C1': [-42, 43], 'C2': 23, 'C3': 24891, 'C4': 3011226680},
               {'C1': [121, -7], 'C2': 51, 'C3': 37989, 'C4': 721750062},
               {'C1': [-38, -11], 'C2': 229, 'C3': 22746, 'C4': 3008752774},
               {'C1': [-83, 80], 'C2': 208, 'C3': 63331, 'C4': 3856072320},
               {'C1': [-28, -34], 'C2': 180, 'C3': 45675, 'C4': 3408539264},
               {'C1': [-48, 113], 'C2': 150, 'C3': 27028, 'C4': 3947536551}],
        'B6': 57765,
        'B7': {'D1': -1131658174,
               'D2': [-20710174, -645829219, 1896489249],
               'D3': 0.638954222202301,
               'D4': 2196,
               'D5': 114138498,
               'D6': 1922679024,
               'D7': -0.7288568937870137}},
 'A3': 18413267139190526912,
 'A4': -1642836534,
 'A5': 13755016837434535106,
 'A6': -116,
 'A7': -127,
 'A8': 14788973056312660389}

Вариант №34

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

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

(b'&KVHqbmngw\x00\x06\x00\x1cD\xbf\xbf\xd20nG\x961t\x00\x00\x00e?b\xdb\xb6'
 b'gd>\xf8Q\xdb\xd8,>*\xa8\x1c\xac1\xbe\x9b\x86\xd0\x96[\xbe\xc8xi\x19\x8e\xbej'
 b'Q\xf6\xa6\x07??\x14\x84\xd0\xc2\xca$\xf6B\xc6\xdc\xb5\x1di\xc4\xfa\x9c\x8e7'
 b'\xe8C\x90\xb6\xf9\xc5\xe0f\xbc\x83\xcbRh$\xc5\xa9\xfa\xb2\x00@8X\x05F\xa9yY3'
 b'4\xdb\xb3\x0b\xf1\xc6\x0c\x8be\x86\x1f\x07o\xa3\xb0\xabl\x0e\xb8.'
 b"\xf2\xaa\x11\xca\xf5*'\x8e\x82\x81\x8aG\xdf\r:\xeb\xd3\xa9\x83\xcbyL\x00\x00"
 b'\x00\x02\x00\x00\x00U\x0c?\xec\xa5\x18BaMN\xfd\xcf')

{'A1': 'qbmngw',
 'A2': [{'B1': 0.8861650228500366, 'B2': 103, 'B3': 100},
        {'B1': 0.48499950766563416, 'B2': 216, 'B3': 44},
        {'B1': 0.16665691137313843, 'B2': 172, 'B3': 49},
        {'B1': -0.30376291275024414, 'B2': 150, 'B3': 91},
        {'B1': -0.3915436565876007, 'B2': 25, 'B3': -114},
        {'B1': -0.2288282811641693, 'B2': 166, 'B3': 7}],
 'A3': 17599,
 'A4': -0.28420598021400356,
 'A5': {'C1': 178,
        'C2': {'D1': 63,
               'D2': 0.5801515579223633,
               'D3': 14036071828754455733,
               'D4': 493470970,
               'D5': 40078,
               'D6': 14312},
        'C3': [945292614, 2843302195],
        'C4': 3808834773754186891,
        'C5': 25990,
        'C6': 2235878488847117326,
        'C7': -5174932109545245398,
        'C8': {'E1': 2850359107054460685,
               'E2': 4245719798740908364,
               'E3': [4868592381070436028, -8949969227221718534],
               'E4': 12,
               'E5': 0.8951531692968417,
               'E6': 64975}}}

(b'&KVHgkirri\x00\x06\x00\x1c\xc1\xac\xbf\xdc\x1f\\f\x08\xf1T\x00\x00\x00e'
 b'?Hd\x9d9\xe5\xbd\xe4=\xb6\xec\x13\xbf]\x96\x03\xd6\xd9\xbfjA[q\xa5'
 b'\xbe\xfa\x19\xb4@\xa4?9\x87\xa2\xc9D\xf9\xbc\xb7I\xc4\x9e\x93!\x8d\xca\x886'
 b'k\x03\x8dO\xd6\xd9M\xefR\xe7\x97\x95{\x86\xe2\xc5`\x00\xd1\xbbs\xf7!d'
 b'\x05q\x00@3\xbaq\xf0\xe4\x91~\xfen\x0c\xe2\xca\x1f\x07\xeb6D\x9b\xb8\xd8'
 b'\xb7.gf\x8b\xfb5B*\x87\x1a3\x19<\x12\xd9\xcd\x01\xaf\xa2z\xba\x02"'
 b'.\xea\x95\x14\xd7\xf9\x00\x00\x00\x02\x00\x00\x00U\xe2?\xeb\xe1g\x85'
 b'\x9a\xf2\xe8\x1bn')

{'A1': 'gkirri',
 'A2': [{'B1': 0.7827852368354797, 'B2': 57, 'B3': -27},
        {'B1': -0.1114458292722702, 'B2': 236, 'B3': 19},
        {'B1': -0.8655702471733093, 'B2': 214, 'B3': -39},
        {'B1': -0.9150597453117371, 'B2': 113, 'B3': -91},
        {'B1': -0.48847734928131104, 'B2': 64, 'B3': -92},
        {'B1': 0.7247258424758911, 'B2': 201, 'B3': 68}],
 'A3': 49580,
 'A4': -0.43941411938046326,
 'A5': {'C1': 113,
        'C2': {'D1': 249,
               'D2': -0.022374041378498077,
               'D3': 11426513572441110123,
               'D4': 59592662,
               'D5': 55629,
               'D6': -4270},
        'C3': [867856880, 3834740478],
        'C4': 7929962401624484662,
        'C5': 17563,
        'C6': 13319597307879394299,
        'C7': 3837676592221591868,
        'C8': {'E1': 1358342169754237626,
               'E2': 153736922342414329,
               'E3': [-1758772771688364704, 59034376874320901],
               'E4': 226,
               'E5': 0.871265183399001,
               'E6': 7022}}}

Вариант №35

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

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

(b'\xffTRCH\x9c\xf26+\x00\x00\x00\x02\x00\x00\x00\x13\x00W\x16\x03\x07\x9d\x08'
 b's\xf9\xcaOZ%^\xd8\x82b\x02\xbf\xc3\r\xfa\xd0sW\x88?\xe5\xedP\x1f#\xd0z?'
 b'\xec:\xb4r\x05\x8d\xa8\x16\xea\x10\x9c\xeb=\x05\xd8\xbe\x1e\xbf\x8e\xbf'
 b'2\xc1\x94>\xee\xf2\x17\xbe\xbd\xac\xd8\xb5\xc4\x95\x06\x18F2O/\xd1\x7ff\x0c'
 b'\x18>}j\x99\x12\xe6\xdf\xa9\x91?\xeb\xd7\xd4\xd3\x8f\xf7\x1c\x00\x00'
 b'\x00\x05\x00\x19\xbf\xd5h\xde\xd3b\xc2\x9c\xa2\xfb\x99\xd1\x00\x00\x00\x03'
 b'\x00#\x96"\x96\xff\x00;')

{'A1': 2633119275,
 'A2': [{'B1': 22, 'B2': 775}, {'B1': 157, 'B2': 2163}],
 'A3': {'C1': 6214,
        'C2': {'D1': 3625168801888603160,
               'D2': 0.2474769502878189,
               'D3': 4838,
               'D4': -33,
               'D5': -22127,
               'D6': 0.8700966007306508,
               'D7': [63946, 20314, 9566, 55426, 25090],
               'D8': -0.3345257820429113},
        'C3': 41723,
        'C4': 39377,
        'C5': [-0.14886412790536618, 0.6852188690377397, 0.8821661211954295],
        'C6': -1776118017,
        'C7': {'E1': 384438428,
               'E2': -348322344,
               'E3': [-0.1550275981426239,
                      -0.6982662677764893,
                      0.4666907489299774,
                      -0.37045931816101074],
               'E4': 3049559302}}}

(b'\xffTRCH\xfe~\x05/\x00\x00\x00\x06\x00\x00\x00\x13\x00g\xc4\x8c\xf3 \x94'
 b'.\xc0RH\xfd\x07] el\x80\xa8\x02\xa1\x00|,99\xbf\xe28\xb3\xa4\x91\xe0\xca?'
 b'\xe0\xf3L\xb9FrF?\xd8\xdb\xee\xb5\x91\xc0X\xbf\xde\xd4\xf7\xbc\xf6\x810\xfc'
 b'g\x148\x92KI\xf6\xbe\xe3`\xd6=\xc1>p>7R\xfe<\x13\xd8\xb0_/\xcd\xc8\xc7'
 b'J\x9f\xb3+\x1a\xbd\xeb}^=\x91b\xda\x9c\xbb\x8bD\xdf?\xe1\xe7\x8d\x82_'
 b'+\xc4\x00\x00\x00\x03\x00%?\xe7\xaa@\xbd\xc3Cd\x90\x98\x07\x87'
 b'\x00\x00\x00\x04\x00+i\x02\xcb<\x00K')

{'A1': 4269671727,
 'A2': [{'B1': 196, 'B2': -29453},
        {'B1': 32, 'B2': -27602},
        {'B1': 192, 'B2': 21064},
        {'B1': 253, 'B2': 1885},
        {'B1': 32, 'B2': 25964},
        {'B1': 128, 'B2': -22526}],
 'A3': {'C1': 51018,
        'C2': {'D1': -6939155206992331426,
               'D2': 0.07098932564258575,
               'D3': 40123,
               'D4': -117,
               'D5': 17631,
               'D6': 0.5595157190631359,
               'D7': [41216, 31788, 14649],
               'D8': 0.7395328241637853},
        'C3': 37016,
        'C4': 1927,
        'C5': [-0.5694215978865256,
               0.5296996706634409,
               0.3884236119402025,
               -0.48174851849946076],
        'C6': 1761790780,
        'C7': {'E1': 4234613816,
               'E2': -1840559626,
               'E3': [-0.44409817457199097,
                      0.09435737133026123,
                      0.1790275275707245,
                      0.00902383029460907],
               'E4': 1596968392}}}

Вариант №36

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

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

(b'\xbePWJH\x03\x00\x8d\x00u\xcb\xcdP\xb9\x1b\xa0#\xd7\x1f\x00c^\x96\x07'
 b'\x00\x00\x00\x99\x00\x00\x00\x8c\x1c\x7f\x164\xd5\xa7\xd2\x03'
 b'\x00\xa0\x00\xd5p\xbc\xbd-\xd1\xb4P\x07\x17\x87I/nsqp\x04\x008\x00'
 b'\x00\x00\xff\xa9\x9f\x89Bz\x8cV\n\x80\x12\x9d\xd4\xe6\xeb\x90\xbftybhm'
 b'n\x06\x00S\x00\x00\x00F-\x1b\xafC\xca9;\xf2\x88H\x01\xfe%\x99\xde?tkwi'
 b'qb\x06\x00p\x00\x00\x00\xe8u\x15\x97\xbb\xce\x0ba\xc7\xf0\xd3\xe8'
 b'\xb2\n\x1c\xc8?<\x00\x00\x00Y\x00\x00\x00v\x00\x00\x00\xd1\xb2 P\x1f\xf41'
 b'\xf9\xc3\xb8')

{'A1': [{'B1': 'nsqp',
         'B2': 255,
         'B3': 169,
         'B4': [159, 137, 66, 122, 140, 86, 10],
         'B5': -0.016524893500234672},
        {'B1': 'tybhmn',
         'B2': 70,
         'B3': 45,
         'B4': [27, 175, 67, 202, 57, 59, 242],
         'B5': 0.4780974369542794},
        {'B1': 'tkwiqb',
         'B2': 232,
         'B3': 117,
         'B4': [21, 151, 187, 206, 11, 97, 199],
         'B5': 0.1883557675916161}],
 'A2': 2567082270339746677,
 'A3': {'C1': -41,
        'C2': 31,
        'C3': 99,
        'C4': -27042,
        'C5': [209, 178, 32, 80, 31, 244, 49]},
 'A4': {'D1': -3267408584941560692,
        'D2': [-7, -61, -72],
        'D3': -0.09201208502054214,
        'D4': 45,
        'D5': 46289,
        'D6': 1872},
 'A5': 793347863}

(b'\xbePWJH\x02\x00m\x00\xff\xba\x93\x99\x03\x88dq\xdfY\xb8-2\xf7\x04'
 b'\x00\x00\x00u\x00\x00\x00\xd8\xf2\x8a\x8a\x8b\xc1r\xbb\x03\x00y\x00\xae'
 b'\x18\xb9>\x89\x19\x98_\x9f\xca&?Sdbbm\x04\x008\x00\x00\x00\xcd\xff\x82l\xabC'
 b'+(\xea$\x0b\x06\x82\xb1/\xe5?jun\x03\x00S\x00\x00\x00(\xb1\xa5\xc9qm\x1dB'
 b'\xfe\xe4\xdb\xcd\x1a\x1dz\xd3?<\x00\x00\x00V\x00\x00\x00\xba\xb4;BM\r\xae')

{'A1': [{'B1': 'dbbm',
         'B2': 205,
         'B3': 255,
         'B4': [130, 108, 171, 67, 43, 40, 234],
         'B5': 0.6620719470523437},
        {'B1': 'jun',
         'B2': 40,
         'B3': 177,
         'B4': [165, 201, 113, 109, 29, 66, 254],
         'B5': 0.3043282281645914}],
 'A2': 8170805172999797503,
 'A3': {'C1': -33,
        'C2': -18343,
        'C3': 45,
        'C4': -2254,
        'C5': [186, 180, 59, 66]},
 'A4': {'D1': -4939673036203035944,
        'D2': [77, 13, -82],
        'D3': 0.36151641607284546,
        'D4': -119,
        'D5': 38937,
        'D6': 40799},
 'A5': 1396647626}

Вариант №37

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

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

(b'VSSIC\xa6\x87;\xf74\x0b3\x1f\xc5Q\x9dMM1\x08\x05\x00\x02\x00\x00\x00l\x00'
 b"\x00\x00\x04\x00p\xb6\xd4\x1f\xa1+wG'p\xd2\xcc\x0b\xbf\xb6;\x9a?\xbd{"
 b"\x10\x8c\x00\x05\x00x}\x17\tU'\x01\x83\x0b\x04\x00\x9cf%\xf5\xe5(>\xe8"
 b'\x01\x8f\x00\x04\x00\x00\x00}\xe4|r{\xb9R\xc1|\x90SK\x9c\xbd3Qe\xc5\xd8~<'
 b'\x12a\xb8\x18\x00V\x00a\xa2\xb7<\xca3\x9eT\xb5k\xb3\x92\xa9\xbaq/\xa0'
 b'\xb1t\x85\xc5\xc8\xb2\xb6\x9a,.%~\x97')

{'A1': 42631,
 'A2': 59,
 'A3': -633869333348134499,
 'A4': 1296904456,
 'A5': 5,
 'A6': {'B1': [{'C1': [114, 123],
                'C2': -71,
                'C3': 1388412048,
                'C4': 1397464253},
               {'C1': [51, 81], 'C2': 101, 'C3': -975667652, 'C4': 308394008}],
        'B2': [-23881, 15562, 13214, 21685],
        'B3': {'D1': -5272554486664575193,
               'D2': 1892862987,
               'D3': -0.08684696251064516,
               'D4': -116,
               'D5': [107, -77, -110, -87, -70],
               'D6': 9013683440536617739,
               'D7': 288402338689180968},
        'B4': 0.4531368911266327},
 'A7': [1898946737, 1954923976, -1296655828, 774209175],
 'A8': -7044}

(b'VSSIC/\x1d\xe7q\xb5\xa4\xf3>~\x1bcV&JR\xbc\x00\x02\x00\x00\x00l\x00'
 b'\x00\x00\x04\x00p\x14\xdb\x1a\x8d\x16\xe9;\xbf\x06\xb6\xa7\xc2?\xec\x83'
 b'\xe6\xd0\x0fHn\xac\x00\x05\x00xv8\xd8S#Ca\xd6P\x86"\x1d~\x8d\xc0\xde?t'
 b'\xf3l\x00\x03\x00\x00\x00}X[\x07|\xbdi\xbfP\xe9\xaeL\xf8\x94\xf9vc UBF'
 b'w\xfa\x8b\xec\x00V\x00a\x9c\x9ft2\x9cW\xb0|\x97\xac.\x89\xeb\x9f\x82\xa1'
 b'\xfd=\x18\xe6\x82m\x83\xf0?')

{'A1': 12061,
 'A2': 231,
 'A3': 8193636461702945635,
 'A4': 1445349970,
 'A5': 188,
 'A6': {'B1': [{'C1': [7, 124], 'C2': -67, 'C3': 1774145769, 'C4': -1370687340},
               {'C1': [-7, 118], 'C2': 99, 'C3': 542458438, 'C4': 2012908524}],
        'B2': [-25441, 29746, -25513, -20356],
        'B3': {'D1': 1502824093935287231,
               'D2': 112633794,
               'D3': 0.8911012710252757,
               'D4': -84,
               'D5': [-105, -84, 46, -119, -21],
               'D6': 8518796546756796886,
               'D7': 5802362679986077918},
        'B4': 0.9568393230438232},
 'A7': [-1618828803, 1025042050, 1837363263],
 'A8': 22619}

Вариант №38

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

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

(b'QGQU\xf4C\x00\x02\x00[{7\xc2\xfeW3\xcd{\x1f\xeb6\x06\xf4\xb9\xc4\x8dC\xfd'
 b'.\xf0}D3F\xe1@\xaa\x03\x83\xaeO\xb9\x88\x80\x9f\xae\xfe\x83aO\x0b\x98'
 b'\xd1\xdc-\x914\x00\x00\x00\x03\x00\x00\x00+\xd4uk@\x1fx\xd8\x19\xcb\xd1>'
 b'\xc2\xe7\xe4wG\x8f\x90\x00\x00\x00\x05\x00\x00\x00A\x001\x00K')

{'A1': {'B1': {'C1': 62531,
               'C2': [{'D1': 5695814180849684788, 'D2': [32927, 44798, 33633]},
                      {'D1': 4522431944273137552,
                       'D2': [54389, 27456, 8056, 55321, 52177]}]},
        'B2': [31543, 49918]},
 'A2': [1463012731, 535508486],
 'A3': 62649,
 'A4': 50317,
 'A5': 4899123580077617990,
 'A6': 225,
 'A7': 4659540628568258952}

(b'QGQU\xa5_\x00\x02\x00W\xadu\xabtYi\x1d\x90\x15or\x9b\x9b\xbeDj\x0f\xb5'
 b'\xa7~\xc0\x08\x8b\x82\xf4Kz\xafV\x0b\xa0V\x07h\xd3\x88V\x91\xc2\xf4\x9a\xfe'
 b',\x19\xe9\xf1\xba\xc4J\x00\x00\x00\x04\x00\x00\x00+\xfe\xbf\xf4\xa6]'
 b'\xcd0\xd4[\xa3\xc1)\x00\x00\x00\x02\x00\x00\x00C\x003\x00G')

{'A1': {'B1': {'C1': 42335,
               'C2': [{'D1': -131701796526963638,
                       'D2': [26835, 34902, 37314, 62618]},
                      {'D1': 6759112304381641001, 'D2': [65215, 62630]}]},
        'B2': [44405, 43892]},
 'A2': [1500061072, 359625371],
 'A3': 39870,
 'A4': 17514,
 'A5': 1131995044183051138,
 'A6': 244,
 'A7': 5438852284100400647}

Вариант №39

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

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

(b'DTMT\x9dF{\xb9\xf9t\xf3\xe8\x87\xe3\x82\xa8 \x1ebv\x00\x08\x00\x00'
 b'\x00w\x00\x08\x00\x00\x00\x7f\xda\xc7\xb8\x9e\xcb\xadtS\x1ffn\x00'
 b'\x08\x00\x00\x00\x8f\x00\x04\x00\x00\x00\x97`\x9a\xfa,\x9c\xf8\x97G\x93'
 b'uh\x00\x08\x00\x00\x00\x9f\x00\x06\x00\x00\x00\xa7%\xa1m\xc9\x1f\x03'
 b'q\x90\xd4\xbf\x08J\\H\xe7\xec\xc0\xbb\x9e\xaa\x10`\xf0\t\x8e\xdc$\xc2o\xae'
 b'\xab\xf2\xe8yfk-[\\\x1a\xbb{\xf9\x01\x8bw+\x9d\xc8\x89\xac\x8a\xb6\xaa'
 b'\x9b\xa4V[\xd0\x86SXE}\x00\xac\xec$\xbf\x8ds\x1b\x89\x9bK\xa3\xa6\x17e\xdc=)'
 b'\xf7\x1c\x02L\xc5\xbb(\xcfQ!\x88\xb3 |\x16BM\xd6\x11')

{'A1': 40262,
 'A2': 8915431218060232675,
 'A3': -2102910946,
 'A4': [{'B1': 'bv',
         'B2': [123, -7, 1, -117, 119, 43, -99, -56],
         'B3': [35244, 35510, 43675, 42070, 23504, 34387, 22597, 32000],
         'B4': 218,
         'B5': 14391427206888051487},
        {'B1': 'fn',
         'B2': [-84, -20, 36, -65, -115, 115, 27, -119],
         'B3': [39755, 41894, 5989, 56381],
         'B4': 96,
         'B5': 11167287278715750291},
        {'B1': 'uh',
         'B2': [41, -9, 28, 2, 76, -59, -69, 40],
         'B3': [53073, 8584, 45856, 31766, 16973, 54801],
         'B4': 37,
         'B5': 11632174547606802644}],
 'A5': -0.5323846340179443,
 'A6': 18663,
 'A7': {'C1': -322913378,
        'C2': -1441767184,
        'C3': 2446,
        'C4': -601570705,
        'C5': 44715,
        'C6': 4075321702},
 'A8': {'D1': 27437, 'D2': 1532762811}}

(b"DTMT\x16\xd5?\xfa\xa2\xb5\xb1\xa4\x19U\xcf'\x89\xf4sy\x00\x04\x00\x00"
 b"\x00w\x00\x03\x00\x00\x00{\x8ao\x1c\xa4g\xfa\x03'\xf4ac\x00\x03\x00\x00\x00"
 b'\x81\x00\x06\x00\x00\x00\x84\x83\\4Z\xaf!\x9e\x94\x8dyl\x00\x04'
 b'\x00\x00\x00\x90\x00\x05\x00\x00\x00\x94\xfa\x18>\xffH)8\x83_=\xea\xe7j\x9f'
 b'U\xb9s\xf3\xab5K\x88\xa7\xda\xa7\xe7#\xf1\x1e\xe4XD\xccET\x03#\xc9'
 b'O\xb4\x1e\x04<\xa4\xaa\x0c\x03%\xf6\xb0\xd1\x16\xd6\xfe?\xdd\xd2\x12'
 b'\xa2\x1c<\x1b\xb7\xc5\x84s\xd8\xeblF=\xb9\xf4\x89\xea\xd3\x0f\xed>\xdf')

{'A1': 5845,
 'A2': 4610176069820225877,
 'A3': -819492364,
 'A4': [{'B1': 'sy',
         'B2': [4, 60, -92, -86],
         'B3': [3075, 9718, 45265],
         'B4': 138,
         'B5': 8006455004040996852},
        {'B1': 'ac',
         'B2': [22, -42, -2],
         'B3': [16349, 53778, 41500, 15387, 47045, 33907],
         'B4': 131,
         'B5': 6644035058508141709},
        {'B1': 'yl',
         'B2': [-40, -21, 108, 70],
         'B3': [15801, 62601, 60115, 4077, 16095],
         'B4': 250,
         'B5': 1747114390860628831}],
 'A5': 0.11469919979572296,
 'A6': -24747,
 'A7': {'C1': -1183583317,
        'C2': 894142631,
        'C3': 55975,
        'C4': -417074914,
        'C5': 58456,
        'C6': 1154237780},
 'A8': {'D1': 803, 'D2': 3377443870}}

Вариант №40

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

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

(b'CUI\xbf\xcb\xe6\xc8uf\xab\x90\xb5\x03\xd3\x8cY\t\x00>\x00H\x00R\x00'
 b'\x00\x00\x02\x00\x00\x00\\\x8c\xce\x00\x03\x00^\x00\x00\x00\x02\x00\x00\x00'
 b'j>y\x83\xb5r\x82\xbc\xbe\x1eM\xb1k\r \xe8\x00Z\x92\x8d\x15\xa9\xb1\xe0'
 b'\xd9\xbd|\xdc\x94\x1b\xa3J\xf1\x8c7\xc3\xcbvz\xd7z\xae\x9b\x97{\xc5\x7f\x0e'
 b'jb\xbfA7\x10\xbe\xb5\xa5\x18\xbf]XWj\xf3\xcb9\xa6\xd8b\x14')

{'A1': -0.21798043949578672,
 'A2': -1258040436,
 'A3': 22793,
 'A4': [{'B1': {'C1': -110, 'C2': -8280525758404117124}, 'B2': 220},
        {'B1': {'C1': -108, 'C2': 1991517861527929803}, 'B2': 118},
        {'B1': {'C1': 122, 'C2': -2919829425111710337}, 'B2': 14}],
 'A5': {'D1': 'jb',
        'D2': {'E1': -29490,
               'E2': [-0.7547464370727539,
                      -0.35477519035339355,
                      -0.8646292090415955],
               'E3': [1794362169, -1495768556],
               'E4': 0.24366648495197296,
               'E5': [114, 130, 188, 190, 30]},
        'D3': 5598373515929059418}}

(b'CUI\xbf\xe2\x8a\\U\x82q\xca\x12b\xfb\xb0\xca\x8e\x00>\x00H\x00R\x00'
 b'\x00\x00\x02\x00\x00\x00\\\xd7(\x00\x02\x00^\x00\x00\x00\x02\x00\x00\x00'
 b'f\xbe\xb3\x9dH47\xa8\rL\xa9\xf4\x845U}H\x96\xd7\xf5\xc1\xd8\x96\xb9'
 b'\x16\x98&4\xb5\xdc\xf30\xb6\xb7\xb1@q61&\xee\xbc\xe6\xf46\x9f\xbc\x8dgj?\x1f'
 b'\x1e\xc9?]-\xc1\xc8E\xd1\t\x85We\x0b')

{'A1': -0.5793897314175009,
 'A2': 308476848,
 'A3': -13682,
 'A4': [{'B1': {'C1': -41, 'C2': -738070722050090970}, 'B2': 52},
        {'B1': {'C1': -75, 'C2': -2525621404700688271}, 'B2': 54},
        {'B1': {'C1': 49, 'C2': 2805387318024118204}, 'B2': 141}],
 'A5': {'D1': 'gj',
        'D2': {'E1': -10456,
               'E2': [0.6215634942054749, 0.8639793992042542],
               'E3': [-934948599, -2057870069],
               'E4': -0.35080933570861816,
               'E5': [52, 55, 168, 13, 76]},
        'D3': 12246558651329628310}}

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

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

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

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

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

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

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

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

Поле	Описание
1	Массив структур C, размер 2
2	int32
3	uint64
4	Структура E
5	double
6	int8
7	int16

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

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