ИКБО-11-22

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

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

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

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

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

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

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

(b'BAZO<\xad\x9b\xd8\xe3}\xe6?\x00\x03\x00\x00\x00\\?\n\xe2\xc3\x1a\x14'
 b'\xf4fI\xc00\xaa\xc3\xb0\x99\xfa>\x17\xde(\xbe\x04\x03Y\xbc\xc1\xd1N\xbd\xef'
 b'oR?\x18\xb6<<\x1aZI\x19\xe1c\xf7\xbf\xeae\x9f\xea\x9d\x06p{\xfb\x06:~8'
 b'{\x0c\xafi\x96h\xe4:\x00\x00\x00\x06\x00h\xc4{pba\xfawxb\xe2sfm\xcc'
 b'\x1e(\x86\xf2?^\xc1\x98j\x84\xa5\xc1')

{'A1': 0.021192476153373718,
 'A2': -478288321,
 'A3': [{'B1': 'pba', 'B2': -6},
        {'B1': 'wxb', 'B2': -30},
        {'B1': 'sfm', 'B2': -52}],
 'A4': {'C1': {'D1': 0.5425226092338562,
               'D2': 1879395664681513130,
               'D3': 50096,
               'D4': 39418,
               'D5': [0.1483083963394165,
                      -0.12891902029514313,
                      -0.023659374564886093,
                      -0.11691154539585114,
                      0.5965306758880615,
                      0.009420939721167088]},
        'C2': 25,
        'C3': 225,
        'C4': 25591,
        'C5': -0.8249053556721275,
        'C6': 123,
        'C7': {'E1': -5,
               'E2': 104496696,
               'E3': 8866654634415547450,
               'E4': [7720, -30990, 16222, -15976, 27268, -23103]}},
 'A5': 196,
 'A6': 123}

(b'BAZO>\x1b\xd6&==\xc4?\x00\x03\x00\x00\x00\\?w\xd9\xf2|\xc1\xde \xf2\xa2'
 b'\x9b;\x17S\xeee?K\xad\xe7\xbfb>z\xbe&_\xc6\xbfC\x8d\x1e>\x97GS\xbe\xcd'
 b'\xc6\xb7a\n\x0cy?\xef\x18\xe4xp\xbf\x16\xbb\x81\xc8\xb6\xd1\xb8\xfd\x9fs\xec'
 b"\x1db{'\x00\x00\x00\x05\x00hB\x16hdw\xd0yxt\x9aaul\xa9\x9a\xf6\x0c\xfa"
 b'\xe0\x81\x1c|\x85\xee')

{'A1': 0.15218409895896912,
 'A2': 1027458111,
 'A3': [{'B1': 'hdw', 'B2': -48},
        {'B1': 'yxt', 'B2': -102},
        {'B1': 'aul', 'B2': -87}],
 'A4': {'C1': {'D1': 0.9681693315505981,
               'D2': 8989710564299283259,
               'D3': 5971,
               'D4': 61029,
               'D5': [0.7956222891807556,
                      -0.8837658166885376,
                      -0.16247472167015076,
                      -0.7638720273971558,
                      0.29546603560447693,
                      -0.40190669894218445]},
        'C2': 97,
        'C3': 10,
        'C4': 3193,
        'C5': 0.9717886307098265,
        'C6': -69,
        'C7': {'E1': -127,
               'E2': 3367424440,
               'E3': -171290802874320089,
               'E4': [-25866, 3322, -8063, 7292, -31250]}},
 'A5': 66,
 'A6': 22}

Вариант №2

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

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

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

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

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

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

(b'LJFm\x11ycb\x00\x82%~\x00\x00\x00\x02\x00\x00\x0092\xfc\x0f\xf0\xbf\xeeX_'
 b'\xc7\xbd-\xb6\xb5\x15F\x1d?&\x9e?\xeb?\xe1\xfcpfg\x00r\x00\x05\x00'
 b'\x00\x00c\x00\x97kg\xbfc!\xbf>\xee\x16!?CY\xda\xbd\xe2S)?P\x10!\xbe'
 b' \xca\x80\xbd\xe9\xea\xbe\xbe\xc3\xdf\x04?q\xf9\x94\xbf!\xdb"\x00'
 b'\x02\x00\x00\x00;>\x95\xa5\xa2\x00\x02\x00\x00\x00C?U\xf4K\x00'
 b'\x02\x00\x00\x00K?|a\x10\x00\x02\x00\x00\x00S?\x11Pm\x00\x02\x00\x00\x00'
 b'[?p\xdb\xaa\xd7c\x00\x00\x00\x02\x00\x95\x9d\x92\xee')

{'A1': 1259146843393238398,
 'A2': 'kg',
 'A3': {'B1': 855379952,
        'B2': -0.9482878590728692,
        'B3': -19179,
        'B4': 17949,
        'B5': 0.6508521437644958},
 'A4': -21,
 'A5': 0.5620653152509603,
 'A6': [{'C1': [-0.8872336745262146, 0.4650125801563263],
         'C2': 0.29227930307388306},
        {'C1': [0.7630897760391235, -0.11051017791032791],
         'C2': 0.8357588648796082},
        {'C1': [0.8127461075782776, -0.15702247619628906],
         'C2': 0.9858560562133789},
        {'C1': [-0.11421726644039154, -0.3825608491897583],
         'C2': 0.5676334500312805},
        {'C1': [0.9452145099639893, -0.6322499513626099],
         'C2': 0.9408518075942993}],
 'A7': {'D1': [215, 99], 'D2': -99, 'D3': -110, 'D4': 238}}

(b'LJFm#\x96/R\xb9T6\xc6\x00\x00\x00\x02\x00\x00\x009\xd8|2X?\xe7\xa3F'
 b'\x81|\xb3"\x9dN\xe6q\xbe\x8a+u\xed\xbf\xdfa\x135\x8a\xee\x84\x00\x06\x00'
 b'\x00\x00k\x00\xa9zu?\x17\xa4\x94\xbe\xd1L\x8b=>\xe5\xb0\xbd\x99W#\xbf'
 b'\x01\xc8\xfd=\xfa!F\xbf4\xab\xb3>\xe5\xea\xa4>\x03F\xea>\xe4\x89\x10>'
 b'\x8b\xe9\x0c\xbd\xbf\xcep\x00\x02\x00\x00\x00;\xbfa\xfe\xb4\x00\x02\x00'
 b'\x00\x00C\xbef4\xb1\x00\x02\x00\x00\x00K\xbe\x9c\x99\x07\x00\x02\x00'
 b'\x00\x00S>\xb6\xe9\x03\x00\x02\x00\x00\x00[\xbe\xc5"\x19\x00\x02\x00'
 b'\x00\x00c\xbe\x06\x9a\xb0\x10]\x00\x00\x00\x02\x00\xa72\x98\xc0')

{'A1': 2564289070177203910,
 'A2': 'zu',
 'A3': {'B1': -662949288,
        'B2': 0.7386810807271085,
        'B3': -25266,
        'B4': -6543,
        'B5': -0.2698628008365631},
 'A4': -19,
 'A5': -0.49029998997477997,
 'A6': [{'C1': [0.5923550128936768, -0.4087871015071869],
         'C2': -0.8827927112579346},
        {'C1': [0.04660576581954956, -0.07487323135137558],
         'C2': -0.2248103767633438},
        {'C1': [-0.5069730877876282, 0.1221337765455246],
         'C2': -0.30585500597953796},
        {'C1': [-0.7057449221611023, 0.4490557909011841],
         'C2': 0.3572464883327484},
        {'C1': [0.1282002031803131, 0.44635820388793945],
         'C2': -0.3850257694721222},
        {'C1': [0.2732623815536499, -0.09365546703338623],
         'C2': -0.13144946098327637}],
 'A7': {'D1': [16, 93], 'D2': 50, 'D3': -104, 'D4': 192}}

Вариант №3

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

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

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

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

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

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

(b'\xc8BUAJfxcyseaa\xcb\xd0H\xfa\xc8C\x1aL\xa3\xd51\xfb\x05er\xddP\xf5\x03'
 b'\xd2N\x00\x04\x00\x00\x00E?\xc2h\x0cv\x0f\xef\xb0\x00\x00\x00u\x9b#\x97\xd0'
 b'\xd0V9,b0-\x9b\x0f\x82\x0f4\x8e\n\x7f\xd3\x07\xacl\xa7J\x00\x03\x00'
 b"6\xc7\xc0\xe7Ov\xceka\x00\x04\x009E\xf9d\xc5\x07j\xcb\xf4\x00\x04\x00=' \x0f"
 b'\xd8~\xdf\x93\xfb\x00\x04\x00A\x8a\x97F\xca\xd6\xd6\xa4\xc7[\x1ci\xccD\xe9P'
 b'\xef\xa9\x8fV\x88(\xdf\xcb\xe9')

{'A1': 'fxcyseaa',
 'A2': {'B1': -53,
        'B2': -3438222577471173469,
        'B3': 15362335804532907344,
        'B4': -184298930,
        'B5': [{'C1': 756555292332566346, 'C2': [-105, -48, -48]},
               {'C1': 14393758737557777249, 'C2': [86, 57, 44, 98]},
               {'C1': 5042172055213755380, 'C2': [48, 45, -101, 15]},
               {'C1': 2819270789249864699, 'C2': [-126, 15, 52, -114]}],
        'B6': 0.14380031361349443,
        'B7': {'D1': -8460215537990458169,
               'D2': 6565238682849726703,
               'D3': 12218079456880741353}},
 'A3': [155, 35]}

(b'\xc8BUAJtnuzpasu\xf7\xe2\xc1\x03\xb9\xb7\xc5W\xad\xa8v\xe8\x01D_'
 b'\x90\x9al\x9c\xe3\xa2\x00\x02\x00\x00\x00:\xbf\xc5\x1b\xd1?\x93`\x88'
 b'\x00\x00\x00R\x03$\xcd\xc9,(\xa7\x98\x0c[:\xf0\x81\x08\x00\x02\x006sN'
 b'\x1f\xdbg\x92V`\x00\x02\x008\x9fBu$\x88\xef\x057\x85\xe8\xaa\xae\x04\xc6'
 b"n\xa8\xee\xaf\xe5y%'\xb18")

{'A1': 'tnuzpasu',
 'A2': {'B1': -9,
        'B2': -2107399054445684819,
        'B3': 12139144937763475610,
        'B4': 1822221218,
        'B5': [{'C1': 12076415986764382472, 'C2': [-51, -55]},
               {'C1': 8308613389741086304, 'C2': [44, 40]}],
        'B6': -0.16491141895562955,
        'B7': {'D1': -6970880473439468233,
               'D2': -8797594207687119192,
               'D3': 17199217810428375352}},
 'A3': [3, 36]}

Вариант №4

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

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

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

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

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

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

(b'VYPX\x1c@\x99u4\x007=.\x98\xfc\xfah\xcc~pQ\xcf\xc0\xfd\xa3\x87\xf7\x13'
 b'\xfc\x91\x13\x95\xb4\x04\x14Vh\x06\x9aUQ\xa4\xfd\xda\xd6\xb3\xa3\x03\xbbXle'
 b'smo\xbf\xecJ\xfb0\x03\xb8xSW\x00\x00\x00\x05\x00\x00\x002!#D\xf3\x9e\\\x13'
 b'\xdc@"\r]g/\xfb\xd1%\x14\xdb\xb2\xe5v\xc7\xe0\xe6\x1b-]\x05\xd7\xd2'
 b'`\xa6\x92\x0b\xcdjC\xa0\xd6\xd5\xbc\x87')

{'A1': 1083798836,
 'A2': {'B1': -0.8841529786857469,
        'B2': 21335,
        'B3': 'lesmo',
        'B4': [{'C1': 555959539, 'C2': 40540, 'C3': 333201442},
               {'C1': 224225071, 'C2': 64465, 'C3': 622123954},
               {'C1': 3849766880, 'C2': 58907, 'C3': 761071063}],
        'B5': [-46, 96, -90, -110, 11, -51, 106, 67],
        'B6': -1596533316,
        'B7': 135},
 'A3': {'D1': 0.04262636601924896,
        'D2': 4201172094,
        'D3': [28753, -12352, -605, -30729, 5116],
        'D4': 10453863760452146792,
        'D5': 110777681,
        'D6': -92,
        'D7': -154575170168439976}}

(b'VYPX\x1c\xd6\x0b\xaf\\\x007?{\xa5\x8e\xec\xe5\x8e*\xd1G\x03\xe6\xc7'
 b'\x17\x08\x85\x1de\x9e\xf4EZ6i\xf9E\x1f\x8eye\x9d\x00\x8d\x88\xec\xfbkT\x03dh'
 b'clf\xbf\xdf\xf1\x9f\xa1K\xe8\xbc\x1cB\x00\x00\x00\x05\x00\x00\x002\x1dX\x8f'
 b':\x8a\xc6WaA\xbf\xaf\xbf\xa0\xd8\xac\xba\xa7\xbch\x1ez\xe4\xf8'
 b'\x81\x8f\xb5\xc7\xbe\xe2\xaf\xa6\xe7\x94\x0cj#q<`\xd7(f\x92')

{'A1': -703877284,
 'A2': {'B1': -0.4991225314294174,
        'B2': 7234,
        'B3': 'dhclf',
        'B4': [{'C1': 492343098, 'C2': 35526, 'C3': 1465991615},
               {'C1': 2948571352, 'C2': 44218, 'C3': 2814142494},
               {'C1': 2061826177, 'C2': 36789, 'C3': 3351175855}],
        'B5': [-90, -25, -108, 12, 106, 35, 113, 60],
        'B6': 1624713318,
        'B7': 146},
 'A3': {'D1': 0.9829949140548706,
        'D2': 3974467114,
        'D3': [-11961, 998, -14569, 2181, 7525],
        'D4': 11453856006072301893,
        'D5': 529430885,
        'D6': -99,
        'D7': 39838523127976963}}

Вариант №5

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

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

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

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

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

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

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

(b'\xc3PRLZ\xfa\xad\xbf\xca\xbbG,\xcd2\x90xpbc\xa3\x000\x00>\x00Lakqitmvl\x00j'
 b"?>\xd6\x97\x98\xcc\xe0\xaf\xbe%\xff\x97\xbf\x0ev'\x00(e\x7f^G\xbf6"
 b'\x85\x19\xbf\x17\xc4\xab\x006vF7\xb5?R\x12h\xbf}y\xbd\x00D?\xe01\xef\xa2\xbf'
 b"~N\xbf\xd4\xa3:(\x0b6\xd4\xbf\xc4'\x82y\xff>\x08\xe1\xc5\x87\xd0\xf1J/@\xda="
 b'\x00U<\xaa\n?1\x00\x00\x00\x03\x00Rhz\xa4\xc6')

{'A1': 90,
 'A2': -1363,
 'A3': {'B1': -0.20884027183128184, 'B2': 'xpbc'},
 'A4': -93,
 'A5': [{'C1': -0.5564903616905212,
         'C2': {'D1': -1731403601, 'D2': -0.16210781037807465}},
        {'C1': -0.5928446650505066,
         'C2': {'D1': 1702846023, 'D2': -0.7129684090614319}},
        {'C1': -0.990138828754425,
         'C2': {'D1': 1984313269, 'D2': 0.8205933570861816}}],
 'A6': 'akqitmvl',
 'A7': {'E1': 3787818960,
        'E2': 17386761267003064405,
        'E3': 1017776703,
        'E4': 49,
        'E5': [0.5060957125351224, -0.3224625960400378, -0.15745573956381542],
        'E6': 104,
        'E7': 31396,
        'E8': 198},
 'A8': 0.7454618811607361}

(b'\xc3PRL\rB\xa1\xbf\xe4i\x0e|\xaa\x93|opsk$\x000\x00>\x00Lkkfxmbkv\x00r'
 b'>\x02\xd1bV\x8bP\t?Y\xc3I?{2\xa8\x00(3\x97\xcfy?b\x12\x9d\xbfP\xea>\x006'
 b'\xcd\x8cS=?M(\x05\xbf\x00{\x19\x00D\xbf\xcc\r5&W\n\x00?\xea\x95k\xd1\x80'
 b'\x08\x10\xbf\xe0\xeb]\xd7\xf5\xec`\xbf\xb1b\xee\xee\x05x \xb7\xa1'
 b'\xe8\x0e\xc0>\x80g\x00\x99\xcd!F\x0c\xcfAY\x00\x00\x00\x04\x00R\x16\xd2~'
 b'\xf8')

{'A1': 13,
 'A2': 17057,
 'A3': {'B1': -0.6378242907418179, 'B2': 'opsk'},
 'A4': 36,
 'A5': [{'C1': 0.9812417030334473,
         'C2': {'D1': 1451970569, 'D2': 0.8506360650062561}},
        {'C1': -0.8160742521286011,
         'C2': {'D1': 865587065, 'D2': 0.8830965161323547}},
        {'C1': -0.5018783211708069,
         'C2': {'D1': -846441667, 'D2': 0.8013918995857239}}],
 'A6': 'kkfxmbkv',
 'A7': {'E1': 3080841230,
        'E2': 13852650683718290721,
        'E3': 1175244609,
        'E4': 89,
        'E5': [-0.21915306446142324,
               0.8307398883628156,
               -0.5287312715512478,
               -0.06791585265224898],
        'E6': 22,
        'E7': -11650,
        'E8': 248},
 'A8': 0.12775185704231262}

Вариант №6

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

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

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

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

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

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

(b'NPM\xfb\x00\x00\x00\x8f\x1c\x05\xda@\xed,u]\xb5\x00\x03\x00\x9b\x83\x07\xdc'
 b'I\x9e\x0f\xb6\xad\xce\xbb\xd3\xa4\xee\xce\x04\x98=\x97\x14\xce\xbe\xfb%'
 b'\xfe\x00\x00\x00\x02\x00\x00\x00\x15\xbf\xb7g\xc3\xc3D:\x90\x026['
 b"\xbfY\xe3\xab\x00\x1dO\x0b,\x88\xcd!=\xa2\x93't7`\xa2\x82\x10\xab^$\x90sm"
 b'\x13\xd3\x06\xd8\xe4z\xbe\xc4\xf7\xe0\xbe\xb9\xe4\x7f\x00\x00'
 b'\x00\x02\x00\x00\x00R\xbf\xc4\x85\x96\x13\xa1\xeb\x90\x07\x87\xa7\xbe-N'
 b'\x93\x00Zc\xac\x1d\xc2\xfdh\x18\x07\xab\x01\x98\xcf\x00\x00\x00?\x00'
 b'\x00\x00|\xbf\x13\xf4\x9f\xd6T\x8d')

