ИКБО-23-22

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

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

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

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

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

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

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

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

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

(b'\x08MNU\x00VH\x82\xb7\x1e\xb6\xbe\x85Z?\xec\x1cG\n)\x9b\xb0?\xeb'
 b'\xd5\xa0\x9atwz\xbf\xebW\xca\xdd\xf7\xd1\xa4W\x8ak\x95B\x8a\xe3\xe8\x00\x02'
 b'\x00\x00\x00s?A?\xbe\x00{\x00\x00\x00\x04\x00\x00\x00\xad\xe5\x99\xdd9\xba?'
 b'\xa8\xa3tv\x00\x00\x00\x02\x00\x00\x00J\xf0E\xdb\x00\x00\x00L\xd2'
 b'\xa6X\xff\xd2\xeerw2\xf4\xdd\x9a\x17\xca\xda(\x85B\xff\x1b\xaa'
 b'\xed\xc5\x07\x00\x00\x00[\x00\x00\x00g\xb6\x87>\x81%\x0b=\x1f\xfa'
 b'\xe6\xbc\xfc\xb2+<\xd7\x11\x8a\xf21\x0fA\xbfta\xac\xbf\xecF\xa8\xe9/\x9f'
 b'\x06\x83]\xf8\x16d\x17\xfe\xe4\xe5\xd5\xcb\xf7\x8a/\xb1\xb7\x83\xa0/'
 b'O\xb9\xc3s\xf9')

{'A1': {'B1': -37, 'B2': {'C1': 'tv', 'C2': 61509}},
 'A2': 5224939860246037850,
 'A3': 0.8784518431174231,
 'A4': 0.8698275582025723,
 'A5': -0.8544668517411549,
 'A6': {'D1': 6307972516896498664,
        'D2': [{'E1': 15178917449877582455, 'E2': 854908314},
               {'E1': 1714422475737202459, 'E2': -1427258105}]},
 'A7': 0.7548788785934448,
 'A8': {'F1': {'G1': -18809,
               'G2': [0.2522357404232025,
                      0.03905763477087021,
                      -0.030846675857901573,
                      0.026253480464220047],
               'G3': 4063301441,
               'G4': -0.9546153545379639,
               'G5': -0.8836254648603876,
               'G6': -8980749306854637852,
               'G7': 16561367468760609207},
        'F2': [-31840, 12111, -17981, 29689],
        'F3': 16544497946129836195}}

(b'\x08MNU\x00W)r\x92>\xab.\x0e~\xbf\x9fh\xe5\xd0\xfe\xf8\x00\xbf\xd1'
 b'\xb2g\x11\xbf\x7f\xdc\xbf\xe4\xafx\x1f\x18\xcc\xe2\x0e}\xcf\xcd3m'
 b'\xfd\xa3\x00\x02\x00\x00\x00t\xbe]\xad\x07\x00|\x00\x00\x00\x05\x00\x00'
 b'\x00\xae\xabm\x04\xfc\xc6,\xcdEkwa\x00\x00\x00\x03\x00\x00\x00J\xe3\x8e\xd7'
 b"\x00\x00\x00M\x15\xd4\xea\xd9I\xd1';\xab\x88k\xf41\xa1\xcb(\xa0\x03\xa9j"
 b'\x8b:Ex\x00\x00\x00\\\x00\x00\x00h\x7f\x99>\xc7\x19g=\xc9\xea\x91?k'
 b'\xc2\n\xbfER\x16UY\xe1$?eIF\xbf\xb9Z\xdd\xfa\x14\xf60\xc4QP\xeb\xf6V'
 b'\xceGV\x8b\xfee{\x03m\xccr\x05\xcb\xa4\xfdl\x18\xbcg\xbe')

{'A1': {'B1': -41, 'B2': {'C1': 'kwa', 'C2': 58254}},
 'A2': 2986610300757610110,
 'A3': -0.030673590546705043,
 'A4': -0.2765138314553022,
 'A5': -0.6464195830689301,
 'A6': {'D1': 1044219168857914787,
        'D2': [{'E1': 1573140388826392379, 'E2': -1417122828},
               {'E1': 3576362954452609386, 'E2': -1959115400}]},
 'A7': -0.21648035943508148,
 'A8': {'F1': {'G1': 32665,
               'G2': [0.3888656795024872,
                      0.09859193116426468,
                      0.9209295511245728,
                      -0.7707837820053101],
               'G3': 1431953700,
               'G4': 0.8956493139266968,
               'G5': -0.0990427718688458,
               'G6': -4300567194781692345,
               'G7': 6236357820833557964},
        'F2': [29189, -13404, -660, 6332, 26558],
        'F3': 12352534836650233157}}

Вариант №2

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

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

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

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

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

Поле	Описание
1	int64
2	uint8
3	int32
4	double
5	int8
6	uint8
7	float
8	float

(b'LRHc\x00\x00\x00\x04\x00`~Hi\xfa\xde\xbb\x812\xd6\xd9-\xe4\xdeU'
 b'\x83\xd3\xb7\xff\x16\xd8\x87\xf3\xaf[\x00d\x00\x83\x10R\x99\x1a\x94\x9d'
 b'\xd3\xf5?\xeb\xf1\xba\x8d\xca4b\xd4~\xcb\xfe\x1b\xecA\x92\xa1\xfa^I~\x9d'
 b'qo<\x17\x91\xe6\x05\r]\x8c\xf6:\xf3\x98 \xb9\nf~\xb1\x01\n\x7f\xd9X9\xa2\x1c'
 b'\xe1\xde[\xf9\xae\xd35r&\xafz;\x0c\x7f`\xc6^?\xeeg`\xfdO\xe8(\xd0@?'
 b'[\xb6\xbf?Z\n\x94\x8f\xa4\xaa\x93\xb2\xbc+K\x17\x1c\x04\xe4\xae?\xd2\x1a\xed'
 b'\xc7\x88\xf3\xd8\x14k?#\xc1\x85>u\xdd\x03')

{'A1': 99,
 'A2': [225, 222, 91, 249],
 'A3': {'B1': 32328, 'B2': 7636661015067940569, 'B3': 11748},
 'A4': 3730146259,
 'A5': {'C1': 13258340947251670875,
        'C2': [{'D1': -5849272726632564165,
                'D2': 12,
                'D3': 2137048670,
                'D4': 0.9501194903853092,
                'D5': -48,
                'D6': 64,
                'D7': 0.8582572340965271,
                'D8': 0.8517239093780518},
               {'D1': -8096158678769718453,
                'D2': 23,
                'D3': 470082734,
                'D4': 0.28289360509716976,
                'D5': 20,
                'D6': 107,
                'D7': 0.6396716237068176,
                'D8': 0.2401009052991867}],
        'C3': [4178, -26342, -27491, -11275]},
 'A6': 0.8732579011281241,
 'A7': -11138,
 'A8': [14699216935310238202,
        6794100727543184407,
        10513095935105234490,
        17552815526792036017,
        75012915269837340]}

(b'LRH.\x00\x00\x00\x03\x00`:\xe7ydxeb\xb0h\x0e\xb2\x84AWZ\xe2\xa5\x80'
 b'c\xa6\xbd\\n8\x00c\x00\x82\xda-|\xe1d\x9a`\x14?\xef\xf4\xdb\xedRv\xbe\x83-'
 b'\xb6j\xab\xb8\x9eF\xd6*\x9c\xa2Q\x95\x84\xbd~4\x82D\xed\x9c\x18p\xf0?'
 b'\x17\x1a\xe4\x95\xb8i\xa3\xaeV \r\xd96\x05\xce\x97{\xbb\xc7\x03\xd3\xc7i\xd6'
 b'\xed\x10C><\x109\x8e?\xc7\xcd\x87\xe6S\x98\x10\xe8\x81\xbf\x16?\xbe\xbe\xff'
 b'\xbfC(\x07b\xd7\xce\xfa\xf6\xb0\xca\x0e"\x94\xb2?\xd5J\x10T1\x9cD\xcd6>g\xa6'
 b'\xf7\xbfr\xd2\xba')

{'A1': 46,
 'A2': [123, 187, 199],
 'A3': {'B1': 15079, 'B2': 8747248753103104014, 'B3': 45700},
 'A4': 1096243938,
 'A5': {'C1': 11925641381069745720,
        'C2': [{'D1': 275783259591086147,
                'D2': 62,
                'D3': 1007696270,
                'D4': 0.18595980402386703,
                'D5': -24,
                'D6': 129,
                'D7': -0.5869101285934448,
                'D8': -0.4995060861110687},
               {'D1': 2884382765384136368,
                'D2': 202,
                'D3': 237147314,
                'D4': 0.3326454946713435,
                'D5': -51,
                'D6': 54,
                'D7': 0.22622285783290863,
                'D8': -0.9485279321670532}],
        'C3': [-9683, 31969, 25754, 24596]},
 'A6': 0.9986400256345502,
 'A7': -31955,
 'A8': [13144507271851988522,
        11286673318762872372,
        9386888778027692095,
        1664894343962010542,
        6205975513081958039]}

Вариант №3

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

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

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

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

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

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

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

(b'ZFNR\xff\x00\x00\x00u\x86~\x8a2\xc4C\xb4\xe3,+\xae:\x1b\x0f\x00'
 b'\x02\x00\x85\xbf*\x06\xf3?\xea\xc2rB\xc0\x0e\xf6\x8dTSc\xd1\xaa\xbfX\x96'
 b'\x9a?))e\xbc%\xabJ\x00\x00\x00\x87\xaa\x08\x94]\xf7\x93\xac\xf0\xdb\xfb\x9d'
 b'h\xbe\x04\x00\x02\x00\x97\xbfg\x98\xaf\xbf\xc5w]\xe1\xfd\x078\xde\xc8\xa0<W'
 b'\x07>\xfd\x10k>\xdd\xc7\x06>G3s\xbfx\xc1\xad\xa2l\xa1\xd4\xb6\xf1\r'
 b'c\x84>\xc5\xf9\x19\xa9\x1f\xad.7\xe8\xe9\xa5\x86\xf3q\xd8\xa9\xf1v\xc6gz'
 b'\xf3$\xc7s\xea_\xe7T\xa5')

{'A1': 21247,
 'A2': [{'B1': {'C1': 3069250915,
                'C2': [33854, 50681, 6569, 8109, 11831, 59625]},
         'B2': -8755408674915896093,
         'B3': {'D1': 741060154,
                'D2': 27,
                'D3': 15,
                'D4': [-91, -122],
                'D5': -0.6641685366630554,
                'D6': 0.8362361243930241},
         'B4': {'E1': -1923853469,
                'E2': -11862,
                'E3': [-0.8460479974746704,
                       0.6607878804206848,
                       -0.010111639276146889]}},
        {'B1': {'C1': 4084324521,
                'C2': [61814, 50791, 31475, 9415, 29674, 24551]},
         'B2': -6194538156141597456,
         'B3': {'D1': 3690700136,
                'D2': -66,
                'D3': 4,
                'D4': [84, -91],
                'D5': -0.9046735167503357,
                'D6': -0.16770528349484848},
         'B4': {'E1': -557277124,
                'E2': 22279,
                'E3': [0.4942658841609955,
                       0.4331590533256531,
                       0.19453220069408417]}}],
 'A3': -0.9717052578926086,
 'A4': -1569938988}

(b'ZFN\xda\x82\x00\x00\x00u\x80q\xea\xe8w\xb6@\x00iHX\xb096\x00\x03\x00\x85\xbe'
 b'T c\xbf\xec0\xff\xce\x10\xf6\xf4\xf6\x95\x7f\x91c\xf2\xbfTe\x91>\x9f\xeb'
 b'>\xbdK\x81y\x00\x00\x00\x88=2\xd1b@\x13(\xbf\xdc\xd7\xa4\xd0\xe7\x8f\x00'
 b'\x03\x00\x98?J\x99z\xbf\xe2L\xcbM\xbe\x8al\xaf@\x10\x1dkI\xbe\xc4\x96'
 b'\xbf\xbd1\xd3\xc8\xbf4\xe6\xf9?B\x0fv\xe5\x97|\xf4<\x9c:\xf2%qFG\xc4\xc8\x9a'
 b'\xf5\x1bo\xb9A\xc9O\xc5\xdf7\x8a\xc9\x18\x95wi\xdc\xc7\x0b\xceM\x87\xac\xbc'
 b'5\xd0~')

{'A1': -9598,
 'A2': [{'B1': {'C1': 1016871666,
                'C2': [9585, 17991, 50376, 39669, 7023, 47425]},
         'B2': -9191307080324726784,
         'B3': {'D1': 1766348976,
                'D2': 57,
                'D3': 54,
                'D4': [-55, 79, -59],
                'D5': -0.2071547955274582,
                'D6': -0.8809813523036767},
         'B4': {'E1': -157974639,
                'E2': 25586,
                'E3': [-0.8296747803688049,
                       0.3123416304588318,
                       -0.04968402162194252]}},
        {'B1': {'C1': 3744959177,
                'C2': [6293, 30569, 56519, 3022, 19847, 44220]},
         'B2': 4409817205061134527,
         'B3': {'D1': 3705119952,
                'D2': -25,
                'D3': 143,
                'D4': [53, -48, 126],
                'D5': 0.7914043664932251,
                'D6': -0.5718742865031579},
         'B4': {'E1': -1354756067,
                'E2': 27465,
                'E3': [-0.38396260142326355,
                       -0.04341486096382141,
                       -0.7066493630409241]}}],
 'A3': 0.758048415184021,
 'A4': -443056908}

Вариант №4

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

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

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

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

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

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

(b'HDRZ\x00\x00\x00U\x00\x00\x00a\x00\x00\x00m\x00\x00\x00y\x00\x00\x00\x85'
 b'\x00\x00\x00\x91\xbfi\x8b\xeb<M\xcb\xc1\xcc\xca\xd2crcdxfkn\xa9'
 b'\xc9\xb6\xc9\xf6$\x10\xe3J\xb7r[\x0f\x1b\xde\x02\xf1\xe5\x93\x8a"\xc7Q@E'
 b'\xc1\xc7\xd3i\x1e\x00\x00\x00\x03\x00\x00\x00\x9d\xe0\xc6C\xa1G _8\xda\xc2<'
 b'\x8b\x8e\x9e\x1b\xe5\n0\xbb\xa5zm\xc9\x02\x90\x180\xfe\x19\n\x8f'
 b'\xc0\x86\x92o\xe4knB\x9c7\xec\xe7(\x9d^\xab\xea7\xde\xc7\x1fMT!'
 b'\xa9\xc6\x86\xf5\xe8\xef\x18\xca\x8d\x17p(\xc3;\xbeF:\x96\xbd\xbc\xc4z\x12')

{'A1': [{'B1': 16196707469846667064, 'B2': 3670162571},
        {'B1': 10276682070238477221, 'B2': 2054015234},
        {'B1': 10383102808802627520, 'B2': 2257743844},
        {'B1': 7741198048217065256, 'B2': 2640227306},
        {'B1': 4025874054171074985, 'B2': 3330733544},
        {'B1': 17228743081838258371, 'B2': 1002325562}],
 'A2': {'C1': -0.9122912287712097,
        'C2': 0.012560785748064518,
        'C3': 52426,
        'C4': -46},
 'A3': 'crcdxfkn',
 'A4': -22071,
 'A5': {'D1': [46793, 63012, 4323, 19127, 29275, 3867, 56834, 61925],
        'D2': 147,
        'D3': -8493006795482742329},
 'A6': -45,
 'A7': 26910,
 'A8': [-26947, -17212, 31250]}

(b'HDRZ\x00\x00\x00U\x00\x00\x00a\x00\x00\x00m\x00\x00\x00y\x00\x00\x00\x85'
 b'\x00\x00\x00\x91>\xfc\x83\x85\xbfp\rLOd\x99ejlekwda?CW\xf2\xd9\xee\xc9X\xd2'
 b'\xc3\xd9\xde!\xc0\xd5-\xe7\x9a\xa6t\xcc\xd6\xaa?O\xb5\x7f!\x052\x00\x00\x00'
 b'\x08\x00\x00\x00\x9d\x18\x16\x9c\xcaTZZ`\xda\x82\xb3\xf98\xc6\xa8;4\xc4\xfb'
 b'\xf3a\x91\x8dj\x94Wsn{\xcd\xdfW\xe6\x96\xf2\xd0\xafE\xa8\xb0,\x1b$s\xdc3('
 b'\x8ePj\xe5\xfc`\x1c\xfb\xf5\xb4\xb3\x98p\x83\xdb\xcc\x98b!\\+\xe1\x1cP'
 b'\xbd\xbb<\x10\x00n\x96\x11\xa5L\xe6\x13\xcf\xf4\xeb\xa8\x14')

{'A1': [{'B1': 1735747099210439264, 'B2': 3665998841},
        {'B1': 4091142283754535923, 'B2': 1636928874},
        {'B1': 10689139158947848023, 'B2': 3868652240},
        {'B1': 12629686204638110835, 'B2': 3694340238},
        {'B1': 5794696742672595957, 'B2': 3031668848},
        {'B1': 9501412793721642027, 'B2': 3776729277}],
 'A2': {'C1': 0.4931909143924713,
        'C2': -0.9377028942108154,
        'C3': 20324,
        'C4': -103},
 'A3': 'ejlekwda',
 'A4': 16195,
 'A5': {'D1': [22514, 55790, 51544, 53955, 55774, 8640, 54573, 59290],
        'D2': 166,
        'D3': 8416337830343587199},
 'A6': 33,
 'A7': 1330,
 'A8': [-17604, 4096, 28310, 4517, 19686, 5071, -2837, -22508]}

Вариант №5

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

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

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

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

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

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

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

(b'UAK\x93\x03\x00\x00\x00"\x00\xb0\x02N0\xe6m\xcf?T\x00\x00\x00\xdc\xe2B/g\x94'
 b'&\xc4\x03\x00_\x00\x00\xeb>\xef\x81\x8bpBP\x1d\x05a\x0e\n\xaapb\x1d'
 b'\x7f\xf7nL\xe6\xcfI\x17\xeeh\xc1\xa3\x1a\xf5o\xff\xd3\xebMb\xe2>\x96\xbf'
 b'\xac\x1aiI\xbexl\xb6\x9f\xf5a9\x89\x02\x00\x00\x00L\x00Tzt\xbfP\xb1O?\x92'
 b'~y?')

{'A1': {'B1': [{'C1': {'D1': 60160, 'D2': 2340548414, 'D3': 17008},
                'C2': [80, 29, 5, 97, 14, 10]},
               {'C1': {'D1': 28842, 'D2': 4152302946, 'D3': 19566},
                'C2': [230, 207, 73, 23, 238, 104]},
               {'C1': {'D1': 41921, 'D2': 4285527322, 'D3': -5165},
                'C2': [77, 98, 226, 62, 150, 191]}],
        'B2': 0.24554135664586374},
 'A2': {'E1': 962721183, 'E2': 137, 'E3': [1231624876, -1234405186]},
 'A3': [-7460, 12098, -27545, -15322],
 'A4': [-0.9549915790557861, 0.8112993240356445, 0.9745875597000122]}

(b'UAK\x93\x06\x00\x00\x00"\x00\x90<\xf1\xb7\xd1D\xd6\xbf\x82\x00'
 b'\x00\x00\x9f\xe9z\xe2\x9ej\xb4\x01\x05\x00\x8d\x00H\xaa\x1f\xc1\xdaJ'
 b',\x12\x13#]3\x02\x0b6.\xb9\xd0\x85\xd7H\t\xa78\xbfG5V[\x9a\xbb\x8c\x95\x9d'
 b'a\xb5\x13;\xd0!*\xb5\x7fH.\x7f\xb6\xdb+\xb0\xb9\xd0\xfb\x0c\xcc\x0c\x18n'
 b'\xa4\x93\xf7\xdc\x85\xe6\r,\x1a5\xb1\x97\xfe\x9a\xbc=?7Pg\xdf\xb0@\xb9'
 b'\xb3\x80T\x90\xb7\x9a\xb1%\x06\xd3/C\xe1\x8e\xf3\x80\xa9\xd0+\x03'
 b'\x00\x00\x00v\x00\xeczH?\x1aeF?\tn/\xbe\xc6\x82G\xbf\x87\xe0\xc2\xbe')