{'A1': {'B1': [{'C1': 91,
                'C2': -0.8511301875114441,
                'C3': {'D1': 14896732897792623768,
                       'D2': [0.07377015054225922, -0.4905242323875427],
                       'D3': [2198330441, 2651829933],
                       'D4': -0.09142707364319791,
                       'D5': 2,
                       'D6': 54},
                'C4': [20235, 11400, -13023, 15778, -27865, 29751]},
               {'C1': -89,
                'C2': -0.16924504935741425,
                'C3': {'D1': 8317325883897078906,
                       'D2': [-0.3847036361694336, -0.36307141184806824],
                       'D3': [1621262864, 2875073680],
                       'D4': -0.16032672842615314,
                       'D5': 7,
                       'D6': -121},
                'C4': [25516, 7618, -664, 6151, -21759, -26417]}],
        'B2': -0.5779513716697693},
 'A2': 28,
 'A3': 421720902509878709,
 'A4': [-42, 84, -115]}

(b'NPM\xfb\x00\x00\x00\x8f\x95\xa4\xc4P\x9b\x0e\xa4\xban\x00\x04\x00'
 b'\x9b\x01\x19\xbb\xbb\xcf`\xf6\x9al1\xcd\xe1\xd1\xfcZ\xc8\xbfW\x08G\xbee['
 b'\xcc\x00\x00\x00\x02\x00\x00\x00\x15\xbf\xd54\xc1f\x1fgH\x05s\xcc\xbd\x02nB'
 b'\x00\x1d\xa0\x99~\xef\xc5\x0c%+\xd9\xa5\xdd\xf7n\x84\x11#\x88\r\xf9P_\xdb'
 b"\xaa#\x11'\xb4C\xbe\xcd\x82\x85\xbb\xc4\x84\xd9\x00\x00\x00\x02\x00\x00"
 b'\x00R\xbf\xe5\xb9%\xa4\x17\x92\xaePW7?4\xe8\xb5\x00Ze\xcc\xfc\x83\xed'
 b'wN\x9c\x80)\xa9\x88\x00\x00\x00?\x00\x00\x00|?\t\xa5\xca\xb0\xf3\xbe\x17')

{'A1': {'B1': [{'C1': -52,
                'C2': -0.031843431293964386,
                'C3': {'D1': 7796238799729351368,
                       'D2': [-0.839970052242279, -0.22398298978805542],
                       'D3': [18463675, 3479238298],
                       'D4': -0.33134493801991427,
                       'D5': 5,
                       'D6': 115},
                'C4': [-24423, 32495, -15092, 9515, -9819, -8713]},
               {'C1': 55,
                'C2': 0.7066758275032043,
                'C3': {'D1': 6907301521091179587,
                       'D2': [-0.40138640999794006, -0.005997281987220049],
                       'D3': [1854148899, 2282617168],
                       'D4': -0.6788509564326739,
                       'D5': 80,
                       'D6': 87},
                'C4': [26060, -893, -4745, 20124, -32727, -22136]}],
        'B2': 0.5376859903335571},
 'A2': 149,
 'A3': 11872703144551299694,
 'A4': [-80, -13, -66, 23]}

Вариант №7

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

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

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

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

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

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

(b'\x87TOM\xd3\xeb7\x04\x00\x00\x00d\x00\x9d\x18??\x02\x00\x00\x00\x94\x00\x00'
 b'\x00\x03\x00\x00\x00\x96\x00\x1a\xa2\xd5W\xafc\x02TC\xcc\xa7\xe6\xdesF\xd2>'
 b'\x13)\x91vV\xff\x18\xca\xd1t\x93K\xe9]\x88\xb6\xacK\xf1\x0f\xb8\xe9\xed\x19'
 b'b~lw\xe0s\xee?\xc9F\x1c\xc9\xc3\\\xa3\x166J\x93\xd3\x1a\x1b\x14\x17'
 b"\xe7'<\xecXv\x82V\xa2]\x16y\xdfq\xee\xbf\x14\xe4\xb9\xa5\x0e\xd7\x978TJ\xeb?"
 b'n\xa9gA\xa8>\xef-\xeb|\xc8?\xe9\xf1\x9c\x8e\xb0\x17\x9c\xf82\xc4\xcf?avZ\x00'
 b'a\x8f\xa0\x1b\xa7\xc9\xdf\xcc5\x81')

{'A1': -45,
 'A2': 14315,
 'A3': [{'B1': 1451390552, 'B2': -0.9514005055415746},
        {'B1': -1514544108, 'B2': 0.8528233628591992},
        {'B1': 1097312622, 'B2': 0.19131221526048603},
        {'B1': -1902317079, 'B2': 0.24817502154490745}],
 'A4': {'C1': 0.7464693188667297,
        'C2': 'av',
        'C3': [2405498970, 3383172000, 2167786719]},
 'A5': 6053510453883413018,
 'A6': 67,
 'A7': {'D1': 3739658188,
        'D2': 0.4106937348842621,
        'D3': [1989224723,
               3390635862,
               1267954897,
               3062390249,
               267471788,
               435022264],
        'D4': 0.9516451199051057,
        'D5': 1631249486000703177,
        'D6': 1662983964439300662,
        'D7': [10215, 60476]}}

(b'\x87TOM. _\x04\x00\x00\x00d\x00+\xd5\x05?\x02\x00\x00\x00\x94\x00\x00'
 b'\x00\x06\x00\x00\x00\x96\x00V\xc6"\x90,_;D\xab\x8f\x8c\xa5\xef\xd7\xd7q\xbf'
 b'!\x0b:\x95j\xdb\x069r.\x93^\x16 \x04\xaf\x14\xa7x\r)\xd9\x8a\xef,\xac\x8bU'
 b'\xb9\xf8\xd0\xbf7\xe0\x94R~h\x8b\xdb\x03Q\xe3\x8dj\xfb\x95\xaf\xb4o8_'
 b'\x06\xbf\xe0x\xd4\xba\x0eL\x84\x9a\xd6?\x1e\xa9\\\x9a\xea9;\x97v7\xe7\xbf'
 b'\xddlb&\xa0\xaa\xa0\xa3\x866\xe8\xbf]3\x86i\x94C\xdb\xd2\xc4\xf9\xe8?xvU\x13'
 b'\xb36U\xfb\xdd\xae\x94\xa1&\xc3>\x0c\x1a@\xe0\xcc^\x97\x11S\xb6\xd9')

{'A1': 46,
 'A2': 24352,
 'A3': [{'B1': 2027994886, 'B2': 0.35318095614904377},
        {'B1': -1705203426, 'B2': -0.725520415662513},
        {'B1': 643984605, 'B2': -0.7566559978343612},
        {'B1': 1770402653, 'B2': 0.7804893606463446}],
 'A4': {'C1': 0.5227839350700378,
        'C2': 'xv',
        'C3': [917705557,
               2933783381,
               3274088852,
               1075448894,
               2539572448,
               3652604689]},
 'A5': 4916628063206426198,
 'A6': -85,
 'A7': {'D1': 4020604047,
        'D2': -0.9446997046470642,
        'D3': [2503609121,
               956750698,
               1586703986,
               2936283158,
               226010900,
               4018854185],
        'D4': -0.2651809058576784,
        'D5': -2626891065879896009,
        'D6': 12652295163232866563,
        'D7': [28596, 24376]}}

Вариант №8

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

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

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

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

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

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

(b'RGI\x04\x8bX\x96\x16C\x0c\xd9_O\x9c\x02\x00(\x005\xb7\xfc\xbeHA,\xc7K^'
 b'\xc6/{w\x02\xbfM-{\xc89\xf3\xcea#\xbfiqcsw\xedM\x1b\xf3\xb2M\x8a'
 b"\x00\xb9\x8c7\x06\xf0\xe6\x1d\x1c3\xd6\x98c\xcbUVEwJ2\x93\x17V\xf6v\xd26'"
 b'\x9f\xe5?Bcn?xpcbdcXs\x17\xdf\xcevY%X\x19\xb3m\xd32\x14\xd9\xf7T\xed'
 b'\xdf\xac\x91\x84\xbe\x0c\x1aA~\xcc\x80\x85D_\x8c\x83\x80?')

{'A1': 6906564985830660235,
 'A2': -25521,
 'A3': [{'B1': -0.6382111310958862,
         'B2': 'iqcsw',
         'B3': 19949,
         'B4': 10140136630010442523,
         'B5': {'C1': 3874489911,
                'C2': 6182144421575990301,
                'C3': [17750, 19063, -27854, 22039]},
         'B6': 0.6756778784508402},
        {'B1': 0.9312020540237427,
         'B2': 'xpcbd',
         'B3': 22627,
         'B4': 6351581216287692659,
         'B5': {'C1': 3547181849,
                'C2': 12456936043521315890,
                'C3': [-31599, 3262, 16666, -13186]},
         'B6': 0.008063408524835891}],
 'A4': -0.4935852587223053,
 'A5': 16712,
 'A6': {'D1': [-14548, 24139, 12230],
        'D2': -0.5096356272697449,
        'D3': 11597,
        'D4': 51323},
 'A7': -3271}

(b'RGI\x04\x1e\xadba0OS\x14\x9c\x06\x02\x00(\x00]\x9d\x07?\xedR#L|\x17'
 b'\x11*\xe7\xc3\x02\xbd\x93\x16\x1f\xed8FQ\x8f\x86>veine\x8b\xf1m\xb2\xf6\xdf]'
 b'4av-?\x9d!9b\xe3\x16+\xce\xdc\x9b6\x19!&RZ\r\xe5\xce\x06\x0f\xcb0'
 b'\xb7\xe5\xbf\x8a\x1b\x86=hlliq\xab_\x11\xa6\xf0n\xeb\xfa\xc9\xf2\xc0X\xbdy]G'
 b'\x04\xd8\x9f\xaf\x1d\xcfw\xb2@i\xc6 9R\xf0\xd4Q]\x9b\x1c\xef?')

{'A1': 1464601373036424478,
 'A2': 1692,
 'A3': [{'B1': 0.26281216740608215,
         'B2': 'veine',
         'B3': 61835,
         'B4': 8530156747010519661,
         'B5': {'C1': 563953453,
                'C2': 11231078255218090553,
                'C3': [6454, 9761, 23122, -6899]},
         'B6': -0.6786121335973918},
        {'B1': 0.06548221409320831,
         'B2': 'hlliq',
         'B3': 24491,
         'B4': 17494790116582925841,
         'B5': {'C1': 2042452160,
                'C2': 14924277841234511709,
                'C3': [-19849, 26944, 8390, 21049]},
         'B6': 0.972242052330925}],
 'A4': 0.5297449231147766,
 'A5': 21229,
 'A6': {'D1': [19491, 6012, 10769],
        'D2': -0.03192510828375816,
        'D3': 5779,
        'D4': 60703},
 'A7': 17976}

Вариант №9

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

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

Поле	Описание
1	float
2	Структура B
3	int64
4	Структура E

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

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

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

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

(b'ZZP\xcd>\x92<\x95\x00\x00\x00`\x00\x00\x00e\x00\x00\x00j\x00\x00\x00o'
 b'\x00\x00\x00t\x00\x00\x00y\x00\x00\x00~ri\x00\x83\xd1S\x16J\xc2p\xb3l'
 b'.\xd6P\xbd;\xd7\xf4\xa2c\x1a\t\xdc?\x1b\xdc`\x00\x05\x00\xab\xa4\x81Fd'
 b'\x8e\xe8\xf3\x03\x05\xaf\x91:\x15\xcft\xa3\xb02\xcd\xd7$\xc8}\xc08_\x80\x19'
 b'\xd3>>\xd1n{\xbe\xcd~\xc3\x93\xbc\xf6Z\x8e\x19?-\x1f\xd8\xed>\xb3\xfb'
 b'\x89\xcd\xbfa\x14\x9f\x04?\x18\x08\xfa S\xac\xbf\xccdb\xd6\xd8\xcc bX'
 b"\xfd\xba\xcc\xfbR\xe1\x0f\xfe\x077>\xd6'o\x13\xd5\x8a\x98=\x98_\x10z\x8d"
 b'X}|\x837\x92>\xd8\xa4\xeb\x95\xc3\x8a')

{'A1': 0.28561845421791077,
 'A2': {'B1': [{'C1': 211, 'C2': 0.18634578585624695},
               {'C1': 123, 'C2': -0.4013577401638031},
               {'C1': 147, 'C2': -0.030072476714849472},
               {'C1': 25, 'C2': 0.676267147064209},
               {'C1': 237, 'C2': 0.35152843594551086},
               {'C1': 205, 'C2': -0.8792209029197693},
               {'C1': 4, 'C2': 0.5938869714736938}],
        'B2': 'ri',
        'B3': {'D1': 8275,
               'D2': -84,
               'D3': -0.22181354036874357,
               'D4': 98,
               'D5': 6412486833998061839,
               'D6': [-142084120218472685, -3059465606528036742],
               'D7': -1923580548},
        'B4': 3511883338},
 'A3': -4435848355736301379,
 'A4': {'E1': 4312184146515069404,
        'E2': 0.6088314056396484,
        'E3': [-31945, -28098, -10076, -5227, -15478],
        'E4': 2759935588,
        'E5': 142,
        'E6': [-5901, 773, -20591, 14869, -12428, -23632, 13005],
        'E7': -41,
        'E8': 2650506645240512537}}

(b'ZZP\xcd\xbf\x04\xc0\x10\x00\x00\x00`\x00\x00\x00e\x00\x00\x00j\x00\x00\x00o'
 b'\x00\x00\x00t\x00\x00\x00y\x00\x00\x00~km\x00\x83\xfe\xe3R$\x8a@\x06\xa5'
 b'\xdc^\xf0v\xbfPq\x08\xf1\x9c\xa7\xc4=\x8eo\xfc\x00\x05\x00\xab\n\x07\xadp'
 b',\x85\x14\xa1\x9c"p4\x03\x0f6\xa2\x11|:i\xb7+\xb5\xb9#\xbec\xbbw\xbf\x7f\xcb'
 b'u)?L\xac\x95k?gu\xa8\xa7\xbfQ\xfe\xe9\xcc\xbf\x14\xfe\x11\x8a>\xc9'
 b'\x8a\xeb\xb4\xbe.\xe8\xb7\xa2\x8eY\xbf\xdc\xb5I\xc4\x8b\xb6\xe8k!\xc9:}a'
 b'\xa3O\xd6\xf8\xab\x99\xc7B\xfc\xbai<\x8a\x16\xc1I\x12\xc1a\xcc\x9f\xa8Y!'
 b'\xc9\x9d\xf6\xdd\x05\xbb\xf9\x1cA')

{'A1': -0.5185556411743164,
 'A2': {'B1': [{'C1': 119, 'C2': -0.9991982579231262},
               {'C1': 41, 'C2': 0.7995083928108215},
               {'C1': 107, 'C2': 0.9041390419006348},
               {'C1': 167, 'C2': -0.8202958703041077},
               {'C1': 204, 'C2': -0.5820017457008362},
               {'C1': 138, 'C2': 0.3936379849910736},
               {'C1': 180, 'C2': -0.17080961167812347}],
        'B2': 'km',
        'B3': {'D1': -23922,
               'D2': 89,
               'D3': -0.44856495088502735,
               'D4': 107,
               'D5': 2434541383753879510,
               'D6': [-528159450184500631, 4362324208472211809],
               'D7': -861951911},
        'B4': 4276310564},
 'A3': -8484774388529434506,
 'A4': {'E1': 13785642742608340932,
        'E2': 0.06954953074455261,
        'E3': [8649, -25098, -8955, -17415, 7233],
        'E4': 168275312,
        'E5': 44,
        'E6': [-31468, -24164, 8816, 13315, 3894, -24047, 31802],
        'E7': 105,
        'E8': -5247901133996923973}}

Вариант №10

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

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

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

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

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

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

(b'TVLH\x00\x00\x00(\x00\x00\x00\x07\x00\x00\x00M\x00T\x00\x00\x00\x03\x00\x00'
 b'\x00Z\x00\x02\x00\x00\x00~\x17\x13?\xbb\xf3\xb1(\xe4\xbf\x00\xfd\xe2'
 b'\x84\xc6\xfc\xd2\x1edgE^\x12\xbb\xaak\x99\xcc?\xe5@\\\xfcngF\xbf'
 b'\xee\xa7\xff\x9b\xf2\xcef\x02\x9dcjeonjy\xcf\x14\xbf:\xa8\x9f\x18\x1e'
 b"\xa7\xa7?\x01\x87\xcb\t\x9be0>\xedx\xa1\xbd\x9a:\xe7n2'\x8a\xaf{\xecS?^"
 b'\xc9\x0e\xe4\xbc\x05\x82M\xac')

{'A1': {'B1': -0.5038739442825317,
        'B2': -2067333934,
        'B3': 30,
        'B4': 'dg',
        'B5': 4998453233655192012,
        'B6': 0.6641068392084228,
        'B7': -0.9580076261394879,
        'B8': 669},
 'A2': 'cjeonjy',
 'A3': {'C1': 53012, 'C2': -0.7291354537010193},
 'A4': [{'D1': 404662183, 'D2': 0.5059782862663269, 'D3': 161178928},
        {'D1': 1055750305, 'D2': -0.07530765980482101, 'D3': 1848780682},
        {'D1': 2944134227, 'D2': 0.8702553510665894, 'D3': -457439870}],
 'A5': [77, -84],
 'A6': 387137467,
 'A7': 4088473828}

(b'TVLH\x00\x00\x00(\x00\x00\x00\x02\x00\x00\x00M\x00O\x00\x00\x00\x03\x00\x00'
 b'\x00U\x00\x02\x00\x00\x00y\n\xec\r\xef\x943B3\xbf\x11\x0c\xb9'
 b'\xc4\x91\xc6\xee\xf9vn,\x933{d\x1b\xcf\xa7?\xc1\x82\x90\x9fa}\x10?\xe8^]b'
 b'\xc1\x99\xa2\xf1\x8bovD ?D\xa2\x18\xbf\x0f\tB?&s\x86\xc2E(~q.\x9d'
 b'\xde?\x00\x99\xb13\xa24:owL\xe1\xbf\\\x10\x93\xe7\xacx\x7f\xbb\x82')

{'A1': {'B1': -0.5666003823280334,
        'B2': -997079314,
        'B3': -7,
        'B4': 'vn',
        'B5': 3211967564298833831,
        'B6': 0.1367970255114206,
        'B7': 0.7615191391785638,
        'B8': 61835},
 'A2': 'ov',
 'A3': {'C1': 17440, 'C2': 0.7680983543395996},
 'A4': [{'D1': 3205433666, 'D2': 0.6502002477645874, 'D3': -1035655042},
        {'D1': 1898880478, 'D2': 0.5023451447486877, 'D3': 866268218},
        {'D1': 1870089441, 'D2': -0.859627902507782, 'D3': -408127361}],
 'A5': [-69, -126],
 'A6': 183242223,
 'A7': 2486387251}

Вариант №11

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

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

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

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

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

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

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

(b'BEDsxacl\xa3T\x0e\xcdh\x8d\xe2QN4\x1c+3a+\x0b\xcf25v\xa34\xf3\x03'
 b'\x8d\xd1:\x9c\xf4\xe6\x90\xb0X\xb9\xadd=B\t\xc6\xf7\xa3\xdaV`\xbc\xd4\x06'
 b'>\xc2\xe2\xef\xcaK\x9c<|\x91n\xe3\x8d079 \xc6\xa6\xa8\x92;\xaa\x84q\x89a&'
 b'7\xfc?h\x8d\xc0\x1e\x0b\xe0_\xe1\x00\x00\x00\x03\x00k\x8a\xf9\x81z\xd2\x8dA'
 b'\xe7;')

{'A1': 'sxacl',
 'A2': {'B1': [{'C1': -23724,
                'C2': [3789, 26765, 57937, 20020, 7211],
                'C3': 51},
               {'C1': 24875, 'C2': [3023, 12853, 30371, 13555, 909], 'C3': 209},
               {'C1': 15004,
                'C2': [62694, 37040, 22713, 44388, 15682],
                'C3': 9},
               {'C1': -14601,
                'C2': [41946, 22112, 48340, 1598, 49890],
                'C3': 239},
               {'C1': -13749,
                'C2': [39996, 31889, 28387, 36144, 14137],
                'C3': 32},
               {'C1': -14682,
                'C2': [43154, 15274, 33905, 35169, 9783],
                'C3': 252}],
        'B2': {'D1': 63,
               'D2': 7533888986941513697,
               'D3': [65, 231, 59],
               'D4': [-118, -7, -127]},
        'B3': {'E1': 31442, 'E2': 141}}}

(b'BEDmrdpr\xef\xb2\xdfb\xafXe<e\xde\x0f^/\x15r\x81\x82}\xed}\x8bv\xd5\x1d'
 b'=\xbd\xb8zEW\x81t\x83b3\xa7PC-\xaaC\x04D\xa1_[6\xdaF\xf4]1\xeeO;N'
 b'\xbb\xcbd\xe6J+c\xbf\x7f\xc9\x97\x1e\xa1\x9e\xe5\x92]\xe6uV\x82\xe7E\xe2'
 b'\xfe\x02p(F\x14 \x00\x00\x00\x02\x00k\xb6\xfc\xb6\x9f\x06\x8c\xa5\x0c')

{'A1': 'mrdpr',
 'A2': {'B1': [{'C1': -4174,
                'C2': [57186, 44888, 25916, 26078, 3934],
                'C3': 47},
               {'C1': 5490,
                'C2': [33154, 32237, 32139, 30421, 7485],
                'C3': 189},
               {'C1': -18310,
                'C2': [17751, 33140, 33634, 13223, 20547],
                'C3': 45},
               {'C1': -21949,
                'C2': [1092, 41311, 23350, 55878, 62557],
                'C3': 49},
               {'C1': -4529,
                'C2': [15182, 48075, 25830, 18987, 25535],
                'C3': 127},
               {'C1': -13929,
                'C2': [7841, 40677, 37469, 58997, 22146],
                'C3': 231}],
        'B2': {'D1': 69,
               'D2': -2090230496318057440,
               'D3': [165, 12],
               'D4': [-74, -4, -74]},
        'B3': {'E1': 40710, 'E2': 140}}}

Вариант №12

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

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

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

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

(b'TWX\x00\x00\x00\x02\x00*\xbe2\xce{\xe9\xb7@x\x12\x85\x99B\x06\xeeB|\xc8\xb5{'
 b'\x8e\xf3/ \xff^\x00\x00\x00,\x00f\xc8\nsv\xbf\xd0\xaa&\xdc\xc1\xa8d'
 b'__\x83\xe7\xc2\xd8\x16_\x12\xbf\xdb\xe2\x1d\x1e\x8b\xfa\x94\xbf\xc0\x96'
 b'OR\xff \xb8?\xdc\xde-\xdb,\x81\xac\xbf\xebf\x10[\xbd\xa3*?\xdcagg}4'
 b'\xd0\xc2=\xdc\xcdq\xf2\xb23\xb7\x1d\xb6\xad"\x1e\xd0Q\x18\xea\x04g\x82];'
 b'\x14\xdfQ\xc9\x8cR?\x11\xf0\x92')

{'A1': 'sv',
 'A2': {'B1': -0.1746157854795456,
        'B2': 16841000216026257730,
        'B3': 6,
        'B4': 60994,
        'B5': [{'C1': 124, 'C2': 3367336846}, {'C1': -13, 'C2': 790691678}],
        'B6': {'D1': -0.26038524206399516,
               'D2': 95,
               'D3': 24451,
               'D4': -406661098,
               'D5': 24338,
               'D6': [-0.43567588790021117,
                      -0.12958709290092485,
                      0.4510607376451172,
                      -0.8562089721500332,
                      0.4434450636516205],
               'D7': -62}},
 'A3': {'E1': 4457663620476711863,
        'E2': 498511138,
        'E3': 7888,
        'E4': 20760,
        'E5': -368810110,
        'E6': 6717986218535652434,
        'E7': 0.5700770616531372},
 'A4': [200, 10]}

(b'TWX\x00\x00\x00\x02\x00*?T\xe60aB\xab\xe9JG#\xc7B\x02RU=\xcf\xa5'
 b'\x95\x12{\xdaJ\xfb\x00\x00\x00,\x00f\xc17zb?\xd5\xd2<\xc9\xec\xb5p\rmMA'
 b'\xfbv\xed\xe1b\xbf\xe2\xeb\x03\xb7Y\x8a\xee\xbf\xe5\xe29F\x1b\x8f\x8e?\xdeB'
 b'&\xa2\x89\xeb\x90?\xc7Xs\xafX\xa5X?\xd9!G.\x0b\xe6\x08\xa3@\x12.\x01\xabK'
 b'p\xcc\x89\xd4\x1a|az\xe5\xbe\xb7\xae\x98\xd5}\xd7O\xd7\x17\xd90\xea\xbf^'
 b'+\x05')

{'A1': 'zb',
 'A2': {'B1': 0.8316373825073242,
        'B2': 7008352988603818951,
        'B3': 66,
        'B4': 594,
        'B5': [{'C1': 85, 'C2': 1037018517}, {'C1': 18, 'C2': 2077903611}],
        'B6': {'D1': 0.34095687598422497,
               'D2': 13,
               'D3': 27981,
               'D4': 1106999021,
               'D5': 57698,
               'D6': [-0.5911882954645458,
                      -0.683865200928709,
                      0.4727875315945136,
                      0.18238683759526952,
                      0.39265613075949135],
               'D7': -93}},
 'A3': {'E1': 4616803152711872716,
        'E2': -1982588292,
        'E3': 24954,
        'E4': 58814,
        'E5': -1213294379,
        'E6': 9067804159970455786,
        'E7': -0.8678439259529114},
 'A4': [193, 55]}

Вариант №13

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

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

(b'NLX\xb1\xf9o\x1b\x94\x03\x00d\x00\x00\x00\xb6\x91\xa5\x9c\x06?'
 b'\xc2\x97\xad\xde\xa6\r\xb4\x9a\xf6\xdb*-B\xbfjtV\xa0\xeb\x98\xb5\xb7\xe5\xff'
 b'\xed\xd5\xcc>p#u\xc8\xdcJt\xfc\xdaT\x1f\x860>\xd1q\xe9\xb8=\x8b<\x9d\x87|'
 b'\x1cg\x00X\xe2fs\xf1;\xce\xbf\x10\x1cg\n1\xa0w\x89{\x03\x00\x00\x00'
 b'\x8c\x00\x00\x00lve=\xa3\xd2(\x13\x9e\x9da\x8c{{\x9f\x00\x1d\x01+R'
 b'\x01\x0b\x1c*\xcazs\xad\xd0\xfbkjE\x861TT\x10~\xcbg\xcaE')

{'A1': 2484826105,
 'A2': 'lve',
 'A3': 37302,
 'A4': {'B1': [{'C1': 0.5258277058601379,
                'C2': -26686,
                'C3': -2596718037018681683},
               {'C1': -0.7585016489028931,
                'C2': 29802,
                'C3': -7397833788645290},
               {'C1': 0.40006962418556213,
                'C2': 9072,
                'C3': 6114477020511258741},
               {'C1': 0.17238663136959076,
                'C2': 29137,
                'C3': 8973313665918679273}],
        'B2': 28,
        'B3': {'D1': [7033951998149043005,
                      3098789907120487308,
                      8321185543728333138,
                      3568616078118211757],
               'D2': 2114999380,
               'D3': 203},
        'B4': -0.23620432028634997,
        'B5': 16,
        'B6': 8901777668375734044,
        'B7': [103, -54, 69]}}

(b'NLX\xb1\xb7\x08\x0bO\x03\x00d\x00\x00\x00\xd4\xed\xecW\xe4\xbe\xafeow'
 b'[=\xad\x9a\x9d\xc3\x06\x1b\x0b?\xee\xde\xc2\xca\xd5b\x0c\xf16\xc8\x1e\xd46?'
 b'\x0b3z\x99\xde8\xf8\x88>%\xc9]\xdc>\x9e\x13n\x8d\xe9\x91\xe5\xa5\xb0\xd8'
 b'!g\x00\xf0\xb5\xab\xb8D\xa7\xc8?|\xca)q\xb6k>\x06\xc8\x05\x00\x00\x00'
 b'\x8c\x00\x00\x00dwy\xc3\x82\xf1x4J\xe3c\x92\xd2j\xfd\xbc7\x9d\xe3h'
 b'\x088\x8d\xb9\x898\x85 \xa1\xcf\x8e\xa3_\xbf\xb7\x07\x1b&\x83_\xd8\x7f\x93$'
 b'S')

{'A1': 1326123191,
 'A2': 'dwy',
 'A3': 60884,
 'A4': {'B1': [{'C1': -0.44598329067230225,
                'C2': 26031,
                'C3': -4351151596120606865},
               {'C1': 0.5433810949325562,
                'C2': -8466,
                'C3': -4019760581881509182},
               {'C1': 0.7141741514205933,
                'C2': 13067,
                'C3': 2683733027646773626},
               {'C1': 0.4304030239582062,
                'C2': 5022,
                'C3': -2832581760201945746}],
        'B2': 33,
        'B3': {'D1': [7197678218696032963,
                      16401326702798230162,
                      9599574035771426920,
                      13240406585572827424],
               'D2': -2094654713,
               'D3': 95},
        'B4': 0.19260462777258125,
        'B5': 124,
        'B6': 14413276289789143498,
        'B7': [-40, 127, -109, 36, 83]}}

Вариант №14

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

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

(b'NTD\x00\x03\x00\x00\x00~%\xa8\xeb\xf5C\t\x02\x1b\x02Y\xa7,\xfd\x00\x00'
 b'\x00\x83Z\xf6\xca?{^y\x84\xdf\xff\x81\xa8\x0cx\xf7\x81S\xf6\xab\x94\xf9{'
 b'"\x85\x12\xc5\xca\xe4`\x83\x8ez\xb6\xd5:\xa7l\xc1\xdb}\xfe\x92F\xfe\xde\xde'
 b'f|\x93\xdfx\xbf\x7fL>\x81\x9d\xe6;S\x00\xb7\x00~k\xd4\xfd\x0b\xec"\xa5!\xddN'
 b'\'\x96\xa7\x98\xb8,\xa8\xb2\xab\xbd\xd0\xaf\xe4{y\xb8\xc9=\xf1S"\xbfH\xbb'
 b'w?sziss\x0b|\x03\xcbq$\x88U\x00\x00\x00\x02\x00\x00\x00\x81')

{'A1': 'szi',
 'A2': 9640,
 'A3': 60405,
 'A4': 4830394390358370092,
 'A5': 253,
 'A6': {'B1': 827540603840792661, 'B2': 'ss'},
 'A7': [{'C1': 1526123071,
         'C2': 123,
         'C3': 94,
         'C4': [31108, -8193, -32344, 3192, -2175, 21494, -21612, -1669],
         'C5': 2487415009913888899},
        {'C1': 2390406869,
         'C2': 58,
         'C3': -89,
         'C4': [27841, -9347, -366, 18174, -8482, 26236, -27681, 30911],
         'C5': 9172775267467672403},
        {'C1': 11993214,
         'C2': 107,
         'C3': -44,
         'C4': [-757, -5086, -23263, -8882, 10134, -22632, -18388, -22350],
         'C5': -6071467268754409032}],
 'A8': {'D1': 201,
        'D2': 0.11783434450626373,
        'D3': -0.7841104865074158,
        'D4': 63}}

(b'NTD\x00\x04\x00\x00\x00~\xa7\xda\xf9Wql\x11\x17!\xcb\xa5ZE\x00\x00'
 b'\x00\x84\x03p\x92w\xcf\x88\x93\xda\x0f\x93\xa7\x1b\xc7;[B\xbe\xdb\x0f<\xeag'
 b'f\x8e\xcc)\xe9\xa1\xd2\x01\x88\x19\xa8$\xd2`\xdc?\x87FK5j#7\xd8\xa8/\xe6\x8d'
 b'\x14\xac\xdd\xa4\xf9\xac\xc1+\xaa8\x8a6EV\xe7Q\x8fS\xa2D\xe5?\xff\x8c-gC\xb8'
 b';\xbc\xf9\xf8\x11OVvs.\xd0d\x91\xbfM\x89d\xbe!${kbkjspb\xf6\x9e\xd1\x16'
 b'\x11\x85\x0b&\x00\x00\x00\x02\x00\x00\x00\x82')

{'A1': 'bkjs',
 'A2': -22566,
 'A3': 63831,
 'A4': 8172926214819521882,
 'A5': 69,
 'A6': {'B1': 17770871072363973414, 'B2': 'pb'},
 'A7': [{'C1': 57709175,
         'C2': -49,
         'C3': -120,
         'C4': [-27686, 3987, -22757, -14533, 23362, -16677, 3900, -5529],
         'C5': 7390068518946984449},
        {'C1': 2283382820,
         'C2': -46,
         'C3': 96,
         'C4': [-9153, -30906, 19253, 27171, 14296, -22481, -6515, 5292],
         'C5': -2475579374776374728},
        {'C1': 2318812502,
         'C2': -25,
         'C3': 81,
         'C4': [-28845, -23996, -6849, -116, 11623, 17336, 15292, -1544],
         'C5': 1247310688543494244}],
 'A8': {'D1': 145,
        'D2': -0.80287766456604,
        'D3': -0.15736572444438934,
        'D4': 107}}

Вариант №15

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

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

(b"SNON\x83\x00'\xcaWkk\x08\x08\x92\xc2\x00\x00\x00\xa0\xb6`*1\xa4"
 b'\xcf\xcd\x8f\xbd\x1e;\xed\xe9\xb7\xc7\t]=\xdfn\xca\xce\xf5R\x00'
 b'\x05\x00\x00\x00\x13\xbe\xf1\xf5\xd3\xf9^\x90[\xe9\xdbj\r]mtK\x96Jc1m\xc64'
 b'\xf4l\xe4\xda\x9cI\xc6\xdcQ,\x1cST\xcc\x96\x15^\xbfIm\xb1\xd3\xc7\xfe'
 b'\xa7\xef\x83\x8e\xdd\xed\xbfB7R\xcfnw\xebs\x0f-G\xf4d\x8e\xfc\x8b\xc2'
 b'\xf8\xd1\x17E\x0f\xa9\x1f\x1b0q\x80\xc7\xd0\x0f\x7f\xeeb\xfb\x08\x80'
 b'\xcb\xe8<\xe2\x86\xd1\xdb\x970l\x93\xacIm\xaa6[F0\xa1\xbf\xeaH\xc5C\x8b\x9a.'
 b'\x00\x02\x00\x00\x001\xa6\x00\x9b')

{'A1': {'B1': 3402560850,
        'B2': [-1235211727, -1529885297, -1122092051, -373831927, 1564335982]},
 'A2': 14580240426075722434,
 'A3': {'C1': -0.8213831252331312,
        'C2': [{'D1': -0.47257861495018005,
                'D2': -477785786014799347,
                'D3': 93,
                'D4': [28020, 19350, 19043, 12653, -14796, -2964],
                'D5': [-6950, -25527, -14628, 20780],
                'D6': [2041068293797011135, 5291080660381771759],
                'D7': 2207178221},
               {'D1': -0.7586566209793091,
                'D2': -3499728007288902329,
                'D3': -12,
                'D4': [25742, -885, -15624, -12009, 17679, -22241],
                'D5': [6960, 29056, -14384, 3967],
                'D6': [17177567942683650108, 16322964640515517587],
                'D7': 2890493354}],
        'C3': 166,
        'C4': {'E1': 54, 'E2': 23366, 'E3': 12449}}}

(b'SNON\x83\x00\x1bm\xb7\xca\xec\xfb5\xe6G\x00\x00\x00\x94}r\xe0e\x96\x81\xea&)'
 b'_\x9c\xa2\x00\x02\x00\x00\x00\x13\xbfvL\x85\xe7gp!\xb1\xd3\xa0'
 b'\x8b\x94\xf9\xe9&\x12\xd8\x88\xc5w\xf9\xca\xcf\xba\n\xe2\tdE;ro\xcc='
 b'\x8f\xd0f\x10~\x02}Mq\x0c\x95jG\xcd\xd3DD\xcb?\x11SN1\x9a\x9b\x18&t'
 b'\x8a\x92\xa4"\x99X\xe5\x89\xa1NH\x92q\xf8I\xa9]\x9c\x87\xc5\xd3\x99\x15['
 b'\xbc\x1f\xec\x95\xed_Z"\xdc\xe9\xf4q\xba\xfd;\xe5\x99\x9eCI*\x80\'\xf9'
 b'\xbf\xe0e\xb6\x15\xe5R\x1c\x00\x02\x00\x00\x00%\x99\x00\x8f')

{'A1': {'B1': 694131874, 'B2': [2104680549, -1769870810]},
 'A2': 7906010790047901255,
 'A3': {'C1': -0.5124159267093691,
        'C2': [{'D1': -0.9621050953865051,
                'D2': -1772324638327332725,
                'D3': -108,
                'D4': [-1559, 9746, -10104, -14985, -1590, -12358],
                'D5': [2786, 2404, 17723, 29295],
                'D6': [14717077282544975362, 9028997126808029133],
                'D7': 3544466635},
               {'D1': 0.56767737865448,
                'D2': 3574339782298602130,
                'D3': -92,
                'D4': [8857, 22757, -30303, 20040, -28047, -1975],
                'D5': [-22179, -25465, -14893, -26347],
                'D6': [6610193454061150042, 2512139928255266107],
                'D7': 3852049987}],
        'C3': 153,
        'C4': {'E1': 73, 'E2': 10880, 'E3': 10233}}}

Вариант №16

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

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