{'A1': {'B1': [{'C1': {'D1': 43592, 'D2': 1255850271, 'D3': 4652},
                'C2': [19, 35, 93, 51, 2, 11]},
               {'C1': {'D1': 11830, 'D2': 3615871161, 'D3': 2376},
                'C2': [167, 56, 191, 71, 53, 86]},
               {'C1': {'D1': 39515, 'D2': 2643823803, 'D3': -19103},
                'C2': [19, 59, 208, 33, 42, 181]},
               {'C1': {'D1': 18559, 'D2': 3686170414, 'D3': -20437},
                'C2': [185, 208, 251, 12, 204, 12]},
               {'C1': {'D1': 28184, 'D2': 3707212708, 'D3': -6523},
                'C2': [13, 44, 26, 53, 177, 151]},
               {'C1': {'D1': 39678, 'D2': 926891452, 'D3': 26448},
                'C2': [223, 176, 64, 185, 179, 128]}],
        'B2': -0.3479503914176769},
 'A2': {'E1': -794197773,
        'E2': 43,
        'E3': [-1699245996, -754571855, -1897839825]},
 'A3': [-5729, -7558, 27294, 436],
 'A4': [0.783125638961792,
        0.7749801874160767,
        -0.1713181883096695,
        -0.7793391942977905,
        -0.38061925768852234]}

Вариант №6

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

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

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

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

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

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

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

(b'\xf9LXY\xc0\xb2\xb30\xe4\xff\xa8?x\x00\x00\x00\x81\x00\x00\x00'
 b'\x8a\x00\x00\x00\x93\x00\x00\x00\x9c\x00\x00\x00\xa5\x00\x00\x00'
 b'\xae\x00\x00\x00B\x92\x1b`\x02O\xf7\xd1\x05\x00\xb7\x00\x88np\xc5\x9f{H\xf6'
 b'\xde?\xc2\xae\xc8a\x92\xa6\x14\x89\xe6\xbf\xd0\xf2\x8b\x92]<\xcc\xbf'
 b'o=\x9e\xda\xa2\x1fq\x13\xa1\xf9Z\xbfQ\xb2\x86\r\xbbM<\x91\x15\x89\xc48'
 b'\xfe>\xf2\x8f\xa0\xe7\xe6\xbf65L\x80?\xa7\xeb?\x8a\xac{0\xfdq&\x08\t\\\xdf8'
 b'\xa8\x9f\x00\xb5i\x93\xd3\x854\xa4k\xdf\xfe9L\x81\x1a\xeb\x17\xcb\xa9\x9blf'
 b'\xd9!\xc7.\x8e\xa2\xf8&\xb0p\xee\t\x06\x97\xb9\x9d\xd6\xf8\x19\xf6'
 b'\x16\xfe\xa0\xb6\xe1\xb6\xb6dhahe')

{'A1': {'B1': 0.04882729620462589,
        'B2': [{'C1': 813411466, 'C2': 253, 'C3': 151529073},
               {'C1': 2822299484, 'C2': 159, 'C3': -1821788928},
               {'C1': 2754905555, 'C2': 107, 'C3': 1278869215},
               {'C1': 401283713, 'C2': 203, 'C3': 1718393769},
               {'C1': 784802265, 'C2': 142, 'C3': -1339623262},
               {'C1': 101314160, 'C2': 151, 'C3': -120152647},
               {'C1': 4262917657, 'C2': 160, 'C3': -1229528650}],
        'B3': 15129648344795419202},
 'A2': {'D1': 'dhahe',
        'D2': {'E1': 28296,
               'E2': 0.4837819297091164,
               'E3': 44738,
               'E4': [-0.7042334798198278, -0.22059220939254098]},
        'D3': [111, 61, -98, -38, -94, 31, 113, 19],
        'D4': 974662433544796577,
        'D5': -1858318917},
 'A3': 952404245,
 'A4': -0.7157748042536409,
 'A5': 0.864166021901531}

(b'\xf9LXY\xd8-\xa34nR\xdc?x\x00\x00\x00\x81\x00\x00\x00\x8a\x00\x00\x00'
 b'\x93\x00\x00\x00\x9c\x00\x00\x00\xa5\x00\x00\x00\xae\x00\x00\x00'
 b'\x80\x8b\xa3+\x17\xccR\x19\x05\x00\xb7\x00\xbcvP\xaax=\x97\xdb\xd8?\xc0e'
 b'\xbe>\xa0i!G\xe0?x*\x1c\r\xa3\xc1\xe4?\xb4\xcc`l\\\xec\x1f\xb8\xa2\xf0\xd0T'
 b'\xa0F(\x03\x95\xeb\x83\xf0N\x9a\xdf\xdc\x06}\xda\xb5\x816\xe0\xbfHGv\x8c'
 b'\x9f\xc2\xec?\xc7\xcd\xee\x9ex\x9d\xaf\xe3\xf3\xdb;>$Ti[^\xcb\x10\x94'
 b'9\xc8\x16\xc4&\xf4q\xd4\xd1^\x16_\xd8\x95\x8d\xd9E\x0b\x8b\r\t\x9c\x8b\x87'
 b'\xea\x02o\xfb\xcb\x8d%F\xa5\x05?\xd6\xfa\xcc\xbb\xb2\x18\xd0Mxfrnd')

{'A1': {'B1': 0.4425311578786171,
        'B2': [{'C1': 2666450375, 'C2': 120, 'C3': -203182179},
               {'C1': 608058331, 'C2': 84, 'C3': -883008663},
               {'C1': 3359216656, 'C2': 22, 'C3': 1911826116},
               {'C1': 375312852, 'C2': 95, 'C3': -645032488},
               {'C1': 227216197, 'C2': 9, 'C3': -360215652},
               {'C1': 3422252802, 'C2': 141, 'C3': 94717477},
               {'C1': 3438990911, 'C2': 187, 'C3': 1305483442}],
        'B3': 1824745198926924672},
 'A2': {'D1': 'xfrnd',
        'D2': {'E1': 30396,
               'E2': 0.38840275767384913,
               'E3': 26048,
               'E4': [0.5086829245573978, 0.6486373191886079]},
        'D3': [-76, -52, 96, 108, 92, -20, 31, -72],
        'D4': 227509435613900962,
        'D5': -259789931},
 'A3': -589325746,
 'A4': -0.5066536475968924,
 'A5': 0.8987577193640641}

Вариант №7

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

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

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

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

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

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

(b'MEM\xe9\xfaWq\xbf\xe9\xf3/t?\xd7\x06\xd0Yoo\x96.9ys\x01%\x1cb\x81b\xf7>'
 b"\xed'\x95\x86\x15`t\xf1\x84\xf5\xbf\x13\xf5\x9a\xd4\x97\x92\x19yN\xad=\xd5F"
 b'\xcb\x13\xd39\xc5>~G>\x06\x11\x18 \xe4\x8c\x1c\x0b\x96S?Q\xec\xc4-'
 b'\xa1\x8c\xa6\xfe\x14\xf2\xbfLMp$\xc5\x04\x88\xde\xec&>\xe5\xdd\x9a\xefZC'
 b'!;X\xa5?1\xc2\xb9\x00r\x8d\xcb^\xd0*\xfby\xb5\xb3u\x86\x13G\x05\xef\xe4\xach'
 b'\x8d5\xcc')

{'A1': -369469583,
 'A2': -0.8109357138152695,
 'A3': -12199,
 'A4': 'oo',
 'A5': {'B1': 150, 'B2': 11833, 'B3': 'ys'},
 'A6': [{'C1': [1, 37, 28, 98, 129, 98, 247], 'C2': 0.4631926119327545},
        {'C1': [134, 21, 96, 116, 241, 132, 245], 'C2': -0.5779663324356079},
        {'C1': [212, 151, 146, 25, 121, 78, 173], 'C2': 0.10413893312215805},
        {'C1': [19, 211, 57, 197, 62, 126, 71], 'C2': 0.13092458248138428},
        {'C1': [32, 228, 140, 28, 11, 150, 83], 'C2': 0.820019006729126},
        {'C1': [45, 161, 140, 166, 254, 20, 242], 'C2': -0.7980566024780273},
        {'C1': [36, 197, 4, 136, 222, 236, 38], 'C2': 0.44895631074905396},
        {'C1': [239, 90, 67, 33, 59, 88, 165], 'C2': 0.6943774819374084}],
 'A7': {'D1': 10217364427787434421,
        'D2': -77,
        'D3': 30086,
        'D4': 323421679,
        'D5': -6996,
        'D6': 1754084812}}

(b'MEM\x12\xf2J\xac?\xe8\xf9\xa8qn\x90\x1c\x9b\x89tgc\xf6)mn\x00\xeeU\xdc'
 b'?\x8f\xfe?\x06)\xd9\xed\x7fx>=\x10\x8f>Q\xbe\xfcP\xc9\xff0\x08\xd0\xed?b\xb6'
 b'\x9fz\xb6\xec|\xbb\x7fO>s\x9by2h-O)\xed\x91?\r\x88\x87\x9a\x8c\x1e\x04?Wg=)'
 b'\x9e\xb4b\xe6\xe5\x04}\xd3I\xbd\xe1IAX\x8b\x87(\x0cp\xad\xbe\xd3A)'
 b'\x00r\xf1\xf5\xea\xc2\x9c\x8a"\xdft\xd1}\xfe\xa2\xd4\xcf\xb7\x14\x99j~\xe2')

{'A1': 317868716,
 'A2': 0.7804758277384312,
 'A3': -25719,
 'A4': 'tg',
 'A5': {'B1': 99, 'B2': 63017, 'B3': 'mn'},
 'A6': [{'C1': [0, 238, 85, 220, 63, 143, 254], 'C2': 0.5240760445594788},
        {'C1': [237, 127, 120, 62, 61, 16, 143], 'C2': 0.2048301100730896},
        {'C1': [80, 201, 255, 48, 8, 208, 237], 'C2': 0.8855990767478943},
        {'C1': [122, 182, 236, 124, 187, 127, 79], 'C2': 0.23789776861667633},
        {'C1': [50, 104, 45, 79, 41, 237, 145], 'C2': 0.5528644919395447},
        {'C1': [154, 140, 30, 4, 63, 87, 103], 'C2': 0.04141111671924591},
        {'C1': [98, 230, 229, 4, 125, 211, 73], 'C2': -0.11000300198793411},
        {'C1': [88, 139, 135, 40, 12, 112, 173], 'C2': -0.41260650753974915}],
 'A7': {'D1': 17435099654005596895,
        'D2': 116,
        'D3': 53629,
        'D4': 4272084175,
        'D5': -18668,
        'D6': 2573893346}}

Вариант №8

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

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

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

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

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

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

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

(b'SCF\xdb\xcfz_c\x80\xd7\xaf\x1d\xb2\x17qk?X\x80\nD\xca>\x02\x00\x9b\x00\xa3'
 b'\x00\xf1\xf9\x83\x00\x86\xe5\xe9\xd0\x0b|\x0f\xfe\x0b\xab\xa5\x8b\x02]\xe5'
 b'\xe9:\xc3\xe3\xbf\x08\xfc\x16{\xfc@\xdb?\xf2\xb3\x82\x01\xb6\x83\xe9'
 b'?\x0c\xfd\xfdO\x04\x80\xe6?\x12\x06\xc0\xee\xcc\xc7\xeb\xbf\x04\x00\x00'
 b'\x005\x00\x00\x00R3\r\x9et\xed\xe0Sh\xb6\x94\r<U\x00b\xf9\x06ma\xce\xe8\xbf'
 b'H\xc9\x8cI\x80\x00\xd6?\xa8\xf4\xaf\xcf\x19\xd8\xe2?\x03\x00\x00\x00'
 b"l\x00\x00\x00\x93rv\x82\xa9\x08\x07\x8b\xe2'8\x80\xaf\x84\x00e"
 b'\x00\x94\x00\xba\xc9fF\xb8rX8\xd8\x08\x02\x00\x00\x00\x9f\x00\x00\x00')

{'A1': {'B1': 2139165294447262415,
        'B2': 178,
        'B3': 0.9196943640708923,
        'B4': 32856,
        'B5': 0.3950503468513489,
        'B6': [{'C1': 46696,
                'C2': 148,
                'C3': 15373,
                'C4': {'D1': [0.4258414461182274,
                              0.797327998113927,
                              0.7031270563456089,
                              -0.8681397116744753],
                       'D2': 6044091785054860114}},
               {'C1': 10210,
                'C2': 56,
                'C3': 44928,
                'C4': {'D1': [-0.7751929406584106,
                              0.34378058607685036,
                              0.5888794952767471],
                       'D2': -8428758653469298029}}]},
 'A2': {'E1': 29368, 'E2': 14424, 'E3': 2264, 'E4': [51642, 18022]},
 'A3': [8649201, -789977722, -32539637, -1952077045],
 'A4': -0.6175818031578333}

(b'SCF\xdbT\r\x8a\x1e7\xef?\t\xe6\xef\xe5W?\x1a%\xd2\xd4O\xbf\x02'
 b'\x00\x9b\x00\xa3\x00\x82\x07\x89\xda\x8f\x99y\xbd\x83\rrv##\x86'
 b'\x8d\xd4\xfd\xf8\xf8\x1e"\xe9?|]\xa4\x97$\x8a\xd1\xbf\x02\xf9\x14'
 b'4\xb7\x85\xe7\xbfj\xd5X\x93\xc9\x00\xe3\xbf\xf8v\x07\xad\x7fF\xe8'
 b'?\x04\x00\x00\x005\x00\x00\x00_\x81;\xf3\x0b&\x9e\rF\xca\xd3\x1c\xc5U\x00'
 b'8\xb48S\x1c+\xe3\xbf8\xa8\xba\x00\xd5\x9f\xdb?R\xcf`\xb9\x85\x19\xec?'
 b'\x03\x00\x00\x00l\x00\x00\x00;&)\xaa b\xf2\xdb\x99x(W\t\x84\x00e'
 b'\x00\x94\x00\xc89/\xca\xc8\xfd\xe2\x15e\xea\x02\x00\x00\x00\x9f\x00\x00\x00')

{'A1': {'B1': 666514289888726356,
        'B2': 230,
        'B3': 0.8433522582054138,
        'B4': 9498,
        'B5': -0.8118411302566528,
        'B6': [{'C1': 51782,
                'C2': 211,
                'C3': 50460,
                'C4': {'D1': [-0.27405657585901344,
                              -0.7350727097725953,
                              -0.5938461187239856,
                              0.7586058024860156],
                       'D2': 981263601580605791}},
               {'C1': 30873,
                'C2': 40,
                'C3': 2391,
                'C4': {'D1': [-0.5990125298900528,
                              0.4316303736801532,
                              0.878115522448278],
                       'D2': -2597906142606055877}}]},
 'A2': {'E1': -568, 'E2': 5602, 'E3': 60005, 'E4': [14792, 51759]},
 'A3': [-628553854, -1116104305, 1987186051, -1920589021],
 'A4': 0.7854151594873948}

Вариант №9

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

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

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

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

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

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

(b'PMUK\x9d\xd2\xab\xd2\x92\xe6\x91\xee\x00\x00\x00\x02\x00[\xca\xe1X!\x00\x00'
 b'\x00o\xbf\xba:\xc0~\x061P?\xde\xc4\xec\x7f\xca\xaa@\xbf\x8a\xc9hI\x96'
 b'w\x80?\xb6\x04\xd0\x88\x7f\xf6@\xbf\xe7\x1b\xbeK#_*\xbf\xe8\x9b\xb6DC'
 b'X0\xbf\xc0T;\xe7\xf0~\x90?\xec}\x8a\xcc3q\x98\x85wc\x0bbf\xd6B\xa1m'
 b'T\xb3\xde\x92\x05\xb5\xd5g\xc6\xdb\xe0\x00\x00\x00]\x00\x00\x00e\xbf'
 b'\xd4\xc6\xd5)\xf3\xfe\x9c\x00\x02\x00m.\x13u\xd1\xbd\xaa\xe4\xe1,'
 b'\xa6\xb6\x84WT\xd8\xf08<\x06y\xd4-\xc6A\xbf3-\xde\xbe\xbe\x05N')

{'A1': -760491374,
 'A2': 59025,
 'A3': 238,
 'A4': 'wc',
 'A5': -891201503,
 'A6': {'B1': [{'C1': 190998230, 'C2': 1117875540},
               {'C1': 3017708037, 'C2': -1244305466}],
        'B2': {'D1': -0.32463578316672126,
               'D2': [219, 224],
               'D3': 773027281,
               'D4': -0.08344436436891556,
               'D5': 3217459663319914736,
               'D6': 4052120885047182913},
        'B3': -0.6999186277389526,
        'B4': -0.3711342215538025},
 'A7': [-0.10245898319971514,
        0.48076927642492606,
        -0.01307946657726311,
        0.0860109647037115,
        -0.722136637453308,
        -0.7690078099501587,
        -0.1275706179157976,
        0.8903249729442448],
 'A8': 133}

(b'PMUK\x9dK\xdaa\x1e\x1b\x07\x1a\x00\x00\x00\x02\x00[F\xd12\xc7\x00\x00'
 b'\x00u?\xea{W\xe6u\xc0\xe2\xbf\xe29\xea\x04\xb7G2\xbf\xe9\xfbm\xa2\xa8'
 b'[8\xbf\xef\x15\xf5-\x89\x9c\xb8\xbf\xdb\x95\x15OU\xb9t\xbf\xeb\x0e}r\xd9'
 b'\xf4\x18\xbf\xde\x90\xd9Y\xcfM\x84?\xe8\x82)\xe2\xed\x1cH\x1frw\xba\x82G'
 b'3\xd1\x03\x9c\x91\xd2[Zp\x89\x82\xbd\xd3\x08Q\xa7\xad\xdau ]\x00\x00\x00'
 b']\x00\x00\x00e\xbf\xd8\x92\xad\xa4\x95\x15\x88\x00\x08\x00mB\x91-'
 b'E\xbe\x0f\x04a\x9e\x0f5?\x1b\xe1~/V\xbc2\x85?\x97x&>c\xdb5\xbe\xed\xdc*')

{'A1': 1272602910,
 'A2': 6919,
 'A3': 26,
 'A4': 'rw',
 'A5': 1188115143,
 'A6': {'B1': [{'C1': 3129100083, 'C2': -788292463},
               {'C1': 3529202288, 'C2': -1987920429}],
        'B2': {'D1': -0.3839525325059516,
               'D2': [8, 81, 167, 173, 218, 117, 32, 93],
               'D3': 1116810565,
               'D4': -0.1396651417016983,
               'D5': 11389380527810248239,
               'D6': 6249925930762336294},
        'B3': 0.22251589596271515,
        'B4': -0.4645703434944153},
 'A7': [0.8275565625354171,
        -0.5695695964916239,
        -0.8119419266612118,
        -0.9714303864865519,
        -0.4309743189577582,
        -0.8455188029471428,
        -0.47759088297353736,
        0.7658891136314958],
 'A8': 31}

Вариант №10

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

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

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

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

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

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