(b'PFY\xb2\xc6\xd3\x16\xbd\r\xec(M\x00\x00\x00T$\xc3YSh^\xa2<\xd5\xa6\xe5\xbf'
 b'oq\xefv\xb0~Nh[!m\x01\xc7kZ\x18\xdf\x1bV\xc5\xa9\xd5\xaa;I\xc4\xa6\x81'
 b'\xd5!\x9b|\xb6\nB\xf5\xc9\xd16\xea(\x9e#\x06\x00\x81\x00\x00\x00W%*?l2\xf2'
 b'>\xecW\x93\xbeXy\xb1\x0f\x01\x88\xc8?\xe4t&}\x89_4\xc1\x87\xbd\x97'
 b'\xcc\xf7\xbe\xe0\x90\xda1_\xa5\xaf\xbf\x1f\xa62\x06N\xb8QU_\xf7\x90\xa7\xa7'
 b'T\xf5l')

{'A1': 3172389830,
 'A2': 13,
 'A3': 10476,
 'A4': {'B1': {'C1': 0.664632260799408,
               'C2': [{'D1': 0.47304093837738037,
                       'D2': -0.28778016567230225,
                       'D3': 0.19165051714203218,
                       'D4': -28,
                       'D5': 116,
                       'D6': 1602845990},
                      {'D1': -0.06628647446632385,
                       'D2': -0.48398277163505554,
                       'D3': -0.06180856212202612,
                       'D4': 31,
                       'D5': 166,
                       'D6': 3092121138}]},
        'B2': -144747183},
 'A5': 1505961044,
 'A6': {'E1': 83,
        'E2': -0.6766153511297945,
        'E3': 'oq',
        'E4': 239,
        'E5': [7863666927917248630,
               6204798207322212097,
               12016810226349353413,
               4758816602565236097,
               2566533824054938101],
        'E6': [144, 167, 167, 84, 245, 108]}}

(b'PFY\xb2\xa9\xdfr\xa3h\xd5\x10M\x00\x00\x00=\xf7Q\xe9\x03\x90\x0cV\xff'
 b'[\xa8\xce\xbfeo\xb9w\x02\xe7j.\xc5Yb\xcfv\xd4\x8a>(\x10<\x81\xcb\xf7\xee\x16'
 b'd\x82\x0fL{%*\x11\xba\xac\xe7\x9a)\x1a\x85P\x18\xc0I\x05\x00\x81\x00\x00'
 b'\x00\xf1W\xb5>\x84\x07\x00?\nX\xe3\xbe\xd6\xbe\xbf\x1e\xd7\xab\xe5'
 b'\xbf\xd1*\x0b\x1c\x1c$V|}>7<g\xbf\xe4\x01#8\xc7\x9a\xd8?\x96]\x11vv'
 b'T\x9d\xdb6\x912X6|\x11')

{'A1': 2742214569,
 'A2': 104,
 'A3': 4309,
 'A4': {'B1': {'C1': 0.3541865646839142,
               'C2': [{'D1': 0.5001146793365479,
                       'D2': -0.4440310597419739,
                       'D3': -0.6772266007009999,
                       'D4': -47,
                       'D5': 42,
                       'D6': 605821963},
                      {'D1': 0.24754461646080017,
                       'D2': -0.9032625555992126,
                       'D3': 0.3844469116411615,
                       'D4': -106,
                       'D5': 93,
                       'D6': 1417049617}]},
        'B2': -1858675811},
 'A5': -380504259,
 'A6': {'E1': 3,
        'E2': -0.23951292007049974,
        'E3': 'eo',
        'E4': 185,
        'E5': [7086912291796877943,
               4328003490985309903,
               1117565707202579329,
               16693922501639895884,
               5314274294406719898],
        'E6': [50, 88, 54, 124, 17]}}

Вариант №17

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

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

(b'FMM\x10\xda?\x07\x8f\x8d\xd7O\x00Q\x00V\x00[\x00\x00\x00`yx?w\x83\xca\xb1'
 b'#JJ>\xfai2\x00\x03\x00\x00\x00la\xfa\xba\xf1;\x96\xc5\xaa"\x1f\x84'
 b'\xdab\xdc\xf5\x9a\xd9\xf8U\x9bq\xb5\xbf\xaal8\xdd\xfdM\x18\xc3\x19}YJ'
 b'\x08s\n\xd212\x08*\xaf\nO\xa5g\xa2{\x08\xdaP\xf4\x87\xd9\xfe\xbf\xe2'
 b'\x10\x1e\xa1\xe0n\xaa\x96\xe6\xb5F`D[G')

{'A1': {'B1': 4314, 'B2': 0.5295341610908508},
 'A2': 55119,
 'A3': [{'C1': 50, 'C2': 137015050},
        {'C1': 79, 'C2': -1519934853},
        {'C1': 8, 'C2': -632228729}],
 'A4': {'D1': 217, 'D2': 254, 'D3': -0.5644677316335749, 'D4': -26906},
 'A5': 'yx',
 'A6': 0.9668546915054321,
 'A7': {'E1': 2971880010,
        'E2': 0.48908382654190063,
        'E3': [-19130, 24644, 23367],
        'E4': 7060160911106295210,
        'E5': [572490970,
               1658647962,
               -638036581,
               1907736490,
               1815666173,
               1293468441,
               2103003656,
               1930089009]}}

(b'FMMM\t\xbd\xd8>\xcc,\xce\x00Q\x00V\x00[\x00\x00\x00`zy\xbf2\xd7C\xc7'
 b'\xc1\x1c\xc9\xbf\t\xb1V\x00\x02\x00\x00\x00l\x0f\x8a\xa1\xcc\xc8\xc1['
 b'\xd1a\xbb\xd3\xc4f@\xc8P|Ba\xbf>\xe2\x9d\x18\xfe\x8e\x1d\x9b4\x82\x7f'
 b'\xff\xedur\xdf\xcc\x0b|o\xe3\xc6A\xe5\x06\xe5\xb2(\x8d\xd5\xdb\xf2*K\x92'
 b'l\x00?\xe7\xd3.\xbe\xa2\xc7.$R\xcb\x9e$\xd2')

{'A1': {'B1': 19721, 'B2': -0.10558852553367615},
 'A2': 11470,
 'A3': [{'C1': -29, 'C2': -968760058},
        {'C1': -27, 'C2': -1305965099},
        {'C1': -37, 'C2': -232109166}],
 'A4': {'D1': 108, 'D2': 0, 'D3': 0.7445291255337219, 'D4': 9298},
 'A5': 'zy',
 'A6': -0.6985971331596375,
 'A7': {'E1': 3351321801,
        'E2': -0.5378621816635132,
        'E3': [-13410, 9426],
        'E4': 1119885358268505041,
        'E5': [1639699396,
               1715521616,
               2084725183,
               1055038744,
               -24240741,
               880967679,
               -311069985,
               -871662481]}}

Вариант №18

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

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

(b'PGWT7sqp\xbf\xea=W\xbclCr\x1c8#8\x13\x81\xf3\xddS\x00aE3\x87@\x8d'
 b'\xc5\xfcM\x07\x938\xf9\x1a\xaaz\xff\xde\xf6jH\xe4\xbdXP\x87\x8f\x9b4\xb5'
 b'\x18\xac\xd9\xcd44\x82\xa5\xe9\xb6\x0f&\xa1\xd7\xc4\x1c\xa1\x00t\xef'
 b'v\xd5#\x7fG\x95\xb5\x00\x00\x00\x88\xe4\xe9\x84q\x00\x06\x00\x00\x00'
 b'\xa7,Y\xcd\x96\xc1\xdd\x1b\xca\x7f[X\xf1\xa0\x8an\x85\t\xb1\x07\xae\x99\x08k'
 b'\xca%#\x027\x9c\n\xda\x8e#\x00\x05\x00\x00\x00jB\xbf\xa3\xae\xf7d\x13A'
 b'@"\xe1j\x07\xd1Y\xb3\xdb3\x85\xbfHt8\xa2\x8a\xd0:c\x11\xa5\xc8\x86'
 b'\xaai\x00\x87i')

{'A1': 'sqp',
 'A2': {'B1': -0.8199881248602721,
        'B2': 28,
        'B3': 4045138546744614227,
        'B4': {'C1': 44, 'C2': 6470993998983711359},
        'B5': [{'D1': 1161004864, 'D2': 141, 'D3': 50684},
               {'D1': 1292342072, 'D2': 249, 'D3': 6826}],
        'B6': [8863047741614908605,
               6363735324328506648,
               -5991532205136763415,
               -5327997357604463455],
        'B7': {'E1': -5865647780627406078,
               'E2': 932973274,
               'E3': 36387,
               'E4': [23384, -3680, -30098, -31479, -20217]},
        'B8': -1191530702956948043},
 'A3': {'F1': 66,
        'F2': -0.03844426247235555,
        'F3': 585198087,
        'F4': -11943,
        'F5': -1277480059,
        'F6': -0.7830233573913574,
        'F7': -6734341343590373944},
 'A4': -6935,
 'A5': 33905,
 'A6': [134, 170, 105, 0, 135, 105]}

(b"PGWT7bdg?\xee\xaf\xc5vf\n\xb2NzD\x85\xbeL'\xd7\xff\x00aa\x83o\xe4y"
 b'\xf2\x8a\xee\x04\x8c\xbd\x11\xde\xa9\xd6K\x93\x1e\xdaO\xc3\xc1\x03\xfd\x8a'
 b'\x8c\xc3i\xc6\xd7\x83\xe5\x00^^\x93\x83\x16\x0b\x89N\x08&c\x03P\x00t\xd3'
 b'[7\xac\x0eL\xe3\xc4\x00\x00\x00\x88\x96\xdd\x98\x9a\x00\x03\x00\x00\x00'
 b'\xa7\x10d\xd8\x0e\x15\xe6Y\\\xde\x03\xd4\x90\x8f\x14\x0fqX\xae\xfc'
 b'\r\x86&\xb2B3%\xaf\xd7\xeaI$J\x08\x00\x05\x00\x00\x00j\xa8?\xe4v'
 b'\xdd\xf4\x9b\xd7\x98\x02\xb8\x1e\x1ee\xec\x03\x97#\xa6>&\xccz\x92'
 b'\x88\xda\xc1\x936\xffuk\x0bd')

{'A1': 'bdg',
 'A2': {'B1': 0.9589564621422453,
        'B2': 78,
        'B3': 8810313823411492863,
        'B4': {'C1': 16, 'C2': 7266573485984013534},
        'B5': [{'D1': 1636003812, 'D2': 121, 'D3': 62090},
               {'D1': -301691715, 'D2': 17, 'D3': 57001}],
        'B6': [-3005146565618711615,
               287538288400123607,
               -8942741079760600298,
               831281403137295184],
        'B7': {'E1': 974508916428973487,
               'E2': -672511708,
               'E3': 18952,
               'E4': [980, -28529, 5135, 29016, -20740]},
        'B8': -3216916296712264764},
 'A3': {'F1': 168,
        'F2': 0.6395101335062803,
        'F3': 45620766,
        'F4': 26092,
        'F5': 60236710,
        'F6': 0.16288939118385315,
        'F7': -7887814222406025355},
 'A4': -26915,
 'A5': 39066,
 'A6': [107, 11, 100]}

Вариант №19

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

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

(b'BRJGH\xb2:\xd6~\xe6?\xd1w0\xdbv\xe1,\x00<\xbf\xef\x1c\xdf\xb5N\x15p'
 b'\x7f\x85:\x01\x16\x92?\xdaSk\x1c\x7fZ\x98\xbf\xe0\xbe\xafw\xbe'
 b'\x90\x82\xdc\xc7\x00\x02\x00"\x00\x02\x002btospilj?\xe5G\x9bG\xa0\x19@'
 b'\x00\x02\x00\x00\x00\x1c\xf1\xc1\x00\x00\x004\xbf\xbeP\xde\x82\xad\xaf\x80'
 b'\xbe\xaa\x86\x07?.\xe0\r?K\xc2\n?+\x14\xd8>\xa9\xe1\xafO\xab,`\\x\xe8\x86')

{'A1': 178,
 'A2': 0.0016364722978323698,
 'A3': 0.2728998320776721,
 'A4': {'B1': 'btospilj',
        'B2': 0.664991035359698,
        'B3': [{'C1': 32645, 'C2': 58}, {'C1': 278, 'C2': 146}],
        'B4': -3647,
        'B5': {'D1': [0.4113414552970567, -0.5232770289189974],
               'D2': [-36, -57]},
        'B6': -0.1184214657820899,
        'B7': [-0.3330537974834442,
               0.6831062436103821,
               0.7959295511245728,
               0.6682868003845215,
               0.3317999541759491],
        'B8': 5740730942393739398},
 'A5': -0.9722746411431853}

(b'BRJGHa?\x141\xdd?\xe8<\xa5B\x7f\x91\xf4\x00=?\xe5\xebJ\x1a\x83B&\xcf\xfcXS'
 b'#\xdf\xbf\xc3\xfdb\xd0@\x9f\xa8\xbf\xe0\x98D\x1a\xad,08m6\x00\x02\x00'
 b'"\x00\x03\x002yluchkvw\xbf\xe4\x90#\xa68y\x86\x00\x02\x00\x00\x00\x1c/'
 b's\x00\x00\x005\xbf\xc4\xba!es\x930\xbe\xaf\xe1\x02>\xdc9\xc1?x\xb1'
 b'\x8e>\x9c\n\xf3=d\x1b@\xe8\x02\xfe\xcb\x95\xe2EX')

{'A1': 97,
 'A2': 0.5788858532905579,
 'A3': 0.7574030207438782,
 'A4': {'B1': 'yluchkvw',
        'B2': -0.6425951239105394,
        'B3': [{'C1': -12292, 'C2': 88}, {'C1': 21283, 'C2': 223}],
        'B4': 12147,
        'B5': {'D1': [-0.15617022675109848, -0.5185871621155282],
               'D2': [56, 109, 54]},
        'B6': -0.1619302506798248,
        'B7': [-0.343513548374176,
               0.4301281273365021,
               0.9714592695236206,
               0.3047710359096527,
               0.05569005012512207],
        'B8': 16718204917099152728},
 'A5': 0.6849718587710114}

Вариант №20

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

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

(b'GQHP\x17\r$\\\xae\xc4dW\x00\xd8\xb7\xc8\x8a?\x03\xd7\xdc5R\xf6\xfc\x8d\x0f+'
 b'\xbf5\xf7\xfb\x93\x85\\\xd4\x936\xbf\x1f!Z\xd3Z\xad{\x17>?2\xdf\xcf'
 b'\x9f\x9f\x84\x87\xdf\x9b=\xfd\x1a\xddb\xddsO\xd3G?\xf8\x16\x93\x13Q\xcb\r'
 b'\x87\x92\xbdu^\x02\xc7\xe6e\xc4vnrywt\xc7z9?\x85\x9cP\xbc\xdf\x13\x00\x1d'
 b"\x00'\x001\x00;\x00E\x00\x8aW\xdf\xcd\xbb\xab\xd0\x06\xe5%\xfe\x87\x04\x00O"
 b'\x00\x00\x00\xac\xb9\xfd>')

{'A1': 9229,
 'A2': 1690611292,
 'A3': {'B1': 'nrywt',
        'B2': 0.7245296835899353,
        'B3': -123,
        'B4': -541306724,
        'B5': [{'C1': [56535, 21045, 64758], 'C2': -0.6682060360908508},
               {'C1': [63285, 37883, 23685], 'C2': -0.7131931781768799},
               {'C1': [8479, 54106, 44378], 'C2': 0.7425457835197449},
               {'C1': [57138, 40911, 33951], 'C2': 0.07610993832349777},
               {'C1': [6909, 25309, 29661], 'C2': 0.7805680632591248},
               {'C1': [5880, 5011, 52049], 'C2': -0.07154665142297745}],
        'B6': 22410,
        'B7': {'D1': -12833,
               'D2': -8647432568912696389,
               'D3': [24181, 50946, 26086, 30404]},
        'B8': 0.49555718898773193},
 'A4': 2328410072,
 'A5': 831}

(b'GQHP\x1793\x9c]\xc2RS\x00\x07\x93d\x8d\xa3Q\x995\xdf[\x7f\xe0\x1ffP'
 b'?q\xae\x98\xc9\xfc\xe4\x90\xd2t\xbf\xe2c+\xa8\xaf\xef\x17a\xba\xbe+/\xa6'
 b'\x19\xad\x9e\xdb80\xbf\xa8:\xdaB@\t)pH?\x9b\xf8\x92\xe3%4k\xdbq?\xd3'
 b'\xf4R\xfezhibv\xeb\xd0\xf5\xbeK/\xdb\xc8"\x13\x00\x1d\x00\'\x001\x00;\x00E'
 b'\x00\xc32##\x9e\xfd\x9d-]\xbc\xd1\xdf\x02\x00O\x00\x00\x00\x99\x9a\x82=')

{'A1': 13113,
 'A2': 1388469660,
 'A3': {'B1': 'zhibv',
        'B2': -0.4801095426082611,
        'B3': 75,
        'B4': 583588655,
        'B5': [{'C1': [13721, 23519, 57471], 'C2': 0.814058244228363},
               {'C1': [44657, 51608, 58620], 'C2': -0.9563379287719727},
               {'C1': [25570, 43051, 61359], 'C2': -0.36402198672294617},
               {'C1': [12075, 6566, 40621], 'C2': -0.6883675456047058},
               {'C1': [15016, 17114, 2368], 'C2': 0.7829614281654358},
               {'C1': [63643, 58258, 13349], 'C2': 0.9447543025016785}],
        'B6': 12995,
        'B7': {'D1': 8995, 'D2': -2318865224735785570, 'D3': [62675, 65106]},
        'B8': 0.06377143412828445},
 'A4': 2372178695,
 'A5': 20899}

Вариант №21

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

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

(b'HUYN\x1e\x00\x00\x00\x02\x00\x00\x00i\xa6\x83-\x02\xa1\xc6Q\x00\x8f?\xec'
 b'\xf1lb*6\xf8I\x9aZk\xd1\x10|MR\n\xa1%\xed7\xbfV\x12\xb9\xac\x04\x16\xd8'
 b'S\x14\xa3;\xd5\xe6\xa1\x9a\xae\xe9\x9apb\xedR\x9e\xc9\xfe\x0f\x80'
 b'\xd1\x87\xc87\xf7\x0e\xea\xac\xdfu/\xd2}\x1d\x05\xe1\x0b\x07&\x9d'
 b'\xc2+\x00\xa1\x00\x7f\xbb\xd9\xf4\xff\xb4|zlbubb\xad\xf4\xc8\x1b\x00\x03'
 b'\x00\x00\x00`gtati\x8bZ:E\x00\x06\x00\x00\x00c\xbf~aJ\xbfvG\xec?'
 b'\xe4\x94\x14;F\xe6\xe2=\x89\x8c\x03\x00\x02\x00\x00\x00\x871w<\xec9\xd3?'
 b'\xd2\x11\x86\xc9\x1f\x98p\xbe\xb8\xed\xfc')

{'A1': [{'B1': 'lbubb', 'B2': -1376466917, 'B3': [0, 127, -69]},
        {'B1': 'gtati',
         'B2': -1957021115,
         'B3': [-39, -12, -1, -76, 124, 122]}],
 'A2': 166,
 'A3': 33581,
 'A4': 44156497,
 'A5': {'C1': 0.643076053405107,
        'C2': 0.06716158241033554,
        'C3': [-0.9936720132827759, -0.9620349407196045]},
 'A6': 0.9044706265719631,
 'A7': [5303650930297699405,
        5911714645142912854,
        1349298696937296660,
        11762230038338645737,
        11128503450665404926,
        1117123088697784078,
        16910136395275861277,
        423631965290086955],
 'A8': {'D1': 12663,
        'D2': 0.028836166486144066,
        'D3': 0.2823197330566307,
        'D4': -1095176708}}

(b'HUYN\x1e\x00\x00\x00\x02\x00\x00\x00fw-\x10\x18\x14}c\x00\x8c?\xe9\xcfu!\xa4'
 b')pvc\xce\xbf\xd5\xa4z\x16D\xb3H\xe1\xd1P\xa6\xed\x10\x04C,F~\xa7q\xe5"'
 b"\xc1E\xf6\\\xa5\xdbG\x8f\xe3C\x08\xb0\xef\xef*'\x15{\xc4\xe1 \x87\xe2%"
 b'\xfa?3\x81B%U\x0b\xa2G\x13\xb2!\xb6\x00\x9eR\xa2\xf2%\xef\xadsesvq4'
 b'W\xae\xce\x00\x03\x00\x00\x00`fqedc\xee\xa8%\xfb\x00\x03\x00\x00\x00c'
 b'\xbc\x14\xbd\x9c<\r@\x13\xbf\xe5\xfe+q\x18o\xa6=\x8f\xdcn\x00\x02\x00\x00'
 b'\x00\x84\xfd\x1b\xbe\x87\xe1 ?\xeb.P\xc5\xbc\xd0\x067\x95l\xf5')

{'A1': [{'B1': 'sesvq', 'B2': 878161614, 'B3': [82, -94, -14]},
        {'B1': 'fqedc', 'B2': -290970117, 'B3': [37, -17, -83]}],
 'A2': 119,
 'A3': 11536,
 'A4': 403996003,
 'A5': {'C1': -0.6872765740295008,
        'C2': 0.07024465501308441,
        'C3': [-0.009078409522771835, 0.008621233515441418]},
 'A6': 0.8065744072967345,
 'A7': [8530889442488252950,
        4950380550126872301,
        1154121261954017137,
        16510971690123830747,
        5156589975410634735,
        3037420095012937863,
        16295705976064000549,
        6128170144124510646],
 'A8': {'D1': 64795,
        'D2': -0.26538944244384766,
        'D3': 0.8494037496625431,
        'D4': 932539637}}

Вариант №22

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

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

(b'UKEY\x00\x02\x00%\x00\x00\x00\x04\x00\x00\x00)\xd5rs\x15erj,\x1f\x00\x00\x00'
 b'9\xfbX\xf6b\xc9\x96<\x93\x00\x1d\x00!ztie\xbe\xf4\xbb\x8d>\xa1\x89'
 b'\x10\xbe\xfc\xd7\xc3\xe1>\xf1Yn\xbf\xb9\x9f]\x0f\t\xd4`\x00\x00'
 b'\x00\x03\x00\x00\x00-R\xc6\x83G\xfdL\xba\x86W\xfe6\xfc\xe5Q.nn&\x8f@t\xd4'
 b'\x1fZb\xfbD\xf2\xd8NLe\x9ci\x14\xf4\xa6\x1f\xbe#_-\xad\xd6\x9c\x85\xa6U\x1fV'
 b'[9\xa7\xaa\x85\xb3\x9c')

{'A1': [{'B1': -1192, 'B2': -2462}, {'B1': -13930, 'B2': 15507}],
 'A2': 'ztie',
 'A3': {'C1': 213, 'C2': 1920144741},
 'A4': 29290,
 'A5': 11295,
 'A6': {'D1': 225,
        'D2': 0.4713854193687439,
        'D3': -0.10008794419430123,
        'D4': [-0.4779933989048004, 0.31549882888793945, -0.49383363127708435],
        'D5': 82,
        'D6': -4142388079011133865,
        'D7': [-128637477493772690,
               2778510365630093922,
               -340880660932827748,
               7571945867850949471,
               3291522870423213343,
               6222630702425682844]}}

(b'UKEY\x00\x04\x00-\x00\x00\x00\x06\x00\x00\x005M\x19N\x8c\xedw\x97\x8a'
 b'\x0f\x00\x00\x00G\xe5\xb8\xcaM\x8c\xab\x10\xcdI\x1ap\xf6\nA\xe3'
 b'\xbf\x00\x1d\x00!\x00%\x00)klvswl??ox\xbf\x10\xa2\xac\xbf%\xd2\x83\xfa'
 b'?\x03\xbaU?\xe65\x92=+\x9e\xac\x00\x00\x00\x03\x00\x00\x00;\xc2\nC\xff'
 b'\xe2\xa3\xe0\xb7\xf6\xb5E\x86e\xe44\x1b\x98\x97;sD\xed\x07\xc8G\x9c\x12\x10'
 b'\xeb[\x02S\xf4\xa1\xd2\x99\xf9\x94\x93\xc2)L\xd9\x96[u\xd1\xa8k\xda\x943'
 b'p:\x8b-\xf9')

{'A1': [{'B1': -6728, 'B2': -13747},
        {'B1': -29525, 'B2': 4301},
        {'B1': 18714, 'B2': 28918},
        {'B1': 2625, 'B2': -7233}],
 'A2': 'klvswl',
 'A3': {'C1': 77, 'C2': 424578285},
 'A4': 30615,
 'A5': 35343,
 'A6': {'D1': 250,
        'D2': 0.5145619511604309,
        'D3': 0.6940394587263277,
        'D4': [0.7477946281433105, -0.5649821758270264, -0.6477434039115906],
        'D5': -62,
        'D6': 739716112695998454,
        'D7': [-5384750007273120872,
               -7549313610484823993,
               -7200674251181763596,
               -6786192391275298263,
               5537622536391600235,
               -2696473719776530951]}}

Вариант №23

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

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

(b'\xb5HDV\x00\x03\x00\x00\x00a\xbf\xb3Q.\x99\xf1~\xf0?\xd9L\xd1@n@\xd4 r'
 b'\xbf\x7f\xc9\xb7\x17E\xfa!\xd5SwM5\\\x889\x85\xc7\x18t\xd6\xf5\x0cq'
 b'Ul\x1a\x11\xf5\xae\xeb\xdd=\x07?\xe95\xe7C\x07\x86\xe4}\xe9\x81\xbdK\x82'
 b'\xaa\x1f\x00\x02\x00d\xde\xb8\xe9\xaa\x9bn\xd0\x00\x00\x00\x03\x00\x00\x00'
 b'lfke\xa2\xd7\x0c"\xe5\xb9\xb0\xbb~\xe5\xc5/#A\xc9\xdd\x08\xa2[A(1\x01\x12'
 b'\xe2}\x0e\x1f\x82\xbd\xed5')

{'A1': 'fke',
 'A2': -0.07545748957044984,
 'A3': 0.39531356136377593,
 'A4': 8306,
 'A5': -0.9991716742515564,
 'A6': [{'B1': 5957, 'B2': {'C1': -1503, 'C2': -10925}},
        {'B1': 30541, 'B2': {'C1': 13660, 'C2': -30663}},
        {'B1': -31289, 'B2': {'C1': 6260, 'C2': -10507}},
        {'B1': 3185, 'B2': {'C1': 21868, 'C2': 6673}},
        {'B1': -2642, 'B2': {'C1': -5155, 'C2': 15623}}],
 'A7': 0.7878300007980354,
 'A8': {'D1': 9072925574330231327,
        'D2': [2732002338, 3854151867],
        'D3': -8520,
        'D4': -23,
        'D5': 2862313168,
        'D6': [9143931424691309021, 622160033935851794, 16320216153160805685]}}

(b'\xb5HDV\x00\x02\x00\x00\x00a\xbf\xbe\xd3\xdb\x1a\xa2\xf1\xf0?\xe4\n\xe4t\xed'
 b'\xd2\xd0\xc2\xf9\xbdq9+\xa7vS\xdf\xed!\xb1{\xa3\x8a|3\xfc@G\x13^\x1c\x99\xf5'
 b'\xb6\xee\xd6\xc4G\xed\x06\xb6\x9f\x8a?\x80\xb3(\r\xb2m\x00R\x98\xa2\\7\xe3'
 b'h\xf1\x00\x02\x00cPrs\x9c\xc6\x1f\xdf\x00\x00\x00\x05\x00\x00\x00keh\x8c'
 b"\x9e#u\xdc\x92\xa7\x06\xe7S\x94\xa0\x89\xee\xd6\xe4\x8f*'\x99\x02\xc2G}\xde"
 b'\xf0_\\C\x98\x9a\xea\xe1\x1c\xa6\x8a\xe2\x85\xf9\t^\xa8\x86\xcd\xb5'
 b'\x8c\\\xad')

{'A1': 'eh',
 'A2': -0.12042016411118772,
 'A3': 0.6263296397943012,
 'A4': -15623,
 'A5': -0.05889241024851799,
 'A6': [{'B1': -22666, 'B2': {'C1': 21471, 'C2': -4831}},
        {'B1': -20101, 'B2': {'C1': -23670, 'C2': 31795}},
        {'B1': -960, 'B2': {'C1': 18195, 'C2': 24092}},
        {'B1': -26123, 'B2': {'C1': -18706, 'C2': -10556}},
        {'B1': 18413, 'B2': {'C1': 1718, 'C2': -24694}}],
 'A7': 0.008154213827131773,
 'A8': {'D1': 5951685424528451825,
        'D2': [2359174005, 3700598534],
        'D3': 20594,
        'D4': 115,
        'D5': 2630229983,
        'D6': [16668830063058147044,
               10316101434575308669,
               16064444720706263786,
               16221023073317812489,
               6820849853724908717]}}

Вариант №24

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

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

(b'\xafSMXGM\x00\x00\x00J\xd6(\x14@f\x1dI-.\xda2\xe4\xdcW\xbf\x865\xd0'
 b'\xbfp\xf0]\x0e\x99\x9d\xbd\xbf\\\x0c*S9+\xd8\xbf\x00\xf0v\xfe\x1d1\xca'
 b'\xbf\xce\x01f\x93\x02\x00\x00\x00\x15\x00\x00\x00d\xbf\xf1H\x02\x00\x00'
 b'\x00%\x00\x00\x00\x02\x00\x00\x005\x00=\xed\xaf|\xae\x1f&\xa1\xd6\xe4\xaf>d'
 b'Wh?\x9d\x8aj?\xa6%\xe2S%\x89%0s?\xa2\xaf\x15}h\xfc^\xc51V\xbe\r\xe7\xe9\xf8'
 b'\xc5\xfd')

{'A1': {'B1': [{'C1': 2472935886,
                'C2': [-0.25326698957310456, -0.11568600273852936]},
               {'C1': 1223802724,
                'C2': [-0.37763817903050323, -0.204623936891835]}],
        'B2': -6834740550211474115,
        'B3': {'D1': [0.34354275465011597,
                      0.907583475112915,
                      0.9161775708198547],
               'D2': 166,
               'D3': 626254373,
               'D4': 9609,
               'D5': [29488, 41535, 5551, 26749, 24316, 12741],
               'D6': 18286295545495273046}},
 'A2': 5268479564495509066,
 'A3': 853159469}

(b'\xafSMXGM\x00\x00\x00\xfc\x17\xb0V0\x1f\x1b\x19\xb0"\xcb\x18\xca\r\xfd'
 b'\xe5,]\xe3\xbf@\x06\x8b%\xc2\x84\xe5\xbf\x18/\xc0\x95i}\xda?\xa0hG'
 b'+\x9d\x9a\xbc?s\x1b;A\x02\x00\x00\x00\x15\x00\x00\x00\xf2\x9f\x85'
 b'\xfe\x02\x00\x00\x00%\x00\x00\x00\x02\x00\x00\x005\x00\x7f\xbd\x11\xb7%'
 b'\xc3\xebc*\xb6\x00?\xdd\x85\xac>;)\x0c\xbf|\xdbbH\x1b\x8b3\x1c\xc4'
 b'\xb9O\xf7\xfdA\x0e\xaf1A\x9f\x94T@\xf3\x10\xafr\x0f')

{'A1': {'B1': [{'C1': 1094392691,
                'C2': [-0.6051239482844093, -0.6724558575880977]},
               {'C1': 4270170098,
                'C2': [0.41390456794828046, 0.11173422152151824]}],
        'B2': 7200062996034469247,
        'B3': {'D1': [0.5027796030044556,
                      0.33695879578590393,
                      -0.5475041270256042],
               'D2': 124,
               'D3': 457728731,
               'D4': 13195,
               'D5': [50204, 20409, 65015, 3649, 12719, 40769],
               'D6': 1113144545249350804}},
 'A2': 1809073967792658428,
 'A3': 415965872}

Вариант №25

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

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

(b'SNV\xdeB\xeb\x87Xc\xbeN\xf9\x83apwubqdrs\xe9\x8d\xbfd\x8a-?\xe6#\xd0'
 b'\t`\xcf\xba\xbf\xecGh\xe5w\x9f\xaa\x00\x00\x00\x03\x00\xbc\x0c\x0e'
 b'\x8f\x98\x07\xa39\x81\xb6\x19\xe8\xbf\xe2`{\x05\xf5v\x18l`\xe1\xa8\x8aj\xdc'
 b'>.\x910d\x00\x00\x00\x05\x00\x00\x008!\xd0\xf7E\xa0}!\xeb\xa4l\x8e@e\xa1\xf3'
 b'?\xde\xfc\xfd\xe6\xb9~\x88\xb7\xf3\xc1\xfd%=3\xe4\x95+\xa8\x10'
 b'\x00\x00\x00\x03\x00\x00\x00e\xb7\xf3<\xb5\xbc\xb8\xe2\xb9w\x16\xa1\xbc'
 b'\xfdO!\xeb?\xed\x18\xa3\xd8\x8e\x1a|Uc\xc1tc\xd5\xf8\\\xbdg\x83W'
 b'\x00\x00\x00\x04\x00\x00\x00\x90\xc3RpH}\x9d\x1f\xdf\xdb)\xa4\xa6\x00=\x00h'
 b'\x00\x94')

{'A1': 1122731864,
 'A2': 99,
 'A3': -0.20212368667125702,
 'A4': 'apwubqdr',
 'A5': 115,
 'A6': {'B1': {'C1': 59789, 'C2': -0.8927333950996399},
        'B2': 0.6918716605346085,
        'B3': -0.8837170106680692,
        'B4': [{'D1': -0.5742774120696508,
                'D2': 1818288552,
                'D3': -8472717589316816796,
                'D4': [57, -127, -74, 25, -24],
                'D5': 567342917,
                'D6': -6882307359592640960},
               {'D1': 0.48419139415452905,
                'D2': -1208761859,
                'D3': 2683358009830909968,
                'D4': [101, -95, -13],
                'D5': 3086171317,
                'D6': -4847875712669539908},
               {'D1': 0.9092578153220781,
                'D2': 1432600948,
                'D3': 7193929056992592727,
                'D4': [-3, 79, 33, -21],
                'D5': 3276959816,
                'D6': 9051425872399672486}]},
 'A7': [3086, -28776, 1955]}

(b'SNV\xde\xf1\x1eXG^\xbfgSZqurhplryr\xda\x18\xbb\xc4R\xfe?\xe3\xba\xd6\xa07\n^'
 b'\xbf\xe8\xad\xeb4"\x18\xfc\x00\x00\x00\x02\x00\x91\xaf\x0c\xd8\xa1\xf6\xc9'
 b'\xc1\xe2b\x9a\xbf\xe6T\x12\x01*\x91\x84$o\x08\x9f,\x15/hzZ\x94X'
 b'\x00\x00\x00\x04\x00\x00\x008x\x98\xaf\xf7\x0fQ:\xddY2\x0f0o2\r\xd9'
 b"\x04?\xc6O\x98\r~\xd2\xb8\tmt\xae\xb511\x8f\xef\x8a\x0e'\x00\x00\x00"
 b'\x05\x00\x00\x00d\x94\x0esE\xe8n\xde{)3\xce\xd7\x00<\x00i')

{'A1': -249669561,
 'A2': 94,
 'A3': -0.9036155939102173,
 'A4': 'qurhplry',
 'A5': 114,
 'A6': {'B1': {'C1': 55832, 'C2': -0.00599133875221014},
        'B2': 0.6165574197005517,
        'B3': -0.7712303179003182,
        'B4': [{'D1': -0.6977624914912188,
                'D2': 611256479,
                'D3': 3176497237955613784,
                'D4': [-63, -30, 98, -102],
                'D5': 2023272439,
                'D6': 1103728106041118512},
               {'D1': 0.17430401476817337,
                'D2': 158168238,
                'D3': -5390472784716886489,
                'D4': [111, 50, 13, -39, 4],
                'D5': 2483974981,
                'D6': -1698175388918493481}]},
 'A7': [-20724, -10079, -2359]}

Вариант №26

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

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

(b'ORE\xcc\x88\xe4P\x82Q\xbf;\x83\x9e\x1f,.n\xb15\x89\x01\xbc\xbe\xfb'
 b'\xb2\xd7P\x06\xba1\xc0\x03\xaf\xbe\x8eX\xfb-\x94\xb8\xb6\xf0\xfbk'
 b'\x88\xbf{\xde/\r\xbc\x07a\xfa;\x9c\x0e\xbe\x8a}0\x8f\x83~yzy\xa5'
 b'\xbdY\xb8\x97\x8c\xb0\xbbSH\x88\x87\xa8\xc6k\xbf\xbfT6QY\x1e<4\xcd'
 b'\xee\xfa&\xf6\xa4\xc0!/:>\xc3\xf5\xfb\xacx\xd8\xe5<\xaa\x0f\x1b\xa6\x97\xd5'
 b'\x07T\x86\xbe\xd0;\xe8\xbd9@\x9bZC\x85>H\x1d\xa2\xe14\x1e\x9en\xc8^\x00\x94')

{'A1': {'B1': [{'C1': 204,
                'C2': 2296664194,
                'C3': 81,
                'C4': -0.732477068901062,
                'C5': 7980},
               {'C1': 46,
                'C2': 1857107337,
                'C3': 1,
                'C4': -0.023313377052545547,
                'C5': 55120},
               {'C1': 6,
                'C2': 3123822595,
                'C3': 175,
                'C4': -0.2780226171016693,
                'C5': 11668},
               {'C1': 184,
                'C2': 3069246315,
                'C3': 136,
                'C4': -0.9838590025901794,
                'C5': 3516},
               {'C1': 7,
                'C2': 1643789212,
                'C3': 14,
                'C4': -0.27048635482788086,
                'C5': 36739}],
        'B2': 126,
        'B3': 'yzy'},
 'A2': -23107,
 'A3': 22968,
 'A4': 10920297515069245575,
 'A5': [{'D1': 2831575999,
         'D2': -0.8289538025856018,
         'D3': 6421636316167862822,
         'D4': -2396},
        {'D1': 3223400250,
         'D2': 0.38273605704307556,
         'D3': -6018822422903779557,
         'D4': -22889},
        {'D1': 3574027398,
         'D2': -0.4067070484161377,
         'D3': -4811743690890181314,
         'D4': 18461}],
 'A6': [41697, 13342, 40558, 51294],
 'A7': [0, -108]}