(b'\xd1YUH\xbf\xd8_o\xbe}\xf7T\xb2ON}\xc1\xdcD\x01M\x00\x00\x007\x00\x00\x00'
 b"C\x00\x00\x00O.z\x05'\x19\xc5\xd7 \x00\x03\x00\x00\x00[\x00\x00\x00\x02\x00"
 b'\x00\x00\x8eG\x7fx\xbc\x9b\xa0m\xcf\xa8\x8c\xc0!C\x87A=\xaa3[\xe51'
 b'\xe8\\\xdbk\x04\x9e\xdaM\x11\xffa\xc5g\xd1gdsq\x087\xa5X)!\xd9WTEXk\x00\x00'
 b'\x00\x02\x00^\xb6\xdb\xc0\x90,V\x9dW3\x86\tj\xdb\xec,\x17\x9d<\x00\x00'
 b'\x00\x02\x00v\xcd\x12\x11\x8a\xa7\x1b\x00b\x00z')

{'A1': -0.38082498171558155,
 'A2': 178,
 'A3': 1330544065,
 'A4': -9148,
 'A5': {'B1': 333,
        'B2': [{'C1': 1199536316, 'C2': -7232660262903562207},
               {'C1': 1132937533, 'C2': -6182496823506608933},
               {'C1': 1795464922, 'C2': 5553500610913358183}]},
 'A6': 3348994938397644576,
 'A7': 'dsq',
 'A8': [{'D1': 2963888998885709931,
         'D2': [2103, 42328],
         'D3': [182, 219, 192, 144, 44, 86]},
        {'D1': 678596501271190844,
         'D2': [40279, 13190],
         'D3': [205, 18, 17, 138, 167, 27]}]}

(b"\xd1YUH\xbf\xe3\x04\x96|\x14u\xf4C\x083\x1f'\x9b\n\xd3-\x00\x00\x00"
 b"7\x00\x00\x00C\x00\x00\x00O\x87'\xc4\x94\xbb\xe9J\\\x00\x02\x00\x00\x00[\x00"
 b'\x00\x00\x02\x00\x00\x00\x8dS\x8enB\xb6!\x0fy\xb0\xd5\x90\x02C\xdc\xae\xbfk'
 b'\x04\x15\xb5\xdc9\x89\xc1k\xfb\xfd\x9em\xc9?\xe8wI\x08\x8ewu\xc8\xbbx'
 b'\x16\xc7;\xfa\xf9\x15\xbd-O\x00\x00\x00\x02\x00] u\xf6@\xc0R\xc1{\xa7'
 b'\x90\x87\xd4\xcc\x94\xf0\xd5\xd5\xed\x00\x00\x00\x02\x00u\xb4\x02\xb4\xfb)'
 b'\xfb\x00a\x00y')

{'A1': -0.5943100379406006,
 'A2': 67,
 'A3': 137568039,
 'A4': -25846,
 'A5': {'B1': 54061,
        'B2': [{'C1': 1401843266, 'C2': -5322956269242970110},
               {'C1': 1138536127, 'C2': 7711312332793153985},
               {'C1': 1811676574, 'C2': 7910924488119224462}]},
 'A6': -8707775211410732452,
 'A7': 'wu',
 'A8': [{'D1': -4090399888817443505,
         'D2': [51387, 30742],
         'D3': [32, 117, 246, 64, 192, 82]},
        {'D1': -8659071243458849299,
         'D2': [49531, 42896],
         'D3': [180, 2, 180, 251, 41, 251]}]}

Вариант №11

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

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

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

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

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

(b'LBDY\xac\x00\x00\x00\x89?V\xd0\xb1^\xb4\x87\x12\xf3\xa2\x86\x06\xfa|\xf9'
 b'\x87\xa5\xb3)\xbc\xee\xea\xd3U#VO\xb6\x1a\x1c\x9c\xe7\xeb\x85\xfe\xefA\xa7U'
 b'\x85|\x00\x1e\x00(\xd2\xd5\xb7\x01A^ud:\xf8N\xe9\xb5t\xa2\x8c\x17\xa2'
 b'g!\x00\x02\x00\x00\x002>\xf9\xdaYx\xbf\xbf\xea\x86\xc1U*\x00\x00\x00\x04'
 b'\x00\x00\x006\xec\x1a\xdf\xda>\x9a\xa5\xb4\xbdlp!\xbe\xf1\x1d\x00'
 b"\x00\x00\x03\x00\x00\x00:\xc3\xf3\x96\xcf\x82\x11\xbf\xdd\xb1'y%_"
 b"@\x1e\x1e\x00\xcb'j\xd7\xd2z\xd7\xf1\x05\x98V\x98\x1c\t\x00\x00\x00=\xe5{"
 b'\xf0&\x99`\xc6a')

{'A1': {'B1': 2170172942978832338,
        'B2': 122,
        'B3': 15560224339387751433,
        'B4': {'C1': 100,
               'C2': 989351657,
               'C3': -5371489732970518751,
               'C4': [{'D1': -5421, 'D2': 6134842017766317212},
                      {'D1': -6165, 'D2': 9655417716388234620}],
               'C5': 0.487993985414505,
               'C6': 8700884019107157290,
               'C7': {'E1': [210, 213, 183, 1],
                      'E2': 3961184218,
                      'E3': 0.30204546451568604,
                      'E4': 189,
                      'E5': [27760, 8638, 61725],
                      'E6': [65, 94, 117],
                      'E7': -1007446321,
                      'E8': -32239},
               'C8': -0.4639376338068253},
        'B5': 16536074505393587809},
 'A2': 0.8391218781471252,
 'A3': 1588889362,
 'A4': [-207452666, -92472953],
 'A5': -1514985028,
 'A6': -18}

(b'LBDY\xac\x00\x00\x00\x88\xbej\x8c\x15}^\x19\x7f\xc6\xde\xdb\xda3\x0f\xe0'
 b'\xe6\x0b\xddT\xe93Y\x8b#z\x8b\x89\xba\xc6\x8b\x8c\xe6\xa2\x9b\xe0>\x0eE\xd6'
 b'\x9c\x87\x00\x1e\x00(\x87\x17u\xc3+\t\xb0\x00D\xa2\xa2\xc4v\xdb\xd4\xa0l\x8c'
 b'I\x00\x02\x00\x00\x002?`\xee\xc4\xfc\x91\xfc\xeb\xbe\xbc.\xe5\x00'
 b'\x00\x00\x03\x00\x00\x006\xcc\xf2\xc3\t>\x19#w\xd8\x0bjP\xd6\xe8\xad\x00\x00'
 b'\x00\x03\x00\x00\x009!\x9dfg\xb0\xfa?\x8e\xbc#\xaf\xeb\n\x80&\x1a\xca5'
 b'\xfa\x06\x04\x97\xc4\x9a\x95$5\xb4\x02\xe6B\x00\x00\x00<\x9e\x06\xfes.\xe1C'
 b'\xef')

{'A1': {'B1': 2745729256012514455,
        'B2': 196,
        'B3': 11138849066442745410,
        'B4': {'C1': 176,
               'C2': 4498082,
               'C3': -4289999888752800695,
               'C4': [{'D1': 22923, 'D2': 2556509162146532236},
                      {'D1': -6494, 'D2': 11232045701684173959}],
               'C5': 0.878643274307251,
               'C6': 18199605658628402917,
               'C7': {'E1': [135, 23, 117],
                      'E2': 3438461705,
                      'E3': 0.14954935014247894,
                      'E4': 216,
                      'E5': [2922, 20694, 59565],
                      'E6': [195, 43, 9],
                      'E7': 563963495,
                      'E8': -20230},
               'C8': 0.015007284933181042},
        'B5': 11387068478514086895},
 'A2': -0.22904999554157257,
 'A3': 2103318911,
 'A4': [-958473254, 856678630],
 'A5': 199054569,
 'A6': 51}

Вариант №12

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

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

(b'.NLO\x00\x02\x00\x00\x00h_o6\xda?\xde6@\xbbf\xb3L\x00\x02\x00\x00\x00p'
 b'?\xed\\M\xc2\xdb@@\x00\x00\x00x\x0f\xf0\xcbB$.\xc3\xbb\x02\\\xcc\xd5'
 b'\xde\xab\x9b\t\xd1|\x1c\xb2In\xf04?\xab\x85\xa2\xf4\xa2a\x00\x8b0uU'
 b']\x9c\x079C\xb4\xea\xed]\xfb\x00\x05\x00Hc\xa5\xe5h\xf9\nK\x0cG\x00'
 b'\x02\x00[\xd6\x00\x00\x00R\x00\x00\x00_>\x06\x85\xb3\xbd\x8f=\xb1'
 b'\xd4\xaf\xff\x15\xda\xb5\x87i<7\xb4\x9c\xbf\x19cj>\xb4Z ')

{'A1': {'B1': {'C1': [{'D1': 3941424635,
                       'D2': [-29904, 30037, 23964, 1849, 17332],
                       'D3': 99},
                      {'D1': 172690503, 'D2': [-23067, 26873], 'D3': 214}],
               'C2': 1601124058,
               'C3': 0.47206133175750575,
               'C4': [0.13136939704418182, -0.06994188576936722],
               'C5': 0.9175175481596014,
               'C6': {'E1': -726663403,
                      'E2': -625637527,
                      'E3': 60,
                      'E4': 55,
                      'E5': 46236,
                      'E6': -0.5991731882095337,
                      'E7': 0.3522500991821289},
               'C7': 4080},
        'B2': -13502,
        'B3': 9262},
 'A2': 3283812956,
 'A3': -13099,
 'A4': [57003, 39689, 53628, 7346, 18798, 61492],
 'A5': 0.05375394092806296}

(b'.NLO\x00\x02\x00\x00\x00dWR\x87>?\xe6\x9f\x89}pz\xb2\x00\x03\x00\x00\x00l'
 b'?\xd4V#<\x1d\x83\x04\x00\x00\x00xX\xb19\x8dK\xf0\xf2<\xd5\xbaT\xdeB^1\xb8'
 b'2\x1e\x8f\x13)mB\x9d\xbf\xe6\x8ajp\xfd\xde\xf6\x14#\xe9\xc7\x03\xbd\x0ef'
 b'\x00\x02\x00HA\xcaE_\xb2\xf8\xad\xbe\xb1M\t\x00\x03\x00U\xc1\x00\x00\x00L'
 b'\x00\x00\x00[\xbdo\xe2s?s\x12\xf0>\xdd\xf2Q\xee*\xa6\xd4\xb9e\xa9\xac'
 b'~\x11Y\x90\xbe\xf2\xb6\xc6\xbfQ\xff\xb2')

{'A1': {'B1': {'C1': [{'D1': 62721638, 'D2': [5155, -5689], 'D3': 65},
                      {'D1': 3199290633,
                       'D2': [-13755, 24498, -1875],
                       'D3': 193}],
               'C2': 1465026366,
               'C3': 0.706974740027212,
               'C4': [-0.058565568178892136,
                      0.9495077133178711,
                      0.4334893524646759],
               'C5': 0.31775742407448626,
               'C6': {'E1': -299194668,
                      'E2': -1184519764,
                      'E3': 126,
                      'E4': 17,
                      'E5': 22928,
                      'E6': -0.47405070066452026,
                      'E7': -0.8203078508377075},
               'C7': 22705},
        'B2': 14733,
        'B3': 19440},
 'A2': 4064073146,
 'A3': 21726,
 'A4': [16990, 12728, 12830, 36627, 10605, 17053],
 'A5': -0.7043964583271805}

Вариант №13

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

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

(b'ASRD\x99\x0e\n\x89\n\xe2\xb9\x8a\x98Ay\x00\x02\x00\x00\x009>d\xdd3\xbf~*'
 b'\x04\x07\x0cn\xc2\xad\xe85W\x00\x00\x00\x05\x00x\xbfX8\xcc\x00'
 b'\x00\x00\x05\x00\x8c\x8b\xa8Mn\xbfZ\xb0:\xbeLi\x16\xc5\x7fG\xf3\x9f\x10\x07'
 b"\x99\x0f\x11\xf7\x02\x00\xaa\xfd\xc6Y\xeb\xf1e_\xae\xf4\xb5\x00'\xf7"
 b'\x12\x87h\x84\x9a\xb0sA\xf6G_rW\x91\xf4\xbdH\x93\x16f\xb3\xc9\xadj\xc5vN\x92'
 b'\x00\x00\x00A\x00\x00\x00L\x00\x00\x00W\x00\x00\x00b\x00\x00\x00m'
 b'\x93q\x18\x8a7\x83\x1e\x86Kcj\x12+\xe2`\xb5q\xdf\x8d\x82')

{'A1': 3594,
 'A2': {'B1': 35082, 'B2': -7495, 'B3': -1969733255},
 'A3': {'C1': [-0.854251503944397, -0.1996196210384369],
        'C2': 0.223500058054924},
 'A4': {'D1': -0.9928286075592041,
        'D2': 507902640406410583,
        'D3': [{'E1': 197,
                'E2': [127, 71],
                'E3': 62367,
                'E4': 4103,
                'E5': -1727065609},
               {'E1': 2,
                'E2': [0, 170],
                'E3': 64966,
                'E4': 23019,
                'E5': -245014610},
               {'E1': 244,
                'E2': [181, 0],
                'E3': 10231,
                'E4': 4743,
                'E5': 1753520816},
               {'E1': 115,
                'E2': [65, 246],
                'E3': 18271,
                'E4': 29271,
                'E5': -1846231736},
               {'E1': 147,
                'E2': [22, 102],
                'E3': 46025,
                'E4': -21142,
                'E5': -982102382}],
        'D4': -0.8446166515350342},
 'A5': [2473662602, 931339910, 1264806418, 736256181, 1910476162],
 'A6': 2343062894}

(b"ASRD\x99n\xf8'\xd1\t\xc5\xe2\x17\xde\x18\x00\x03\x00\x00\x009=\x7f("
 b'\x9d\xbex\xed\t0\xa7\xda*Q\xa1-\x1f\x00\x00\x00\x07\x00\x92>\xfbP\xaa\x00'
 b'\x00\x00\x05\x00\xae+\xea-\x9e\xbd\xd1\x9f\xf7\xbeV1\x00>\x8a\x86\xd1F~i'
 b'\xbb[-\x80\xd4\x02\xc5WO\x18Fc\xc2 Mw\x84\x95X\xdbY\xe6\xa2\xec\x942\x85\x02'
 b',2i>\x99*\xf8\xa9\xac\xba\xf43\xdcO|\xc6g\xc5\xe2B\xf1\x01\x18\xdb\xa0\x04/v'
 b'\xa1\x1fjv$\xd5\x19DT\xc7\x90Z\x8d\xd8&\x1e\xa9\xa8\x00\x00\x00E\x00\x00'
 b'\x00P\x00\x00\x00[\x00\x00\x00f\x00\x00\x00q\x00\x00\x00|\x00\x00'
 b'\x00\x87\x11P\xb1\xb9\n/\xcc\xbc\xca\xc0*Y\\\x929\xe7\xcbl\nw')

{'A1': 28408,
 'A2': {'B1': 10193, 'B2': 2501, 'B3': -501752296},
 'A3': {'C1': [-0.10235588997602463, -0.20917129516601562, 0.27055981755256653],
        'C2': 0.06229459121823311},
 'A4': {'D1': -0.24309171736240387,
        'D2': 3506010710224219423,
        'D3': [{'E1': 70,
                'E2': [126, 105],
                'E3': 47963,
                'E4': 11648,
                'E5': -738015913},
               {'E1': 79,
                'E2': [24, 70],
                'E3': 25538,
                'E4': 8269,
                'E5': 2005177688},
               {'E1': 219,
                'E2': [89, 230],
                'E3': 41708,
                'E4': -27598,
                'E5': -2063455182},
               {'E1': 105,
                'E2': [62, 153],
                'E3': 11000,
                'E4': -22100,
                'E5': -1158401060},
               {'E1': 79,
                'E2': [124, 198],
                'E3': 26565,
                'E4': -7614,
                'E5': -251586341},
               {'E1': 160,
                'E2': [4, 47],
                'E3': 30369,
                'E4': 8042,
                'E5': 1982125337},
               {'E1': 68,
                'E2': [84, 199],
                'E3': 36954,
                'E4': -29224,
                'E5': 639543720}],
        'D4': 0.4908497929573059},
 'A5': [290501049, 170904764, 3401591385, 1553086951, 3412855415],
 'A6': 736767390}

Вариант №14

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

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

(b'ORR\xb2\x01JjU\x7f\x95W9\x01\xbf\xac\xd5]\xbf\xb2\xcfB=69\x00K\x00]'
 b'\x00Tr\xdc\xd3\x8fE\xb7"\rio\x00\x00\x00\x81wbsjcqohu\x9b\x00\x00'
 b'\x00/\xd3\x9c\xb3\x00\xaaH\xa0\xe1?\xb3\xea\x9c\xbe\x9d\xb2\xea\x89\x94'
 b'b\x8eL\xe8\xd9{$\xe1\xbf\x84\x0fi\xbf\x7f\xfe\x83\xc1\xac\x00\xb0\xb2GO\x8b'
 b'\xd8\xb7\xbf\x8f]o\xbf\x8e\xa9\xe1\xac=\x85\x00\x91\x03\xf2\xa7]\x97'
 b'1\xee@\xd3z\x16|\xe6?o"t*\xeb\x94?I\x9e\xd5\x0cY\x9d$\x1a)Ku\x12\xad$\xf95'
 b'\xaf\xa5J\x08\x00\x00\x00\x85\x00\xf6d\x05\x02\xc9\x12\xa6^$3\xe4g?\xca\x07'
 b'\x00\x00\x00\x8d\x00\xab9A)')

{'A1': 18945,
 'A2': 106,
 'A3': 85,
 'A4': 38271,
 'A5': -0.504781186580658,
 'A6': {'B1': -0.8665416240692139,
        'B2': 0.04756135493516922,
        'B3': 54,
        'B4': [{'C1': -11473,
                'C2': 0.5508158989301708,
                'C3': -0.3064781129360199,
                'C4': [157, 178, 234, 137]},
               {'C1': 25236,
                'C2': -0.5357035881046543,
                'C3': -0.9103929996490479,
                'C4': [127, 254, 131, 193]},
               {'C1': 172,
                'C2': -0.09314795194195358,
                'C3': -0.9350213408470154,
                'C4': [142, 169, 225, 172]}],
        'B5': 29268,
        'B6': 7569744719221085148,
        'B7': {'D1': 6748628663769531709,
               'D2': 12695,
               'D3': 0.7026474379472611,
               'D4': 712254063},
        'B8': 30593},
 'A7': 'bsjcqohu',
 'A8': {'E1': [235, 148, 63, 73, 158, 213, 12, 89],
        'E2': -10,
        'E3': 3372352868,
        'E4': 18,
        'E5': -3873262924707111258,
        'E6': [9373, 10522, 30027, -21230, -1756, -20683, 19109],
        'E7': 692140459}}

(b'ORR\xb2 J_nP\xdb\x9b:\xb9\xbe\xcf\x1eV\xbf\xbd:\xf3>{9\x00K\x00]'
 b'\x00\xfcx\xd5?\x1c\xf8\xbb\x84=6o\x00\x00\x00D\xc9tdqbfdwn\x93\x00\x00'
 b'\x00\x0f\xc7\xac\x0b]OJ\xfb\xe8\xbfR\xba\xbf\xbc<\xbfP*Tj\x12>Z\xc1\xa6:\xee'
 b'?\xac\xfa\xec>a\xa9\xc3\xfdbT\xf0u\x1f\xd7k\x0b\xe8\xbf\xf5%\x7f?\xad'
 b'\xe3\x8c\xa4H\xc0\xd7\xa7B\x14\x9e\xcdf\x0e\xce.n\xca`\xbc\xe9'
 b'\xbf\xf2\x8a\x0e\xddE@\xfen\xe6-Sk\xee`\x8f&l\x9a\x08\x00\x00\x00\x85'
 b'\x00\xb8\xe6\xde\x1e\x986\x852\x0c\xc1U\x8e2u\x03\x00\x00\x00\x8d'
 b'\x00\xc8\x17\xd9\xb9')