(b'OREo\x10=\xad\xda\xd0>V\xc8L\x8b\xe6\xa0#\xd4%f6\xbe\x88\xba\xe6n\xbf\t'
 b'z\xf8\xbe\xc2\x1e>\x9aL\x17[\xf3\xbc\xeeE\xae\x8a\xf3\xbf4\xe0a\xb0\x15\xa5'
 b'\xa8\xe6\x99M\x0e\xbe$\xbc\x8f\xfe\x80\x01avb\x15\xf9/\xf9\xb6u\x08\xf1Q'
 b'F\x9e;\x19U}d=!\xb3\xa2\xe9\x1dI\xc4k@d\xc5\r\xb5\xd9\xc9\x83'
 b"\x96\xbf\x1d\xf5\xbc;\xdc&J\x10F\xf6b\xd2;\x9aq\x0eR?2\xa4{''\xb2|\xbf"
 b'\x9c\xa3\xfd\xb3\x96\xbd\xd8\xdfp8\xc0\xb4\x076O')

{'A1': {'B1': [{'C1': 111,
                'C2': 272477658,
                'C3': 208,
                'C4': 0.20974844694137573,
                'C5': 35814},
               {'C1': 160,
                'C2': 601105766,
                'C3': 54,
                'C4': -0.26705092191696167,
                'C5': 28351},
               {'C1': 9,
                'C2': 2063122114,
                'C3': 30,
                'C4': 0.3013617694377899,
                'C5': 23539},
               {'C1': 188,
                'C2': 3997544074,
                'C3': 243,
                'C4': -0.7065487504005432,
                'C5': 45077},
               {'C1': 165,
                'C2': 2833684813,
                'C3': 14,
                'C4': -0.16087554395198822,
                'C5': 65152}],
        'B2': 1,
        'B3': 'avb'},
 'A2': 5625,
 'A3': 12281,
 'A4': 13147424519721754171,
 'A5': [{'D1': 425033060,
         'D2': 0.03947795182466507,
         'D3': -1649080780585933627,
         'D4': 3509},
        {'D1': 3653862294,
         'D2': -0.6170308589935303,
         'D3': 4313364642656613986,
         'D4': -11717},
        {'D1': 2591100498,
         'D2': 0.6978222727775574,
         'D3': 2821419940431307773,
         'D4': -19562}],
 'A6': [48600, 57200, 14528, 46087],
 'A7': [54, 79]}

Вариант №27

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

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

(b'CDO^\x00\x00\x00\x02\x00\x00\x00v\x00\n\x01a\xb5\xee,\xcd.\x0c\xc4\xca'
 b'!\x08\xbd\x87\xc5\x88\x00\x00\x00\x94\x00\x00\x00iJ\xe2\xefc\xf6\x88'
 b'X?\x17\x1aY\x97\xe7\xbe@\xf3\xe5;Q\x9b\xf9\xd6)5\xf7\xda\ri\x15\xe2'
 b'\x04\x9d#\xbfj\x9a;\x87)\x83\xfa\xd5x\x1a\xc4\\\x0c>\x1d\x06m\x10\xcd\xfa'
 b':1\x80\n\xab\xfa\x98\x98:H\xbf\x05\xbe\xa6.\x00\x00\x00>\x00\x00\x00N\x00'
 b'\x00\x00mgU\xf8s\xe3\xac{\x97\xa2J\xaf\x0e\xc6=\x1d\xc9[-V\x89\xe0'
 b'e\x94\xd0\xbe\x04\x00x\x00\xb8$\x8d\xa2\xa6\xb9\xf5\xb4zN')

{'A1': {'B1': 5204640102187993728,
        'B2': -1497496129,
        'B3': [{'C1': 2539198999, 'C2': -7254951665902502169, 'C3': 891934457},
               {'C1': 1762515703, 'C2': -7319828084658216427, 'C3': 2200536891},
               {'C1': 444126714, 'C2': 1183608999733124292, 'C3': 825948877}]},
 'A2': 'mg',
 'A3': 3372401099727241482,
 'A4': {'D1': -4213191083757485044,
        'D2': {'E1': 3767096877,
               'E2': -0.40738216042518616,
               'E3': [-478939051, -1567130708, -972116150, 1539906877]},
        'D3': {'F1': [184, 36, 141, 162, 166, 185], 'F2': 1316664565},
        'D4': 105,
        'D5': 1676665418},
 'A5': 0.8458398580551147}

(b'CDO^\x00\x00\x00\x02\x00\x00\x00v\x00O\xfeEU1j\x00\xcf"<\x98\xd7\xce-\xa2'
 b'\xc3\x88\x00\x00\x00\x94\x00\x00\x00\x16\x16\x83\nj3\x0c\xa7\xbe\x9d2sw\xf7]'
 b'\x0c\xcc"a\x96R\rX\xee#\x18\x89\xb8G\xe5<G\xdc[P*\x8al\xb8dv\xc5\xfd9\x04ov'
 b'\xd1\x0b\x8b\xba\xa8\x00\x1d\xd4\xf10\x95l\x88\x8c3\xdc\x85!*`\x10\xfd.\x00'
 b'\x00\x00>\x00\x00\x00N\x00\x00\x00qp\xfa\x17\xc8 &h\x14\x0e\x047\x07\x184{6I'
 b"\xa8'\to\x8dMc\xbf\x04\x00x\x00\x02c\xce\xac\xb6\xfd\xa4f\xc8h")

{'A1': {'B1': 2415578889113332885,
        'B2': -49258454,
        'B3': [{'C1': 2004038301, 'C2': 5951050759696834039, 'C3': 602822669},
               {'C1': 1203276056, 'C2': -8490885791985746715, 'C3': 1986312300},
               {'C1': 70909381, 'C2': 47492902448887407, 'C3': 821154845}]},
 'A2': 'qp',
 'A3': 14916038725967674959,
 'A4': {'D1': -4349863923682886622,
        'D2': {'E1': 1862870952,
               'E2': -0.8879020810127258,
               'E3': [549984250, 236218406, 403126020, 1228307252]},
        'D3': {'F1': [2, 99, 206, 172, 182, 253], 'F2': 1757963940},
        'D4': 22,
        'D5': 1779073814},
 'A5': -0.3262649476528168}

Вариант №28

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

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

(b'ONDM=\x15@,m\x8e?|\xc9*\x88\x9d\x05\x00*\x00\x00\x00vvda\x06\x00'
 b'\\\x00\x99\x0f\xf2@b\x00\x00\x00\x0f\x00:\xbe\xa8\xc4L,\xc5\xf8\xdd\x91\xd2 '
 b'k\x8c2(\xdaBe\xab\x83\xba\x9b\x16\xbbQ\xcd\xca\xf4\xf7\x0bi2\x9d\xaf&!!E\xe5'
 b'\xf6a\xcd\xf0\x9f\xcfg\xe5\x81\x8d\x98\xb9trzptm\xf3\x0c^\x01\xd4\x9b'
 b'\x04b\xed\xcaW\x18(\xa4\xd54\xd36\xca\x8bR\x94C\x87^su"\x13\xb2\xea\xbft\x8a'
 b'\xb4Y_\x05\xd2?')

{'A1': 8953031183780812093,
 'A2': -1652020535,
 'A3': [{'B1': 743228584, 'B2': {'C1': -1851, 'C2': 550670813}},
        {'B1': 674401387, 'B2': {'C1': 17114, 'C2': 3129191269}},
        {'B1': 1371215515, 'B2': {'C1': -13619, 'C2': 1762392052}},
        {'B1': 649043250, 'B2': {'C1': 8481, 'C2': 1643570501}},
        {'B1': -811601715, 'B2': {'C1': -6809, 'C2': 3113782657}}],
 'A4': 'vvda',
 'A5': 'trzptm',
 'A6': 1089605529,
 'A7': {'D1': [22940915,
               1644469204,
               408406765,
               886416424,
               2345285331,
               2269353042],
        'D2': -0.8342376397155069,
        'D3': 0.2815779090907775},
 'A8': -0.1816408485174179}

(b'ONDM]hD\x017:\xc4Y\xba|\xfe\xcf\x02\x00*\x00\x00\x00odbw\x05\x00>\x00A\xf2'
 b'"XC\x00\x00\x00fc\x89\xbe\xd9\xae\xec%\xa5\xf1\x00\x96\xaaQh\xe6\xe9\xca'
 b'\xa6\xc6\xc1e\xb8\xcezgson\x02DRy\xa9\x94-\xa6a\x8a\xf5\xd8{+\xdb\xbd\r'
 b' i\x9a\x92\x9c\xa8c\x10\x8a\xbe\x15\\\x9c\xdd?\x90S\xe2fj\x95\xb1\xbf')

{'A1': 6468358972729747549,
 'A2': -805405510,
 'A3': [{'B1': 636268249, 'B2': {'C1': -3675, 'C2': 1370134016}},
        {'B1': -890640792, 'B2': {'C1': -14682, 'C2': 3468191169}}],
 'A4': 'odbw',
 'A5': 'zgson',
 'A6': 1478685249,
 'A7': {'D1': [2035434498,
               2788005033,
               3639970401,
               3185257339,
               2590580749,
               1671994514],
        'D2': 0.46266843913522937,
        'D3': -0.06868615161722702},
 'A8': -0.2683364748954773}

Вариант №29

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

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

(b'AXFFYz\xa7\x80\xfeL\xdb\x00\x00\x00\x84+Ywk@"\x00\x02\x00\x95?\xe8n'
 b'\xbc}\xcfoLE\xeb!\xff?\xe5hs\xec(\x06\xf0\xafta\xd7<Oa\xed\xd8}\xc5'
 b'\x9a\xad\xe9\xafX\xa5H\x1d\xdav\x9cWs\xbf\xec\x895.\xd09\xb8\xbfs\xd1'
 b'R\x15\x0c\x00\x05\x000\xa7gW\xdbV\xd3X[\xf1\x03\x12\n\xdd\x8b\x8d\x88R'
 b'\xec\xb9\xed\xcb\xb6?\xc98/\n\x87\xce\xd0=ND\xceM\xaf\x00\x04\x00\\\x17'
 b'v%\x04\xf2\x00\x02\x00\x00\x00.\x17\xd3uZ\x8d\xc5I\x00D\x00l\xbe\xb8\xf2'
 b'\xa9')

{'A1': 2057797886,
 'A2': 19675,
 'A3': {'B1': 'ta',
        'B2': 23,
        'B3': -45,
        'B4': 1968868805,
        'B5': 73,
        'B6': [{'C1': 115,
                'C2': -0.8917489923786013,
                'C3': -0.9524127244949341,
                'C4': 5388,
                'C5': [-683913375,
                       -304579131,
                       -1699878481,
                       1487226909,
                       -629760937],
                'C6': -89,
                'C7': 1733811030},
               {'C1': 182,
                'C2': 0.19702709211525482,
                'C3': 0.05035858601331711,
                'C4': 19887,
                'C5': [-749184015, 51514077, -1953658798, -323359285],
                'C6': 23,
                'C7': 1982137586}]},
 'A4': 11097,
 'A5': 2003517474,
 'A6': {'D1': [-16712, -3415], 'D2': 0.7635176141006723, 'D3': 1173037567},
 'A7': 0.6690005886486841,
 'A8': -81}

(b'AXFFYs\x91K\xeeXK\x00\x00\x00\x80\x8b\x8a?\xf8r7\x00\x02\x00\x91\xbf\xdf\xbb'
 b'\x9b[\x12\xc0L\xd1\x82\xb1>?\xd1\xa8~\x95L?\xd8\x99gi\x12v?\xb1kZ\xebb'
 b'\xde\xbf\xea\xb8\xb9\xf2\xff1J\xbf+x\x87v\xda\x00\x02\x000)\r\x08\xbe\xb7'
 b'\x19\x9ak\x86\xfc\xcc\x11\xbf\x18\xb7\xed\xc7\xf4e\x11k\xac\x18\x99\xf9'
 b'\xbc~\x1a\x17z?\x99\xa8c\x94y\x10\x80?LXe\x85/\x00\x06\x00POl\x18\x80\x10'
 b'\x00\x02\x00\x00\x00.s\xea+\x05\xe4\x02W\x008\x00hs\x00\xba\xc6')

{'A1': 1938901998,
 'A2': 22603,
 'A3': {'B1': 'gi',
        'B2': 115,
        'B3': -22,
        'B4': 721806338,
        'B5': 87,
        'B6': [{'C1': 222,
                'C2': -0.8350496049911638,
                'C3': -0.6698078513145447,
                'C4': 30426,
                'C5': [309739441, 1801120610],
                'C6': 41,
                'C7': 218676919},
               {'C1': 122,
                'C2': 0.025056415497843876,
                'C3': 0.7982237935066223,
                'C4': -31441,
                'C5': [429550470,
                       -53734977,
                       414707143,
                       -194702997,
                       -1407673863,
                       -1132586473],
                'C6': 79,
                'C7': 1813544976}]},
 'A4': 35722,
 'A5': 1073246775,
 'A6': {'D1': [29440, -17722], 'D2': -0.49582561391708135, 'D3': 3515003198},
 'A7': 0.2759090860354241,
 'A8': -103}

Вариант №30

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

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

(b'\xf5LMHT\x00\x00\x00\x02\x00\x13\x97J\x00\x86phvn1\xd6\x94l\xd1\x9dR(?'
 b'\xb8\xff\x06\x0bM\x80\xf0gMh1X\x03\xe7\x0fc\x00\x00\x00\x02\x00\x00\x00\x0f'
 b'\xd5.D\xa13\x97\x1d/\xac\xe4bV\xbf\xad\x97\x97y~h`\xe2B\xca\x00'
 b'\xb3\x1f\xe8\x07O\x00\x00\x00\x02\x00\x00\x00\x11\xef\x85\xa9\x9d3\xb9\xc0'
 b'\xd9\x85\x16K\xc9f\x99\xf2\xc12\x189\t\xed\x0ex\xa2\xe0w\xf1\xc6\x92\xc3\xca'
 b'\xc9\xd5\x0f\xa8\xcftn\xed\xbd\x00\x03\x00]!\x00\x00\x00i\x8a')

{'A1': [{'B1': 3591220947968676392,
         'B2': 0.0976413514704324,
         'B3': 103,
         'B4': 1298674008,
         'B5': 999,
         'B6': 3939,
         'B7': 'ph',
         'B8': 3576579233},
        {'B1': 3717472108018950742,
         'B2': -0.057797177868636807,
         'B3': -30,
         'B4': 1120534707,
         'B5': 8168,
         'B6': 1871,
         'B7': 'vn',
         'B8': 4018514333}],
 'A2': 38730,
 'A3': {'C1': {'D1': 840448265,
               'D2': -1365020996100689466,
               'D3': [2462304969, 3574573263, 1953426877],
               'D4': [867811545, 2232830921, 1721365185],
               'D5': 33},
        'C2': -118}}

(b'\xf5LMHT\x00\x00\x00\x03\x00\x15-\xe6\x00\xa9huxnvy\xc6a\xb4&\xa9\x99\xc0'
 b'\x7f?\xe7\xf6o\xd1A\xb4\x06\xf9\x14\x96\xb0"\x99u\\\xf2\x00\x00'
 b'\x00\x02\x00\x00\x00\x0f\xbdL@+8c \xe7\xfc\xd7\x92\xed?\xe5\x1c\xda\x9e\x1f'
 b'<\xac\xea\xe4\xb7\xb5R\xc3\xa9F$\x00\x00\x00\x02\x00\x00\x00\x11\r\xd2aG\x8e'
 b'0\xe7f\xbc\xbe\xca\xfb\xbf\xc8\xcf|v6\xae\x08{\xa6|\x7f\xa4|\xf1\x8c\x9f'
 b'\x00\x00\x00\x02\x00\x00\x00\x13\xd2\x84\x05\x18W\xea\xfb\x9e\xe5\x85q5'
 b'\xda\x1eoI4\xb0Z\xb3B\xcaY1)Kd$\x07c\x86\x95l9\x1a\x87\x00\x02\x00\x84'
 b'\x8c\x00\x00\x00\x8c\x00')

{'A1': [{'B1': 14294904770397847679,
         'B2': 0.7488326155704506,
         'B3': -7,
         'B4': 345419810,
         'B5': -26251,
         'B6': 23794,
         'B7': 'hu',
         'B8': 3175890987},
        {'B1': 4063127469569839853,
         'B2': 0.6597722137757009,
         'B3': -22,
         'B4': -457722542,
         'B5': -15447,
         'B6': 17956,
         'B7': 'xn',
         'B8': 231891271},
        {'B1': 10245943580707179259,
         'B2': -0.1938319756712732,
         'B3': 123,
         'B4': -1501790300,
         'B5': 31985,
         'B6': 35999,
         'B7': 'vy',
         'B8': 3531867416}],
 'A2': 11750,
 'A3': {'C1': {'D1': -635539639,
               'D2': 3796634211839531313,
               'D3': [692806692, 123963029, 1815681671],
               'D4': [1475017630, 3850727733],
               'D5': -116},
        'C2': 0}}

Вариант №31

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

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

(b'TIYS\xd4\x0c\xf6J\xba\x19\xae\xc8l\xb7b\xc1\x01\x9b\x9e\xd2\xa6\x9b\xde\xb8'
 b'2\x02C}Co\xf8]}\x11h(\x93\xdd\x9cq\x804\xa1\xad\xfc\x93I\xf1 \xbdR\x82'
 b'\x99\x9a~\x8eK\x0fx\x97\xbb\xce\xfc\xd7\x17T\xe0F\x0e\xebh\xd9\x9a|\xe7\xad'
 b'n\xec\xcd{\x01^p\x7f\xbe\x92\x1e\xcb\xc6"\xf3$ F\x9f\xfa\x86.\x94\xea'
 b'S\xa5F\x86\xf2\xd8\xe8LA\x82D\xfb\xc8\xbb\xb3=vEg\x15\xf1W\xa6\xcc'
 b'\xea\xfba\x13k\xaa\x97\xcdY\xc5\x9eAV\xe8G}!q\x00\x00\x00\x98\x18\x81'
 b'\xc1\x9cu\x11\xb4_\xa1\xdcQ\x00\x06\x00\x92V\x86\x003\xb8\x96K0')