{'A1': 18976,
 'A2': 95,
 'A3': 110,
 'A4': 56144,
 'A5': -0.3617752492427826,
 'A6': {'B1': -0.8364076018333435,
        'B2': 0.4750575125217438,
        'B3': 123,
        'B4': [{'C1': -14577,
                'C2': -0.7806750822131696,
                'C3': -0.023404274135828018,
                'C4': [60, 191, 80, 42]},
               {'C1': 27220,
                'C2': 0.9446595932403758,
                'C3': 0.4628499746322632,
                'C4': [97, 169, 195, 253]},
               {'C1': 21602,
                'C2': -0.7513941957110415,
                'C3': 0.9966729283332825,
                'C4': [173, 227, 140, 164]}],
        'B5': 30972,
        'B6': 3908425994483810261,
        'B7': {'D1': -3630441973097709496,
               'D2': 3686,
               'D3': -0.8042453721731933,
               'D4': 3708717810},
        'B8': 51524},
 'A7': 'tdqbfdwn',
 'A8': {'E1': [69, 64, 254, 110, 230, 45, 83, 107],
        'E2': -72,
        'E3': 2552159974,
        'E4': 54,
        'E5': 8444968750235267717,
        'E6': [24814, 9871, -26004],
        'E7': 3118012360}}

Вариант №15

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

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

(b'\xb4TJMBzrqffhw\xf9\x1e\x02\x00u\x00\xf8\x81\t\x87>\xad]\xa2:\x15o\xcc\xaag'
 b'\x95UuKte\xba\xdcL\xfb\xc3;\x94\x8e\x0f\x9diW\xb2H\xac\xe0fB\xbf\x16G\x06'
 b'{\xa57\x07\x00\x00\x00\x1c\x00\x00\x00\x0e;\x0c\xa4\x99\x99 \xa7\xc6'
 b'\xfe\xa5\x1a\xe4\xab\xc1!B3\xf1\x1bD\x1e\xf1uyp\xdd3\xa1[\xe0L^'
 b'\xb6\r\x04\x00\x00\x00J\x00\x00\x00\x8c\xe1\x90#\x00\x00\x00N\x00\x00\x00')

{'A1': 'zrqffhw',
 'A2': 7929,
 'A3': [{'B1': 14121965567454049355,
         'B2': {'C1': -5595887888692767685,
                'C2': 1726000200,
                'C3': [48962, 18198],
                'C4': 933591814,
                'C5': [111, -52, -86, 103, -107, 85, 117]},
         'B3': 14,
         'B4': 3131},
        {'B1': 13955498673442834087,
         'B2': {'C1': -1072344774466125279,
                'C2': 3715135861,
                'C3': [41267, 57435],
                'C4': 230055500,
                'C5': [-92, -103, -103, 32]},
         'B3': -116,
         'B4': 37089}],
 'A4': {'D1': -8,
        'D2': 0.26374438405036926,
        'D3': [173, 93, 162, 58],
        'D4': 21}}

(b'\xb4TJMBiszvsywr\xb3\x02\x00s\x00B\x7f\xf1Y?v\xb9}\x8a\xaf7\xd9\xb1\xdb'
 b'\xa7\xe8)6\xc4\xa06Ay\x89\xc6\xf8\xfc\x8a\xee.C\xab\xd6\xfa\xb5\xa3\xb3R'
 b'"\xba\x02\x00\x00\x00\x1c\x00\x00\x00\x18,\xe2\\\xd7N\xcfl\xa4\''
 b'\xac\xf7\xa5\\\xbd\xef!\xadL\x07Y\x8f8\xefQ\x93\x954\x9d-C\x0c\xa1\xb3'
 b"\xd9\xfa\xf9f\x07\x00\x00\x00E\x00\x00\x00'\x0b'\x1e\x00\x00\x00L"
 b'\x00\x00\x00')

{'A1': 'iszvsyw',
 'A2': -19598,
 'A3': [{'B1': 11584443695128632241,
         'B2': {'C1': -8431590870750772938,
                'C2': 2873306862,
                'C3': [64214, 41909],
                'C4': 3122811571,
                'C5': [55, -39]},
         'B3': 24,
         'B4': 57900},
        {'B1': 12475516039375222700,
         'B2': {'C1': -7831215250818398388,
                'C2': 765277333,
                'C3': [3139, 45985],
                'C4': 1727658713,
                'C5': [92, -41, 78, -49, 108, -92, 39]},
         'B3': 39,
         'B4': 9995}],
 'A4': {'D1': 66,
        'D2': 0.851341187953949,
        'D3': [118, 185, 125, 138],
        'D4': -81}}

Вариант №16

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

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

(b'LAMD\x1e\x15\x00\x00\x00l6\xe3\x00w!\xe4\xbfb\x00\x00\x00\xed\xef1'
 b'\xc5\xd9\x08O\xa6\x8d\x1aa\x00^\xc7>\\\xaf\x94D\xe9\xaa\xb7M\xaa\xf0\xb9\xc3'
 b'ub\x07r\xc38f\xf2\x8c\xb9*\x00.\x002\x006\x00\x98\x851\x87\xe1\x97TN4\xf3'
 b'\xa1\xda\xb0J\xd1\xad\x84\x9a\x14\xee\xf3|\xfd\xb5NO\x08\xf3\xddO'
 b'$\xa8\xe7\x9f\xc7\xaa-\xfbc\xfcnq\x04\x00:\x00\xfc\x04\x00B\x00\xf7r\xf2'
 b'5\x1f\x82\x18\xea\xe3\xad\xf6\xc6\x02\x00\x00\x00R\x00\x02\xe6\xbb\xde\xfc'
 b'\xfd\x07\xbf\xb1v\xabIL\xd7\xda\x0c\x08O\x83\xda\xd5\xde\x84\x03\xcd')

{'A1': {'B1': 3308384237,
        'B2': 27332268423842009,
        'B3': 94,
        'B4': -6131294012300312889},
 'A2': -0.6290850655875153,
 'A3': {'C1': -260088179900047385,
        'C2': 'nq',
        'C3': [{'D1': 19895, 'D2': 61610},
               {'D1': -15431, 'D2': 25205},
               {'D1': 29191, 'D2': 14531},
               {'D1': -3482, 'D2': 47500}],
        'C4': 252,
        'C5': {'E1': [2268169624, 1314166753, 3668046644, 2916174512],
               'E2': 905081591,
               'E3': 31,
               'E4': 130,
               'E5': 2917394968,
               'E6': -14602,
               'E7': [13113775077085977220, 12115896712217251662]},
        'C6': 2,
        'C7': 12807964652715555814,
        'C8': [43894, 19529, 56023, 2060, 33615, 54746, 34014, 52483]}}

(b'LAMD\x1e\x15\x00\x00\x00lt\x07\xc5FL\xde\xbf\\\x00\x00\x00\xb2\x83\xbd'
 b'\xb0\x1d\x8b\xa2k&O,\xc2\x13\xddY~\x93\xb7\xcc\xaaQ\xfb!5+f\xc2\xd5\xffw>'
 b'\xac\x9f*\x00.\x002\x00\x19\xe6\xf1\xa3O\xcb\xad\xbe\xac\x11Q\xd7\xa24\xfah'
 b'H\xde\xbe\x16\x0e\x1ag "\x1ez\xa4#\x1f\x9b\xb41\x96\xadn\x91\x16\x06\x18'
 b'pl\x03\x006\x004\x04\x00<\x00\xdd\x88\x8b\xfc\x1a\x82"\xb8J\xd7\xba%\x02'
 b'\x00\x00\x00L\x00\x88Q\xbc\xfc\xbe\x99\xa9t\xb883\x9f\xe61\x84\xa2\xa0(\xb1'
 b'\xe7\xda\xec\xc3\x14\xd6')

{'A1': {'B1': 2965210034,
        'B2': -4455098904943097059,
        'B3': 19,
        'B4': 5884740951938587101},
 'A2': -0.4734055446732046,
 'A3': {'C1': 1731095920653473329,
        'C2': 'pl',
        'C3': [{'D1': 8699, 'D2': 11061},
               {'D1': -15770, 'D2': 65493},
               {'D1': 15991, 'D2': 40876}],
        'C4': 52,
        'C5': {'E1': [2750539289, 3199060815, 3612414380, 1761227938],
               'E2': -57964323,
               'E3': 26,
               'E4': 130,
               'E5': 3611998242,
               'E6': 9658,
               'E7': [2334863579628363336, 13014029786160963106]},
        'C6': 136,
        'C7': 13291434878076501073,
        'C8': [13112, 59039, 33841, 41122, 45352, 56039, 50156, 54804]}}

Вариант №17

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

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

(b'ZGAC\x02\x00E\x00\x00\x00x\x00\x00\x00\xba\x00\x00\x00\xa3\x9a\xe7b\xf0\xd8'
 b'\xfb\x7fhV\xfb$;e\xf9=\xe9N%\n%<\xc0\xb3\x81\xb8\xa6\xe4\xee9\x82\r\xa9\x88'
 b'\xcc\x05\xb72\xa7s\x84\xecR \x9cns\xd3;\xc0?vjBj\x0c-!\xb6\xe5?v'
 b'\x9d\x15\x15i~\xe5?\x16\x8f\x88\xff$\xe7\r0\xd3?\x8b\x02\x00\x00\x00G\x00'
 b'\x00\x00\xec\xe2\xb4H\x02\x00\x00\x00W\x00\x00\x00\xf8\x88,\xe1\t\x88'
 b"\xe7B]\x90\xfb\x16j\x8aY\x00`n\xb0'\xe1A\xa8?\x96G\x19\x84\xefX\xec?Je"
 b'\xf50\xc5\xd6ewg\x87[\xee\xbfE\x02\x00\x00\x00\x86\x00\x00\x00\x06\xbf{>'
 b'\x05\x00\x00\x00\x96\x00\x00\x00\x1e\\\x19\xb0\xa9\xcd\xeaj\xe8\xf6\x8d\xe8'
 b'\x83\xa3\x9b\x00')

{'A1': 'vj',
 'A2': [{'B1': 10402544276482941228,
         'B2': -1972758789,
         'B3': {'C1': 0.2998080022116416,
                'C2': -117,
                'C3': [0.6784826164105839, 0.6716809665494299],
                'C4': 1219814124,
                'C5': [22, -113],
                'C6': -30472}},
        {'B1': 17791587884632485913,
         'B2': -1551636339,
         'B3': {'C1': -0.9486729641750411,
                'C2': 69,
                'C3': [0.04737762078749763, 0.8858563976339038],
                'C4': 1048297222,
                'C5': [74, 101, -11, 48, -59],
                'C6': 23582}}],
 'A3': -25949,
 'A4': {'D1': -25,
        'D2': [-3998, -1064, 26751, -1194, 15140, -1691, -5827, 9550],
        'D3': -6433249458674457334},
 'A5': 14738215656054451940,
 'A6': -1489848571,
 'A7': 1391232115,
 'A8': 0.12682574402171642}

(b'ZGAC\x02\x00E\x00\x00\x00}\x00\x00\x00\xbc\x00\x00\x00\x19\xe7\xbc\xaf$\xae'
 b'\xf3\xaa\x84\xc4\x8a\x1c\xb8\xd9Q\xfb\xb0\xcf\xdd\xe5\x1e\xf6'
 b'\xef\x06\x13\x86\x9d\xda\xd7\xc1n\xe2\x97\x9c\x86\xbd\xfbj\xfaI\x0eD'
 b'\xd4^\xe5\xa9op^\xe7?rv\\\x05\xcc\x1a\xda\xca\xd0?\x1e\xd4\xcd\xe5\xd4'
 b'\x04\xe9\xbf\xb9\x04\x02L\xed\xf0\xbf\xa8T?NNb\xcf?\xe3\x02\x00\x00\x00G'
 b'\x00\x00\x00w\xf6eR\x07\x00\x00\x00W\x00\x00\x00S\x9d\x9d/\xa8\x99EQd'
 b'3\x98\xd0\xa7\xf4^\x00\x16\xe6i\x04\x9dK\xe1?t\x10\x98T7\xd5\xe7\xbf('
 b'\xfb\xc0\xc03\x1d\x99\x9d\xe8\xbf\xd0\x02\x00\x00\x00\x8b\x00\x00\x00~\x87'
 b'Ur\x02\x00\x00\x00\x9b\x00\x00\x00\xd6a\xea\x90\x0c\xfa\xd0\xdf\xc2.'
 b'|\xf5\x95y\x9d\x00')

{'A1': 'rv',
 'A2': [{'B1': 3703174152977919901,
         'B2': -190328680,
         'B3': {'C1': 0.24518755741761322,
                'C2': -29,
                'C3': [0.2623811017693549, -0.7818397987708783],
                'C4': 1382413943,
                'C5': [-71, 4, 2, 76, -19, -16, -65],
                'C6': -25261}},
        {'B1': 3369501559867871466,
         'B2': 2039870844,
         'B3': {'C1': -0.7692380495409665,
                'C2': -48,
                'C3': [0.5404801450924335, -0.7447773601748069],
                'C4': 1918207870,
                'C5': [40, -5],
                'C6': 25046}}],
 'A3': -6375,
 'A4': {'D1': -68,
        'D2': [9391, -3154, -31574, -30012, -18404, 20953, -20229, -8753],
        'D3': -7095963242359021851},
 'A5': 9699794696225806298,
 'A6': -93652035,
 'A7': 3561229897,
 'A8': 0.7302782231264862}

Вариант №18

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

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

(b'\x8cJJB\x00\x00\x00*\xed\x86R\xef\xd9\xee>^p\xf5\x00\x04\x00\x00\x009'
 b'\xcc>\x14\xca\xa4!\xee\xa0t\xa9\x00\x00\x00l\x00\x00\x00\x9eO5\xca\x9a1B'
 b'\xb2u\xdc?\x0e\xfcU\xdfljnpv#\xbbZjRb\x19\xa1\xa5\xc9p?\xe4Q{'
 b'\xbd\x1e\xd7\xe2\x8c\x8c?:w\x0e\x00\x00\x00\x03\x00\x00\x00=$Z\xd7k\x00\x00'
 b"\x00\x04\x00@\x12Fm\xb7\xcb\x18\x00H\xc5Ro\xc9\x98B\xb5'\xf8\r\xbf\xc2"
 b'?\x81\x91\xe8\xda`\xfc\x7f?\t\xfc\xdf\x00\x00\x00\x02\x00\x00\x00r'
 b'\xea\x90\xc8\xae\x00\x00\x00\x03\x00t\xf5\x87\xad\xc3X\x89\x00z\x17\x10')

{'A1': {'B1': {'C1': 20277, 'C2': -895864510, 'C3': -78, 'C4': 30172},
        'B2': 0.5585377812385559,
        'B3': 57196},
 'A2': 3985003247,
 'A3': -9746,
 'A4': 0.2172277718782425,
 'A5': 'jnpv',
 'A6': -13250,
 'A7': 1498190291698480297,
 'A8': [{'D1': 51992,
         'D2': {'E1': 0.6349466985473067,
                'E2': -29556,
                'E3': 0.7283791303634644,
                'E4': [35, 187, 90],
                'E5': 9306,
                'E6': 55147,
                'E7': [27218, 25113, -24155, -13968],
                'E8': 306605495},
         'D3': 50514},
        {'D1': 22665,
         'D2': {'E1': -0.1425630533646709,
                'E2': -897,
                'E3': 0.5390147566795349,
                'E4': [111, 201],
                'E5': -5488,
                'E6': 51374,
                'E7': [-26558, -19161, -2035],
                'E8': 4119309763},
         'D3': 5904}]}

(b'\x8cJJB\x00\x00\x00*\x06v\r\x02\r\x03>\xc9z\xe2\x00\x04\x00\x00\x009'
 b'j\x1f\xbaPdo\x0c\tB\x8b\x00\x00\x00h\x00\x00\x00\x9b\xdd\xc0\xd3\xd2)\xc6'
 b'\xdaW\xce?{\xf2\xee\x1c\xbddgqj\x93\xbe\xb4\xa1\xf2Md\xbf\xc42.#\x08P\x00'
 b'>\xf0>\xe8FT\x00\x00\x00\x03\x00\x00\x00=\xfbx\x01\xbc\x00\x00\x00\x02\x00@'
 b'.\x99\x83\xf1z\xa7\x00D|\x9b\t\xfd\x17uCp@\xfc\xb1\xbf\xcbA\x8e\x11'
 b'\xae\xcc\xa0]3\xbc\x12\xc1\xa2\x00\x00\x00\x05\x00\x00\x00n.\x91\x01'
 b'\xde\x00\x00\x00\x02\x00s\x8ar\x02\x82\x15H\x00w}\xe6')

{'A1': {'B1': {'C1': -8768, 'C2': -741201466, 'C3': -38, 'C4': 22478},
        'B2': 0.9841755628585815,
        'B3': 7357},
 'A2': 108399874,
 'A3': 3331,
 'A4': 0.3935156464576721,
 'A5': 'dgqj',
 'A6': 27167,
 'A7': -5021403156412022133,
 'A8': [{'D1': 31399,
         'D2': {'E1': -0.15778137884683474,
                'E2': 16112,
                'E3': 0.45366156101226807,
                'E4': [147, 190, 180],
                'E5': -1160,
                'E6': 444,
                'E7': [-24078, 19812],
                'E8': 781812721},
         'D3': 31899},
        {'D1': 5448,
         'D2': {'E1': -0.2129380785314412,
                'E2': 23859,
                'E3': -0.00895729847252369,
                'E4': [9, 253, 23, 117, 67],
                'E5': 11921,
                'E6': 478,
                'E7': [28736, -847],
                'E8': 2322727554},
         'D3': 32230}]}

Вариант №19

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

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

(b'@DTZEEojp\xa9,\xef?\xf4\xe8\xee\xb4\xb1\x07\x00\x18\x00m\x00genexxi,'
 b'P\x94\xadj>\xd5\xa1cO\x94\xd8\x8c\x92\xdd:u\xbf&\xef>U\x8b\x8c\x93'
 b"\xed\x8c\x17\xb66\x1a\xea\x9b\xe2'\xa6W\xd3\x04\x00\x00\x00\x1f\x00\x00"
 b'\x00"\x8a\x16?\xc62tM\xf7\xee\xb7\x84\x95W\xf4\xba\x86\xb5\xa6*\xa7\x97\x0e'
 b"[\x03\x00\x00\x00'\x00\x00\x00\x02\x00\x00\x00-\x00\x00\x00\xb2GL\x99i\xf3")

{'A1': 28485,
 'A2': 106,
 'A3': 43376,
 'A4': -5641621748890734804,
 'A5': 'genexxi',
 'A6': {'B1': [{'C1': -0.9579294323921204,
                'C2': 17119181138623917862,
                'C3': [6028, 14006, 59930, 58011, 42535, 54103],
                'C4': [20524, -21100, 15978, -24107]},
               {'C1': 0.5880452394485474,
                'C2': 9563375079668331206,
                'C3': [22421, 47860, 46470, 10918, 38823, 23310],
                'C4': [20323, -10092, -28020]}],
        'B2': {'D1': 18354, 'D2': 4083784012}}}

(b'@DTZE\x99\x7f\x86\x80\x13\xeeT\xd1]\t\xb4\xda\x84\x04\x00\x18\x00h\x00nven'
 b'\xe5\xfd\xe8\x18\xff\x18V\x8b\xe8\xbc\xc2U\xd8<~> \xaeJ-{\x9c$Sdx[\x8a'
 b'\xc4\xec\xbeAouS~\x02\x00\x00\x00\x1c\x00\x00\x00B2\xae>+\xac\x19\x8c'
 b'\xd9=3\xfc\x1c-P\xb9\xeb8\xa1\x81\xe1H\nS\x04\x00\x00\x00 \x00\x00\x00'
 b'\x02\x00\x00\x00(\x00\x00\x00\xfd\xc3\xda.\xec\x8f')