{'A1': 54284,
 'A2': {'B1': [63050, 47641, 44744, 27831],
        'B2': [{'C1': [7115970654118258331, 16048632257438368623],
                'C2': -8,
                'C3': 93,
                'C4': 2098292776,
                'C5': -7791899768984919635},
               {'C1': [18199971819119530626, 11068298183826176151],
                'C2': -69,
                'C3': -50,
                'C4': 4241954644,
                'C5': -2286123356604753284},
               {'C1': [16694121357071024478, 8106407389081355810],
                'C2': -13,
                'C3': 36,
                'C4': 541499386,
                'C5': -8777914889551919482},
               {'C1': [17498991766362277115, 14464351704789116693],
                'C2': -15,
                'C3': 87,
                'C4': 2798447355,
                'C5': 6995053026671942085}]},
 'A3': 11403491287110590833,
 'A4': {'D1': -1268801060,
        'D2': 81,
        'D3': [24, 129, 193, 156, 117, 17],
        'D4': 6234670956281219888}}

(b'TIYSJ\x87\x8e\xa5\n\xc9\xc2u8A\xcb\xe1"\x9c\x12`W\x7f8_\xe57\xa3\xa7'
 b'\xd5T\xb4\xc3\xee\x0f4\x88$\xdbo9E\xca/\xd9\xd2O\x15XY\xc6\x87\x91\xe8k\xf0d'
 b'\xab\xbe\x82\x12&\xd2\xaf\x0c\xf1_\\\xd5\x7f\xdb\xbb\xc6P\xd5\x85\xf4L":\x9a'
 b',\x0fn\xb4\xba\xf6\t\xf7\xa26\x17\x81+5j{\xce`\x9f\xbd\\\x83\x80t\x19\x7fzi'
 b'\xcb\\\x1a\xdcmw\x8b0\xca\xf7\x1d\xdf\xebr\xd9Z\xa8*\x17\xe0`\xf4=\xa6'
 b'\xb0\x82\x96p\x19\xb9P\xff\xa5\xab\x00\x00\x00\x97\xba\x0c\xb4\x89\x1b#'
 b',$\x1b\xdf\x00\x05\x00\x92"\xb5k\xe9\x1c\xe1=o')

{'A1': 19079,
 'A2': {'B1': [36517, 2761, 49781, 14401],
        'B2': [{'C1': [14691061513177814911, 4062217416043124052],
                'C2': -76,
                'C3': -61,
                'C4': 3993973896,
                'C5': 2655838697039736793},
               {'C1': [15154354740332496785, 16747743954476106258],
                'C2': 38,
                'C3': -46,
                'C4': 2936861023,
                'C5': 6689393403253641429},
               {'C1': [9652423611257596943, 7977206405871936054],
                'C2': 23,
                'C3': -127,
                'C4': 724920955,
                'C5': -3575682468482416524},
               {'C1': [1837321767792417500, 7887926314042596831],
                'C2': -21,
                'C3': 114,
                'C4': 3646597162,
                'C5': 1720481659778150530}]},
 'A3': 10840192586799359403,
 'A4': {'D1': 590095387,
        'D2': -33,
        'D3': [186, 12, 180, 137, 27],
        'D4': 2501023817030253935}}

Вариант №32

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

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

(b'*VJYK\xb2\xbd%\xd0\\<\xcb\\\xbfys\x03\x00\x1a\x00\x00\x008bbj\x9d\xf5'
 b'\xa9\xd5h\x00\x03\x00\x00\x00\x17\xde\xac\x80N0\xd8\xf7\xcbRk\n\x0f<\xa5A'
 b'H\xce\x89\xf7\xa1\x7f\xd4\x19\xb5|\n\xaa\xbc\xbf\xb6\xb2\x89\x92r\xb7'
 b"\xff\x82O\xe2A\x9b\xfd\xd7\x88<\x99\xdf\x13\tw+?\xa1<\xfb'^\xa6\x81"
 b'\xd7\xf3\x92Qm\xaa:\x17\x9dY\xd6\xedq\xf7F\x00\x00\x00-')

{'A1': 12879492086180399964,
 'A2': -0.9744111895561218,
 'A3': {'B1': 40437,
        'B2': -87,
        'B3': -10904,
        'B4': 'bbj',
        'B5': -559120306,
        'B6': 819525579},
 'A4': {'C1': 2709509145,
        'C2': [{'D1': [-19076, 2730, -17217],
                'D2': [46770, 35218, 29367, 65410]},
               {'D1': [20450, 16795, -553], 'D2': [34876, 39391, 4873, 30507]},
               {'D1': [16289, 15611, 10078],
                'D2': [42625, 55283, 37457, 28074]}],
        'C3': 58,
        'C4': 1701615013857457990,
        'C5': {'E1': 82, 'E2': 7712994064970369230, 'E3': -30217}}}

(b'*VJYK;\x01\x83bC\xf2\xd5T\xbe\xf8\xd0M\x00\x1b\x00\x00\x009pohu\xc7'
 b'5\xd7\x9a\x17\x00\x04\x00\x00\x00\x17\xbc\xac\xban\x05\x99\xe3g\xf8\xb8'
 b'W\xbe\xac\xda\x81\xa0\xd4\x0eV\x19\xa5\xba\xbf\x9a\x8b\x8fJ\xcf<\xfd'
 b'\xf2\xe8Z\x83v\x07\xd0m\xd0\x19R\xf3\x1a\x17\xc4S\x85\xaa\xaa\xee'
 b'\n\x0b\xa0\xc8m@\xea\x11\x99l\xfd\xadxK+\x18\xc8n\xfa\xcf\x1e\x1a\xaa\xea'
 b'\x00\x00\x00.')

{'A1': 4251823981284480340,
 'A2': -0.48596420884132385,
 'A3': {'B1': 50997,
        'B2': -41,
        'B3': -26089,
        'B4': 'pohu',
        'B5': -1129530770,
        'B6': 93971303},
 'A4': {'C1': 430291647,
        'C2': [{'D1': [-25973, -28854, -12484],
                'D2': [65010, 59482, 33654, 2000]},
               {'D1': [28112, 6482, -3302], 'D2': [6084, 21381, 43690, 60938]},
               {'D1': [2976, -14227, 16618],
                'D2': [4505, 27901, 44408, 19243]}],
        'C3': 24,
        'C4': -4003987251215553814,
        'C5': {'E1': -8, 'E2': 13283295275562148052, 'E3': 3670}}}

Вариант №33

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

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

(b'DHML%)k\x90\xe1\xdd?rdjnxwueC"\x00\x04\x00u\x00\x83m\xaf\xbe\xe9\xe8'
 b'\xb6=&\xfd1\x94<\xea\xccU V\x94A\x11J\xc5\xec\n\x06\x00%\x00\x00'
 b'\x00\xa2\x89;\xbf\x83\x13.|UEJ\x02\x00>\x00\x00\x00"\xafN\xbd\xd1\xe6'
 b'S\xe1\xaa\xf7\xb2\xe6\xea\x87\xcd\x04\x00O\x00\x00\x00\x14\xa8x?\x08'
 b'\x96\xcf\xd6\xcaz\xdb\x02\x00d\x00\x00\x00k\x0c ?\xc41\x00\x00\x00B\x00\x00'
 b'\x00W\x00\x00\x00h\x00\x00\x00')

{'A1': 0.46689234223284326,
 'A2': {'B1': 'rdjnxwue', 'B2': 67, 'B3': {'C1': 64806, 'C2': 49}},
 'A3': [{'D1': 2796,
         'D2': [15508, 52458, 8277, 37974, 4417, 50506],
         'D3': -0.7325688600540161,
         'D4': 131},
        {'D1': 19013,
         'D2': [11795, 21884],
         'D3': -0.05045998841524124,
         'D4': 209},
        {'D1': 52615,
         'D2': [21478, 43745, 45815, 60134],
         'D3': 0.9713146686553955,
         'D4': 8},
        {'D1': 56186,
         'D2': [53142, 51926],
         'D3': 0.625189483165741,
         'D4': 196}],
 'A4': [-0.34263238310813904, 0.08931142836809158]}

(b'DHM\xdcBoXE\xc0\xe3\xbfbqdifoptu"\x00\x04\x00y\x00\x04=\x15?\xe8\xcb'
 b'~>\x10\xdd\xc3]\xfcD\x85\xb3\xdd\xc1c\x03\x00%\x00\x00\x00C[\x0c?\xa7'
 b'#\x9d\x1a6\x98{\x02\x008\x00\x00\x00\xc2x3\xbe\x07N\xf9)o\xe4\x83\xc0'
 b'f\xd1\xa3\x04\x00I\x00\x00\x00\xa0\x06\xbf=\xbf\xd5\xa8\x9e\xe9\x02\xd5'
 b'\xffe\xc7:\xaa\xceK\xe4W\xaf\x07\x00^\x00\x00\x00\x84\xf9"?j+\x00\x00'
 b'\x00<\x00\x00\x00Q\x00\x00\x00l\x00\x00\x00')

{'A1': -0.6172205664862207,
 'A2': {'B1': 'bqdifopt', 'B2': 117, 'B3': {'C1': 56592, 'C2': 195}},
 'A3': [{'D1': 25537,
         'D2': [64605, 34116, 56755],
         'D3': 0.5482675433158875,
         'D4': 167},
        {'D1': 31640, 'D2': [40227, 13850], 'D3': -0.1752653419971466, 'D4': 7},
        {'D1': 41937,
         'D2': [63822, 28457, 33764, 26304],
         'D3': 0.09327435493469238,
         'D4': 191},
        {'D1': 44887,
         'D2': [43221, 59806, 54530, 26111, 15047, 52906, 58443],
         'D3': 0.6366198062896729,
         'D4': 106}],
 'A4': [0.5829622745513916, 0.24882471561431885]}

Вариант №34

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

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

(b'WQA*\x02\x00\x00\x00\x88\x00\x00\x00\xb0MgJ\xe3&\xdc??\xa8T?\x08\xb3\x9cU'
 b'?\xb2\xe7R\x9f\xbe\xc5\xb7/>>e\x87X\r?S!\xe2;\xbfbZpj?\xde.\xaa\x9d\xbd\xf9'
 b'l\x16\x9bS.D\x9d\xearJ\x93\xd1\xab\xc2T\x00L\x84\xca\x1bQU?fbUY\xe4'
 b'\xb3\r\xc0\xbe\xf2\xd8\xae\xe0\x03\x00\x00\x00\x8a\x00\x00\x00k\x11\xb3;'
 b'\xb4\xa9mj2\xcb\xda\xbe\xe3\xd6\xa7\xca/\xb3\xf3\x8f\x02\x00\x00\x00'
 b'\x8d\x00\x00\x00k\x96\xaf+tv\xcc3\xe1`V\xccTtp\xdc\xbf\xb8\x93\x82dU\xb2\xc5'
 b'\xbf')

{'A1': {'B1': 'tv',
        'B2': 0.4398735262486424,
        'B3': [{'C1': 0.8306922316551208, 'C2': 8},
               {'C1': 0.8344222903251648, 'C2': 178},
               {'C1': -0.31117936968803406, 'C2': 197},
               {'C1': 0.18572889268398285, 'C2': 101},
               {'C1': 0.5521320700645447, 'C2': 83},
               {'C1': -0.7339192032814026, 'C2': 98},
               {'C1': 0.9157768487930298, 'C2': 222}]},
 'A2': {'D1': -0.07698474824428558,
        'D2': 11332233498990111993,
        'D3': 6107632961275458282,
        'D4': {'E1': 0.0013010760686185119,
               'E2': 102,
               'E3': 3831059810,
               'E4': -0.37510451674461365,
               'E5': [55538, 57518],
               'E6': [-52, 51, -31],
               'E7': 7668972332042621291,
               'E8': -0.42733150720596313},
        'D5': -8073912689100335389,
        'D6': [-0.4443636730296472, -0.16950480849950877]},
 'A3': 732927595}

(b'WQA*\x04\x00\x00\x00\x88\x00\x00\x00\x00fU\x84\x0f\xdd\x87\xbf\xd9\x9fd\xbf'
 b'\xb8\xc1\x92N\xbfU\xd85;\xbf\xf0\xeb)\xe8\xbe7?*\x14?\x97\xc6\xe6\x99'
 b'\xbe\x1a1\x00h?N\xea&\x08?&\xdf:\n\xb6\x9f\x1e\xaa,\xc7\xc6\x18Y'
 b'\x15\x00\x9d\xbcd\xf3\x84M\xf6\xd5\xbf\x1c\xa0\x89yB\xf6\x94\xf2\xbe'
 b'\x16\x02\xa0\x84\x06\x00\x00\x00\x8c\x00\x00\x00K%&\x8aP\xc5\x06h$F[>'
 b'\x8f\xe9\xfc\x18>Z\xe8F\x03\x00\x00\x00\x92\x00\x00\x00c\x87\xd8\xefitzf'
 b'\xb9\xafr\xeb\xfaH8\x80p\x97{\x83\xe5\xbf\xa2A*\xd8\x98\xeb\xe2?\xe8\x86'
 b')1\xfd8\xd6\xbf')

{'A1': {'B1': 'itzf',
        'B2': -0.011652108407974815,
        'B3': [{'C1': -0.8930640816688538, 'C2': 184},
               {'C1': -0.8069267868995667, 'C2': 85},
               {'C1': -0.731290340423584, 'C2': 240},
               {'C1': -0.45344480872154236, 'C2': 55},
               {'C1': 0.5787696242332458, 'C2': 151},
               {'C1': -0.30058878660202026, 'C2': 26},
               {'C1': 0.906252920627594, 'C2': 78}]},
 'A2': {'D1': 0.5318437814712524,
        'D2': 12258410839953563430,
        'D3': -7133678337342912724,
        'D4': {'E1': -0.34315813048813104,
               'E2': 28,
               'E3': 1115261344,
               'E4': -0.4737927317619324,
               'E5': [534, 33952],
               'E6': [-71, -81, 114, -21, -6, 72],
               'E7': 7495895579510580555,
               'E8': 0.21413475275039673},
        'D5': 5109433000005527951,
        'D6': [-0.672300143985928, 0.5912594053243547, -0.3472283344363931]},
 'A3': 4023945059}

Вариант №35

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

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

(b'\xffEUG:r\x10>\x03\x00\x00\x00j\x00\x03\x00\x00\x00m\x00\x00\x00\xe90zx8\x01'
 b'\xcd\xd5\xbf\x07\x00v\x00\xaf\x1d4,\xa4\xc4$0\x1bC\xd6"\xa6\xf4Y\xca\x12'
 b'\x8aj\xed\xf6"&\xe7\xfa\xf7\x8e\x89\xd9E\xc6\x8d\xcc>\xb6a\xb3q\x14\xd2\x0c'
 b'+\xd5\x9cS\x10\xa7\x94%hH\xff\xca\xbb\x0eO\xfa\xbb\xf1i\x02\x06\xde\x88k'
 b'\xbe^\xbb\x99\xe0\xffpocK\xa0\x88\x19g\x14\xca\x10\xb4vnxmrdi')

{'A1': 0.1410607397556305,
 'A2': 'poc',
 'A3': {'B1': [{'C1': -24501, 'C2': -120},
               {'C1': 26393, 'C2': 20},
               {'C1': 4298, 'C2': -76}],
        'B2': -23,
        'B3': -0.3406374980421871},
 'A4': 'vnxmrdi',
 'A5': [741612975,
        807716004,
        584467227,
        -900074330,
        -311784942,
        -416931082,
        -1987119110],
 'A6': [2378581465, 1639333580, 3524555187, 2631215884, 2493976659],
 'A7': {'D1': 4282935333,
        'D2': 7634089527112285130,
        'D3': 2296251906,
        'D4': -16789,
        'D5': 94},
 'A8': -2057797}

(b'\xffEUG\xc3}e\xbf\x03\x00\x00\x00j\x00\x03\x00\x00\x00m\x00\x00\x00\xb6\x88'
 b'\x88\x85\x06\x06\x98\xe1?\x07\x00v\x00M\xc1d\xd8^\xf1s\x14\x81\x84\x08N\x18'
 b'V\xb5\xc4\xf1\x9a\xa5\xfcZ\x89\xa9\xf1\xfc\t/\x17\xb5?\xd2HA\xba\xab\xbe-'
 b'D\xfbzH;\x85\xdd&\xce\xb5\xd2\xa2>U\xd2W\xd3O\xed\xb5@\xdb\x1d\xcc\x84u@%'
 b'\x9d\r\xc9\xd4j\x06gdq\xecC\xeeuYa0\xeb\xd9czkxmdi')

{'A1': -0.8964502215385437,
 'A2': 'gdq',
 'A3': {'B1': [{'C1': 17388, 'C2': -18},
               {'C1': 22901, 'C2': 97},
               {'C1': -5328, 'C2': -39}],
        'B2': -74,
        'B3': 0.5498075606704029},
 'A4': 'czkxmdi',
 'A5': [-664485555,
        343142750,
        1309181057,
        -994748904,
        -56255759,
        -240547494,
        388958716],
 'A6': [1221738421, 3198925377, 2063287341, 3716496200, 3535130150],
 'A7': {'D1': 3528801954,
        'D2': 2151384397114233687,
        'D3': 1081443532,
        'D4': -25307,
        'D5': 13},
 'A8': 107664585}

Вариант №36

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

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

(b'6EZU^\xb1\xe3\x0fahjk\x00\x8d\x00\xaeV\x99\xc2\xe6]\x07\xcb\x19\x91\x1d\x92F'
 b'G\xc61N\xc9\x10\xdd}\xf82bbr\xf3\x9b\x7f\xfb\xb7\xdf\xa3e~\xcb\xbdg\x15\xf2G'
 b'$\x8a`C\x10\x84\r%\xbc\xf3\x0e\x0f\xa4X\xb3\xce\x9e\xfd\xda\xa6F\xfe\xe4\xc8'
 b'p.\xafp=L\xa60\xfd\xd8|\xc3\x179\x84\x16!\xae\x0f\xaf\x94w\xe0\xf6'
 b'\xaf%\xbc\xde\xa0\x0f\x00\x00\x00&\x00\x00\x00=\x00\x00\x00T\x00\x00'
 b'\x00\xdb\xffV*p(,\x00b\x99\xa8\x13\xa2c\xd9\xdc\x85\xa4\x98\x1f\xae\x03\x00'
 b'\x81\x00')

{'A1': 266580318,
 'A2': 'ahj',
 'A3': {'B1': 41182,
        'B2': [{'C1': -3816978913484515666,
                'C2': -1843556071,
                'C3': [18246, 12742, 51534, 56592],
                'C4': 63613,
                'C5': 50},
               {'C1': -5189413837833346462,
                'C2': 2120590303,
                'C3': [48587, 5479, 18418, 35364],
                'C4': 17248,
                'C5': 16},
               {'C1': -6625060086842323580,
                'C2': -1630620840,
                'C3': [56061, 18086, 58622, 28872],
                'C4': 44846,
                'C5': 112},
               {'C1': -4360371757246952387,
                'C2': 377764119,
                'C3': [44577, 44815, 30612, 63200],
                'C4': 9647,
                'C5': 188}],
        'B3': 710344667},
 'A4': {'D1': 133, 'D2': -1373661020, 'D3': [2893936, 329816418, 3705234338]}}