{'A1': 32665,
 'A2': 134,
 'A3': 4992,
 'A4': -8873582163458435858,
 'A5': 'nven',
 'A6': {'B1': [{'C1': 0.24827897548675537,
                'C2': 5991085457164381728,
                'C3': [30820, 35419, 60612, 16830, 30063, 32339],
                'C4': [-539, 6376]},
               {'C1': 0.3402271866798401,
                'C2': 18172936925937773611,
                'C3': [11548, 47440, 14571, 33185, 18657, 21258],
                'C4': [6399, -29866, -17176, 21954]}],
        'B2': {'D1': -15363, 'D2': 2414620378}}}

Вариант №20

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

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

(b'BEK\x00\x00\x00E\xe7\x9c~\x11v\x92D\x10I\x15\x99\x03\xfb\xe4\x00\x05\x00'
 b'~\xbf\xe3J\x82\xc3#\x0f\x00\xbf\xe5h0nR)\x08\xbf\xe1\xde \xbe\xc8!'
 b'\xb6\xbf\xdbW\x90\r\x19Ep\x04{\xd4\xc1\xf8\x13\x9cH\x80\xea\xff'
 b'\x15\xb2\x0c\x98\xcf\x10\xa1\xae\xber\xbe\x1e$\xbe\x0e\xb7\xe6\xfb\xf4G'
 b'J\xaf\x81?XY/\xd2{1\xed\xf0.>Sf\xe9\xd1n\xcf\xfe\x06\xbe\xbe\xc8`\xe6\xc4'
 b'\x05}\xb8\xda\x17\xbfI\x8cS\xe3\x00L\x00V\x00`\x00j\x00t')

{'A1': {'B1': [-78, 12, -104, -49, 16, -95], 'B2': 174},
 'A2': 231,
 'A3': -1669459594,
 'A4': 146,
 'A5': 4904500351316786148,
 'A6': {'C1': [{'D1': [190, 114, 190, 30, 36],
                'D2': -0.13937339186668396,
                'D3': 251},
               {'D1': [244, 71, 74, 175, 129],
                'D2': 0.8451108336448669,
                'D3': 210},
               {'D1': [123, 49, 237, 240, 46],
                'D2': 0.20644725859165192,
                'D3': 209},
               {'D1': [110, 207, 254, 6, 190],
                'D2': -0.39136427640914917,
                'D3': 196},
               {'D1': [5, 125, 184, 218, 23],
                'D2': -0.7872974276542664,
                'D3': 227}],
        'C2': {'E1': -0.6028455554264553,
               'E2': [-0.6689684061723549,
                      -0.5583652235227905,
                      -0.42721940306827033],
               'E3': 75224257}},
 'A7': -570940892531458283}

(b'BEK\x00\x00\x00E\xdd\x08\x86"\xe6np\x89N-o\x1d\xd0\xfd\x00\x04\x00'
 b't\xbf\xd5\xb0\x8d\x88srD\xbf\xc5&q6\xfa\x19x\xbf\xd3\x82cl(\xcf8\xbf\xd0\xab'
 b'P\x16R\xc4\xf4\x1e0kc*\xcc1\xb8\x0c\xe1\xb1\x8aa\xe3\x078\xf4\xecl'
 b'\xa0K\x0e\xd8-\xbfS_ C\xd8\x11\xa3\xa8\xa2\xbd~\x81\xbb3\x82\xb5\xfb\x0c'
 b'`\xbfC\x9f`\x90IEh@\xbf?Z\t\x12<\x00L\x00V\x00`\x00j')

{'A1': {'B1': [97, -29, 7, 56, -12, -20], 'B2': 108},
 'A2': 221,
 'A3': 143008486,
 'A4': 110,
 'A5': 8109098561102008573,
 'A6': {'C1': [{'D1': [160, 75, 14, 216, 45],
                'D2': -0.8256702423095703,
                'D3': 67},
               {'D1': [216, 17, 163, 168, 162],
                'D2': -0.06213543936610222,
                'D3': 51},
               {'D1': [130, 181, 251, 12, 96],
                'D2': -0.7641506195068359,
                'D3': 144},
               {'D1': [73, 69, 104, 64, 191],
                'D2': 0.8517009019851685,
                'D3': 60}],
        'C2': {'E1': -0.33890093159951484,
               'E2': [-0.16523566421910707,
                      -0.304833274483133,
                      -0.2604561059952879],
               'E3': 506489699}},
 'A7': 3083894511401808266}

Вариант №21

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

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

(b'\xbcJHD>\xab9\x9dL?\x15D\x07=\x00#\x00\x00\x00O\x1ckO\x00\x00\x00\x04\x00'
 b'm\xc7+B~sp\xa1\xfe\x19\x94\x00\x02\x00!\xf7\x0b\t\xa3\xbeO\x1c\x18?'
 b'\xe2\x9bmx"\xde\xb2\xbf\xea\x93^\x9e\xbdYr?\xed\r\x80H\xf8\x8cp\xe5'
 b'/\xf2+\xf1%\x9c\xb4\x9e\x98\xb3\xc9\x87\xaa\xf0\xf8\xfeNY\x96i[C\t+'
 b'\xb1(\xa7\xcfkPl(\x06#\xe4Z\xf8')

{'A1': [{'B1': 0.3344239294528961, 'B2': 76},
        {'B1': 0.5830692648887634, 'B2': 61}],
 'A2': {'C1': -1577182828,
        'C2': 'sp',
        'C3': 4144695715,
        'C4': -0.20225560665130615,
        'C5': [0.581473097458874, -0.8304894543060029, 0.9078980851376297],
        'C6': -449842645},
 'A3': {'D1': 241,
        'D2': 2710239669029947783,
        'D3': -6129125321731369367,
        'D4': 6576109964151531471,
        'D5': 1800432680,
        'D6': 6},
 'A4': 28,
 'A5': 27471,
 'A6': [35, 228, 90, 248],
 'A7': 3341501054}

(b'\xbcJHD\xbf?,\x0eN\xbe\x82\xd6\n;\x00#\x00\x00\x00O\xdc\xf1\x0c\x00'
 b'\x00\x00\x02\x00mx(`Ytw\xa8x,\x15\x00\x02\x00!o\xa75\xd9\xbf2\xf0\xb8?'
 b'\xea\xe8\xa4\x0f\x9dh0?\xd8\x05c\x92\xf4\x16\x98?\xabi\xbfN\x0e\xfa\x00\xc3'
 b':\xc8\xa7br\x81\xd6\xcdl\xc0\xdf\xa7\x86V\x04^\xbd\xf9\xe0\x91\x107\xac\xd4'
 b'\x8b\x13\x10\x86R\x8c\xcd\x94\xf3N/')

{'A1': [{'B1': -0.7467659711837769, 'B2': 78},
        {'B1': -0.2555392384529114, 'B2': 59}],
 'A2': {'C1': -1468519403,
        'C2': 'tw',
        'C3': 1873229273,
        'C4': -0.6989855766296387,
        'C5': [0.8408985428789091, 0.37532891608166485, 0.053541162756562954],
        'C6': -1019557721},
 'A3': {'D1': 98,
        'D2': 8251112170100678567,
        'D3': -8766814819669385071,
        'D4': 1168592657192259718,
        'D5': 1384959380,
        'D6': -13},
 'A4': 220,
 'A5': 61708,
 'A6': [78, 47],
 'A7': 2015912025}

Вариант №22

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

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

(b'\xd5BHU\x00p?\xe3ZN\xdf\xdb\xb7$?\xba\xd6\x06\xa8\x7f\xfePg\xbf\xea:\x00\xd1'
 b'D\xd7\xe0\x18I\xcaI\xe5\x8dT\xfe\xddpkpil\x86?\xedbG\xec\xb4\xa3~k\xb9'
 b'[\xf7=\xa5\x1aP\xb3ybjro\x80\xf6I\xd0\xfd\xbf\xd5\x8f#\x9b\x81\x89\xb4{\xb82'
 b'e\x00\x00\x00\x02\x00\x00\x00st\x00\x00\x00\x02\x00{\xac*\xe7tI\xd8\xc7\xde'
 b'\xc40V\xda\xf1\x16P?Al\x1a>\x80\x0e.\xac\x8b')

{'A1': {'B1': 61718, 'B2': 80},
 'A2': 0.604773938391848,
 'A3': 0.10482827771920111,
 'A4': 103,
 'A5': [{'C1': -0.8195804679187368,
         'C2': {'D1': 407489097, 'D2': -443722498, 'D3': 221},
         'C3': 'pkpil',
         'C4': 134},
        {'C1': 0.9182471869618067,
         'C2': {'D1': 1807309815, 'D2': 1034230352, 'D3': 179},
         'C3': 'ybjro',
         'C4': 128}],
 'A6': {'E1': 4132032765,
        'E2': -0.33686151682027377,
        'E3': 2075669093,
        'E4': [0.7555557489395142, 0.25010818243026733],
        'E5': 116,
        'E6': [-84, -117],
        'E7': 44074,
        'E8': 231},
 'A7': [116, 73, 216, 199, 222],
 'A8': 3291502298}

(b'\xd5BHU\x00p?\xcc\x0e\x93Kw\xa3\xe0?g\xd0\xf9\xb0\xcb\xae\x00\x1b?'
 b'\x92\x9aX\x924\x0e@\xa4\x0c\xa9\xc8+\xff\xc5\xd1\xd5ldqub1\xbf\xef'
 b'\x9f\xda\xc9\xcf\x08J\x93k4\xdd\rc\x86\x9d\x99haeyd\x8c\xb1\xbdG\x9a?\xdcT'
 b'S7\xe8\x86@\x83:Z\xac\x00\x00\x00\x02\x00\x00\x00sd\x00\x00\x00\x06\x00{'
 b'g\xd5F\xce\x17\xcdK\xb1\t\x1al\xdf\xf6\xed\xc4?P\xd0!\xbf\x13\xd6O\xa2'
 b'\x9b\xee.\xd4\x15')

{'A1': {'B1': 63213, 'B2': 196},
 'A2': 0.21919480500153465,
 'A3': 0.0029072644014058735,
 'A4': 27,
 'A5': [{'C1': 0.01816690819124589,
         'C2': {'D1': 2752293320, 'D2': 738182609, 'D3': 213},
         'C3': 'ldqub',
         'C4': 49},
        {'C1': -0.9882635060860221,
         'C2': {'D1': 2473276637, 'D2': 224626333, 'D3': 153},
         'C3': 'haeyd',
         'C4': 140}],
 'A6': {'E1': 2981971866,
        'E2': 0.4426467939357259,
        'E3': -2093327700,
        'E4': [0.8156757950782776, -0.5774888396263123],
        'E5': 100,
        'E6': [-94, -101, -18, 46, -44, 21],
        'E7': 26581,
        'E8': 70},
 'A7': [206, 23, 205, 75, 177],
 'A8': 152726751}

Вариант №23

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

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

(b'STT\nbg<\x00g\x00\x92\x00 x\xd42\xf5\xd1\xa67i\xe1\x18\xa9}\xa0B&\x97$)\xbe'
 b'\x85\xf7z\xf8L\xa9\xf4l\xd65\xe5V<\x16\xd2\xd1\x18OM\xc9\xf8\xac\x14!'
 b'\xfd\xaa\xf9q\x97\xd4.A\xd7q?\xa5\x19\xcc\x02\xe1\xbd\xd2\xfe\xd9?.\x00\x00'
 b"\x00\x94\xc0\xa5\xc7\x1e\x98E Voz\xfe\xc2\x0c\xe1\xa4\x0f\xf6J'\xf3\xd5\x13"
 b'\xab\x9b2\x96\xc0E\xc9\xeb\x1cWX\xbf\xb0\xd0\xe1\xbfY\x00\x00\x00\xbf\xf1zV'
 b'Z\x95\xb3\x17\xc5\xf0l\xf5\xb6\xcb\xb8@\x10B\xd2\x86\x9f29O\xc8\x19ka'
 b'\x90\xc7(\x9cAL\xa4\x928\xd2\xbf\x84\x00\x00\x00\xf6\x03\xae\x7f\xc1J)\xb8')

{'A1': 'bg',
 'A2': [{'B1': {'C1': 1093588119,
                'C2': -1522568745,
                'C3': 25,
                'C4': 0.4061781744276629},
         'B2': {'D1': 1327026642, 'D2': -14003, 'D3': 8212783399645261048},
         'B3': [3349528724, 541431838]},
        {'B1': {'C1': 849062675,
                'C2': -918175594,
                'C3': 235,
                'C4': -0.5567249047478273},
         'B2': {'D1': -25530538, 'D2': 3266, 'D3': -3030034921380928287},
         'B3': [1450897855, 397645146]},
        {'B1': {'C1': 432557881,
                'C2': -946839189,
                'C3': 40,
                'C4': -0.2847029308768698},
         'B2': {'D1': -177409851, 'D2': -13386, 'D3': 3647782460803006648},
         'B3': [2142110710, 3089713857]}],
 'A3': 30752,
 'A4': 16242574720715010772,
 'A5': [2636618174451001624, 12199398697662266921, 1602251109887798516]}

(b'STT\nkg<\x00g\x00\x92\x00L$X1\xc7\xa0s\x1e1\xe6\xa0\x9bSU\x8f\xbd-\xfe?\x13'
 b'\x01\x9cC\x087\xd5E\xb7R\xbe\x1c\x91i\x06\xc6\xae3a\xf8U\x85fMF\x08L\x9eE'
 b'\xdf\xfc\x1f-\xf3\xe10\x9fY4,$\xff\xc8\xc9\xd1\xbf.\x00\x00\x00\x80\xeb\xde'
 b'\n\t\x89\xe0\x8a)\x8d\xcb\x92[\x06\xfd\xcd\xed\xdfM.\xa2@U:\xb18\x95'
 b'@\x9e\x00\x89\xc8\x90+\xc9\xc9@\xc5\xbfY\x00\x00\x008\xfa\x0eq'
 b'\xe5\x12\xd0\x13\x03\xa6LK\x99\xf2\x17\x9b\xc9\xc4e\x02\xbb\xe6\xa1\xfa'
 b'\xb8\xc2\x06\xea\xb1\xf5\xde\x86Zs\xe8\xb9@\xe2\xbf\x84\x00\x00\x00`\xf9w\rI'
 b'\xa8\xfa&')

{'A1': 'kg',
 'A2': [{'B1': {'C1': 757071071,
                'C2': -1624186381,
                'C3': 89,
                'C4': -0.27794098774092224},
         'B2': {'D1': 1630777030, 'D2': 22008, 'D3': 5016530633360238213},
         'B3': [182381440, 2329970953]},
        {'B1': {'C1': 951138901,
                'C2': 10371221,
                'C3': 137,
                'C4': -0.16603967974436373},
         'B2': {'D1': -1832153815, 'D2': 1627, 'D3': 4657335876658777597},
         'B3': [1896806968, 332403429]},
        {'B1': {'C1': -1028064607,
                'C2': -172889594,
                'C3': 222,
                'C4': -0.5704011478472502},
         'B2': {'D1': 1263314435, 'D2': -3431, 'D3': -1820858988224734441},
         'B3': [225966432, 653961289]}],
 'A3': 9292,
 'A4': 16587072384549728600,
 'A5': [18315503682895190944, 15363757740270883647, 462059989420390213]}

Вариант №24

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

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

(b'sZXL=\x02\x003\x00\x00\x00\x04\x00\x00\x00]\x00\x00\x00\x03\x00\xbd\x00\x00'
 b'\x00\xc3\x8fP\xdd7X\x9d\x99\xd6?\xba\xd5/W\xa2\x0fZ%\xf3U\x00i\xb4J\xd3\x83t'
 b'np\xa6\xb7\xf8o\x14.u\x168\xa7\t\xebv\xba\xe8\x8b\xec\x99qo\x95n'
 b'\x1d\xebT\xcb\xfc{\xf4\xc7\x86XVLd\xdc\xbdk\x13\x02\x00\x00\x005\x00\x00'
 b'\x00\x9a\xba\xaa>\x02\x007\x00\xec\xc07\xa7\xf9\x13\xe7\xbf\x02\x00\x00'
 b'\x00?\x00\x00\x00\xc8y\x079\x02\x00A\x00\x80\xd8t\xcb\x01\xc8\x95'
 b'?\x02\x00\x00\x00I\x00\x00\x00H\x16\xe0\xbe\x02\x00K\x00\x84\xba\xaf'
 b"'\xdf \xe8?\x02\x00\x00\x00S\x00\x00\x00Z\xd4\x81\xbd\x02\x00U\x00\xf0O\xc8"
 b'E\xdcT\xda?\x1b\xc2m')

{'A1': 61,
 'A2': 'tn',
 'A3': [{'B1': [112, 166],
         'B2': 0.3334549069404602,
         'B3': {'C1': [342882487, 940995886], 'C2': -0.7211883798572933}},
        {'B1': [167, 9],
         'B2': 0.00012919970322400331,
         'B3': {'C1': [3904534251, 1905912971], 'C2': 0.021270778697008996}},
        {'B1': [111, 149],
         'B2': -0.4376699924468994,
         'B3': {'C1': [1424694638, 4101766347], 'C2': 0.7540126586080338}},
        {'B1': [199, 134],
         'B2': -0.06339330971240997,
         'B3': {'C1': [1682724440, 325828060], 'C2': 0.41142947020239173}}],
 'A4': [27, -62, 109],
 'A5': {'D1': -28733,
        'D2': 0.3531258927827894,
        'D3': 2691480917229163962,
        'D4': 9499018177770706419}}

(b'sZXL\x05\x02\x003\x00\x00\x00\x03\x00\x00\x00S\x00\x00\x00\x07'
 b'\x00\x9b\x00\x00\x00-\xb1\x80\xa2W\xd2\xb4\xd1\xbf\xbf#\xcbe\xb7\xb4'
 b'\xdf\xea\xd4\x8c\xa7F=\xe6\xa7\xea\xa2woya\xc6S)\xb9\xec`;\x18\xe9'
 b'\xd3\x12\x97\x8a\x8a\xe1\x8aR\xa4Chb\x87\xe1\x88u\xa7\xfaf\x02\x00\x00\x005'
 b'\x00\x00\x00\x83D\x05\xbf\x02\x007\x00\xaa\xe5y\xec\xff\x81\xec\xbf\x02'
 b'\x00\x00\x00?\x00\x00\x00\xd4\xb8\xf8\xbe\x02\x00A\x00xO+\x81\x9b'
 b'\xb9\xd0\xbf\x02\x00\x00\x00I\x00\x00\x00\xf7\xdc}?\x02\x00K\x00t'
 b'\xd6\xb0\x88\xc6;\xe0\xbf6\x98!\x15\x84\xd0\xdd')

{'A1': 5,
 'A2': 'wo',
 'A3': [{'B1': [121, 97],
         'B2': -0.5205766558647156,
         'B3': {'C1': [3106493382, 406544620], 'C2': -0.8908691042590153}},
        {'B1': [233, 211],
         'B2': -0.4857851266860962,
         'B3': {'C1': [2324338450, 2756872929], 'C2': -0.2613285790841853}},
        {'B1': [67, 104],
         'B2': 0.9916529059410095,
         'B3': {'C1': [2296481634, 1727702901], 'C2': -0.5072968168012282}}],
 'A4': [54, -104, 33, 21, -124, -48, -35],
 'A5': {'D1': -20179,
        'D2': -0.12429361472426059,
        'D3': 15342321047855024931,
        'D4': 11739379986006976396}}

Вариант №25

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

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

(b'WUGV\x98\x00\x00\x00\xe7\xc5N\xbf\xad\x9b\xdd\xe9\x9ex\xfa\x9f\x18\x00\x8d]'
 b'\xf2\xf0\xe8\xbfZ\xf7\xdc}\x18\x99~L|\xbe\x02\x00\x00\x00\xb4\x00\xef4\x106'
 b'Pr\x030\xba\x18\xfe\x04\xa0\xf6\xc9\x17Z\xaf\x88[\xf5-\xc2.\xebnNFS\xcd8\x16'
 b'm\x00vB\x0f\xf4\x0c\xab\xb8T\xfb\xfb\xf8\xd8}\xab\xf9\x94\xd7\x13'
 b'\x9e\xb6\xa2\xae\xdeX@\x07>\x00\x00\x00S\x00\x00\x00\tJ\xfd\x8f\xe1\xdd`\x8f'
 b'>\xb7\xf3\xdc\xdd\x98Y~\x15#\xd9D\xe2\x83\x87\xb2\xa6\xde?\xed'
 b'\x03\x00\x00\x00p\x00\x00\x00\x03\x00s\x00sp\xe3N\x11\x0e\xb0='
 b'\xde\x87\x02\x00h\x00\x00\x00y\x00\x00\x00\xb8n\xecR/\x92\xea\xbf'
 b'\xfb\xec\x05\xab')

{'A1': {'B1': 28787,
        'B2': 20195,
        'B3': 1034948113,
        'B4': 34782,
        'B5': [{'C1': 136,
                'C2': 62811,
                'C3': 6000569791816843821,
                'C4': 1099571003234072781,
                'C5': 3316},
               {'C1': 171,
                'C2': 21688,
                'C3': -7711944329895805957,
                'C4': 6403747734039172055,
                'C5': 1856}],
        'B6': {'D1': 1548773834954175415,
               'D2': -9949,
               'D3': 0.4789244006529183,
               'D4': 237,
               'D5': [9, 74, -3],
               'D6': [57743, 24797, 16015]},
        'B7': -0.8303448314286106},
 'A2': {'E1': -0.8077072501182556,
        'E2': -6919085253577565267,
        'E3': -0.7794124438441967,
        'E4': 2111633242},
 'A3': -26344,
 'A4': {'F1': -0.24638554453849792,
        'F2': [-4869, -21755],
        'F3': 907031791,
        'F4': 805532240,
        'F5': 186,
        'F6': 24,
        'F7': -5811306212974656258}}

(b'WUGV\x9a\x00\x00\x005\xe1n\xbfT%\x13\xb1\xe2\xe7\xf4\xf4\xe0+a\x02'
 b'5\xe0\xef\xbf<@\x13\xe0a\x9e\x84\xb4Z\xbf\x02\x00\x00\x00\xb6\x00Z.\x848'
 b'\x1da\xd0\xa9r\xf33Z\xb7\xf3x\xf5\xae\xc9\x19\xae\x17J\xd9\x8cU\x91\xc4\xb2'
 b'\xee\x0c\xccO\x04\xedF1\xb2w\xb7\x9b\xeb\xce\x9cY\xed\xde\xf6b'
 b'\x80\x0b\xd4\xccS\xd6u|+\xac\xb2\xf7>\x00\x00\x00S\x00\x00\x00\xe4\xa4M\x18'
 b'\xc2"^Y\x98HS]\xb9\xba\x85d\xc8ce\xb2\xb8x\x8a\tP\x9b\x9d\xed?T\x05\x00'
 b'\x00\x00p\x00\x00\x00\x03\x00u\x00%\xc9\xe7\x08\x16\x98\xf21\xbc&'
 b'\x02\x00h\x00\x00\x00{\x00\x00\x00\x00n\x99w\xe6\x1b\xd1\xbf3\xdb\x88\xf4')

{'A1': {'B1': 51493,
        'B2': 2279,
        'B3': 837982230,
        'B4': 9916,
        'B5': [{'C1': 25,
                'C2': 6062,
                'C3': -1246718018343610038,
                'C4': 12840121996403526668,
                'C5': 46967},
               {'C1': 155,
                'C2': 52971,
                'C3': 828771143877745052,
                'C4': 12406146444070997204,
                'C5': 63410}],
        'B6': {'D1': 7305903354590968157,
               'D2': -18254,
               'D3': 0.9254890979030526,
               'D4': 84,
               'D5': [-28, -92, 77, 24, -62],
               'D6': [24098, 39001, 21320]},
        'B7': -0.2673278968775037},
 'A2': {'E1': -0.9331238865852356,
        'E2': -795756273318288044,
        'E3': -0.99611902680169,
        'E4': 3759358012},
 'A3': -24991,
 'A4': {'F1': -0.8543169498443604,
        'F2': [-9421, -2936],
        'F3': 948186714,
        'F4': -1445961443,
        'F5': 114,
        'F6': 243,
        'F7': -3913921126304622029}}

Вариант №26

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

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

(b'GXE\xf7\x02\x00\x00\x00M\x00\x86\xee.\xb8S\xa5\x08\x12\x07$\xd7\x88\xef\xac'
 b'\xc35\xef@\xd8}o\x004\x06\x00\x88\x00je\xec$\x82\x90\xa3R\x8e\x1e\xe5'
 b' \xd0\x8e\xaa\x05\xb7\xec\xc7?\x9d\x1d\x0e\xe1\xa4I\x14(l\xbd.\xc4`A\x87'
 b'\xff\n\x96\xb8\xbfmvryvkh\x01\x0ff=%\x00.\xa2\xaa\xa4srutzjc=\x05C?9\x00\xf8'
 b'v\xa0{\xa6e\xabr\xe6j|\x1e\xec&?\r\xb0\xb0\xb3\x90\xec\xc8\x9a\xbd['
 b'\x045\x17?1\xf9\xb9\xbc\xf5\xb4\xc6>\xc0r\x86=&$\xdc\xbe\x87R\xd3>\x0fv\x12?')

{'A1': [{'B1': 'mvryvkh',
         'B2': 0.05616665259003639,
         'B3': {'C1': [25962, 9452, 36994, 21155, 7822],
                'C2': 8421,
                'C3': 0.18691146637603717},
         'B4': 2762646062},
        {'B1': 'srutzjc',
         'B2': 0.7617986798286438,
         'B3': {'C1': [7581, 57614, 18852, 10260, 48492],
                'C2': -15314,
                'C3': -0.09603947390065093},
         'B4': 2074113784}],
 'A2': 1299470271487340166,
 'A3': [2295800839, 902016239, 2111324399],
 'A4': {'D1': 2196748256248817062,
        'D2': -8019872241233746196,
        'D3': -20,
        'D4': 1539152584,
        'D5': 0.5906527042388916},
 'A5': 52,
 'A6': [-0.02270183153450489,
        0.38809934258461,
        0.06564855575561523,
        -0.42996329069137573,
        0.41273900866508484,
        0.5721139311790466]}

(b'GXE\xf7\x02\x00\x00\x00M\x00u\xd9f\xb0U\x8a\xb3\xf6$\xf6E\x87 \x8b'
 b'\t\x8f<\x96\x18\xedo\x00\xc8\x05\x00\x88\x00\xa9\xf5l\x9d\xde\xbb\xf8'
 b'\xb4\n9_\x85,0\x935I\xb4\xd5\xbf\x90\x06AsO\x157\x83z:\xb3\x05\x08\xe23'
 b'\x8c\x08\xdf\xd1?zpmsxxw\xa92\x00\xbf%\x00mp\xbd\x9cmfkzkmw`\x84\xee'
 b'\xbe9\x00}\xb8\x19\x18?\xc5\xa00(l;\xed\xff\xb8c\x1d1\x87\xa7\xd6\xbf'
 b'~\x87\xf2\xac\xd5\xeat?IgP\xbfE\xa0\xcc\xbe\xfa)8=\xd1\x05n\xbf\x9f\x1bC?')

{'A1': [{'B1': 'zpmsxxw',
         'B2': -0.500773012638092,
         'B3': {'C1': [62889, 40300, 48094, 46328, 14602],
                'C2': -31393,
                'C3': -0.3391287825768383},
         'B4': 2629660781},
        {'B1': 'mfkzkmw',
         'B2': -0.4658536911010742,
         'B3': {'C1': [1680, 29505, 5455, 33591, 14970],
                'C2': 1459,
                'C3': 0.2792378777662923},
         'B4': 404338813}],
 'A2': 17776704254797863285,
 'A3': [2269509156, 2399767328, 3977811516],
 'A4': {'D1': 17094375730485183807,
        'D2': -2979263983466071809,
        'D3': -65,
        'D4': -1393391746,
        'D5': 0.9567082524299622},
 'A5': 200,
 'A6': [-0.8140760064125061,
        -0.39966025948524475,
        0.04496190696954727,
        -0.9297762513160706,
        0.7621402144432068]}

Вариант №27

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

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

(b'%FMIR\x9a\x85i\xd88\x00\x00\x00-\x004\xa8\xc2\xe2\x93\xd1\xbf\xd5n'
 b'\x81\xb0\xf9\xc8O\x03\x00P\x00\x02\x00\x00\x00\x81\x00\x00\x00W\xc4\x17'
 b'\xbf\x07\xc6\xec\xccqjutlgiZ|\xfe\x16\x07\x001\x00\x04\xdbV\x0b*V\xea?'
 b'n\xce\x83u\xd6h\xe6\xbffjf/v\x18\xf6\xe4`._\xfd\xa8\x1c\xb8u\x15\xf6\xb4 '
 b'-0\x196\x0f\x10\xe2:\x81\xbb\x1av[\xe8\xdbc \xcbz\x8d\xb6k\x8e\xfe\xdfb\xa0Q'
 b'\x9aS\x00j\x00')

{'A1': 3630794138,
 'A2': {'B1': {'C1': 385776730,
               'C2': 'qjutlgi',
               'C3': 0.8230180951566983,
               'C4': -0.7002975745403555},
        'B2': 45,
        'B3': -0.27465123185612583,
        'B4': 28373,
        'B5': 45185},
 'A3': -7,
 'A4': 20424,
 'A5': 'fjf',
 'A6': [{'D1': 30255,
         'D2': 24,
         'D3': 2065179014391194870,
         'D4': 30136,
         'D5': 62997,
         'D6': 1157203111067852980},
        {'D1': 15074,
         'D2': -127,
         'D3': 2333950822921411259,
         'D4': 31435,
         'D5': 46733,
         'D6': 11119845301479706219}],
 'A7': -0.5928396582603455,
 'A8': [-14841, -13076]}

(b'%FMIRn\xdd\x92\xb74\x00\x00\x00\x9c\x02\x7f\xa8\xe0\x0e\xb5\xeb\xbf R'
 b'\xb37\x15\xd1\xd1\x04\x00L\x00\x02\x00\x00\x00~\x00\x00\x00z\xb3/'
 b'\xbf[\xc6\x8d=xrhrKb\x1a\x03\x001\x00\\\xb4\x81\x9c\xdf\xf8\xd8?`\x0f\xac,'
 b'Y\xe9\xa6?lcmf3\x8dWHC{\x1fI\xa5IS+m\xb5\x01\x93rI\xf4\x99\xd6?n\xbb'
 b'\xdd\x0f\xfa\x92\xe2\xaam\xd6\xf5\xdc(~M\xbe\xf7Q\x04\x8eR\x82A\x18P\x00'
 b'g\x00')

{'A1': 3079855470,
 'A2': {'B1': {'C1': 442649458,
               'C2': 'xrh',
               'C3': 0.3901900318513236,
               'C4': 0.04474905653299177},
        'B2': -100,
        'B3': -0.8658518207411989,
        'B4': 21024,
        'B5': 14259},
 'A3': 21,
 'A4': -11823,
 'A5': 'lcmf',
 'A6': [{'D1': 36147,
         'D2': 87,
         'D3': 6001509711927264072,
         'D4': 27947,
         'D5': 437,
         'D6': 7944304224421638803},
        {'D1': 56763,
         'D2': 15,
         'D3': 15921867824145011450,
         'D4': 32296,
         'D5': 48717,
         'D6': 1747821421478040055}],
 'A7': -0.6863323450088501,
 'A8': [-14757, 15757]}

Вариант №28

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

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

(b'MVH/\x02\x00h\x00\x00\x00O\x04\x00p\x00\xf3R\x0eY>\x02\x00\x00\x00'
 b't\x00\x00\x00\x84\x00\x00\x00\xe2r\xa0\xc3\xefR\x17=yo\xe1\xb6'
 b'\xe4\x04\xa8\x9fD>\xf5\xfb\x02\x00\x00\x00(\x00\x00\x00\x1e\xb3\xf3\x8b'
 b'\xe1\xe7\x8b\xb5>\x9aivptl|\xd3\xdd0\x85\x01\xb3\r\n\x85\x04\x00\x00'
 b'\x00G\x00\x00\x00<q&X\x9e\x13\xf7\xfc\x94\xfa\xbe*\x00\x00\x00K\x00\x00\x00'
 b'rqxwF\xe57MD\x1cO>m\xa1\xfdg\x84i+\xb0\xd8\xdc\ng\x8e\xa3\xf47$\xda\xcd\xe3'
 b'\x1e(\x1f\x86K\xe7\xec\x18v\x0f\xf3\x98\xe6\x1e\x95\x10E\xaeo\xf4^^4\xb3'
 b"'\xe2\xbf")

{'A1': [{'B1': {'C1': 82097889, 'C2': 40872},
         'B2': -67813820,
         'B3': 'yo',
         'B4': 30,
         'B5': -77,
         'B6': -13,
         'B7': 7609463469853106571},
        {'B1': {'C1': 819843964, 'C2': 389},
         'B2': -2062938701,
         'B3': 'vptl',
         'B4': 60,
         'B5': 113,
         'B6': 38,
         'B7': -4685268648127652264}],
 'A2': 79,
 'A3': 'rqxw',
 'A4': -13,
 'A5': 0.21196869015693665,
 'A6': [4489838433190536518, 12694355992075149677],
 'A7': {'D1': [56536, 26378, 41870, 14324],
        'D2': 36,
        'D3': 518245850,
        'D4': 40,
        'D5': 1114105363592611359,
        'D6': 12557461368647096563,
        'D7': 111,
        'D8': -0.5673461935830049},
 'A8': 4402078350510682850}

(b'MVH/\x02\x00i\x00\x00\x00\xd9\x03\x00q\x007\x97\x9d\x15\xbf\x03\x00\x00\x00'
 b't\x00\x00\x00\x8c\x00\x00\x00\xeaA\xa6\xb3\xde\x88\x84:ygrx\xfeo\xf9R'
 b'\xd9\xf7\xed\x1a\xa5\xaf\x04\x00\x00\x00(\x00\x00\x00\xa1\x7f'
 b'\xd0\xc0\x8f\x15{\x0f\xa2\t-ceb<\xbbt\x86\x1f\xbc\xb9\x10x\xd7\x03\x00'
 b'\x00\x00I\x00\x00\x00\x7fh\x18P\xd1\x8f\x7f\xe3\x1e\xde\x1e,\x00\x00'
 b'\x00L\x00\x00\x00oag,8\x9f\x85\x8ey\x82\x17\x05\xea\xcb\x80\xe1\x91;-'
 b'\xe8C\xc4\x17\x92~.g\xbc\x0e\xf5\xf5\xae\x10\x9c\xef\xe2\xf2\xe45\t&^\xc8'
 b"\x9d\xf4\xbd\xd9(\x16\xbfv\xa0'\x89\xb1\xb9\x97\xd7,O\xdc;R\xc5\xe9\xbf")

{'A1': [{'B1': {'C1': 1392078846, 'C2': 63449},
         'B2': -1348134163,
         'B3': 'ygrx',
         'B4': -95,
         'B5': 127,
         'B6': -48,
         'B7': 3245303193870372800},
        {'B1': {'C1': -2039170244, 'C2': 48159},
         'B2': -679997255,
         'B3': 'ceb',
         'B4': 127,
         'B5': 104,
         'B6': 24,
         'B7': 2224249228414144848}],
 'A2': 217,
 'A3': 'oag',
 'A4': 55,
 'A5': -0.5844358801841736,
 'A6': [1694050062878849068, 3259359153047202309, 7435019200764330984],
 'A7': {'D1': [3772, 62965, 4270, 61340],
        'D2': 226,
        'D3': 154526962,
        'D4': 38,
        'D5': 1596765477778868318,
        'D6': 10932964773052053183,
        'D7': 215,
        'D8': -0.8053370637084973},
 'A8': 4216645641203761642}

Вариант №29

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

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

(b'KEYY\x16\xbe\x10v\n\x1d\x00\x04\x00%=L\r2+\x00\x02\x00)\xbf\xc9\xa2\x80\x98'
 b'$h\xb0\xe8\x1c\x00\x00\x00\x83cxxyms?\xd2\xca"\x87\xcd\x08\xf8\xbf'
 b'\xbe\xbf\x057w\x9fp\xbf\xec\x01/"\xa4W~\xbf\xef\xe6\xbe7\x8bR<\xbf'
 b'\xea\xbb\xd4\xb6\xc4A^\xbf\xde\xb4#\xccjo\x9c?\xe8\xc1\x8f\x10\x7f\x1e\x94F'
 b'\x01\xb9\xber/\x18\xe4\xf5\x1d\xcc\xe5\x1a\xcd\xf3\x80H[\xb8\x9b\x8d'
 b'\xde\x01\x1b;k\xa4V\x84\xa5\x90\xb1d:\x00\x06\x00\x00\x00+?\x13~\xf7\x00[')

{'A1': 22,
 'A2': [{'B1': -0.1410752832889557, 'B2': 29, 'B3': 'cxxy'},
        {'B1': 0.049817271530628204, 'B2': 43, 'B3': 'ms'}],
 'A3': -0.20027167729205564,
 'A4': -6116,
 'A5': {'C1': 25658,
        'C2': [0.29358733426865014,
               -0.12010223964864308,
               -0.8751445461846143,
               -0.9969168743942372,
               -0.8354285783444018,
               -0.4797448631522856],
        'C3': 0.5761560797691345,
        'C4': {'D1': 0.7736277887533611,
               'D2': 5044517285242280164,
               'D3': [-2787, -13083, 6861, -3200, 18523, -18277],
               'D4': 2380136731,
               'D5': 4281696562245374129}}}

(b'KEYY\x9c?`\xd94N\x00\x03\x00%\xbe\xc4\n\xf4W\x00\x03\x00(?\xe4\xc1\x02K'
 b'.x\xd8\xaaw\x00\x00\x00kqvmapb?\xed\x7f\x85p\x7f\xc7\x8e\xbf\xee\x07QX'
 b'\xe3V\xa4?\xd3\xd2\xc7\xd5oV\xa4\xbf\xcb=\xbc#\x10\xf6\xb0\x84\xfa\x97R\x05'
 b'\xa7\xef\x1f\x9b\x9f<M\xd6\x88W\x85|J|\r\xbe\xcd\rW\xf78\xc5\xa0\x80'
 b'Y\xd1\x81\xae\xc2\x00\x03\x00\x00\x00+\xbe[>\xb2\x00C')

{'A1': -100,
 'A2': [{'B1': 0.8783142566680908, 'B2': 78, 'B3': 'qvm'},
        {'B1': -0.3828960657119751, 'B2': 87, 'B3': 'apb'}],
 'A3': 0.6485606640233312,
 'A4': -21897,
 'A5': {'C1': -20798,
        'C2': [0.921816558575516, -0.9383932815641924, 0.3097400268864965],
        'C3': -0.21410635113716125,
        'C4': {'D1': -0.21282149994106225,
               'D2': 9582137535722155807,
               'D3': [-25697, 15437, -10616, 22405, 31818, 31757],
               'D4': 3201109335,
               'D5': -632538454506745471}}}

Вариант №30

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

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