(b'6EZU(\x18:,bjfk\x00\x8d\x00@\xb7\xbb\xd0\xc1\xdf\xde\xa9=\x8a\xd5\xc8B'
 b'`\\\xfa\xc7\xfb\xe8\xe5\x05X\xbe\xdb\x88\xcf\xecP\\\xacw`\xab9\x0e\xa1\xf1'
 b'\xfb\xaf\r7w\x1b\xb3\xa2\xbaWI}\x8a\xeb\x0fwV\x05\x89J\x8b\x9c\xc5f'
 b'\xa4.=\xc4\x1d\xef\x8d`\x92vU\x0fJ6\xc9\xff(\x96\x17V\xbb\xb7\x81\x80'
 b'A\xb9\xfb\x99\xac\x8f\xde\x1f\xe8\x0f\x00\x00\x00&\x00\x00\x00=\x00\x00'
 b'\x00T\x00\x00\x00\x00<\xb0\xa5f8\xdb\xb1q\xd4\xe9\xfb\x0b+5r\x7f\xfd\x99'
 b'\x8c\x1e\x03\x00\x81\x00')

{'A1': 742004776,
 'A2': 'bjf',
 'A3': {'B1': 59423,
        'B2': [{'C1': -6206277212946319552,
                'C2': -925529539,
                'C3': [24642, 64092, 64455, 58856],
                'C4': 22533,
                'C5': 190},
               {'C1': 8623368889147820251,
                'C2': 238660448,
                'C3': [61857, 45051, 14093, 7031],
                'C4': 41651,
                'C5': 186},
               {'C1': 6230466113805568343,
                'C2': -1958049531,
                'C3': [50588, 42086, 15662, 7620],
                'C4': 36335,
                'C5': 96},
               {'C1': -15421432006347118,
                'C2': 1444386344,
                'C3': [47035, 32897, 47425, 39419],
                'C4': 36780,
                'C5': 222}],
        'B3': 2779790336},
 'A4': {'D1': 127, 'D2': 512530941, 'D3': [2983934054, 4226405489, 1916087051]}}

Вариант №37

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

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

(b'ZKQ\xd5\x00\x0e\x00Nvvehly>\xb3q%\xe3\xa9E\xc3\xd9\x92\xea\xf0j8'
 b'\x04\xc4\xc1\x00\x06\x00\x08\x81\r\x03u\xd4\xf9@\xd2\xe3\xeatE\xf5'
 b'\xbf\xac\x0fS\x08\xd4R\xe0\x1eR\xd5\x07m\xd3I\x08_\n\xa1\xc1\x1b\x7f\x00\xcf'
 b"\x00'\x002\x00=AN\x01E\x00\x00\x00\x03\x00H\x84Y\x0c$\xba\x8an\x15GN\x0e\xeb"
 b'`\xfcy6\xa2u6\xcd\xb0\xec\x10[o\x1e\xbe&\xb4\x1e\x1e\xf5\xddH\xc5\x86'
 b'\x1a\xfaQQs\xd0]+\xb9\xf9%\xc7\x0f\x9c^\xeb\xaa~\xa5')

{'A1': {'B1': 0.3504725992679596,
        'B2': -2042024248564585744,
        'B3': 1782056132,
        'B4': -63,
        'B5': 'vvehly',
        'B6': 2165113717},
 'A2': {'C1': 1095631173,
        'C2': [{'D1': 15346368479752778821, 'D2': 245, 'D3': 49068},
               {'D1': 1104236041652411986, 'D2': 213, 'D3': 1901},
               {'D1': 15224709219595960603, 'D2': 127, 'D3': 207}],
        'C3': -31655,
        'C4': [203733642,
               1846888270,
               250306812,
               2033623669,
               919449836,
               274427678,
               3190207518,
               519429448],
        'C5': 14233093334759470032,
        'C6': 93,
        'C7': 733608229,
        'C8': [199, 15, 156, 94, 235, 170, 126, 165]}}

(b'ZKQ\xd5\x00\x0b\x00rnxn?9\x0e\xd8\xafo\x9aK\x192\x80gn\xb2\xd8Kx'
 b'\x00\x03\x00\x08\x12q\xb4\x94g\xbe\x11\x89\xd8\xf2p\x9fb\xac\xf5\xd2</\tz'
 b'%\xf4\x14d7<\xd0)\xb1\xaa\x97\x97\x8c[\xdc\x14\xd3z\xe6\xcf\xb9\x7f,\x86'
 b'\xbd\x01\xac\x9bl\xdd\xa5Z\x02d\x866\xf5\x89\x81?\x0c\x87\xee^g)p\xae'
 b'\xf6\xa9\x00$\x00/\x00:\x00E\x00P\x00[3Q\xc5-\x00\x00\x00\x06\x00f'
 b'\xaa\x17\xf8\xcb\xb5\xef\x91\xf2R\x18>\xaf\xef2\xe3\x98\x81\xac:\xec'
 b"\x82\x00\x1f$b;;M\x10NWqYx\xbb9m\xf8\xeb\xc0\x93'Y^\xe9\x7fgi%\xffR_"
 b'\xe4\x0fa')

{'A1': {'B1': 0.7228827476501465,
        'B2': -5805251747321315225,
        'B3': 1857214539,
        'B4': 120,
        'B5': 'nxn',
        'B6': 309441684},
 'A2': {'C1': 860996909,
        'C2': [{'D1': 7475431715229560991, 'D2': 98, 'D3': 44277},
               {'D1': 15149034964318024724, 'D2': 100, 'D3': 14140},
               {'D1': 14999715380179995739, 'D2': 220, 'D3': 5331},
               {'D1': 8855994112880182973, 'D2': 1, 'D3': 44187},
               {'D1': 7844607931955054134, 'D2': 245, 'D3': 35201},
               {'D1': 4543155581965773168, 'D2': 174, 'D3': 63145}],
        'C3': -21993,
        'C4': [4174099951,
               2448577048,
               1051717426,
               3818422700,
               988578304,
               522478139,
               994906190,
               1467046264],
        'C5': 13490935074639614759,
        'C6': 89,
        'C7': 1592360807,
        'C8': [105, 37, 255, 82, 95, 228, 15, 97]}}

Вариант №38

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

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

(b'WSBX\x97"\x9d\xbc\x06]\x1e3\x98\x916\xf8\x94:\xd2\x1dD\x92\x02\x00'
 b'}\x00\xed\xfd\x7f\x00\x00\x00\xe3\x07[\x87f\xf2\x01a\xd9\x03\x00\x00'
 b'\x00\x83\x00\x00\x00\x1bR*/\x93\x81\xd2\x0b\xb3\xd9^\xcaM\x91\xdb'
 b'\x16\xca\xab\xd6\x18\xf3\xd0^)m\x8b\xe1\xd1?\x03\x00\x00\x00\x86\x00'
 b'\x00\x00,o\x81`\x83\x193\x0cM\xf2*\xe9\xe6\xd3=\xb1/v\xbd\xf1S\x92'
 b'\xed\x16\xab\xc1\xa6\xe5?:\r\x08T\xa6\x89!\xaa\xe1?ve\xe2L\xf9[z'
 b'\x1d\xad\xdb\xc9e')

{'A1': 8855,
 'A2': [1560722589, -1852296418, 982841398, -1841029678],
 'A3': {'B1': 've',
        'B2': 237,
        'B3': -3,
        'B4': {'C1': 19682, 'C2': 23545},
        'B5': -29},
 'A4': 15663803119585155847,
 'A5': [{'D1': [122, 29, -83],
         'D2': 791302683,
         'D3': 198345107,
         'D4': [-77, -39, 94, -54, 77, -111, -37],
         'D5': -13802,
         'D6': -216475989,
         'D7': 0.27939115200341025},
        {'D1': [-37, -55, 101],
         'D2': 1619095340,
         'D3': 204675459,
         'D4': [77, -14, 42, -23, -26, -45, 61],
         'D5': 12209,
         'D6': 1408351606,
         'D7': 0.6766060201256769}],
 'A6': 3386,
 'A7': 0.5520179451438034}

(b'WSBX;e\xb7Yc\x9a\xe7\x15n8\n\x92^fv\xe7\x92\x97\x02\x00}\x00K)'
 b'\x7f\x00\x00\x00\xf6\xcd\x90\x16\x04\xb9\xd8\xff\xfe\x03\x00\x00'
 b'\x00\x83\x00\x00\x00\n\xdc[\xe9\xd2\xdc%\xb9\xe4\xaeB~\xa6\x14~)j\xfei'
 b'mX\xd4\xde\xc83f\x9d\xe4?\x06\x00\x00\x00\x86\x00\x00\x00\x16\x1e\xc4\xe9xP'
 b'^\xeeJP\x9a\xbd\x84\x8e;\x06\xe5\xd8\xd7#\x06(\x08\x92\xb7V<\xce\xbfv'
 b'q,\xf6\xf1\xc0V\xf4\xdd\xbftk\xdd\xd5+\xeeLW0e\xccet\t\xea')

{'A1': 25915,
 'A2': [-1704765001, 946738663, 1717473802, -1751980170],
 'A3': {'B1': 'tk',
        'B2': 75,
        'B3': 41,
        'B4': {'C1': -10787, 'C2': -4565},
        'B5': -10},
 'A4': 18374643293844050125,
 'A5': [{'D1': [76, 87, 48],
         'D2': 3915111434,
         'D3': 3106266322,
         'D4': [-28, -82, 66, 126, -90, 20, 126],
         'D5': 27177,
         'D6': 1483565566,
         'D7': 0.644213772909064},
        {'D1': [101, -52, 101, 116, 9, -22],
         'D2': 3921944086,
         'D3': 3999158392,
         'D4': [74, 80, -102, -67, -124, -114, 59],
         'D5': -6906,
         'D6': 103012312,
         'D7': -0.23621639216804735}],
 'A6': 29046,
 'A7': -0.46803826181698827}

Вариант №39

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

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

(b'HYAA\x00\x8aV?\x02\x00\xb8\x00\x00\x00L6\x12\xed\xd2cA)\x9f\xe4'
 b'\x7f\x10\xa2\x18\xa0\xea\x02\x00\x16\x00\x00\x00\xb1\xe3\xf3k\xd7=+\xc2'
 b'\xa6&\xf3Xh\xbd4\x95\xfa7x\x02\x00\x0e\x00\x00\x00\x11lF\xbf}\x13p'
 b'\xa4\x1e\x00\x00\x00)^:\xaf\xec\x05\x00\x00\x00-\x00\xb7\x82v\xc3'
 b'y\x99\xc9\x1e\xea\x8f\x96\x03\x84\x0c\x8e\x88L\xd4G~{\x92\xdb\xd0(52X'
 b'W\xb2<\xae0\x17v\x0bMm\x03\x00n\x00\x00\x00\xd3u5\xdb~?R\x0f\x1b}\r\xbb'
 b'\x05\xe2#\x1dy\x04\x00^\x00\x00\x00\xb1#\x11\xbf\x0c\x8a\x176z\x00\x00\x001'
 b'@\xe6L6\x04\x00\x00\x00\x89\x00R\r\x1dM\xe5\r\xf1\x94\xc1^7\x00\x91\x00')

{'A1': 0.838043212890625,
 'A2': [{'B1': {'C1': [3977393740, 692151250],
                'C2': -0.7750864624977112,
                'C3': 2758808445,
                'C4': {'D1': [276817055, 3936360610],
                       'D2': 58289,
                       'D3': 0.10518636554479599,
                       'D4': -15829,
                       'D5': -90},
                'C5': -1355129303,
                'C6': 236,
                'C7': [-3290, 26712, 13501, -1387, 30775]},
         'B2': 3279323831,
         'B3': 516528505,
         'B4': 36842},
        {'B1': {'C1': [209978262, 3561785486, 2457566791, 891867355],
                'C2': -0.5669508576393127,
                'C3': 907512332,
                'C4': {'D1': [2992068658, 389066300, 1833765750],
                       'D2': 30163,
                       'D3': 0.9955323338508606,
                       'D4': 3922,
                       'D5': 27},
                'C5': 1290158129,
                'C6': 54,
                'C7': [3453, 1467, 9186, 31005]},
         'B2': 1293749586,
         'B3': 2498825701,
         'B4': 24257}]}

(b"HYAA\xeaCT\xbe\x02\x00\xb4\x00\x00\x00~'x\xe4\xfb\xa1\x95\xbfeN%m<d"
 b'\x03\x1c} \x83`\x02\x00\x1a\x00\x00\x00\xfb\r\xeb\x17\\\xbf\xfb\x99'
 b'\xdf\x0e\x1c_-\x03\x00\x0e\x00\x00\x00\xef\xe3w?\x1ep\x95\xb6"\x00\x00\x00y'
 b'y+\xb4\xcf\x02\x00\x00\x001\x00\xe8\x9f\x92y|\x85\xf1\xffrm\x8d\xad\xcfi'
 b'\x1a\x1d\xfa(\xb2|\x0f*\x9c$\x05\xc6\xc1\xd2\x1d\xe3\xd9_,\x8d\x02\x00l\x00'
 b'\x00\x00IV\x95\x16\x90>\x0b\xcc&\xd1\x8d\xf8\xd5\x9b\xc1j\xb7\xa1,\x04\x00\\'
 b'\x00\x00\x00\x0e\x8d\t?\xdf89\xbbt\x00\x00\x00VH\x1dr\xa0\x05\x00\x00\x00'
 b'\x83\x00\x8c\xf2O"\xe09F\x05q\x8f5\x00\x8d\x00')

{'A1': -0.20729032158851624,
 'A2': [{'B1': {'C1': [3833079678, 3214254587, 1831161445],
                'C2': 0.9683217406272888,
                'C3': 3063246878,
                'C4': {'D1': [469984316, 1619206269],
                       'D2': 3579,
                       'D3': -0.8597399592399597,
                       'D4': -26117,
                       'D5': -33},
                'C5': -1272219271,
                'C6': 207,
                'C7': [7182, 11615]},
         'B2': 2039652328,
         'B3': 4294018428,
         'B4': 28018},
        {'B1': {'C1': [1775218061, 687480090, 705658034, 3322225820],
                'C2': 0.5373085737228394,
                'C3': 3141089503,
                'C4': {'D1': [3810382529, 2368495577],
                       'D2': 22089,
                       'D3': 0.28142228722572327,
                       'D4': -13301,
                       'D5': 38},
                'C5': 1914521686,
                'C6': 160,
                'C7': [-29231, -10760, -15973, -18582, 11425]},
         'B2': 575664780,
         'B3': 88488416,
         'B4': 36721}]}

Вариант №40

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

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

(b'ZMXHh\x93\x00\x00\x00/:w0.\x9f\xd0U\x8e\x00\x00\x00?M-\x00\x00\x00\x06'
 b'\x00\x00\x00\x91\x08\xa8\xd9\x00\xb7q\x13\xd4\xe7\x15\xfbihqq\xbf'
 b'\xed\xda\xaa\x98s\xe8\xb6\x00\x00\x00\x04\x00+\t\xb4\xbf\xd6\xae\xbe\xe8'
 b'\x96n\x1c\x87\x90\xa6\x16\x93\xfc>%\xe4<k\xee|\xc2\xdd\xfc\xc7\x8a\x9a8\xf7'
 b'\xae\xba\xc4\xfe\xea\x16pod\x96\xfd~dTVd\xeb\x9b>\xd7\xf9C\x88\x12J\xed\x13K'
 b'\x02O\xdb\x15;\x93\xa6\x9d#NBr\x02W\xcfc\x06\x9b\xd1f\x19\t\x8d\xe3'
 b'oh\x1e\xa6^\x00\xd6')

{'A1': 26771,
 'A2': {'B1': -0.9329426744073064, 'B2': 'ihqq', 'B3': 2484},
 'A3': 4212888953236247950,
 'A4': {'C1': -0.3544156333316282,
        'C2': 2274403862,
        'C3': [{'D1': 37884, 'D2': [15909, 58428, 27630], 'D3': 31938},
               {'D1': 56828, 'D2': [51082, 39480, 63406], 'D3': 47812},
               {'D1': 65258, 'D2': [5744, 28516, 38653], 'D3': 32356},
               {'D1': 21590, 'D2': [25835, 39742, 55289], 'D3': 17288},
               {'D1': 4682, 'D2': [60691, 19202, 20443], 'D3': 5435},
               {'D1': 37798, 'D2': [40227, 20034, 29186], 'D3': 22479},
               {'D1': 25350, 'D2': [39889, 26137, 2445], 'D3': 58223}]},
 'A5': {'E1': 77,
        'E2': 45,
        'E3': [104, 30, 166, 94, 0, 214],
        'E4': [2216, 55552, 46961, 5076, 59157],
        'E5': 251}}

(b'ZMXH\xc6\x88\x00\x00\x00.4\xab\xf8\xf3}\xaa\x9bU\x00\x00\x00>&\xb9'
 b'\x00\x00\x00\x05\x00\x00\x00\x90)O\x98\xa2Sa\x14\x9f\xa9\xb5\xadwgv\xbf\xd3'
 b'\x0c\xff,\x00x\xf4\x00\x00\x00\x03\x00+S\xc1\xbf\xe2\x0e<\x949'
 b'\xb8\x8c\x9c\xf7\x1brq\x9bOHc-\x82=3\xa0\xf8\xa6m\x1f\x94\xe0|\xb7\x92>\xdbx'
 b'\xc6\x0f\t\xe5qn\x80\x95\x03U\x17]W\x8b\x0e\xf2[\xday\xfd\xae\x1f|b'
 b'\x99.\x1c\xec\xe1I]\x0c\xbb\x1d\xe4/\x83\x83L"%\xf2?\xfe\x029\x88u'
 b'\xfa\x9d\x851\x81')

{'A1': -14712,
 'A2': {'B1': -0.29766825959258303, 'B2': 'wgv', 'B3': 21441},
 'A3': 3795400835658849109,
 'A4': {'C1': -0.564237870695949,
        'C2': 2633440114,
        'C3': [{'D1': 29083, 'D2': [20296, 25389, 33341], 'D3': 13216},
               {'D1': 63654, 'D2': [27935, 38112, 31927], 'D3': 37438},
               {'D1': 56184, 'D2': [50703, 2533, 29038], 'D3': 32917},
               {'D1': 853, 'D2': [5981, 22411, 3826], 'D3': 23514},
               {'D1': 31229, 'D2': [44575, 31842, 39214], 'D3': 7404},
               {'D1': 57673, 'D2': [23820, 47901, 58415], 'D3': 33667},
               {'D1': 19490, 'D2': [9714, 16382, 569], 'D3': 34933}]},
 'A5': {'E1': 38,
        'E2': -71,
        'E3': [250, 157, 133, 49, 129],
        'E4': [10575, 39074, 21345, 5279, 43445],
        'E5': 173}}

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

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

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

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

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

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

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

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

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

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

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

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