(b'CCTTzH\x02\x8c\xbeY\x00\xf5\xec\xe4\xccn\xcb\x1b\x16\x05\x00\x00\x00g'
 b'\x00\x06\x00\x00\x00{\x00\x00\x00^\x86\xb6\xaeX\xd4\xaf\xf7\x97\xf2\xe8'
 b'b>\xdb\xfd\x96\xbb`\x145\xa3u\\\x1d\x04\x00/\x00\x8d\xb9M\xf2f\xa6\x02'
 b'\x00=\x00PN\x19\xf8\xc1I\xee*\x03\x00G\x007\x00A\x00M\x00\x03\x00\x00'
 b'\x00S\x00\x90\xa3\xbet\xf7o\xdb\xbf\xbd\xc8\x90\xbed0\xb1\xbe\xa6:\xf1>X'
 b'7\xb8\xbe\xffO\xb1>\x7f\xb0Gv\x82I\x14h\xc26\xeb\xb0T\x92w6h\x98\x81\xa9\xf4'
 b'\xf2\x84\x1d\xe4Vf\xbf\xa4\xb8HG\xf1}\xcaN\xe7dJ\xd4\x91\xc0?s\xd1,]L')

{'A1': -0.2734549045562744,
 'A2': {'B1': [{'C1': 7516, 'C2': [-26883, 24763, 13588, 30115]},
               {'C1': -22938, 'C2': [-18035, -3507]},
               {'C1': 10990, 'C2': [20048, -2023, 18881]}],
        'B2': -0.4287089004597471},
 'A3': 1593090569949998325,
 'A4': [-0.2827815115451813,
        -0.34607231616973877,
        0.47115057706832886,
        -0.35979723930358887,
        0.3463134467601776],
 'A5': [7499700104157704319,
        3924766492719789762,
        2127092056655501416,
        5136558392741353188,
        -3149594044770124303,
        5502603597809959057],
 'A6': {'D1': 17847717325645973086, 'D2': -105, 'D3': 0.2215917408466339},
 'A7': 219}

(b'CCTTz\xee\xd6x\xbfG\x001\\\x1b\x85\x84\xb7q\xfa\x04\x00\x00\x00U'
 b'\x00\x06\x00\x00\x00e\x00\x00\x00O\xd9qF\xe8\xe7\xe4L\\\x00w\x1f?E\xa9'
 b'\x8f\x1d\x96\xb2R\x02\x00/\x00\xf4#`jq\xa6\x02\x009\x003\x00=\x00\x02'
 b'\x00\x00\x00C\x00\x0cI\xd6I\xa8\xb9\xe3\xbf,\xcd7>t~]?\xe7\xa9\xe6'
 b"\xbd\xf0\xf1\xb7\xbe\xd5\x18\xed\x10\x7f\x96'\x96\x94\xf5\xf3\x15\xf0\n\x16"
 b'T\xcb&a\x8f\xa8I\xf7=\xf0\xe6\x16\x87\xed5\xe4s\x84\xe3\\\xcf\x1c5^'
 b'h\x1f\x95\x15_~\xed\xc1\xb8')

{'A1': -0.9720295667648315,
 'A2': {'B1': [{'C1': 21170, 'C2': [-28759, -27107]},
               {'C1': -22927, 'C2': [9204, 27232]}],
        'B2': -0.6164132539873051},
 'A3': -400337112062534607,
 'A4': [0.17949360609054565,
        0.865210771560669,
        -0.1126287505030632,
        -0.3592677116394043],
 'A5': [-7626961971439658795,
        6059042374950319508,
        4465118543869978315,
        8350858903341688560,
        7520506825609634692,
        -5133560973208742625],
 'A6': {'D1': 5540808426372847951, 'D2': 92, 'D3': 0.6229095458984375},
 'A7': 69}

Вариант №31

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

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

(b'HQCO\x005\xbf\xe1\xc5\xf65\x84]j\x00\x02\x00m\r8I\x08\xdd\xe4b\x03\t\xbe'
 b'\x86\x81\xdd\xc2![\xfc\xa3?\xdf\x8b\xa2\\\x91m`g?\xd8\x97\x177\x8a\x86'
 b'Q?\xc6v\xa0\xfek#p\x00\x00\x00\x03\x00\x00\x00/\xbe\xdfC\\\xbf\x1f\xf0'
 b'*=\xe8\x01\xa3\xde1\xf1\xb8\xa9+\xab\x15\xbf,cP?\x182\x90?\x17\x06'
 b'\x9f\xdfa\xf7\x9c]\xd9-\xe1\xbd\xf1\x92\xcf?&\x93(')

{'A1': {'B1': 0.17549526617792877,
        'B2': [-26857, 14218, -31151],
        'B3': [{'C1': -0.4360607862472534,
                'C2': -0.6247583627700806,
                'C3': 0.11328437179327011,
                'C4': -2435900148016239851},
               {'C1': -0.6733903884887695,
                'C2': 0.5945215225219727,
                'C3': 0.5899447798728943,
                'C4': -2350325279549215263}]},
 'A2': {'D1': -0.5554152531866923,
        'D2': [-0.11795579642057419, 0.6506829261779785],
        'D3': [13, 56],
        'D4': 18696,
        'D5': -572235261},
 'A3': 702146484245766491,
 'A4': 64675,
 'A5': 0.49289759673930256,
 'A6': 26431,
 'A7': 216}

(b'HQCO\x005\xbf\xe8\x91\xc4L,\x86J\x00\x02\x00m\xd2\xd3\xa6\x82\xab\xa8'
 b'\xb7\x05\xaaa\x99\xa0\xeb\xc9\x8b{\xf6\xe9\xbf\xec\x957\x9e\xbc\x1e\xfa'
 b'\xd5\x10$\xff@wN\xb5\x1a\xbf\xcfR\x13*Vv(\x00\x00\x00\x03\x00\x00\x00'
 b'/?\x1c\x0b\xf3>\x9fC\x17?m\xa95\xaarzc\x04O\x9aS?\x1e\xff\x1e?$\x98h?=\x9a'
 b'\xa3\xccV\xfcM\x98\x08Y\xbf\xbfx\xc4l?e^|')

{'A1': {'B1': -0.24469222609779817,
        'B2': [-192, 30542, -19174],
        'B3': [{'C1': 0.6095573306083679,
                'C2': 0.31105872988700867,
                'C3': 0.9283631443977356,
                'C4': -6164730374224111021},
               {'C1': 0.6210802793502808,
                'C2': 0.6429505348205566,
                'C3': 0.7406408190727234,
                'C4': -3722510631781770817}]},
 'A2': {'D1': -0.767793797280498,
        'D2': [-0.9717471599578857, 0.8959729671478271],
        'D3': [-46, -45],
        'D4': -22910,
        'D5': -1415006459},
 'A3': 12277262975618354043,
 'A4': 63209,
 'A5': -0.8932149982728952,
 'A6': 54544,
 'A7': 36}

Вариант №32

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

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

(b'VHER\xba\xa2\x195\x88KP\x00\x03\x00\x8f\x9c\xbf\x15\xc6\xd2\x00\x00\x00\x02'
 b'\x00\x00\x00\x95i//P1\xbd2\xed\xbf\x0e\x92\xa1W\xd0(\xc3\x9a\x03\x9e#'
 b'\x18\xa1^\x03f\x83\xde\xad\xb4\xfc\xb3\xe8\x8bc\xb0\xcc\x96\xd9\xe4\xc6'
 b'*o=\xfd\xf7\xf3\x04\x83\xb2n\x96\xd30H\x1a\x1d\x0b\xf0r\xa9"\x04\x88\x00'
 b'\x00\x00M\x08\x1c\x1b\x88r\xc5\x0f_\xc2p.\x91\x81\x94\xaf\xda\xe7'
 b'\x80\x00\x00\x00cW\x1d\x10\x10\xd2\xa8k\x1c@\xf6?\xa9\xce\xfd\xee'
 b'\x8a\x92\x99\x00\x00\x00y\xf8\xaf\xa6]\x00S\x00i\x00\x7fdb')

{'A1': 2719561096,
 'A2': {'B1': 19280,
        'B2': [{'C1': 2093030827098244232,
                'C2': {'D1': 1855378224, 'D2': 72, 'D3': 26},
                'C3': 136059784},
               {'C1': 3355605672973232000,
                'C2': {'D1': 1925517151, 'D2': -62, 'D3': 112},
                'C3': 1461522448},
               {'C1': 4587425285477667481,
                'C2': {'D1': 3534252828, 'D2': 64, 'D3': 246},
                'C3': 4172260957}]},
 'A3': -1665198650,
 'A4': -46,
 'A5': 'db',
 'A6': {'E1': 7579328719366206189,
        'E2': -0.5569248795509338,
        'E3': [6327602297023208995, 1774803096858517165, -5405247641399086900],
        'E4': -26919,
        'E5': [-28, -58, 42, 111],
        'E6': 0.12400808185338974},
 'A7': 4,
 'A8': -31822}

(b'VHER\xba\xebH\x07\x7f)\xf5\x00\x03\x00\x8f>\x9e\xe7\xab\x86\x00\x00\x00\x04'
 b'\x00\x00\x00\x95g\xe9\x9b\xab\x8djA\x88\xbf[F\xcbe-\x02\x05\xe1\x1f\xa7H'
 b'K\xbc\xdf\x02\xe0\x83v\x1b%@\xe2\xe6\x19\n\xb0\xc8zs\xe7\xe9\x00\x1b?>'
 b'\xc1E\xd3\xb2h\x9d.#\x00\xd6\x97\xcd\xef@b\x9c\xd96\x8d\x00\x00\x00M\x8c'
 b'\x84\xca\xc6z*\xbe\x1b\x08\r\xdfw\xe0\xcd|\xfcy\xb0\x00\x00\x00c\xb7C\xca'
 b'\xf7\xfd\xa3\xdb"\x96\x0b\xa3^\x85\x93\xf1\x8fX\xb0\x00\x00\x00yzK!l\x00'
 b'S\x00i\x00\x7fugpf')

{'A1': 3947366271,
 'A2': {'B1': 10741,
        'B2': [{'C1': 14839150089491527309,
                'C2': {'D1': 2637046528, 'D2': -42, 'D3': 151},
                'C3': 2357512902},
               {'C1': 16102586165856336304,
                'C2': {'D1': 2049621531, 'D2': 8, 'D3': 13},
                'C3': 3074673399},
               {'C1': 11771993346452445360,
                'C2': {'D1': 4255374114, 'D2': -106, 'D3': 11},
                'C3': 2051744108}]},
 'A3': 1050601387,
 'A4': -122,
 'A5': 'ugpf',
 'A6': {'E1': 7487687016594424200,
        'E2': -0.8565489649772644,
        'E3': [7290485596057741128, 5457482051915839003, 2684394855803302088],
        'E4': 31347,
        'E5': [-25, -23, 0, 27],
        'E6': 0.745136559009552},
 'A7': 211,
 'A8': -19864}

Вариант №33

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

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

(b'\xcfANC=\xd3"x\x00|?\x01\x81\xd84\x1e\xaa\xb9\xdb\x97;\xdc\x13\xec\x9a\x0e;%'
 b'\xca\xbc\x1b&}\npU7[\xdb\x02\xbe /a\x87\xf8\x0f\x00\x02\x00(\xbfTT/0'
 b'\x8e\x1a\x05\xc0 \xb7\x00\x02\x007?>\x12L_\xc5oN\xbaX,\x00\x02\x00'
 b'F\xbd\xbc\xbd \xb9\xd4\xeaQ\x89\xba\xa9\x04\x00\x03\x00U\xbfA\xe5'
 b'\x0e\x80\xfc1\xcdW\xee\xb1\x00\x02\x00e?C\x8d\xb4\xc90+\xf036:\x82\xb8(W\xe8'
 b'\xd9F\x8b`_\xe8ppgtuq\x00*\x009\x00H\x00X\x00g\x00\x02\x00t\x06k\to\xbf\xcc'
 b'\xfaK\x96\x84L\x90')

{'A1': 0.10309308767318726,
 'A2': {'B1': -18392,
        'B2': 1474877766,
        'B3': -1956618264,
        'B4': 'ppgtuq',
        'B5': [{'C1': 794920952,
                'C2': 15,
                'C3': [-66, 32],
                'C4': -0.8294095396995544},
               {'C1': 436584480,
                'C2': -73,
                'C3': [48, -114],
                'C4': 0.7424666881561279},
               {'C1': 1867430488,
                'C2': 44,
                'C3': [95, -59],
                'C4': -0.09215760231018066},
               {'C1': 1367980713,
                'C2': 4,
                'C3': [-71, -44, -22],
                'C4': -0.7574013471603394},
               {'C1': 835540974,
                'C2': -79,
                'C3': [-128, -4],
                'C4': 0.7638809680938721}],
        'B6': [-919589904, 859191938],
        'B7': 107678063,
        'B8': -0.22638840531781002},
 'A3': 0.505887508392334,
 'A4': {'D1': 13342,
        'D2': 12302105299730043884,
        'D3': 39438,
        'D4': 992332476,
        'D5': 1956388571926837083,
        'D6': 56066}}

(b'\xcfANC>\xd5\xcbt\x00|=\xda4-B\xec\xd7\xfa\xc6_\xbee\x16\xc2\r\xbe\x17\x9b'
 b'\xd2?JB>RaEnX\xc7\xd2\xd6\xb8\x05\x93\xc1\xd4\x83.\x00\x03\x00(\xbf)\x7fS'
 b'\xb3\xf4\xa6e\xc5yv\x00\x02\x008?^ava\xd5\x00\xc2\xc8\xdc\xed\x00\x02'
 b"\x00G\xbd\xcf\x02\xf4\xb8#f\x18|'n\x00\x02\x00V>\xcb\xc6\x98\xa7i\xe2"
 b'c+\x9e\xe9\x00\x02\x00e\xbf\x144\x10\xd3 b\x84\xf1s\x96%\x91z\xb0\x07\x87aBG'
 b'5\xfcmwyylb\x00+\x00:\x00I\x00X\x00g\x00\x02\x00t\x16Wen\xbf\xd5'
 b'\xa3\xc6\x01x\xd0`')

{'A1': 0.4175678491592407,
 'A2': {'B1': -28294,
        'B2': -1341683871,
        'B3': 1111963132,
        'B4': 'mwyylb',
        'B5': [{'C1': 2478953603,
                'C2': 46,
                'C3': [-42, -72, 5],
                'C4': -0.6620990633964539},
               {'C1': 2791687545,
                'C2': 118,
                'C3': [-77, -12],
                'C4': 0.868674635887146},
               {'C1': 12765404,
                'C2': -19,
                'C3': [97, -43],
                'C4': -0.10107985138893127},
               {'C1': 1712880679,
                'C2': 110,
                'C3': [-72, 35],
                'C4': 0.39799952507019043},
               {'C1': 3798150046,
                'C2': -23,
                'C3': [-89, 105],
                'C4': -0.5789194107055664}],
        'B6': [-752852348, -244083163],
        'B7': 374826350,
        'B8': -0.3381209387182533},
 'A3': 0.10654482990503311,
 'A4': {'D1': 17132,
        'D2': 15562969576850659010,
        'D3': 3518,
        'D4': 396087871,
        'D5': 5350907830809751128,
        'D6': 51154}}

Вариант №34

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

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

(b'KYOP-f\xa6+>g\x90\xcbi\x8e\xf8\x8d\x87\xba\x84\x1d\xb4\xf3\x8a\x16'
 b'\xd9\xa4\x9aQ>\xf5\xe4\xd0G\xaduihctjbn\x003\x08=\x93\xa1\x80s\xbe\x90\x9b-')

{'A1': [{'B1': 11622, 'B2': 42539},
        {'B1': 15975, 'B2': 37067},
        {'B1': 27022, 'B2': 63629},
        {'B1': 34746, 'B2': 33821},
        {'B1': 46323, 'B2': 35350},
        {'B1': 55716, 'B2': 39505}],
 'A2': {'C1': 0.48026132583618164,
        'C2': 18349,
        'C3': 'uihctjbn',
        'C4': {'D1': [144, 155], 'D2': 45},
        'C5': [8, 61, 147, 161, 128, 115, 190]}}

(b'KYOP\xd8\xdc\xe08\\\xac\x89\xbc\xfe\xd6oM\x08Cm\x80\xaa\xbb\x93&'
 b'>\xc1\xcb\xcb\xbe\xafX\xf2\xaa\x1cbcnswfiy\x003\x801\xed\x98\xc9\\\x0cs'
 b'\xae1')

{'A1': [{'B1': 55516, 'B2': 57400},
        {'B1': 23724, 'B2': 35260},
        {'B1': 65238, 'B2': 28493},
        {'B1': 2115, 'B2': 28032},
        {'B1': 43707, 'B2': 37670},
        {'B1': 16065, 'B2': 52171}],
 'A2': {'C1': -0.3424754738807678,
        'C2': 43548,
        'C3': 'bcnswfiy',
        'C4': {'D1': [115, 174], 'D2': 49},
        'C5': [128, 49, 237, 152, 201, 92, 12]}}

Вариант №35

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

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

(b'YHLWHt{\xb9\x05\xa5\x00\x00\x00\x02\x00\xb6\x00\xd07\xbe\x00\xb2\xe0\xd2'
 b'8\x10\xd1~\x0e&\xfeW5\x00F\x02\x00\x00\x00\x15\x00\x00\x00\xa1\xf7\xbeb\xc9'
 b"\x8b@'\xcb\xa2/$\xc4\xba\x02\x00\x00\x00+\x00\x00\x00&&\x8e\x96\x11y]"
 b'13"\x04\xcb\xa0\xf9\x02\x00\x00\x00A\x00\x00\x00y\xea&\t\\g{r\xcf'
 b"\x86\xe9\xb7\x90'\x02\x00\x00\x00W\x00\x00\x00_\xabt\xa3\xd1\xec\xcd"
 b'\x896Y\xe2\xbdtV\x02\x00\x00\x00m\x00\x00\x00\xae\x82\x83$\x15\xf4\xdb\xb52'
 b'\xe6\xb9\xb6\x1a"\x02\x00\x00\x00\x83\x00\x00\x00\x1d\x003\x00I\x00_'
 b'\x00u\x00\x8b\x00\x07+Vp\xf6\x1a\x0f \x06\x00\x00\x00\x99\x00\x00'
 b'\x00\x97\x82\x16\xcf\x02\x9f;k8\x9b\xed\x13\r\x02t7Wt\xcb\xc4\xc7!l'
 b'6\xd6\xde\xf50\xbf&\xad[9\x1e\xbeS\xf5\xafho\xa4\xed\xb9\xdb')

{'A1': 72,
 'A2': {'B1': 96041844,
        'B2': {'C1': 2310094779613326087,
               'C2': [{'D1': 38,
                       'D2': 22526,
                       'D3': 53,
                       'D4': 70,
                       'D5': [953344178, 243192080]},
                      {'D1': 203,
                       'D2': 12194,
                       'D3': 50212,
                       'D4': -70,
                       'D5': [1656682401, 658541513]},
                      {'D1': 51,
                       'D2': 1058,
                       'D3': 41163,
                       'D4': -7,
                       'D5': [-1769069018, 828209425]},
                      {'D1': 207,
                       'D2': -5754,
                       'D3': 37047,
                       'D4': 39,
                       'D5': [153545337, 1920690012]},
                      {'D1': 54,
                       'D2': -7591,
                       'D3': 29885,
                       'D4': 86,
                       'D5': [-1552635041, -1982993199]},
                      {'D1': 50,
                       'D2': -17946,
                       'D3': 6838,
                       'D4': 34,
                       'D5': [612598446, -1243876331]}],
               'C3': -105},
        'B3': [47126146, 946551711],
        'B4': 14288},
 'A3': {'E1': [-4709, 3347, 29698, 22327, -13452, -14396, 27681, -10698],
        'E2': -0.6912516355514526,
        'E3': -21210,
        'E4': 91,
        'E5': 1404968505,
        'E6': 15832947255497240565}}

(b'YHLWZ>\x83\xf1M\xa5\x00\x00\x00\x03\x00\xb6\x00\x1b\xfc\xc2\x00R\xbfR'
 b'\xc9\xe4\x8e\xd16:\xf0X\xec\xcc\x82\x02\x00\x00\x00\x15\x00\x00\x00\x98'
 b'\xd7\xfe|r=\xc86\xd0\xe2Il\x1ca\x02\x00\x00\x00+\x00\x00\x00\xbf\xab\x07'
 b'n ^\xb8m\xa4O\xcd=\xe7\x9f\x02\x00\x00\x00A\x00\x00\x00!\x118\x08\xa1'
 b'\x85\x0b\x14\x84y@7\xdb\xfa\x02\x00\x00\x00W\x00\x00\x000\xbc\xafU\x01wE'
 b'\xb8}\x00\xe2\xe1\x17\xb5\x02\x00\x00\x00m\x00\x00\x00\xd9\x13\xc3\x850'
 b'\xaa\xbe\xe21\x88\x88\x80\x13t\x02\x00\x00\x00\x83\x00\x00\x00\x1d\x003'
 b'\x00I\x00_\x00u\x00\x8b\x00\x0fT\xb4o\xf6K*\x1c\x06\x00\x00\x00\x99\x00\x00'
 b'\x00E\xc4\\@\xa1\x94\xde>\xfd\x01h\xd0\xfd\xdaI\xe1\xe28\xb9\x99\x12\x92\x9a'
 b'u\xa3\xd0X\x82\xee\xfc\xe4h\xbf\xf8-\x07xmg*\xa2\x9dgF\xf0\x9f\xc0\x80')

{'A1': 90,
 'A2': {'B1': 1307673406,
        'B2': {'C1': 2029518103891956751,
               'C2': [{'D1': 58,
                       'D2': 22768,
                       'D3': 52460,
                       'D4': -126,
                       'D5': [-917323950, 919703268]},
                      {'D1': 208,
                       'D2': 18914,
                       'D3': 7276,
                       'D4': 97,
                       'D5': [2097076120, 919092594]},
                      {'D1': 164,
                       'D2': -12977,
                       'D3': 59197,
                       'D4': -97,
                       'D5': [1845996479, 1840799264]},
                      {'D1': 132,
                       'D2': 16505,
                       'D3': 56119,
                       'D4': -6,
                       'D5': [137892129, 336299425]},
                      {'D1': 125,
                       'D2': -7680,
                       'D3': 6113,
                       'D4': -75,
                       'D5': [1437580336, -1203407103]},
                      {'D1': 49,
                       'D2': -30584,
                       'D3': 4992,
                       'D4': 116,
                       'D5': [-2050812967, -490821072]}],
               'C3': 69},
        'B3': [2705349828, 4248755860, 4258293761],
        'B4': 64539},
 'A3': {'E1': [18906, -7455, -18120, 4761, -25966, -23691, 22736, -4478],
        'E2': -0.9097440242767334,
        'E3': 11768,
        'E4': 7,
        'E5': 711421304,
        'E6': 9277591086705384866}}

Вариант №36

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

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

(b'JGJb4x\xdb\xa6\xe4D\xfe-g\x06A;j\xdb5\x98\xadU\x00w\x00\x89\x00\t'
 b'\x8cC\xfe\xde\x8f\x9e\x1a\xe4Y\xdf\xe3\xa4\xd1\x04\x00\x00\x00\x93\x00\xda'
 b'Rt\x1a\x8d\xbdV\xbd\x03\x00\x97\x00\x86\x01\xd4\x8b\x87\x10\xa2\x91\xd3'
 b'?\xdd0\xca\x84\xe3\x8d\x8a\x80(P\x0c\xael\x10x\x81\xcf\xd9R0\x04\x00\x00'
 b"\x00E\x00W\xaaN\x0e\x90-\xdf'\x11Q\tNX}\x9c5\x07M\xbeV\x98\x1bx:\xe1"
 b'\xdb^\xc5\x06\x00\x00\x00_\x00~ \xd1\x06T\xf0\xf5\xe2\x08\x83%w\x02\x00\x00'
 b'\x00\x81\x00Up\n\x17\x93\xf7\x11')

{'A1': 13410,
 'A2': 7434878131705928568,
 'A3': -5937936892191620858,
 'A4': {'B1': [{'C1': 810736079,
                'C2': [-2067124003, -2138403357, -1374924760, -2122837908]},
               {'C1': 3311328225,
                'C2': [240036439,
                       668937616,
                       1309233425,
                       899448152,
                       1455312135,
                       980949912]},
               {'C1': 1998947080, 'C2': [114368638, -487198636]}],
        'B2': -29127671,
        'B3': 36830,
        'B4': 158,
        'B5': -547757030,
        'B6': 227,
        'B7': 53668,
        'B8': [85, 112, 10, 23]},
 'A5': {'D1': -4803443538812185894, 'D2': [-109, -9, 17], 'D3': 390},
 'A6': 0.30576373686033986}

(b'JGJ\xa3$\xd4\xc8W1\x9d\x070\x07\x97\xe4&\xcbJ\x9e\xa5\x8cM\x00c\x00y\x00_'
 b'HhGP\xbe\xeb\x9b}\xf0\xf7\xb1\xe0\xfd\x02\x00\x00\x00\x83\x00\xe5'
 b'\x12\xea\x9c\xcd\xc6\xca~\x04\x00\x85\x00\xc0\x00X@6\x83\xf9\xa6\xef'
 b"\xbf\xfe\\\x89V\xb8'\x1dAS\xbd\xbc\xe6\x02\x00\x00\x00E\x00G\x92\xd2\x97\x18"
 b'\x04\xb7:{\x17\x0f\x1c\xc9 9?\x03\x00\x00\x00W\x00\x10JP\xf1\x12\n\x14'
 b'X\x0f$\x1b\xa0\xf7\xe5p\xf7\x03\x00\x00\x00m\x005\xc2*}\x9b\xa3')

{'A1': 9379,
 'A2': 517922328866703572,
 'A3': -8312063493169290089,
 'A4': {'B1': [{'C1': 3871128915, 'C2': [1451842814, 1092429752]},
               {'C1': 1060708553, 'C2': [-1747807673, 985072664, 470751099]},
               {'C1': 4151371255, 'C2': [-246396400, 1477708306, -1608834033]}],
        'B2': 1198016607,
        'B3': 48720,
        'B4': 235,
        'B5': -135234149,
        'B6': 177,
        'B7': 64992,
        'B8': [53, 194]},
 'A5': {'D1': 9136333380477653733, 'D2': [42, 125, -101, -93], 'D3': 192},
 'A6': -0.9891326487286376}

Вариант №37

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

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

(b'\x1cOLLP5\x0e&B\x0cO\xb8\xf3\x18\xf3\xcf\xa1\xb9\x1a\x13\x88=\x9a"'
 b'\x19\xa2\xc4\x819\xbf\xda\xca\x18\x00\x00\x00ozginoe\xac\n.\xee\x00'
 b'\x00\x00t\x00\x00\x00\x08\x00\x80\xbf\xd6y:\x8e\xf0\xf4t\xbf\xe7N'
 b'\xc5V\xa0\xaf:\xa2*T\xbcma\xe5\x87?\xe3\x9a\x1a8\x7f\x10\x9c?\xa4u?j<k'
 b'\xc0\x00\x00\x00\x94\xc3C\xa0\xd5z\x08\x9f\xc87\xdbs\xf6\x97F\x0e\xd5\xfcAL'
 b"'G\xb97\xd4;\xc9\x7f\xe5\x9f\x7fH\xb8\xdfH\x02\xbfs\xdd\xe7\xbf\x04]t"
 b'>\xa1}\xc9?\x00\x00\x00\x03\x00\x00\x00\x88')

{'A1': 3823035198800378099,
 'A2': [{'B1': 24, 'B2': -13, 'B3': -49, 'B4': -24135},
        {'B1': 26, 'B2': 19, 'B3': -120, 'B4': 15770},
        {'B1': 34, 'B2': 25, 'B3': -94, 'B4': -15231},
        {'B1': 57, 'B2': -65, 'B3': -38, 'B4': -13800}],
 'A3': {'C1': 1945540422, 'C2': 14},
 'A4': 'zginoe',
 'A5': -1408618770,
 'A6': {'D1': {'E1': -10756, 'E2': 4705178899698930747, 'E3': 51583},
        'D2': [229, 159, 127, 72, 184, 223, 72, 2],
        'D3': -0.3511492153082323,
        'D4': -0.7283655826517823,
        'D5': -6761498722277661305,
        'D6': 0.6125613311237603,
        'D7': 0.03995702907396703,
        'D8': {'F1': 63,
               'F2': [-0.9526047110557556,
                      -0.5170509815216064,
                      0.3154127895832062]}},
 'A7': -15549,
 'A8': -6857440680142686245}

(b'\x1cOLLP\x18Yw\xea\xdc}f^J\xbbWgM\xfd\xe5\xa42\xf0\x02\r\xfa\xb4\xf0\xf4CX]'
 b'\x0e\x00\x00\x00orabpbp\x8a&3y\x00\x00\x00t\x00\x00\x00\x07\x00\x80?\xde{'
 b'\xd1y\x91\xb9\x88\xbf\xde\xae\xba\x0e\xdb]\x14y\\\x1f\x9fu\xa1c\x96?\xe0i'
 b'\x8aC\xefc\xd4\xbf\xea\x0b\x9b\x17\xb7\xfc\x00\x00\x00\x00\x8f\x97+\xcb'
 b'oL\xb1\xc6w\x99\xf9\xae\xbe\x9eD@\xcb.~\x1b\xc02T\xf1y*h\xe70\xe3\xca\xc2'
 b'K\xefq?+\xc2\x92?-\xc0\x19\xc7\x00\x00\x00\x02\x00\x00\x00\x87')

{'A1': 1754565380442777182,
 'A2': [{'B1': 74, 'B2': -69, 'B3': 87, 'B4': 26445},
        {'B1': 253, 'B2': -27, 'B3': -92, 'B4': 13040},
        {'B1': 2, 'B2': 13, 'B3': -6, 'B4': -19216},
        {'B1': 244, 'B2': 67, 'B3': 88, 'B4': 23822}],
 'A3': {'C1': 2931727940, 'C2': 64},
 'A4': 'rabpbp',
 'A5': -1977207943,
 'A6': {'D1': {'E1': -13522, 'E2': 9087067995556116778, 'E3': 26855},
        'D2': [48, 227, 202, 194, 75, 239, 113],
        'D3': 0.47630726692195724,
        'D4': -0.479414476879769,
        'D5': 8744899346180432790,
        'D6': 0.5128833128793482,
        'D7': -0.8139167273765224,
        'D8': {'F1': -57, 'F2': [0.6709376573562622, 0.6787124276161194]}},
 'A7': -26837,
 'A8': -3787724435172648455}

Вариант №38

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

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

(b'uDVP\x00\x00\x00\x05\x00m\x00\x00\x00\x81\x8ay9\xc1ddrbk5(jB\xf9o&\xf5\x00'
 b'\x00\x00\xbfzskt=\x00\x00\x00\x03\x00#>\x0c\x90lbet\na\x00\x00\x00\x03\x00'
 b'2?\x15S\xadxts\xb2w\x00\x00\x00\x03\x00A\xbe\x9c\xac\x9dnr\xe4\xe3'
 b'\x00\x00\x00\x02\x00P\xbfQ0\xdebaw"\x00\x00\x00\x00\x03\x00^?#\x1b'
 b'z\x00\x00\x00&\x00\x00\x005\x00\x00\x00D\x00\x00\x00R\x00\x00\x00'
 b'a\x86\xb7\x18%F\x9d\t\xcd\xab\xbf#Uv\xed\xbf\xdann\xf5?Q\xe8\xbf\xe9\xed\r|'
 b'\xd9\x95\xfc\xbf\xdcnh\xc9\xe7\x84\x08\xbf\xc9\xe9\x14\x8dT\x9c\x00?'
 b'\xd85\x92\x1fki\x90?\xef\x17V\xcd%\x81\x02\x996\xd0<M\xff\x00\x00\x00'
 b'\x05\x00\x00\x00\x97\xce+')

{'A1': [{'B1': 29757, 'B2': 'zsk', 'B3': 0.13726967573165894},
        {'B1': 2657, 'B2': 'bet', 'B3': 0.5833080410957336},
        {'B1': 45687, 'B2': 'xts', 'B3': -0.30600443482398987},
        {'B1': 58595, 'B2': 'nr', 'B3': -0.8171519041061401},
        {'B1': 8704, 'B2': 'baw', 'B3': 0.6371380090713501}],
 'A2': {'C1': 9707254070197946829,
        'C2': -85,
        'C3': -0.638022780418396,
        'C4': 237,
        'C5': -0.4129903216355886},
 'A3': 2323200449,
 'A4': 'ddrbk',
 'A5': 3830428318963803893,
 'A6': {'D1': 39222,
        'D2': [-48, 60, 77, -1],
        'D3': [-0.8101870954967008,
               -0.44423885075781344,
               -0.20242554570106108,
               0.3782697016555625,
               0.9715990072982381],
        'D4': -12757}}

(b'uDVP\x00\x00\x00\x05\x00l\x00\x00\x00\x80=HS\x88mwxrr\xa9"\xcb\xf1\xcf'
 b'F3\xde\x00\x00\x00\xc6tmcL\xd5\x00\x00\x00\x03\x00#\xbe\x8e\xcf[emb@ \x00'
 b'\x00\x00\x03\x002\xbe\xde\x80\x8aeu}[\x00\x00\x00\x02\x00A?H{$kmm.\x14'
 b'\x00\x00\x00\x03\x00O\xbe\xbc\xda;lfPu\x00\x00\x00\x02\x00^>\x82E\xfb'
 b'\x00\x00\x00&\x00\x00\x005\x00\x00\x00C\x00\x00\x00R\x00\x00\x00`\xb7R\xa05'
 b'\xa3+\x90a\x02>\xe0\x88\xe2\x14?\xeb\x83\xb2\x9fW$\x04?\xe3.\x1a\xeeP'
 b'z\x8e?\x91<d\xc8]&\xc0?\xd3\xb9\x89\xf2\xa8\x8a\xfc\xbf\xdc\xde\xd7\x0bW'
 b"\r,?\xecl\xb6\x0e\xc2'x\xbf\xd7\xf2\x85\xef\xf3\x18d;1\x1d\x0e@\xd5"
 b'\x00\x00\x00\x06\x00\x00\x00\x96#\xc6')

{'A1': [{'B1': 19669, 'B2': 'tmc', 'B3': -0.27892574667930603},
        {'B1': 16416, 'B2': 'emb', 'B3': -0.4345744252204895},
        {'B1': 32091, 'B2': 'eu', 'B3': 0.7831289768218994},
        {'B1': 11796, 'B2': 'kmm', 'B3': -0.3688524663448334},
        {'B1': 20597, 'B2': 'lf', 'B3': 0.25444015860557556}],
 'A2': {'C1': 13209796809262338145,
        'C2': 2,
        'C3': 0.4385443329811096,
        'C4': 20,
        'C5': 0.8598263847462708},
 'A3': 1028150152,
 'A4': 'mwxrr',
 'A5': 12187527781043024862,
 'A6': {'D1': 15153,
        'D2': [29, 14, 64, -43],
        'D3': [0.5993780760362186,
               0.016831946114769236,
               0.3081993932448055,
               -0.4511010752432465,
               0.8882704056024826,
               -0.3741774409539913],
        'D4': 9158}}

Вариант №39

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

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

(b'YHIt\x00\x1e\x00,\xe7\x0f\x008WM?\n\xf0\xd9\x00\x02\x00\x00\x00Qwmjufd\xf6,'
 b'\x8e0\x18\xf0\x00\x06\x00\x00\x00\x18rp\x11Q\x15\xcb\xfb"\x00\x02'
 b'\x00\x00\x00*co\x01\x8c\x9c\x87\x91\x89A\x10\xec\xa5=\x12)\x1e\xbbao\xbe'
 b'}\xda\x00\x8c\x80?\xe6a\xe9\x91\x12u\x82\xbf\xaa\xf3\xd6q\xa9\x9a`')

{'A1': [{'B1': -2516, 'B2': 2385516784, 'B3': 'wmjufd'},
        {'B1': 4433, 'B2': 365689634, 'B3': 'rp'}],
 'A2': -6385,
 'A3': {'C1': 7164947235602928009,
        'C2': 4688507406531045662,
        'C3': {'D1': [187, 97], 'D2': 111, 'D3': -0.24790191650390625},
        'C4': -29568},
 'A4': 22349,
 'A5': 0.5427375435829163,
 'A6': [0.699452193588215, -0.05264158380014261]}

(b'YHIt\x00\x1e\x00.\x14\x0f\x00:Uo\xbev0*\x00\x03\x00\x00\x00Ssvtmlt\x1e\xe2'
 b'\xc9\xdf<\x8f\x00\x06\x00\x00\x00\x18nggf\x1e\x90\x95\xf5S\x95'
 b'\x00\x04\x00\x00\x00*\xe7\x1cP\xa7N(\x89\x90\xcb%\xeb\x17DO\xa2:7\x0b'
 b'\xbc\xbe\x1a\xbe\xba\x12\x8d?\xe2\xa1\xbb\xba\xdb\xeb|\xbf\xe3r\xacR'
 b'\xbe4\x8c?\xdb\x10\xa1\x12\xa3\xfdT')

{'A1': [{'B1': 7906, 'B2': 3386850447, 'B3': 'svtmlt'},
        {'B1': 7824, 'B2': 2515882901, 'B3': 'nggf'}],
 'A2': 5135,
 'A3': {'C1': 16653274201610291600,
        'C2': -3808379424709041606,
        'C3': {'D1': [55, 11], 'D2': -68, 'D3': -0.1511181890964508},
        'C4': 4749},
 'A4': 21871,
 'A5': -0.24041810631752014,
 'A6': [0.5822428369132093, -0.6077481857370386, 0.42288996525163225]}

Вариант №40

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

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

(b'DIH\x83\x1e\x00\x03\x00-\x00:\xc9\x91\xee:nq\xad\xee\xbf\x04`\xddr'
 b'\xb0\x9e\xb7\x9a\xae\xc7J$\xe5\xf9nr\xf8\x18\xf5&\xe9\x04\xe8\xda*\x03\x00$'
 b"\x00\xbd\x03\x00'\x00\x9f\x03\x00*\x00+")

{'A1': {'B1': 4192543818, 'B2': 'nr'},
 'A2': {'C1': [{'D1': [248, 24, 245], 'D2': 189},
               {'D1': [38, 233, 4], 'D2': 159},
               {'D1': [232, 218, 42], 'D2': 43}],
        'C2': 51514,
        'C3': [61073, 28218, 44401, 49134, 24580, 29405, 40624, 39607],
        'C4': 174},
 'A3': 199}

(b"DIH\x83\x1e\x00\x02\x00(\x00'9\xa8\x96\x86w\xbcA.\xed>W\x8c%-\x14\xf5\x16"
 b'\xfa\x88hv\x92jrl\xa8&\xf5\xf8\x02\x00$\x006\x02\x00&\x00\xd1')

{'A1': {'B1': 1787983464, 'B2': 'rl'},
 'A2': {'C1': [{'D1': [168, 38], 'D2': 54}, {'D1': [245, 248], 'D2': 209}],
        'C2': 14631,
        'C3': [38568, 30598, 16828, 60718, 22334, 9612, 5165, 5877],
        'C4': 250},
 'A3': 136}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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