ИКБО-25-22

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

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

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

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

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

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

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

(b'EZHTC?N\xdaZ\xbe\x18sm\xea.dgiur\x00*\x13\xe9\x00\x00\x00\x04\x00\x00\x00v'
 b'\x00\x00\x00\x81e\xe0/e%I^T\x00\x00\x00\x02\x00$\x19\x85\x9aTL\xbd\x8a*\xbez'
 b'\x07f"\x86\r8_\xcd#\xd8G\xc93\xe3\x88a\xc1\x8f\xb5\xbf6k^.+i}\x98\x91\xb8rw'
 b'y\xc5\x07\x1aJ\x13~\x88jj\x1fz\xb8\xb5U\xbb\xa2(\t%\xa4\xd6\x16\xe3'
 b'\x17\xb5\x03\xd8\xd3\x9cC\xb0y\xee#\xe1\x07\x10\xb9og\xbd\x19X\xdb\x05\xdf_'
 b'\xc4\xc5\x00\x03\x00\x00\x00~\xbf\xe7\x93\xa8*\x90\xf8.')

{'A1': {'B1': 0.8080192804336548, 'B2': -0.148877814412117, 'B3': 59950},
 'A2': 'dgiur',
 'A3': {'C1': 24148,
        'C2': [{'D1': 26080, 'D2': 47}, {'D1': 25893, 'D2': 73}],
        'C3': 6533,
        'C4': -1705751363,
        'C5': 35370,
        'C6': -0.24416884779930115,
        'C7': [2487690379945386968,
               5172722699350425999,
               13096246076186176361,
               9050143672581454277,
               511802955247676010,
               2268328451301417512,
               659114159893583797]},
 'A4': 5097,
 'A5': [984, 54172, 17328, 31214],
 'A6': {'E1': 280588135,
        'E2': -0.03743825480341911,
        'E3': 5,
        'E4': -547371835,
        'E5': [35, 225, 7],
        'E6': -0.736774523865966}}

(b'EZHTC\xbeCE\xcb\xbf0\xe9\xd9\xd6\x89emcld\x00-\x8b!\x00\x00\x00\x02'
 b'\x00\x00\x00y\x00\x00\x00\x80\x9ae.\xfaR9^c\x85qF\x00\x00\x00\x03\x00'
 b'$\xc0Q\x00>\xca6\x98`\xbe4\xd3\xbb5\tO\x80M\xcb@\x0f\x02\xdf\x88'
 b'\xca\xa0I\xc5\x15\xf2\n\xec\xde\x88\xafP\xe7\xdfaa=\xc4\xc4\xea;/hA'
 b']\xd6F\xc80\xediLr"\xe4BY\xfb\x98\xfe<\xc6\xf4\xa34(\x1a\xa3\xf5>|\xba'
 b"+-J\x91>\xb7\xc71b'\xbd2\xa4\x00\x03\x00\x00\x00}?\xa1\x089\x0c3\x0e\xa0")

{'A1': {'B1': -0.19069592654705048, 'B2': -0.6910682320594788, 'B3': 54921},
 'A2': 'emcld',
 'A3': {'C1': 28998,
        'C2': [{'D1': -26011, 'D2': 46},
               {'D1': -1454, 'D2': 57},
               {'D1': 24163, 'D2': 133}],
        'C3': -16303,
        'C4': 4114998,
        'C5': 39008,
        'C6': -0.17658893764019012,
        'C7': [3821673171280150543,
               207034511736292629,
               17441012947465752807,
               16096253461121002043,
               3416052188643248176,
               17107288712638906969,
               18129519836969345844]},
 'A4': 35617,
 'A5': [10266, 41973],
 'A6': {'E1': 724388497,
        'E2': 0.35894158482551575,
        'E3': 98,
        'E4': 666710692,
        'E5': [62, 124, 186],
        'E6': 0.033265860308828055}}

Вариант №2

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

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

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

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

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

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

(b'\xd6LMOT\x00-\xebheboa\xbc\x02\xdeh"\xdc\xe6F\x00\x04\x00\x00\x00^\x19'
 b'[\xdb\xd8\x06N\xea\xdc\t\x04\xa7:\xacs\xecV\x9c\xafq#5#\xa3P~\xba\xb0\xc1#'
 b'\x94\x1a\xfe\x14\xc6\t|\xae\xcfZQ\xef0\xa5$\xdb!\x10\xa6\xdc\x08\x1c\xca\xd2'
 b'Nh\n{\x81S?\xc10\xd8\xe4\x89M\x18btrh')

{'A1': {'B1': {'C1': [{'D1': 113, 'D2': 2536973149430266544, 'D3': -63},
                      {'D1': 35, 'D2': 10672121632183123118, 'D3': -49}],
               'C2': 6508245928735202081,
               'C3': 1199888278141719118,
               'C4': 104,
               'C5': 175866195,
               'C6': 0.1343031993770658},
        'B2': 235,
        'B3': 'heboa',
        'B4': 3154304616,
        'B5': 584902214},
 'A2': 'btrh',
 'A3': 6491,
 'A4': -2605325448416327420,
 'A5': [42810, 44147, 60502, 40111]}

(b'\xd6LMOT\x00-\x0bldrpd\x91\x1d\xea\x9f\xf4\xdc\xc5Q\x00\x03\x00\x00\x00^\x8a'
 b'@G\x1f\xa2Rql\x10\xf0\xe5~O\xa8\x87Q\x918\x885z\xc4\xf5/\xa6\xe3N\xa8e'
 b"\xc2\x87\xda\x81\x1b\x1d\x14\x1d:Uc\xdf\x8c\xb7\xd5\xb3*[\x8b\x9c\xf3'z\x07"
 b'\xd4\x07e\x86\xd5\x87?\xc9y\xaf\x87\xb7\x19pfvd')

{'A1': {'B1': {'C1': [{'D1': 136, 'D2': 3853608988514378574, 'D3': -88},
                      {'D1': 101, 'D2': 14017412613254485021, 'D3': 58}],
               'C2': 6153007311390880554,
               'C3': 6596538647367518164,
               'C4': 7,
               'C5': 1703335303,
               'C6': 0.19902605177612598},
        'B2': 11,
        'B3': 'ldrpd',
        'B4': 2434656927,
        'B5': 4108109137},
 'A2': 'fvd',
 'A3': -30144,
 'A4': 5124993375944839408,
 'A5': [58750, 20392, 34641, 37176]}

Вариант №3

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

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

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

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

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

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

(b'9JDTK\x00\x00\x00\x02\x00\x00\x008\x87?~#\xa8\xccG\xe0?\xe6\xc7M)\xa4Q'
 b'\x8a\xde\xfa\x00\x00\x00\x02\x00\x00\x00t\x04\xa7\x00\x02\x00\x00\x00x\xb4'
 b't:^qqQ\xe9\xdcvn\x10\xb7\xcf&\x99\xb7zk~\xb0\x0e\x92\x06X<\x1e\xa0\xaa'
 b'\x8fd\xe8\xb7\xf3\xe2E\xbeH\xa9/\x1bw\xfaM\xb1\x0f\xf5\x18\xc6\xfaj\x13D'
 b'\xcaW\x1e\xc4H\x8c\x8fv]\xbc\xeaG\xcd\x95y\\\x00:\x00W\xac\x84\xe5\x0f'
 b'z\xf5r\x9f\x0c[\x02\xe1\r-!2')

{'A1': 'vn',
 'A2': -2025882077,
 'A3': -1463007264,
 'A4': 0.7118287862127073,
 'A5': -8454,
 'A6': {'B1': [{'C1': 4279,
                'C2': [3475413431, 2053865136, 244450904],
                'C3': 1008640170,
                'C4': -8114104751846439490,
                'C5': 72,
                'C6': 43311},
               {'C1': 7031,
                'C2': [4199395599, 4112041722, 1779647690],
                'C3': 1461634120,
                'C4': -8318299841756510259,
                'C5': 149,
                'C6': 31068}],
        'B2': 1191,
        'B3': {'D1': [12431312726099587743, 890308516947763506], 'D2': 180}},
 'A7': 8375110298374367708}

(b'9JDTK\x00\x00\x00\x02\x00\x00\x008\x9dq\x13N\x9e\x95\xcfX?\xce\t'
 b'\xe4\x1c\x90\x1e\x80 \x11\x00\x00\x00\x03\x00\x00\x00\x91P\n\x00\x03\x00'
 b'\x00\x00\x97\xf8\xcb\x83\xdc6\x1f\x90\xf5\xbcfs\x9dv\xb6\xe1\xcc\x88'
 b'\x84\xc2M\xca\x9f,\x93]A\x94\x9d\x8b\xf9\x91\x1a\xa7\xdb\x08\x90\xa7'
 b'e\x8f]\xc3^\xde\xadi1\xa6u\x04)N\xed\x189[%L\xa9\xb9\x89\xb2\xa1Qwh\x8b?^i'
 b'm\xd1(\x8b\x01\xe7)G\xf9\xa1\xdf-\x19t.\xf8p\xa1G\x90\x91\xd6\xbc\x08'
 b'NW\x06\xf38\x00:\x00W\x00t\xf4\xa6>~\x96\x8fq*\xa0rk\x82\t\xad\xc2\xf5\x19'
 b'\xbd\xe4\xcd5\x88\xc2\xda')

{'A1': 'fs',
 'A2': -1653533874,
 'A3': -1634349224,
 'A4': 0.2346768512218098,
 'A5': 8209,
 'A6': {'B1': [{'C1': -25226,
                'C2': [3068251272, 2227326410, 2670498653],
                'C3': 1100258699,
                'C4': -463559978405818201,
                'C5': 101,
                'C6': 36701},
               {'C1': -15522,
                'C2': [3735906609, 2792686633, 1324161081],
                'C3': 1529171113,
                'C4': -5077330698957264757,
                'C5': 63,
                'C6': 24169},
               {'C1': 28113,
                'C2': [680198631, 692582817, 3744274804],
                'C3': 788033697,
                'C4': 5156781924802907735,
                'C5': 6,
                'C6': 62264}],
        'B2': 20490,
        'B3': {'D1': [17628846504801169706,
                      11561421399665787637,
                      1854890191564096218],
               'D2': 248}},
 'A7': 14664806936664405436}

Вариант №4

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

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

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

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

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

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

(b'NED\xd5\x81x?\x07\x00\x00\x009\x00\x02\x00\x00\x00t\x00\x00\x00\x02\x00|'
 b'\x00\x00\x00\x99\xcaa?ZAQ\x12\xc3\x06\x97\x1c\xd3\x96\xe5Q\xdcAq\x96\xd4'
 b'\x8fuO\x10\xecyG\xb0\x17rduxchz\x89\xba3\x7f\x02\x00\x00\x00@\x00*\xf4'
 b'\xc4\x0c\x17\xe3ZV\x8c\xa5\x95I\xa8z\xc5\xc5\xe8\xbe\xbf\xe2\xb2\x03'
 b'\x00\x00\x00Y\x00\x8a5gM\x884)\xf70-^0\x9d\xf5\x01D\x00\x00\x00_\x00\x00\x00'
 b'W7')

{'A1': 0.9707310795783997,
 'A2': {'B1': 'rduxchz',
        'B2': [{'C1': [-17783, 32563],
                'C2': 42,
                'C3': 10112369944697816308,
                'C4': -1471572571,
                'C5': [122, 197]},
               {'C1': [-5947, -16450, -19742],
                'C2': 138,
                'C3': 3528334138669885237,
                'C4': -1657774547,
                'C5': [245, 1]}],
        'B3': {'D1': [87, 55],
               'D2': 0.8819976449012756,
               'D3': 2060122789440995674,
               'D4': 1374000851,
               'D5': -36,
               'D6': 65},
        'B4': -1436560914788346255},
 'A3': 397428601}

(b'NED\xc21\xbd>\x02\x00\x00\x009\x00\x02\x00\x00\x00o\x00\x00\x00\x03\x00w'
 b'\x00\x00\x00\xa7(A\xbf_\x04Y\x85\x95\xea \xb4t\xeb3A\xd5y\xc9:\x16x\x92TK'
 b'\x019\x83\x97\xf3ra\xea\x80y\x98=\x92\x03\x00\x00\x00;\x00\xf4E{F\xee'
 b'\x82E\x8e\xb2\x97\xc4"\x89\xc4\x8f\x8d\xe8~\x15\x02\x00\x00\x00V\x00'
 b'yS\x02\x9d\x9a:y\xd4\xc0\xd63Hf\x1b\xb6A\x00\x00\x00Z\x00\x00\x00\n\xe3m')

{'A1': 0.36952024698257446,
 'A2': {'B1': 'ra',
        'B2': [{'C1': [-32534, -26503, -28099],
                'C2': 244,
                'C3': 12866297614089747269,
                'C4': -1994210153,
                'C5': [196, 143]},
               {'C1': [-6003, 5502],
                'C2': 121,
                'C3': 13894864042953867859,
                'C4': 1716007894,
                'C5': [27, 182]}],
        'B3': {'D1': [10, -29, 109],
               'D2': -0.7545265555381775,
               'D3': -5467112019719551905,
               'D4': 1093921652,
               'D5': -43,
               'D6': 121},
        'B4': 93261205347908297},
 'A3': -208174279}

Вариант №5

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

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

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

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

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

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

(b'GYVPh>\x04\x00Z\x00\x00\x00\x94\xbc\xbf\x86I\xc9\xae\xa9\xd0\xd6\xd5\xf8'
 b'\xd5\xee@\x1c`|\x89\xdf\x18\x83\x92td\xfa\xc1\xbf\x04\x00\xaa\x00'
 b'\x00\x00A\xe5h2\x04\x82\xbec\xcaD\xf6v\xec\x01$\xc4\x7f\x13\t?hb$>G,v?5\xe8'
 b'{>\xdaZa?kplkchca\xe9\r\xa1\x03 \x10\xd9\xbe[5\xe1\x97\x02\x00\x00\x00R\x00'
 b'\x00\x00\x11s\xa6\xc6\xd4{-\xd4L\xac\xe0c\x02\x00\x00\x00T\x00'
 b'\x00\x00\xc3\xaf\xef\x97\xf9\x91O\xaf\xb9\xd4"\x02\x02\x00\x00\x00V\x00'
 b'\x00\x00\xd9[\xe9\x8e\xf7\x15\xc7\xc1\xa4\xf1\x88\xb0\x02\x00\x00\x00X\x00'
 b'\x00\x00a\xdfd\xbc')

{'A1': 15976,
 'A2': [{'B1': -4694703406871147031, 'B2': 2548118875, 'B3': 'kp'},
        {'B1': -3157731609920769263, 'B2': 1675668556, 'B3': 'lk'},
        {'B1': -5814268092730069053, 'B2': 35837113, 'B3': 'ch'},
        {'B1': -4483590751025275943, 'B2': 2961764772, 'B3': 'ca'}],
 'A3': {'C1': 148,
        'C2': {'D1': -16452,
               'D2': 134,
               'D3': 51529,
               'D4': [-22098, -10544, -1835, -4395]},
        'C3': 7232,
        'C4': 3750329440,
        'C5': -0.14045386974341834},
 'A4': [97, -33, 100, -68],
 'A5': 7187325009867105601,
 'A6': 14133423645715219658,
 'A7': [0.535453736782074,
        0.1605316400527954,
        0.961613118648529,
        0.24600298702716827,
        0.880292534828186]}

(b'GYVP%\xe5\x03\x00X\x00\x00\x00\x94D\r\x80\xa1\xc5\xd9\xb8\xc9-^]'
 b'\x07&\x88\xb5\x8f\x81K\xef\x14\x9cQ\x0b3\xc7\xee\xbf\x04\x00\x94\x00'
 b'\x00\x00\xd2\x82\xae\xcd\x0e=9\xd5q[ElI^\xf2\xb35\x82\x18>2\xd10?\xc5\xf1'
 b'}>\xe9\x0fT?\x8d\t\x83=bdosky\xc8:3\xadD\xc4v"\xe2\xb5Lk\x02\x00\x00\x00'
 b'R\x00\x00\x00\x91\x0c<k\xd8\xa4t\xc8s\x92\x17\xfe\x02\x00\x00\x00'
 b'T\x00\x00\x00(\x9e8mwzZ>\x84\xdayw\x02\x00\x00\x00V\x00\x00\x00uM\xac#')

{'A1': -6875,
 'A2': [{'B1': 2483388043784043208, 'B2': 1800189410, 'B3': 'bd'},
        {'B1': -4002392919406539631, 'B2': 4262957683, 'B3': 'os'},
        {'B1': 4493038231607615016, 'B2': 2004474500, 'B3': 'ky'}],
 'A3': {'C1': 148,
        'C2': {'D1': 3396,
               'D2': 128,
               'D3': 50593,
               'D4': [-18215, 11721, 23902, 9735]},
        'C3': -19064,
        'C4': 4014702991,
        'C5': -0.9618163319654536},
 'A4': [117, 77, -84, 35],
 'A5': -3082365336168791342,
 'A6': 12966529946595187569,
 'A7': [0.14893420040607452,
        0.6906920671463013,
        0.2479925900697708,
        0.8283677697181702,
        0.06398306041955948]}

Вариант №6

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

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

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

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

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

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

(b'KRU\xd9\x00\x02\x00\x853\xeb\x08G\t/\xe4\xf6\xb9\x10%+:\x99\xe7A'
 b'm\xb1\xca\xe4>es\x85\x0c\x80T\xbd\xcb rc\x8a\x04\x18\xe4G\x80\xc9\xdb'
 b'\x8d\xe1\xdf\x95\xeb@\xfeUZ\xc3,YDZ\xe6\x80\x84\xa1S\xf1\x06UoE0~\xf2\xa0'
 b'0\xde\x83\xf5]\xf5`\xe4\x0f!\xe72*T\x83\n\xe9\x8a>\xfe\xd6(\xc2\xbfS7G\xb5'
 b'\xf1\xeaWjv\xbf\x85\x82\xe9\xea\xee^\x80\x00\x00\x00\x02\x00\x87\x0e'
 b'\x1dc\x1b\xf7\xc0B\xa6\x917rr\x9e\xbb')

{'A1': 'rr',
 'A2': 13291,
 'A3': 2119,
 'A4': 9,
 'A5': 803534521,
 'A6': [{'B1': 4133,
         'B2': {'C1': 43, 'C2': 58},
         'B3': -7356839526896311234,
         'B4': 101,
         'B5': 29573},
        {'B1': 3200,
         'B2': {'C1': 84, 'C2': 189},
         'B3': -3809919512912586524,
         'B4': 71,
         'B5': -32567},
        {'B1': -9331,
         'B2': {'C1': 225, 'C2': 223},
         'B3': -7643944481433402580,
         'B4': 89,
         'B5': 17498},
        {'B1': -6528,
         'B2': {'C1': 132, 'C2': 161},
         'B3': 6048622738544078974,
         'B4': 242,
         'B5': -24528},
        {'B1': -8573,
         'B2': {'C1': 245, 'C2': 93},
         'B3': -765361183008542166,
         'B4': 84,
         'B5': -31990},
        {'B1': -5750,
         'B2': {'C1': 62, 'C2': 254},
         'B3': -3014945823533873227,
         'B4': 241,
         'B5': -5545}],
 'A7': 'jv',
 'A8': {'D1': -0.010503604394940469,
        'D2': [-98, -69],
        'D3': 1017078062627439270,
        'D4': -28361}}

(b'KRU\xd9\x00\x02\x00\x85\xff*\xa8\xbes\xc3\xd7S\x90]\x91\xaf\\\xa5\x88\xaf'
 b'%%\x93#\xbb\x91\xc8j\xd5\xee\xf0rtJ\x8d\xa7uY\x0b\xe7\x1f\xd1\xfe\x9b'
 b'\xe3\xb9\x94~6\xa9i\na\xc1K\x0can\xee\xecxX\xab\xc4\xf0\x91\x07='
 b'\x1c\x8d\x1cQ\x03\xf9\x16\x1d\xd5)e\x1aG\xcb\xe3:zW\xce\xa7\xfe\xf7v\xe5'
 b'\x92\x9fr\x07K\xe6\xe7\xc7\xca\xf0ukt\xbf\xd8re\xb4\xcc\xc9\xe0\x00\x00\x00'
 b'\x03\x00\x87\\\xc8\xf6\x93\xe8\x98\xd2q\xd1\x8fjw0\xda}')

{'A1': 'jw',
 'A2': -214,
 'A3': 43198,
 'A4': 115,
 'A5': -1009298544,
 'A6': [{'B1': 23953,
         'B2': {'C1': 175, 'C2': 92},
         'B3': -6518767886539742277,
         'B4': 145,
         'B5': -14230},
        {'B1': -10770,
         'B2': {'C1': 240, 'C2': 114},
         'B3': 8379665807044053991,
         'B4': 31,
         'B5': -11778},
        {'B1': -25629,
         'B2': {'C1': 185, 'C2': 148},
         'B3': 9094642766132134219,
         'B4': 12,
         'B5': 24942},
        {'B1': -4372,
         'B2': {'C1': 120, 'C2': 88},
         'B3': -6069461892106216307,
         'B4': 28,
         'B5': 20739},
        {'B1': -1770,
         'B2': {'C1': 29, 'C2': 213},
         'B3': 2982819223868488314,
         'B4': 87,
         'B5': -12633},
        {'B1': -265,
         'B2': {'C1': 118, 'C2': 229},
         'B3': -7881455447211317305,
         'B4': 202,
         'B5': -3979}],
 'A7': 'kt',
 'A8': {'D1': -0.3819822564720692,
        'D2': [48, -38, 125],
        'D3': 6685864761954456177,
        'D4': -11889}}

Вариант №7

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

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

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

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

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

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

(b'OFKN\x17\\\x8dY\xd71\x9e\xe9?\xa3\xc6^\x00\x00\x00\x08yr\x15\x02'
 b'\x00\x00\x00\x85\x00\x05\x00\x89\x00\x00\x00\xa48\xc8\xa9\xc8-\x82>\x04'
 b'\x00\x00\x00#\x00\x00\x00\x16\xe5\x1e\xbcX\xbf\x02\x00\x00\x003\x00\x00'
 b'\x000G\xe5\xe9?\xbf\x02\x00\x00\x00A\x00\x00\x00\x1c\x0f`\\\xe7'
 b"\x16\xbf\x03\x00\x00\x00O\x00\x00\x00\xbf\x05B\xa7?;l\rlea'\x00\x00"
 b'\x005\x00\x00\x00C\x00\x00\x00R\x00\x00\x00-K\xaa\xbe0,\xa0\xd9\xa37\xba'
 b'\xbf\x92\xad\x01\xd3)\xa2\x1a\x8a*')

{'A1': 0.8005608755160369,
 'A2': -14685,
 'A3': {'B1': {'C1': 967213164552914367, 'C2': 'lea'},
        'B2': [{'D1': 0.2542555332183838, 'D2': [164, 56, 200, 169]},
               {'D1': -0.8466204404830933, 'D2': [22, 229]},
               {'D1': -0.7496626973152161, 'D2': [48, 71]},
               {'D1': -0.5894677639007568, 'D2': [28, 15, 96]}],
        'B3': -0.3326047956943512,
        'B4': -0.1024114996254617},
 'A4': 359823624,
 'A5': [-21102, -11519],
 'A6': [41, -94, 26, -118, 42]}

(b'OFKN\x17R\x9c\x08\xf5O6\xef?\xafoc\x00\x00\x00\x86\x8d\xbb\xc6\x02'
 b'\x00\x00\x00\x8a\x00\x05\x00\x8e\x00\x00\x00\xae\xa7\xc8\x1b\xae'
 b'\x18=\xbf\x04\x00\x00\x00#\x00\x00\x00\xe5|\x0fr\xba\x1d\xbf\x03\x00'
 b'\x00\x003\x00\x00\x00\xb9\x16t7\xf9\x84\xe6:\x04\x00\x00\x00B\x00'
 b'\x00\x00\xfc\x8d<\xa0\x9d\x9e\xe3R\xbf\x05\x00\x00\x00R\x00\x00\x00\x96'
 b"\x9b\xfab\x16\x06\xa8=ayt'\x00\x00\x006\x00\x00\x00F\x00\x00\x00W\x00"
 b'\x00\x00\x8c\xccf?\xf8\xab_\xe17\xb2\xc2?\\h2\xd9r\x0b\x8a\x0c3')

{'A1': 0.9753799234212102,
 'A2': 28591,
 'A3': {'B1': {'C1': 4442807725620632470, 'C2': 'ayt'},
        'B2': [{'D1': -0.7386578321456909, 'D2': [174, 167, 200, 27]},
               {'D1': -0.6161261796951294, 'D2': [229, 124, 15]},
               {'D1': 0.0017587236361578107, 'D2': [185, 22, 116, 55]},
               {'D1': -0.823785662651062, 'D2': [252, 141, 60, 160, 157]}],
        'B3': 0.9015586376190186,
        'B4': 0.14606379036499084},
 'A4': 3334180230,
 'A5': [26716, -9934],
 'A6': [114, 11, -118, 12, 51]}

Вариант №8

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

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

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

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

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

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

(b'OGQHz\xeb3\xbf\x02\x002\x00w\x8b\x81x\xd5k-\x9f\xbf\xcdP\xb14\x00\x00\x00'
 b'a\x00\x00\x00\xbcz\xb4S}e\xc650NP}\r=\xf7k\xe5\xbfou\x03j\xfel\xb5\x1c8?'
 b'dK\x8c\xe2O\xa8[e\xca\xf6\xc9\x1eu\x1cpu\xa0\xbc>\xce\x1c\xb4V\t$r\xb4>'
 b'9\x86\xc0f\xde\xe3\n\xcf\x8fG\xfc\xbd{\xeb\xb9\xa6>w\x10i\xeb\x03\x98Lf G8'
 b'~\xd5\xd0\x13\x04\x16\x1f\xbf&5\xe4v\x19\te\xbb64\x96\xda\x0c>\xf4G\xef\x8d')

{'A1': -0.7028118371963501,
 'A2': {'B1': 'ou', 'B2': -6976801683133068425, 'B3': -1320104513},
 'A3': [{'C1': 1828612611,
         'C2': {'D1': 0.7191880345344543,
                'D2': 100,
                'D3': 35915,
                'D4': 1537757154,
                'D5': [101, 202, 246, 201, 30, 117],
                'D6': 28700},
         'C3': 0.36841168999671936,
         'C4': 13002494696699993294,
         'C5': [14654, 49286, 56934, 2787, 36815]},
        {'C1': 2076048455,
         'C2': {'D1': 0.32563719153404236,
                'D2': 119,
                'D3': 26896,
                'D4': 1285030891,
                'D5': [102, 32, 71, 56, 126, 213],
                'D6': 5072},
         'C3': -0.6214296817779541,
         'C4': 13503209062713799974,
         'C5': [13366, 55958, 15884, 18420, 36335]}],
 'A4': 31420,
 'A5': 5634062260062999476,
 'A6': -0.6694294159350793}

(b"OGQH\x8e\x99\x01>\x03\x002\x00'\xdfrG\xb2\xc0a$\xf5\x13\xee\xc85\x00\x00\x00"
 b'b\x00\x00\x00\xb0\x91\xa6\x00%A\xaf\xa2\xb8\x01\x10u\x10\xa8\xce{\xdc\xbfro'
 b'vW.\x98\xb0\x7f\xa6\x1d?v{\xa5\xf5Mo\xb8\x8d,\xf8\xed\xe7\x95\x15\x8a'
 b'\x9f\x95Y\xbf\xb4c\xcfr\xbcux\x1ccf7\xf8\xba[\xf5\xb2\x19\xee\xceS\x7fLu\x17'
 b'\xb5\xbe\xbe\xeb\xed\x962+\xdcg\x1c]\x1b\r\xeb\xa5> \xf9-?\xa9\xefU'
 b'\xaf\xaf]\xd6-\x90\xb4\x05\x1b{\xfc\xd6N\xa9\xd8')

{'A1': 0.12656232714653015,
 'A2': {'B1': 'rov', 'B2': 2621588330041761575, 'B3': -923921419},
 'A3': [{'C1': -1332203945,
         'C2': {'D1': 0.6158217787742615,
                'D2': 118,
                'D3': 42363,
                'D4': -1200665099,
                'D5': [141, 44, 248, 237, 231, 149],
                'D6': -30187},
         'C3': -0.8499392867088318,
         'C4': 2051519082507756468,
         'C5': [26211, 63543, 23482, 45813, 60953]},
        {'C1': 1283412942,
         'C2': {'D1': -0.3536945879459381,
                'D2': -66,
                'D3': 60907,
                'D4': -601148778,
                'D5': [103, 28, 93, 27, 13, 235],
                'D6': 16037},
         'C3': 0.6795825958251953,
         'C4': 3302930385865142185,
         'C5': [46224, 6917, 64635, 20182, 55465]}],
 'A4': -28240,
 'A5': 124027863348609190,
 'A6': -0.4450565949681087}

Вариант №9

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

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

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

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

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

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

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

(b'\xbdJFTJ?i$\xea\xfa\x00\x00\x00\x02\x00\x00\x00e\xdb\xf9z\xf7\xec$'
 b'\x1a\x8cx\x08\x91\x13TN\xb6\x81j5\x19\x87\xc2-j-\x02\xc6\xdd\xaa\x85\x08'
 b"\x15\x16\xe6\x08U\xd9u\xef\x97\xf2!\x87\x06y\xc6%\xaag'\xbf\x15&1?"
 b'8\xd3\xab\x8f\x12\xb7\xfdG\xde\x00\x03\x00\x00\x00g\xbf}\xfc\x0c\x82'
 b'\x00\x02\x00s\xc7\x00\x00\x00uqbH\xe9\xbf\t+;\xe2>+\x07\xf8&&\xeaC\xf4g'
 b'\x86\xceX\x84^`\x9a&')

{'A1': {'B1': 0.9107195138931274,
        'B2': -6,
        'B3': 'qb',
        'B4': -2595908504965080436,
        'B5': 120,
        'B6': [{'C1': 8, 'C2': 10453791857103170101},
               {'C1': 25, 'C2': 9782431274647078621},
               {'C1': 170, 'C2': 9585934994950870489},
               {'C1': 117, 'C2': 17264533922361276870},
               {'C1': 37, 'C2': 12278826610696007999},
               {'C1': 56, 'C2': 15252441873579329502}]},
 'A2': {'D1': [1223278345, 725344830, 721942566],
        'D2': -0.9921271800994873,
        'D3': -126},
 'A3': [38, 234],
 'A4': 199,
 'A5': {'E1': 67, 'E2': 4100425422, 'E3': [22660, 24160, -26074]}}

(b'\xbdJFTJ>`\x82\xad\xe0\x00\x00\x00\x02\x00\x00\x00e\xa9\x9c4\xe3+\x0f'
 b'\x05\xcb\xb1\xf8\x8ca\xae\x0e\xf1\x136\x94\xda\xdd7w,\x8b\xa9\x9d\xeck\xbc)'
 b'\x00c\xe6\xd6omp)-\xdd\x9d\x81\xabK\x84\x16\x8e\\\xdd\x8a\xbb\x8b\td'
 b'!\xd5\x8e\xea\x0b\x11\xb8\xa4@\x00\x03\x00\x00\x00g>\xbd\xee\xac\x1d'
 b'\x00\x03\x00s\x0b\x00\x00\x00vkb6?\x10.\xe8ma\xa7!D\xa1\xde\x8f\xe6m\xd8\xfc'
 b'_\x00\xe7]\xed\x8d\xbae\xc0')

{'A1': {'B1': 0.21924848854541779,
        'B2': -32,
        'B3': 'kb',
        'B4': -6225042434648242741,
        'B5': 177,
        'B6': [{'C1': 248, 'C2': 10115557617248188052},
               {'C1': 218, 'C2': 15940340439306575340},
               {'C1': 107, 'C2': 13558368582250164077},
               {'C1': 112, 'C2': 2967271398062115716},
               {'C1': 22, 'C2': 10258317639164823908},
               {'C1': 33, 'C2': 15388494310034416704}]},
 'A2': {'D1': [910102574, 3899482535, 558146014],
        'D2': 0.3709615468978882,
        'D3': 29},
 'A3': [143, 230, 109],
 'A4': 11,
 'A5': {'E1': 216, 'E2': 4234084583, 'E3': [24045, -29254, 26048]}}

Вариант №10

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

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

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

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

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

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

(b'KQDCn\xa3-njec{[\xfc\xea\x9c\x00\x00\x00\xbe&\x8c}\x0ct\xb3*\xb4'
 b'\xb4\xbc\xa34.\xf8}P\xca\xd3\x8b\xc2\xe5p6\xbf\x86\x18\xc2\x03'
 b'\xf9\x00\x00\x00\x06\x00\x00\x00"\xa5\x8c\xf3\xa5\xb5\'\xd0\xb1R\xa1\xe8'
 b'\xe4\x1e\x86\t`\x00\x00\x00\x07\x00\x00\x009\xb0Z{\xc2\xcb_\xcc\xed@\xce\xfe'
 b'\xbd\x18\xfc\x00\x00\x00\x05\x00\x00\x00Q\xc5\x97\\\x83\t\xb5%U('
 b'\xbe\xa6\x00\x00\x00\x02\x00\x00\x00g\xf5I\x05Aq\xd8\x0c@x\x88'
 b'\xfb\xe0\x00\x00\x00\x03\x00\x00\x00z2w\x1d\xffx\x8ae\xba\xc9\xf3(\xb0\x133'
 b'4E\x00\x00\x00\x07\x00\x00\x00\x8e\x00\x00\x00(\x00\x00\x00@\x00\x00'
 b'\x00V\x00\x00\x00i\x00\x00\x00}\x00\x00\x00\x95b\xf4\x8e\x97\x8b\xc3'
 b'\xebF\x00\x00\x00\x06\x00\x00\x00\xa6')

{'A1': 163,
 'A2': 45,
 'A3': 'njec',
 'A4': 123,
 'A5': 1543301788,
 'A6': {'B1': 7130480891570416454,
        'B2': [{'C1': [58736, 14015, 34328, 49667],
                'C2': -7,
                'C3': [125, 80, 202, 211, 139, 194]},
               {'C1': [45394, 41448, 58398, 34313],
                'C2': 96,
                'C3': [165, 140, 243, 165, 181, 39, 208]},
               {'C1': [24524, 60736, 52990, 48408],
                'C2': -4,
                'C3': [176, 90, 123, 194, 203]},
               {'C1': [23683, 2485, 9557, 10430], 'C2': -90, 'C3': [197, 151]},
               {'C1': [16753, 55308, 16504, 35067],
                'C2': -32,
                'C3': [245, 73, 5]},
               {'C1': [47817, 62248, 45075, 13108],
                'C2': 69,
                'C3': [50, 119, 29, 255, 120, 138, 101]}]},
 'A7': {'D1': 646741260, 'D2': 8409111884845589300},
 'A8': 12024}

(b'KQDCn\x0eJausr\xb3<\x8a\xb4\x1d\x00\x00\x00\x8c\x10!\xac\xdb*\xb6OT'
 b'\x89\x90\xdd\r\xb6\xa7\x80\xa6\x083Et>Q\xe9|\xfc\x00\x00\x00\x02\x00\x00\x00'
 b'"7r7?@\x07\x81\x99\xbd\x88\xbfS\xeeo\x14vO\x00\x00\x00\x08\x00\x00\x005\xc9k'
 b'\xcc\x16O\xbd\x18!o\xe9\xf8\x08\xbe9\x84\x00\x00\x00\x06\x00\x00\x00'
 b'N\xf6\xb1\x193\xa5\x87\xa5\x1b\x1b\x02\x81\xa0\xdez\x8b\x00\x00\x00\x06'
 b'\x00\x00\x00e\x00\x00\x00$\x00\x00\x00=\x00\x00\x00T\x00\x00\x00k'
 b'\xef\x17;\x10E\xe9T\x93\x00\x00\x00\x04\x00\x00\x00|')

{'A1': 14,
 'A2': 74,
 'A3': 'ausr',
 'A4': -77,
 'A5': 1015723037,
 'A6': {'B1': 17228303840607556755,
        'B2': [{'C1': [2099, 17780, 15953, 59772], 'C2': -4, 'C3': [128, 166]},
               {'C1': [48520, 48979, 61039, 5238],
                'C2': 79,
                'C3': [55, 114, 55, 63, 64, 7, 129, 153]},
               {'C1': [6177, 28649, 63496, 48697],
                'C2': -124,
                'C3': [201, 107, 204, 22, 79, 189]},
               {'C1': [42267, 6914, 33184, 56954],
                'C2': -117,
                'C3': [246, 177, 25, 51, 165, 135]}]},
 'A7': {'D1': 270642395, 'D2': 3077734619858132237},
 'A8': -18777}

Вариант №11

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

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

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

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

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

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

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

Поле	Описание
1	uint16
2	uint8
3	uint16
4	float
5	int64
6	float

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

(b'MAXC\xbb\xe1\xbckW\x1d\x00Y\xb2F\xfe\xcb\x00o\xa6\x00\x00\x00\x04\x00'
 b'\x00\x00\x85?\xccS\xaa;u\xca\xa0?\xea\x05gEDR\xfc\xbf\xc24d\x8f'
 b'\n\xff\x00\xbf\xdb\x00\xd9>cm\xec\xbf\xe5\xae\xd3\xe7Z\x9c6>\x0b\xf7\x88^'
 b'\t\x19\x02\x00\x00\x00\x89\xce\xc6v\xf9\x00\x00\x00\x03\x00\x9e9\xaf\xd2'
 b'\x00*\xd8C\x8fwU\xb6NW\x7f>\xfd\xb38\xfe\x19\xf0\xce\x1d\xaf\x84)\x80<zf\xd6'
 b'\\hr\xce\xcf\rL6\xce\xb6\xd1\xa0\xd5ycuuX}F\x1f\xef>G0\xfa:\xb5\xc5\xce\xbf*'
 b'M\xb4>\xc2\x97\xb62\xf58"6q\xae\xf9\xd5c\xcb\xaf')

{'A1': {'B1': 48097,
        'B2': [{'C1': 3161151261,
                'C2': {'D1': [967823872,
                              718816143,
                              2002105934,
                              1467956989,
                              3006856729],
                       'D2': -3890}},
               {'C1': 2990997195,
                'C2': {'D1': [498041897,
                              2151447142,
                              3596380274,
                              3469675852,
                              919516881],
                       'D2': -24363}}],
        'B3': -90},
 'A2': 'ycuu',
 'A3': {'E1': [0.22130325225187608,
               0.8131595948094339,
               -0.14222390160102094,
               -0.42192679493538665,
               -0.6775912779456863],
        'E2': 0.13668644428253174,
        'E3': 24073,
        'E4': 6402},
 'A4': {'F1': 22653,
        'F2': 70,
        'F3': 8175,
        'F4': 0.19452276825904846,
        'F5': 4230504916745604532,
        'F6': 0.3800637125968933},
 'A5': {'G1': -825854215, 'G2': [854931490, 913420025, 3580087215]}}

(b'MAXC\x00\xe4^VF\x05\x00Y\xc7\xc9\xe0A\x00o^\x00\x00\x00\x03\x00\x00\x00\x85?'
 b'\xe0\x15\x14:\xdep\x8c\xbf\xd8x\xe7)0\xe5\x80\xbf\xcc{\x04\xd1z\xc5\xf8?'
 b'\xe2l\xdd>\xc3\xe3x\xbf\xdc\xc4P\xea\xd8\xe5\x80?`\xe5\x85X\xed\x11\x14\x00'
 b'\x00\x00\x88\xf1S\xe8\x15\x00\x00\x00\x03\x00\x9d[\xa3x\xd7\x95\xbeM'
 b'\x05|X\xc7\x1b\\\x82\xad\xf0\x02\xae\xbf\x16\x80n\x03\x91\x02\xb4b'
 b'\xaf\xb1J\x93\x1e\xf2\xa3\x0c\xe6d\\\x96\xb1\xe4\xc5"\xf8bmnE\xe3\xf7\x94'
 b'\xc0>\xd8\x04T\x10gkt\xc5\x19\x80\x97\xbe\xeb\x89\x0b\xa0\xe6\xde'
 b'\xa6\xb8\xdf\x842\xd6{\xc9u')

{'A1': {'B1': 228,
        'B2': [{'C1': 1582712325,
                'C2': {'D1': [1537439959,
                              2512276741,
                              2086192923,
                              1552068080,
                              45006614],
                       'D2': -32658}},
               {'C1': 3351896129,
                'C2': {'D1': [59835060,
                              1655681354,
                              2468278947,
                              216425564,
                              2528240837],
                       'D2': 8952}}],
        'B3': 94},
 'A2': 'bmn',
 'A3': {'E1': [0.5025731229575441,
               -0.3823793318038824,
               -0.2225042364930656,
               0.5757890916712389,
               -0.4494821828298754],
        'E2': 0.8785021901130676,
        'E3': 22765,
        'E4': 4372},
 'A4': {'F1': 17891,
        'F2': 247,
        'F3': 38080,
        'F4': 0.42190802097320557,
        'F5': 1182031576475205783,
        'F6': -0.4600299298763275},
 'A5': {'G1': -246159339, 'G2': [2699484838, 3101656114, 3598436725]}}

Вариант №12

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

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

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

(b'MFQD\x000C\xdb\xdf,\xb7\xbf\x04\x00L\x00\x00\x00\r\x80\x00\x00\x00v'
 b'\x12I\xbdLm\xf6\x1c\x10\xc7uv\xe8\xbf\x12\xc5L\x8er,\xe4\xbfx@\xb9e\xf2F\xca'
 b'?\x14Hx\x1d\xf7\x0b\xda\xbf\xb1\xeao\xe6J\x8f\xfe\x1b\xe6l\xb0\x8c\x00l&'
 b'0\x92H3\xb5\xdf\xa2y\xbby\xc6o@2g`\x7f*\x85llB!\xb2\xd8p\n$\x15\xe9\xe8^'
 b"\xb7dv<i/\\\x1f\xee\xcb\xf5_\xea\xde\xe7\xbe\x18X'i\x04\x00p\x00"
 b'\xc7@\xd1\x16\x93\xbe\xa7m%\xc2\x0f\xbeC\xd8i\x18(\x7f\x8d\x7f6\x19\x85\xab'
 b'g\x16\x9a%\x9e')

{'A1': -0.09052847960555255,
 'A2': {'B1': [{'C1': 8764813794158875184, 'C2': -69},
               {'C1': 9178449506108163705, 'C2': 42},
               {'C1': 8131444983135497349, 'C2': 10},
               {'C1': 8531145212408960292, 'C2': 60}],
        'B2': {'D1': 13,
               'D2': {'E1': [526135145, 1609944046, -1092100374, 1764186136],
                      'E2': 16583,
                      'E3': -0.28728345036506653,
                      'E4': 28071},
               'D3': 3175682678},
        'B3': 27980,
        'B4': [-0.7644604576061329,
               -0.6304257182402202,
               0.20529012648558242,
               -0.4069803035537245]},
 'A3': 2017207234965007025,
 'A4': 230,
 'A5': 45164,
 'A6': {'F1': -0.14038904011249542,
        'F2': -10173,
        'F3': 105,
        'F4': 10264,
        'F5': [-29313, 13951],
        'F6': 1739293977,
        'F7': 2653264406},
 'A7': 9836}

(b'MFQDp\x94\x7f\x98\xae\xf2\xee\xbf\x02\x00L\x00\x00\x00\xbcf\x00\x00\x00\x89'
 b'\x0e\x8a\xd9i\xbcL\xce\xfc\x1c\xdfz\xe2\xbfF\xcf\x9f\x1flM\xea?X\x83\x9a'
 b':\x8f\x03\xe0\xbf\x18<\xad\x8bO(\xc8?{\x03\xf8X=\x06\x84\xf1\xcd\x84\xe3'
 b'r\x00!\xfcl\xe4\x13NYt.\xb6\xaa\x9f\xcd\xfd\xdet\x9f\x0ce\x18ZV>\xe1\xe3\x1a'
 b'\x86\x07\x02\x00^\x00\x8b\x16jD\xe4\xbc\xbf\xb2\xe5"\xcf\xbe\xb0j'
 b'\xf8\x84\x8b\xac\xb0N_X\\\xd8\\E\xa7%\x1a')

{'A1': -0.9671242693408555,
 'A2': {'B1': [{'C1': -5319186182967139220, 'C2': -86},
               {'C1': 7281370021857447327, 'C2': 24}],
        'B2': {'D1': 188,
               'D2': {'E1': [-516008358, 126229219],
                      'E2': 5771,
                      'E3': -0.02786465361714363,
                      'E4': 45759},
               'D3': 3649703561},
        'B3': 48233,
        'B4': [-0.5774989668047481,
               0.8219509713803539,
               -0.5004345078087722,
               0.1887301857009056]},
 'A3': 17403041720621859707,
 'A4': 205,
 'A5': 58244,
 'A6': {'F1': -0.4045630991458893,
        'F2': 27312,
        'F3': -8,
        'F4': -29820,
        'F5': [-20308, 24398],
        'F6': 1557683288,
        'F7': 438675269},
 'A7': 64545}

Вариант №13

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

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

(b'ONL\xf1l\x03\x00S\x00(\xcd,\xbf`\xb88)\xc6\xa7\xc6?2\xd8\x02\x00\x00\x00n'
 b'\x00\x00\x00\x0f\x8d,&[\x19\xc8\xde\x13\x86BS\xc8=4|\xbes\xb2\x172`\xef?\n'
 b'\xd4\xd9\x80# \xee\xbf$\xf4\xe2<"[GS\x92\xa0mC\x18\xda\xa8\xceB\x1f\xdcT\x08'
 b'\xa3r\x04\x00H\x00\x00\x006\xb6\x1d\x05\x00L\x00\x00\x00N\x08R\x02\x00Q\x00'
 b"\x00\x00S\xe4!'")

{'A1': 27889,
 'A2': {'B1': [{'C1': [8, -93, 114], 'C2': [160, 109, 67, 24]},
               {'C1': [54, -74, 29], 'C2': [218, 168, 206, 66, 31]},
               {'C1': [78, 8, 82], 'C2': [220, 84]}],
        'B2': {'D1': -0.6750054359436035,
               'D2': 0.1769950581814923,
               'D3': 55346,
               'D4': [-7085, 10017],
               'D5': 640453903,
               'D6': -557311653,
               'D7': 8949846290091640339},
        'B3': [0.9804926359971586, -0.9414231793040255],
        'B4': 36},
 'A3': -7902894464363076876}

(b'ONL\x08B\x05\x00W\x00"Ov?*4\xd1W%\x91\xe3?B\xa1\x02\x00\x00\x00\x84'
 b'\x00\x00\x00\xeb\x13\xb0\x89\xcb\xd5\xde\xa6\xa7\xeeDC\xb14V\xfb\x90Em\n\xb0'
 b'\xbd\xec?\xac\xc9\x0e\x16\xdd\xf6\xe6\xbf\xca\x14\r^\x83\xff\x03`\xb9'
 b'\xdfP4\x1aOC\x9c\r\x94\x91\x83P\xf5\xe5Q\x1f\x8a\xce\x02\x00H\x00\x00\x00'
 b'\xa5\xaa%\x02\x00J\x00\x00\x00\x04\xc3\x1a\x05\x00L\x00\x00\x00\x14\xb1'
 b'\xa4\x02\x00Q\x00\x00\x00\x18\xd7g\x04\x00S\x00\x00\x00\x1d\x92a\xfe')

{'A1': 16904,
 'A2': {'B1': [{'C1': [31, -118, -50], 'C2': [223, 80]},
               {'C1': [-91, -86, 37], 'C2': [52, 26]},
               {'C1': [4, -61, 26], 'C2': [79, 67, 156, 13, 148]},
               {'C1': [20, -79, -92], 'C2': [145, 131]},
               {'C1': [24, -41, 103], 'C2': [80, 245, 229, 81]}],
        'B2': {'D1': 0.9621449708938599,
               'D2': 0.6114680018596392,
               'D3': 41282,
               'D4': [-28131, -415],
               'D5': 2310018027,
               'D6': -1495345717,
               'D7': -336023186250076505},
        'B3': [0.8981552318238517, -0.7176347189727514],
        'B4': 202},
 'A3': -5089063182973137644}

Вариант №14

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

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

(b'=JTRG\xf0I3\x9d\xe9\xd7_\xd55\xae4+3\x93@%,\x05?T\xcb\xb8\x1d gpjiifl'
 b'q\xb62\xd4\x8e\xecyJ\xc0\x00\x02\x00e\x93`\x0c<e\x1e\xf0Ls\x17\x03\x1by>C'
 b'I\x88\xa0\xa08!\x80\x02.F\xe1B4?\xea!S\x8e#\xa7\x80\xbf\xd6Y\x86\xeb\xe6\xd5'
 b'\xc8d"e\xf5B)T?\x00\x02\x00\x00\x00a\xc5\xc6\x9cW:\x7f\xdb\xacA\x1dG<4'
 b'\xb5\xc5\xe9\xc4\xdf\x01g\x8d\xe6\xe5\xd0A\x00\x02\x00\x00\x00c\x8f\x84'
 b'\xff\xd9\x01\xfc\x8a}KvN\xb2Z\x8e\x91\xbfa\xaa:\xf0\xc1r%P\xe1')

{'A1': -4023,
 'A2': 3719385978512946606,
 'A3': 3759155021500197893,
 'A4': {'B1': {'C1': 0.8312335014343262, 'C2': 7456},
        'B2': 'gpjiiflq',
        'B3': -5317954499653317952,
        'B4': [{'D1': [66, 41],
                'D2': 197,
                'D3': -58,
                'D4': [2622962303, 3685499165],
                'D5': 71,
                'D6': 4338292202699808513,
                'D7': 1737352933,
                'D8': -12223},
               {'D1': [84, 63],
                'D2': 143,
                'D3': -124,
                'D4': [4292411900, 2323467126],
                'D5': 78,
                'D6': -5595002830422169030,
                'D7': 4039209509,
                'D8': 20705}],
        'B5': [2472545340,
               1696526412,
               1930887963,
               2034123593,
               2292228152,
               562037294,
               1189167668],
        'B6': 0.8165681625516612,
        'B7': -0.3492142966964278},
 'A5': 1679975925}

(b"=JTRG_?\xa6v\xdbs\xdb'` H\n'\x12\x82XLp=\xcd\x0b\r\x809vzsvzivd\x0el\xb0"
 b'\x80C%\xda\xf0\x00\x02\x00e\xb1P\xd97\xf7\xd0\x0e\x194Pq)\xa8\x8f\x7f\xecr~Z'
 b'\xb29\xef\xe3\xcc5\x19\xb7}?\xd8(\xa2tX\x91\xf4?\xe1P\xb5B\x05\xb3'
 b'\xd8\xbf\x90\x0b\xdd\x1c\x81\x9c\xc4\x00\x02\x00\x00\x00a\\rc\x898'
 b'\xf7\xbbG\xe6\xfd\x01H\xde\xe4\x8c\xe0\x16\x8c\xc8\x08\x04\x04\xfe\xafs'
 b'\x00\x02\x00\x00\x00c\xd6\xe1\xdf\x03\xba\x99\x1c\xe4H\rG\x1bN\xc9'
 b'/\xa7\xe2\xd1\xed\xfa\xfaC\xb6\x8c0')

{'A1': 24383,
 'A2': 11995015948192407584,
 'A3': 5191004480947637360,
 'A4': {'B1': {'C1': 0.1001187339425087, 'C2': 32825},
        'B2': 'vzsvzivd',
        'B3': 1039399678944598768,
        'B4': [{'D1': [28, 129],
                'D2': 92,
                'D3': 114,
                'D4': [1669937399, 3142051581],
                'D5': 1,
                'D6': 5250885509266705608,
                'D7': 134481150,
                'D8': -20621},
               {'D1': [156, 196],
                'D2': 214,
                'D3': -31,
                'D4': [3741563545, 484722701],
                'D5': 71,
                'D6': 1967731293724791277,
                'D7': 4210705334,
                'D8': -29648}],
        'B5': [2974865719,
               4157607449,
               877687081,
               2827976684,
               1920883378,
               972022732,
               890877821],
        'B6': 0.37748013841544936,
        'B7': 0.5411020555017059},
 'A5': -1081078819}

Вариант №15

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

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

(b'GORF\xf6?T\x85.\xc0]\x002\x00\x00\x00\x03\x00X\x00\x00\x00^\x9e*\xbe\\\xd3'
 b'\x9d\x94e\xbb\x00\x02\x00\x00\x00|\xa0\xff\xbd\xe2mchs\x9e\x000\xc3\x00\x04'
 b'\x00\x00\x00*\x00\x00\x00\x04\x00\x00\x00.\xbfDc)\xe0\xaa\xdf\x8e'
 b'\xbfg\xde\xac\xaa5_\xc6\xbd\x8a\xc2\xaaoQ\xee\xdc\x00@\x00H\x00P9\xc5'
 b" \xbd\xbfvn\x10\xf9%\x81\x19c\xcc\x83\xe56P+\x8d\xe5\x84'\xa2\xdbe"
 b":\xaf\x05\xd9)'")

{'A1': {'B1': 0.8301571607589722,
        'B2': -16291,
        'B3': {'C1': 'mchs', 'C2': [158, 0, 48, 195]}},
 'A2': [{'D1': -0.7671380639076233, 'D2': 3769294734},
        {'D1': -0.9057414531707764, 'D2': 2855624646},
        {'D1': -0.0677541047334671, 'D2': 1867640540}],
 'A3': {'E1': 4162769429907009040,
        'E2': 63781,
        'E3': -9144167838361766320,
        'E4': 730719620,
        'E5': 664984421,
        'E6': [58, 175, 5, 217]},
 'A4': 158,
 'A5': 3080001259119601083,
 'A6': [41, 39],
 'A7': -1593852446}

(b'GORF\xf6\xbd\xc6\xee\xe7k]\x004\x00\x00\x00\x03\x00Z\x00\x00\x00`\xd4'
 b'\\\x90\xb9)\x1e|\xe99\x00\x02\x00\x00\x00~\xf1\x947\x8cdsc\x1eP\xd7'
 b'\xf4S\xf19\x00\x03\x00\x00\x00*\x00\x00\x00\x07\x00\x00\x00->0'
 b'\xaf\xe4\x06\xa0,Q\xbe\x9f\xfd\xa1\xe8\xaf\xdb\xe6>^~\x1d:\xf3j\xeb\x00B'
 b'\x00J\x00R\x1d\x1d\x1d\x17\xad\xa4=6\xa2\x8d\xf4\x16DV\xeaZ\x8d\xae\x81k'
 b'\xfbY\xa9\x02\x10#\xceS$\xbdds')

{'A1': {'B1': -0.09713535755872726,
        'B2': 27485,
        'B3': {'C1': 'dsc', 'C2': [30, 80, 215, 244, 83, 241, 57]}},
 'A2': [{'D1': 0.17254596948623657, 'D2': 111160401},
        {'D1': -0.31248190999031067, 'D2': 3903839206},
        {'D1': 0.21727795898914337, 'D2': 989031147}],
 'A3': {'E1': 2097864988959194422,
        'E2': 41613,
        'E3': -858423538877821522,
        'E4': 2171337561,
        'E5': -1459482589,
        'E6': [206, 83, 36, 189]},
 'A4': 212,
 'A5': 6670034634392004921,
 'A6': [100, 115],
 'A7': -241944692}

Вариант №16

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

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

(b'LCG\xb1stuplaly3\x94\xae\\5\xe2\x14,\x00\x05\x00\x94\x00E\xe2\xbd2r\xe0\xca'
 b'\x81\x8c\x02\xc7Lc\x91\x9d\xd5z\xc1\x81\xd0\xb5\xac=\xc9q\xe3?K\xf5\x0b?'
 b'\xaa\xec\x8c\xe8\x82\\\xed\xbf\x1dfA?8\x18Q}\xcdc\xdb\xbf\x00\xe2\x02?'
 b'H\x0f\xccZ\xe2\xe5\xe9?\x02\xb1\x01\xd5U\xc9\x87\x1d>ze\xc35K\x02y'
 b'e\xad\xa3\xbe7\xf7\xb4r\xe1s\x1fcv\x8fd\x91e\x86\x9e\xc9\xdb\x94\x9b\xa7'
 b'E\x15hHT\xdc<L\xd8\xd9\xc6rv\x8f\x0e\x8e(\xbd z>\xd8\xb7\xaa\xdcX1\x8e_/')

{'A1': 'stuplal',
 'A2': 1504823897677378425,
 'A3': {'B1': 0.6076399044592851,
        'B2': [{'C1': 0.5467116236686707, 'C2': -0.9175428907396015},
               {'C1': 0.7554643750190735, 'C2': -0.4279664729878081},
               {'C1': 0.511260986328125, 'C2': 0.809312035883047}],
        'B3': {'D1': 45314,
               'D2': -11007,
               'D3': 51541,
               'D4': 5419452567220264327,
               'D5': 30978,
               'D6': -0.3196822702884674,
               'D7': 7142554946162194231,
               'D8': [-3918546854976647306,
                      5217443557217637595,
                      8270537288727714900,
                      8800241653761609590]}},
 'A4': [55358, 43703, 22748, 36401, 12127],
 'A5': 69,
 'A6': 1915928034,
 'A7': [-13600, -29567, -14590, 25420, -25199, 31445, -32319]}

(b'LCG\xb1rccuqeq*\xa9\xf3\xf4\xb3\xa9w\x9d,\x00\x02\x00\x94\x00v\xc9y'
 b'\xb1\t\xde\x8b\xea\xcbT\xd1\xe2jx\x99\x17\x0e\x9d<`\xfa4+xC\xc3?\xabT\xe1>'
 b'\xca\xabd#L\xfd\xea?\x85\xeat?dV\x10+\x11T\xee?\xff\x95\xde=@\xfa\xa9\xf6'
 b'2\xed\x92\xbf\xc1O\x14,\x9cT\xbb\xf1\xce\xd3\xf7\x1e\'"\xfbZx\xb2z\xbf'
 b'^\x8b\xa0LR\xf4h#S1\xec\xd5\x05\x92@6\x82\x9blv\xef\x8d\x93/P\xc7\x18y'
 b'J\xb3r\x06\xb0!b\x1b\x11W\xdf\x95\xeb\xc0\xb2F')

{'A1': 'rccuqeq',
 'A2': -7100019697152448214,
 'A3': {'B1': 0.15049650296892292,
        'B2': [{'C1': 0.4400990903377533, 'C2': 0.843420094611582},
               {'C1': 0.9567034840583801, 'C2': 0.9477620926943016},
               {'C1': 0.10868453234434128, 'C2': -0.01848296766774582}],
        'B3': {'D1': 20417,
               'D2': 11284,
               'D3': 21660,
               'D4': 2460969771140575675,
               'D5': 23291,
               'D6': -0.979285717010498,
               'D7': 2551557823215471454,
               'D8': [3909285030319108435,
                      3428239800982608770,
                      464630844013201232,
                      -7647297911266336336]}},
 'A4': [49387, 18098],
 'A5': 118,
 'A6': 162625993,
 'A7': [-29730, -13334, -11948, 27362, -26248, 3607, 15517]}

Вариант №17

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

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

(b'YBP[\xe6\xb3\xc1\x85\xbe\xc3\x92\x9f\xea\xe8\xec\xe7\x91\xc9lZ\x03\x00k\x00'
 b'\x00\x00\x8b\x16\x14\xfd\xaf\x18\x13\xdaC\x03\x00n\x00\x00\x00\xe3S\xb1'
 b'\xbfv\xa8J\xd3\xf4\x02\x00q\x00\x00\x00R`\x1f\xe0\x82\x06a3\xc5\x03\x00s'
 b'\x00\x00\x00@\x9c\xa5\xd1\xec\xe3\xa6\xbf5\xc2\x9c\xd6\x84\xa2\rKv\x00dw/'
 b'\x96\xb3\x02\x00\x00\x00\xa7\x00\x00\x00\x02\x00\xa9\x00\xdbbffstiaih'
 b'fd\xc8\x1e\x84\xc9B\x08ne\x920\x15\x93\xf0\xa0\xb6A\xd1Y\xa0x\xb1L'
 b'\x99\xe1\xa5\xbf@#\x07\xd1\xa3\xaa\xc5?\xea\xbf\xb6ngQ\x06\xee\xfe:\xc0\xbd'
 b'2{\x18j8\xd9c')

{'A1': 230,
 'A2': -0.26124343276023865,
 'A3': -27965,
 'A4': [{'B1': -97, 'B2': 6515804389396769002, 'B3': 'bff'},
        {'B1': -117, 'B2': 4889241342216836118, 'B3': 'sti'},
        {'B1': -29, 'B2': -805217820961951405, 'B3': 'ai'},
        {'B1': 82, 'B2': -4236936143832080544, 'B3': 'hfd'}],
 'A5': -0.04470768031279038,
 'A6': 5408157418961814069,
 'A7': {'C1': {'D1': 7880,
               'D2': [3499971383679699332, 6472026392148087573],
               'D3': -0.04273680745312558,
               'D4': 0.16927001673163922,
               'D5': -1295258338141487126,
               'D6': 15102,
               'D7': 192,
               'D8': 410727101},
        'C2': 2519693156,
        'C3': {'E1': -77, 'E2': [106, 56], 'E3': [217, 99], 'E4': 219}}}

(b'YBP["\x1b\x86)\xbfz\x05\x8e\xea\xd2Ff\xb3K\xe2\xd9\x03\x00k\x00\x00\x00c\x8b'
 b'P8\xf89\xbad<\x03\x00n\x00\x00\x00\x02w\xce\xa4\xfcqF\xca\x06\x03\x00'
 b'q\x00\x00\x00\x13X\xac\xaf\xa4\xbbfsN\x03\x00t\x00\x00\x00@\x8e\xd8\xa7\x94'
 b'>\xd4\xbf\x18?\xea,\x90\xc2=\xcew\x00\t\xa0q\xed\xa3\x06\x00\x00\x00\xa8\x00'
 b'\x00\x00\x03\x00\xae\x00*wwhxdxutbjlb\xb3\x90`\xb9u\xc9Zj><b\xdc\x82'
 b'\xce\xadgU\x0b\x80qxN/\xe1\xaa?\x8e\xc4T\xdc4-\xee?)c`C\xadqM\n*)\x99b\x83BQ'
 b'\xdf&\xd1u\xd8}\x90E\xaf')

{'A1': 34,
 'A2': -0.6622025370597839,
 'A3': 1402,
 'A4': [{'B1': -114, 'B2': -2746549588855434518, 'B3': 'wwh'},
        {'B1': 99, 'B2': 4351807898087084171, 'B3': 'xdx'},
        {'B1': 2, 'B2': 489280964907028087, 'B3': 'utb'},
        {'B1': 19, 'B2': 5652974913387998296, 'B3': 'jlb'}],
 'A5': -0.3163196219559019,
 'A6': -3585495803832418536,
 'A7': {'C1': {'D1': 37043,
               'D2': [4341024028991273312, 816672903629298786],
               'D3': 0.05249927361384987,
               'D4': 0.9430183699934263,
               'D5': 742374502559671081,
               'D6': 10538,
               'D7': 153,
               'D8': 1363313506},
        'C2': 3983646729,
        'C3': {'E1': -93,
               'E2': [-33, 38, -47, 117, -40, 125],
               'E3': [144, 69, 175],
               'E4': 42}}}

Вариант №18

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

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

(b'VGCK\xfa\x1441\xd3=16jxosmA\xb7\xc4\xb9\xaf\xc1\xdf;IP\xe2\x0b2S!'
 b'\xb0\x1f\x87\x1c\x86\xbe\xbe\x92\x1a\x9b\x1e\x18\xd0\x06/5\xf3\x81S\x19'
 b'V\x11\xe9\xea\r\x02g3]>\x8e\x8f\xba\n\x18\xc4\xf1\x01\x044\xdc\xb9\x94\x86'
 b'\xae,\xc8\x00CG\xcd\xbf\x19?yig\xe4\xa6\x89\x0cuM>\xc9U\xad?$a&?qr\xe5v'
 b'<\xb7\x14')

{'A1': 1455843362882008682,
 'A2': 'xosm',
 'A3': {'B1': [{'C1': [16823, 50361, 44993, 57147, 18768, 57867],
                'C2': 3626279165290290310,
                'C3': -0.3722084164619446},
               {'C1': [39710, 6352, 1583, 13811, 33107, 6486],
                'C2': 1290820109814149981,
                'C3': 0.27844029664993286},
               {'C1': [2584, 50417, 260, 13532, 47508, 34478],
                'C2': 3226829421978435353,
                'C3': 0.9742645621299744}],
        'B2': {'D1': -7002, 'D2': 2299295053},
        'B3': [0.3932317793369293, 0.642107367515564, 0.9431594014167786],
        'B4': 1983690516}}

(b'VGCK\xfaP\xa3b8\xf6\x9a\x0bEdnwz\x13a\xb6:#KS\x06\xcd\x94K\xcfe\x9c\xea'
 b')\xa4\xbd\x15\xda\xbf:+\xb4\xc5\xe8u\xaf\xb9w/\x1d\xce\xa7"\x99h\xbb*'
 b'\xbd\x8f7]`\xbe)\xf1\x83[N\xea\xf7Q"\xcd\x03\x12\\\x0fL\xd2\xa4\x8c'
 b'\xa5@\xe6\x1b9>\xe9\x9b\xf21\xab\xf1\x89IJ\xbcz\x959>\x0e\xb0Z\xbe'
 b"\xee\x11\xb7'\x8c\x94\xb6")

{'A1': 5810595941033052997,
 'A2': 'dnwz',
 'A3': {'B1': [{'C1': [4961, 46650, 9035, 21254, 52628, 19407],
                'C2': 7321984558775997914,
                'C3': -0.7272293567657471},
               {'C1': [50664, 30127, 47479, 12061, 52903, 8857],
                'C2': 7546672594229353824,
                'C3': -0.16596035659313202},
               {'C1': [23374, 60151, 20770, 52483, 4700, 3916],
                'C2': 15178411285531728697,
                'C3': 0.4562678933143616}],
        'B2': {'D1': 12715, 'D2': 4052306250},
        'B3': [-0.015294366516172886, 0.13934460282325745, -0.4649789035320282],
        'B4': 663524534}}

Вариант №19

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

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

(b'\xcdCKK?\xd6\xd6\xb6!\x10\xf9\x1c,\xd1\x00\x00\x00\x02\x00$\x00\x00\x00g'
 b'>\xf1\xe0\xcds\xe3Cd)\x9d,.mn\x07"+\xe9\xa6\xb8\xf9\xc7K\xe6\xc8\x90\xe1m'
 b'e*\x866\xffu\xf7\xc5\xd0\x07\xa6\x83\xe2\xb4a\x90\x9f\xf6\xb3\x94'
 b'\xaa\x04|\x84X\xa5\xc9\xb7\xf7\x12dw\xa2,\xa0@\xac|:1m?\xdax\x1a\xe0\xe7o'
 b'\x18\xc1\xe0\x00\x00\x00&\x00\x00\x002\x00\x00\x00>\x00\x00\x00J\xf8'
 b'\x93\x9a\xc8`d\x90\x89\x00V\x17\xdaqx\xfbW\x88}\x82h=\x92\xfe\x06\x03'
 b'J\x10\xdd\xe6\xa6G\x82\xa7\x1b\xd0\x89XM_\xa8\xf5Ps+\x12\xc3;$\x88{l\xf8\xc9'
 b'\xde\x1b\x9f\n8r')

{'A1': 0.35685494641428916,
 'A2': 11473,
 'A3': 'mn',
 'A4': {'B1': [{'C1': 119679977, 'C2': -6433117433331529584},
               {'C1': 3782042922, 'C2': -8775545941751640057},
               {'C1': 2793661108, 'C2': 7030294900248979972},
               {'C1': 2089048229, 'C2': -3911386092980952532}],
        'B2': -534913745325617015,
        'B3': {'D1': -24512,
               'D2': [-84, 124, 58, 49, 109],
               'D3': 0.4135806270912652,
               'D4': 193,
               'D5': 224},
        'B4': 23,
        'B5': [-2706248880172270206,
               7511321373244082704,
               -2457093720619148336,
               -8549998819311005581,
               3103757751995104108,
               -519640071770851214]},
 'A5': 0.4724182188510895,
 'A6': 1944273764,
 'A7': 698166318}

(b'\xcdCKK?\xec"\xc4\x17\xa6\xd4\xa6k\xee\x00\x00\x00\x06\x00$\x00\x00\x00k'
 b'\xbe\xbd\x98\x1et\xc2\x8b\xae\xf2\xaa\x9e\xddkdubma\xae`56\xefer\xd7\xb7P'
 b'_}\x89\xa9o\xe5M6\xde\x98\xde\xf6\xa94\xd3J\xd2=\xa9\xb3\x95\x95\x1ar'
 b'\x1a\xa6\x0bz\xe886\xc9\xc5\xa0\x86\xf1\xd5B\xfb\x9fad\x95\xae\x96?\xe74'
 b'X\x1fJ\xa7p\x9e\xbd\x00\x00\x00*\x00\x00\x006\x00\x00\x00B\x00\x00\x00N\xbd'
 b'\x1e\xaa\xdd\xe1\xben\xf8\x00Zf\xe6\xecD\xa0\xf3k\x1aV\x83\x18RP\xda\xf8'
 b'\x071\xe9,\xfci\x91\xbeW\xe4[\xc6\x80\x0bO[\xf0 \xfd%5\x07)\xca'
 b'\xf6\xf4\xc6\xaeO\xed8\xec\x03\xf4')

{'A1': 0.879243894762699,
 'A2': 27630,
 'A3': 'kdubma',
 'A4': {'B1': [{'C1': 2925540662, 'C2': -1196423855177965699},
               {'C1': 2309582821, 'C2': 5563879137819928884},
               {'C1': 3544896061, 'C2': -6218462192842171738},
               {'C1': 192604216, 'C2': 3947903841616385346}],
        'B2': -4819226681288003848,
        'B3': {'D1': -1121,
               'D2': [97, 100, -107, -82, -106],
               'D3': 0.7251396762051012,
               'D4': 158,
               'D5': 189},
        'B4': 102,
        'B5': [-1806993892413072810,
               -9000353348075387087,
               -1644662233550137372,
               6613113888904572960,
               -205699903093278988,
               -4130275927971331084]},
 'A5': -0.37030118703842163,
 'A6': 1958906798,
 'A7': -223699235}

Вариант №20

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

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

(b'PQJX<R\x00Q`p\x00\x00\x00\n\xd8\xbe\x04B\xec\x83\xe3\xfe\xf5\x01>M\xbf\xa5'
 b'\x11\xe1Fzk0\x16\xb5\xaa\xb7p\x81\xcaB\x1c+6\x02\x00\x00\x00\x8c\x00\x00'
 b'\x00\x02\x00\x00\x00\x94\x00\x00\x00jqrN\xa7\xdc\xb4\xa5\x94\xa8n'
 b'\xbfO\xa5\xd7nw\x81p`\xbfh\r\x9c\xbe\x83\xa9j?\x03\x00=\x00\x00\x00'
 b'@\x00\x00\x00I\x00\x00\x004\xf0\xdd\x00\x1f\x08\xf1\xa3[Z\xa5m\xd8\x8fs '
 b'86\x83\x9b\x85\xd0\xa2\xbe\xe8\xd8h\xfb\xbc\xc5\xd3?\xa5\x8d\x80\xbd'
 b'X\xb6\x99;=\\\xa3\x08K;\xe9\xb5')

{'A1': {'B1': -0.30478978157043457,
        'B2': 0.9166490435600281,
        'B3': 'jqr',
        'B4': [{'C1': 78, 'C2': -1514873689, 'C3': -0.9322597980499268},
               {'C1': 79, 'C2': 2003752869, 'C3': -0.876716673374176}],
        'B5': -6633511846888476620},
 'A2': 24657,
 'A3': {'D1': 1839553115,
        'D2': [-28712, 8307, 13880, -25725],
        'D3': -0.31799712777137756,
        'D4': 0.30894398261751954,
        'D5': -0.06277016550302505},
 'A4': {'E1': -2052537236859201526, 'E2': -2, 'E3': -11},
 'A5': {'F1': -0.8017273545265198,
        'F2': 4517,
        'F3': 12300762354449794785,
        'F4': 3903244575237566647},
 'A6': [999929432, 144923709],
 'A7': [15179, -18967]}

(b'PQJX<R\x00\x17\x0cp\x00\x00\x00QD>!\xc1b\x8d\xbfF\xbe\xd9\x0b\x8b>\xf5'
 b'5\xaa\xbf\xe5KM\xe7\xce\xc3\x80\xbeh\x81_\x852{\x02\x00\x00\x00\x8c\x00\x00'
 b'\x00\x02\x00\x00\x00\x94\x00\x00\x00nrt.c\xbe\xfe\xa9\x0c\xad\xc3>Pe9w7\x99`'
 b'U?\xb0U\xc6\xbefx\x14\xbf\x03\x00=\x00\x00\x00@\x00\x00\x00I\x00\x00\x00'
 b'\xc5\x18=@\xbb\xb4\xec\n\xba\xd6\xda\xe2\x9c\xfc?\xfb\xecJc\xa1'
 b'\xc2\xcf\x9b\xbeP\x91\xba5|\xad\xcb?\x8a F>o\xe9r\xe9O\x90=\xa0\x91\xafL\xda')

{'A1': {'B1': -0.3873724937438965,
        'B2': -0.5799621343612671,
        'B3': 'nrt',
        'B4': [{'C1': 46, 'C2': -1442922909, 'C3': 0.3821796178817749},
               {'C1': 80, 'C2': 930560357, 'C3': 0.8335052132606506}],
        'B5': 787202751212624069},
 'A2': 3095,
 'A3': {'D1': 3805992634,
        'D2': [-868, -1217, 19180, -24221],
        'D3': -0.30431944131851196,
        'D4': 0.21623184798694206,
        'D5': 0.19348350167274475},
 'A4': {'E1': -4643947059123174319, 'E2': 70, 'E3': -66},
 'A5': {'F1': 0.2715747654438019,
        'F2': 13813,
        'F3': 14109469001770188714,
        'F4': 8877304460740181632},
 'A6': [-378345105, -1606578097],
 'A7': [-20591, -9652]}

Вариант №21

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

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

(b'XTW\xc4t\xb1\x81N\xa0\x88@qo\x00\x00\x00c-\xc5|\xe5\xf0\ts?A\xael\xccSgY'
 b'\x0b\x99F\x95\xbb$\xc5Z\x02\x00\x11\x00\x00\x00\x03\x00\x00\x00!\x00'
 b'\x0e\x94ov\x17\xe1\xee\x1c\x86\x1b\xef\x1c\x9e\xca[\x98\n\xbf\x93\xa3'
 b'\xcbm\xeaX\xa5N1\xa2\x02\x00;\x00\x00\x00\x02\x00\x00\x00K\x00rJ\xa5\xc3'
 b"x<\x86'\x00\x00\x00O\x00\x00\x00\xfa4a\x94\x02\x00\x00\x00c\x00\x04\x00k"
 b'\x00\x00\x00')

{'A1': 1317122420,
 'A2': 160,
 'A3': 16520,
 'A4': 113,
 'A5': {'B1': [{'C1': 90,
                'C2': [4572008976958145837, 817798416954076737],
                'C3': {'D1': [18073, -17515, -15068], 'D2': 1987023886},
                'C4': 57623,
                'C5': -18},
               {'C1': -94,
                'C2': [6614272849854826012, -1554362392954074472],
                'C3': {'D1': [-23208, 12622], 'D2': -1012577678},
                'C4': 15480,
                'C5': -122}],
        'B2': [250, 52, 97, 148]},
 'A6': 99}

(b'XTW\xc4\x8b\x9e%\x146 \xee\x8fm\x00\x00\x00\x8fN\xc7MX<\xd0\xd9\x92\x9dK\xe8'
 b'\xc0\xd6\xddX\xb7Z\x85V\xabb\x02\x00\x11\x00\x00\x00\x02\x00\x00\x00!\x00zG'
 b'a\xbb/\x11s\xca\xa8\xcbEo\r\xc3\xe2\xfc\xce\xb6\xcb\xd3\xc2\n'
 b'\x12\xa9\xcc\xc7c*\x02\x009\x00\x00\x00\x02\x00\x00\x00I\x00\x94\xe0'
 b'\xc8:\x1e7U%\x00\x00\x00M\x00\x00\x00O\xd2g\xcb\x02\x00\x00\x00a\x00\x04'
 b'\x00i\x00\x00\x00')

{'A1': 338009739,
 'A2': 54,
 'A3': -4576,
 'A4': 143,
 'A5': {'B1': [{'C1': 98,
                'C2': [-7865026316627753138, -5235190652389012579],
                'C3': {'D1': [-31398, -21674], 'D2': -1151252614},
                'C4': 4399,
                'C5': 115},
               {'C1': 42,
                'C2': [-2106825429115754294, 1300065657361452796],
                'C3': {'D1': [-13143, 25543], 'D2': 986243220},
                'C4': 14110,
                'C5': 85}],
        'B2': [79, 210, 103, 203]},
 'A6': -113}

Вариант №22

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

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

(b'YDCU\xd7<B\xbfkcafmn\xc6 \xc2\x8f9a\xe2?\xe1?\xb8Ox3f\x94(\xc5\t\xc4\xf8\x8a'
 b'\xf6\x16`\x9b>7\x00\x00\x001\x1d\xb0\x18\x9f\xc9\xc1R\xaf9\xc7\xfe\x8a?\x8f'
 b'\x1b\xae\xb2\xd6\xd1\xbf\x0b\xebf\xbe\xd6\xaf\x9f\xb2\xff\xcc?\xc4\x87\xb7'
 b'jx\xe3\xe3~D\x01\xa6\\\td\xb2\x06/\x03\x96h\xa1\xe1dYu\xb4\x90'
 b'\x03\x00\x00\x001\x00\x00\x00y\xdb\x91\x02\xb0\xedE\r\xe6\xda\x05\xc7'
 b'\x0bQ\xa5h')

{'A1': {'B1': -0.7587408423423767, 'B2': 'kcafmn', 'B3': 0.5743682678012412},
 'A2': 1337475041,
 'A3': 14126038484303360888,
 'A4': 35576,
 'A5': 246,
 'A6': 0.30346745252609253,
 'A7': {'C1': 1066073799,
        'C2': [{'D1': -1297212529, 'D2': -42, 'D3': -47, 'D4': -65},
               {'D1': -1100551413, 'D2': -42, 'D3': -81, 'D4': -97},
               {'D1': 1070399410, 'D2': -60, 'D3': -121, 'D4': -73},
               {'D1': -471631766, 'D2': 126, 'D3': 68, 'D4': 1},
               {'D1': 1678335142, 'D2': -78, 'D3': 6, 'D4': 47}],
        'C3': 8455900695603222019,
        'C4': 37044,
        'C5': [-13921, 21185, 14767],
        'C6': [-9351, 657, -4688, 3397, -9498, -14587, 20747, 26789]},
 'A8': 414194993}

(b'YDCU\xda\xcew\xbfnovhkk\xb4X\x8f\x81\xb0\xa1\xd0\xbf\xb4\xb3g\xf2\xd6\x1c'
 b'g\xfe\xea\xf5\x0c\x08yG\xfa+HN>5\x00\x00\x00\xfb\x84\xa7\xf8\xa3r\x1c'
 b'\x1f\xd1-\xa4hg\xd1\xf3\x15\x19\xa5q\x88!+\x87!R\x9cA\x1c\xee\xf3\xce'
 b'\xec<l\xad6\xf9\xf0\xad\x92\xa3 \xbbi:\xc5\x8e1#\x98\xddB]\xb5\xa7'
 b'\xacX\x02\x00\x00\x001\x00\x00\x00Q\x94P\x0b\xe5\xa0\x8b\x0bg/Wi&\x19\r\xac')

{'A1': {'B1': -0.968000054359436, 'B2': 'novhkk', 'B3': -0.2598687424882755},
 'A2': 4066882484,
 'A3': 580108841663274198,
 'A4': 18297,
 'A5': 250,
 'A6': 0.20144717395305634,
 'A7': {'C1': 1755590097,
        'C2': [{'D1': 368300391, 'D2': 25, 'D3': -91, 'D4': 113},
               {'D1': -2027216504, 'D2': 33, 'D3': 82, 'D4': -100},
               {'D1': -202499007, 'D2': -50, 'D3': -20, 'D4': 60},
               {'D1': -113857172, 'D2': -16, 'D3': -83, 'D4': -110},
               {'D1': 1773871267, 'D2': 58, 'D3': -59, 'D4': -114}],
        'C3': -6362076356823997647,
        'C4': 22700,
        'C5': [29347, 7964],
        'C6': [-27567, 2896, -24347, 2955, 12135, 26967, 6438, -21491]},
 'A8': 4171728123}

Вариант №23

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

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

(b'TKD\xfd\xf6m\x9a=\xe8\xe4Ko\xa4+\xd5[\xb2\xc2l\xf1zskb\xa9-0e'
 b'\x0f\xdd\xe0\xddh?LO\x94\x94\x9f|\xcc\\8F&\x8aG<u9?\xbcNx\xb4s\xad\xb18\x91'
 b'N,\x80\xd8\xe0\xab\xc0>|\x0b\x98\x8a\xab\x89`\x04\x00n\x00\xc6\x17\x00B\x15'
 b'\x9c\xd2\x13\xf7\x19\xf1\xa2?\xce\xe3\x01\x04\x00\x00\x00v\x00\x00\xda\xac'
 b'=\x91\x89\x95?/\x9d\xf0\xac\xe1\xf2Q\xa6m\xeeN\xf0\xa3\xc1%\xef\xc4p,'
 b'\xad\x08\x8fpA\xc2')

{'A1': {'B1': 253, 'B2': 0.0754050463438034},
 'A2': {'C1': 1867244776,
        'C2': -1050250541783503964,
        'C3': 'zskb',
        'C4': [{'D1': 1697656233,
                'D2': -8945,
                'D3': 0.9096355438232422,
                'D4': -1802219700,
                'D5': 31903,
                'D6': -52},
               {'D1': 642136156,
                'D2': 18314,
                'D3': 0.724445104598999,
                'D4': -1267183940,
                'D5': 44403,
                'D6': -79},
               {'D1': 743346488,
                'D2': -10112,
                'D3': 0.3763113021850586,
                'D4': -1969747076,
                'D5': 35243,
                'D6': 96}],
        'C5': [61597, 57772, 20978, 28070],
        'C6': {'E1': 1428375646945417158,
               'E2': -1561257481,
               'E3': -12737,
               'E4': 483,
               'E5': [-1544532242, -990960191, 145566832, -1035898737]}},
 'A3': 0.021032590283732944,
 'A4': 47}

(b'TKD*\x1b\x03\x87>\x92\\\xa3nL\x86\xa0\x95\xc5f\xd14lryk\xd0\xca\x96q'
 b'\xa5\xf42e??Z\xc3(N\xf0\x8a\xc2\x8f|\xa1\x8f\xa5\xc1\xc3*\xc6\xbe\x85'
 b'Q\x19\xef\xbc\xdfa/"l_p\xaf9\x10)?\xb1\x04!\x01\xce\xd5(\x03\x00n\x00\x12'
 b'\x86\xac\x10%\xf1\xe01\x92d\xbfD\xd5\x8a\xa3r\x03\x00\x00\x00t'
 b'\x00\x06\x14\xd57\xb4}\xeb\xbf\x9d\x06UV;\x0f\xa6F\x89\x8d\xfa'
 b'\xba\x80\xaa\x0bBR\xa3\xf9')

{'A1': {'B1': 42, 'B2': 0.2636955678462982},
 'A2': {'C1': 1856199826,
        'C2': 3805936158909695564,
        'C3': 'lryk',
        'C4': [{'D1': 1905707728,
                'D2': -2907,
                'D3': 0.7476378679275513,
                'D4': 1311294298,
                'D5': 35568,
                'D6': -62},
               {'D1': 2409725071,
                'D2': -15963,
                'D3': -0.3870449960231781,
                'D4': -283553403,
                'D5': 57276,
                'D6': 97},
               {'D1': 1600922159,
                'D2': -20624,
                'D3': 0.6604037880897522,
                'D4': 18941105,
                'D5': 54734,
                'D6': 40}],
        'C5': [21766, 15190, 42511],
        'C6': {'E1': 3594137644137481746,
               'E2': 1153393810,
               'E3': -29995,
               'E4': 29347,
               'E5': [-91387578, 195723450, -106737086]}},
 'A3': -0.8590947237468078,
 'A4': 157}

Вариант №24

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

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

(b"EEIY\x1c\x00\x00\x00\xe4fS\x00\x00\x00\xc0\xc8\xd0'\x06O\xc8\xbfzwbpfn"
 b'\x06\x00\x16\x00\x00\x00&\xf0\x104\xbaW\xa5C\x0c\x92x\n\x0b\xb5\xb4\xa1\r:'
 b'W\xbfR\x1eG\xa4\xa0<\x02\x03\xbe&u\xa8\xec:\x11m\xc6\xcc\xeb\x9cC5'
 b'\x1c\x08\x835\xcbU{\x9c\x8a\xef\x82sZ\xea\xbf\xc03T\xe90\xe6\xe8\xc0\x89'
 b'\x1f\xcc?\x9c\xa9!\xfa!\xdd\xe2\xbf0\xef\x02\x8c\x91d\xb9?+y\xbc\xbe\xeb'
 b'\xae\x87\xc5\xb0\xe7\xbf\xd9\xd4\xc9\x08P"\xacr\x00\x06\xdb\xbf0\xa7'
 b'\xed\xc8fT\xd6?0\xb7\x0b\xfc\x07\x97\xe8\xbf\x15\x0c)\x06\x00\x00'
 b'\x00#\x00\x0e')

{'A1': {'B1': 'zwbpfn', 'B2': 38},
 'A2': 26340,
 'A3': {'C1': [{'D1': -0.8235414082849561,
                'D2': -380357696,
                'D3': [0.21971246642515174, -0.5894937405949352],
                'D4': 0.0991908041787013,
                'D5': 43,
                'D6': 121,
                'D7': -68},
               {'D1': -0.740328564649978,
                'D2': 147444953,
                'D3': [-0.42224131773449347, 0.34890145894916014],
                'D4': -0.7684364245194271,
                'D5': 21,
                'D6': 12,
                'D7': 41}],
        'C2': [883731748099461360,
               982264883410794642,
               -6871288935897671878,
               -1393735275414093252,
               4872028161642926394,
               8887232870377593909],
        'C3': 14},
 'A4': -0.18991162246817872}

(b'EEIY\x18\x00\x00\x00I\x13?\x00\x00\x00\xe4\x89\x15L2\x96\xe6\xbfpm'
 b'\x02\x00\x16\x00\x00\x00\xbb\xb6~\xf8=\x84`L?U@H\xd1\x12\x0e\xe36\xe2'
 b'\xf8K\xe9\xe3\xcce\x1a\xa1\x01\xe0|Q\xf0[\xe3\xb8\xbf\xa8\\\xcc>\xd7?^'
 b'\x04\x9e\xbf\x0c T\x9b\xb2\\\xec?\x04D\xdb\xf0y\x11\xd1\xbf\xe8\xd5\xdatY'
 b'\xe0\xd6?~\xdfCp\xaa]7\xb1N\xc0?k\x07\xc8yf\x1aO\xf6\xe6\x05\xe9?\xa8P'
 b'1\xdbK\xb8\xc7?\xa0C\x1b\xfd83\xb8\xbf\x15{\x0f\x04\x00\x00\x00\x1f\x00\xc1')

{'A1': {'B1': 'pm', 'B2': -69},
 'A2': 4937,
 'A3': {'C1': [{'D1': 0.3632079033732185,
                'D2': -1080163234,
                'D3': [0.8863156350862496, -0.2666916706194231],
                'D4': 0.35744320308307787,
                'D5': 126,
                'D6': -33,
                'D7': 67},
               {'D1': 0.12740149691974834,
                'D2': 2043152235,
                'D3': [0.7819704828951444, 0.1853117771412418],
                'D4': -0.09453159503324438,
                'D5': 21,
                'D6': 123,
                'D7': 15}],
        'C2': [4561126643711114934,
               3955020371744800853,
               1902151696877615330,
               -2063791771441167967],
        'C3': 193},
 'A4': -0.7058345304506557}

Вариант №25

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

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

(b'VRU\x04\x00\x7f\x00mtpyu\x90\xf8x.\xfd\x87\xdd\xbf\x7f&G?\xa6C\x03\x00'
 b'\x87\x00\xfch\xa7\xbdk\x85*R\x90\x8b\xd1\x0b\x10S?I\xc3\xb4\xf8Z\x0c`'
 b'E\x89\x82\x90\xd7tH\xec\xe8\xfaZ4\x03\x03\xcf\xa3\xb8\x17\x18\xd5'
 b'\x07y\xc1\x88\xd8\xd3\x8b\x0b\x85\x0et\xd7\xf3\xa7\xfc\xcf\xdc\xd2>\xe1'
 b"\x12\xa3\x8c \xb0\r'\xf5\x8b\x88\xb3\x03\xb6\x89\x0f\xa3\xc2\x18\x01\xb1"
 b'#\x9d<\x9f\xe4\x188\xfb\x0b\xba\x82.\x80\x88\xa1o\x00s\x00w\x00{\x00\xe5'
 b'{`\x82P\xf8Zp-X1\x86')

{'A1': [{'B1': -79, 'B2': 35, 'B3': 15517},
        {'B1': -97, 'B2': 228, 'B3': 14360},
        {'B1': -5, 'B2': 11, 'B3': -32070},
        {'B1': 46, 'B2': 128, 'B3': -24184}],
 'A2': 109,
 'A3': 'tpyu',
 'A4': {'C1': -0.46142510927519087,
        'C2': 0.7779311537742615,
        'C3': 17318,
        'C4': [2187361253, 1885010000, 2251380781]},
 'A5': 5920691357921798396,
 'A6': -29808,
 'A7': {'D1': 209,
        'D2': 0.8244635462760925,
        'D3': -15543,
        'D4': [-9040618498143094604,
               6555808309116721040,
               1736059195066876724,
               -8371109200478533675,
               -240955948350405365],
        'D5': 0.41184088587760925,
        'D6': 2814098996021367521,
        'D7': 1119626109391506421,
        'D8': [163, 194, 24, 1]}}

(b'VRU\x04\x00\x7f\x00\x07gkeyH\x9b\xe0\xe9\xc8[\xcb\xbf-\x00\x99>'
 b"\xf6\xa7\x03\x00\x87\x00\x1c\xc0*\xd6\xb8\xe6\xe6\\'\xb7\xb1C\xee|"
 b"\xbf\xd1\xd2\xc6\xe6\x0614h\x19Q\xe8\x8br\x81\xd1:r\x07?\x87U@\x04/'\xe4:"
 b'\xfbp\x93m\xde\xf6\xce\x19M\x8e\x12\x9b\xcc\xf3\x80\n\xe7\xd4>_\xe4\x9b\x11o'
 b'\x9a44L\x11\x9b\xfc\x8b1\xafp\xfd\xc8\x11\xba\xb0\x97\xef\xa5k'
 b'\x03\x8c\x84\xecb:W\xad\x98SJo\x00s\x00w\x00{\x00\x00SZ\xc2\x19t]w\x89'
 b'?\xd5\xf8')

{'A1': [{'B1': -80, 'B2': 151, 'B3': -23057},
        {'B1': 107, 'B2': 3, 'B3': -31604},
        {'B1': -20, 'B2': 98, 'B3': 22330},
        {'B1': -83, 'B2': 152, 'B3': 19027}],
 'A2': 7,
 'A3': 'gkey',
 'A4': {'C1': -0.21373855037492206,
        'C2': 0.29882946610450745,
        'C3': -22538,
        'C4': [3260699392, 2002613273, 4174725001]},
 'A5': 6694291577674317852,
 'A6': -18649,
 'A7': {'D1': 177,
        'D2': -0.988010585308075,
        'D3': -11567,
        'D4': [5843816564860053190,
               536555977104853992,
               -2006583413664544961,
               -3533392295419118790,
               -9154748651110773479],
        'D5': 0.4158251881599426,
        'D6': 3761801390588683359,
        'D7': 8119763130480529740,
        'D8': [253, 200, 17, 186]}}

Вариант №26

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

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

(b'BWA\x86%\xb8>\x04?j\xf1B\xde\x9c\x02\x00\x8e\x00\x0f\xeb\xfe\x07\xc7\r'
 b'\x14m\x7f\xde\xab\xafq\x97f}\x02\x00\x00\x00\x92\x00\xc0\xd9f\xe9P\x08\x0cI'
 b'\xa9\xe2TH$\xdf~B\xe5\\\xef?\x00\xf3wX^$\xd0?8nSO\x02\x11\xee?\xc4\xf4W}'
 b"\x023\xa4\x89l\x9b\xe6\x06\xd3\xda\x076\xach\xf6\x9aNN\xeb\x14'D\xaen"
 b'\xe4\x1a\x89\x98^\x9a#X.\x84|1\xd3F\x02\xe1\x99\xcc<\xd2iDc5\x05\x107\x9a'
 b'\xed\x9b\x92)\'\x8f-c0\xd5r\x00\x80\x00\r\xd8\x86\x87"+bg')

{'A1': 0.3596612811088562,
 'A2': {'B1': 4,
        'B2': 27199,
        'B3': {'C1': -1663155471,
               'C2': [{'D1': 12668,
                       'D2': 3775022803,
                       'D3': 3846993727993990297},
                      {'D1': 4101,
                       'D2': 2616039991,
                       'D3': 15361887376287148434}],
               'C3': 7859922398152157967,
               'C4': 9036076216899853951,
               'C5': [2273761293, 1734486818]},
        'B4': 5263591208095504832,
        'B5': 1213522601,
        'B6': [0.9800897883169211, 0.25221975936419483, 0.9395762967428203],
        'B7': 196,
        'B8': 41768948},
 'A3': [1820959795,
        -754522469,
        -1405745190,
        1318778472,
        655682382,
        -462508476,
        1587054874,
        777528218],
 'A4': 132}

(b'BWA`Ud?\xb0\x7f\x8a\x8el\xfbk\x02\x00\x8e\x00\\\xb3\x82\x9b\xf6e'
 b"\x15'\xd3\x80\xc2\x02\x9dR~\x89\x02\x00\x00\x00\x92\x00\xbb:\xe3;"
 b'\x0b\xe7\x01\xb7I\xef\xe6\xe6\xf2\xb8\xc9\xfcAF\xea\xbf0\xa3a\xab\xc1/\xe0?'
 b'\xbc\xf0\x1a\xb0NS\xef?\xf5D\xb9\x13\xbaNv7\xd1<\xb1\xcdD!?}c\xd3\x81F'
 b':s\xceD\x8a\x01\t\xf3\rLz_\xf1\xdc\xa2\xd3\xce\x8e\xd1\xbcq)\n\x87\x04RQ\xc5'
 b'*u\xc3|\xc8\xf6\xc94\x95\x86\xdd\xc1\x88ky\x08\x88\xa4r\x00\x80\x00Qc'
 b'`r\xaf\xdc\xba\xcf')

{'A1': 0.8919277191162109,
 'A2': {'B1': -80,
        'B2': -30081,
        'B3': {'C1': 1811639438,
               'C2': [{'D1': -17199,
                       'D2': 2265590129,
                       'D3': 8990158107721159172},
                      {'D1': -2360,
                       'D2': 2257925321,
                       'D3': 11855735336641020381}],
               'C3': 2816269251835507548,
               'C4': 9907447064571314387,
               'C5': [1918919505, 3485129903]},
        'B4': 13187075219352926907,
        'B5': -421073079,
        'B6': [-0.8210763871445848, 0.5058296534817597, 0.9789193572574031],
        'B7': 245,
        'B8': 3121854788},
 'A3': [-784894386,
        1154330940,
        1669152545,
        977699283,
        -1975202189,
        234031361,
        -245401012,
        -824991012],
 'A4': 142}

Вариант №27

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

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

(b'\xf4ZPUF\xadL~\xc9R\xa7\r\xb49\x8d5\xc0p\xb5\xda\xca\xad}\x15'
 b'\xf8\xdf\x00\x8a\xb17\x02pwUc#\x04\x81\x8f\xddJ\xdd\xce\xa9YP\x0bM'
 b'\xd2\xc2\xfb\xbd\xcd*\x18n\xda9H\x05\xa2 \xa5\x1c\xf6\x99\x00\x02'
 b'\x00\x00\x00&Mn\xd4\x9e\xd4b\x00;ujk\x01\xd9g\x97\x92\xfdz\xa5\xba'
 b'\xfc\xc8\xebR\xaeM\xb4\x1d\x00\x02\x00\x00\x00H\xbe\x85\x8f\x99>\x1a'
 b'\xf5\xe0\xece\xb9\x99J\x8c\x9b\x8b\xe8\x9d\xcc(\xd6\x9071\x11\x1f'
 b'\x00\x02\x00\x00\x00jezj\x00*\x00L\xfbb\x85\x96\xbe\xbd\x92Q\x00r')

{'A1': -21172,
 'A2': {'B1': 126, 'B2': -13998},
 'A3': 12037475538306449520,
 'A4': 13104008912264624351,
 'A5': {'C1': 'ezj',
        'C2': [{'D1': -3555212230510390590,
                'D2': 4223520042,
                'D3': 6254,
                'D4': -9671,
                'D5': 1208328736,
                'D6': -1524828519,
                'D7': [36829, 19165]},
               {'D1': -3142949334578205951,
                'D2': 3647444882,
                'D3': 64890,
                'D4': -23110,
                'D5': -53941422,
                'D6': -1370639331,
                'D7': [19822, 54430]}],
        'C3': -77429354,
        'C4': -0.3702569305896759,
        'C5': {'E1': 3966089625,
               'E2': [19084, -25717],
               'E3': -392311768,
               'E4': -695191759,
               'E5': 17,
               'E6': 31,
               'E7': [-0.26086118817329407, 0.15132856369018555]}},
 'A6': 45367,
 'A7': 175771594086614145}

(b'\xf4ZPUF\xb5\xa1!\xd6\x9a\xcd\x0b\xd2\x82+\x96jNQ\xb5\x00\xcd\xe3\x82'
 b'[\xa3\x00\x9e\xb6\xd1\x94[\xb4\xbe\xb8*\xc3U\x0eHM~\xad4\x94\xd3\xd7\xb7'
 b'\x8f\x08\x15\xd2\xaa:\xd4\xca\x9d\xffE2\xedZM\xea\x8e\xdb\x89\x8d'
 b'\x00\x03\x00\x00\x00&\x9f\x86q+`\x81\xeb\xa3\x86\x98\xdcg\xd0t\x7fPP\x96'
 b'K\xf3\xed\x9e\x96\xebf\xb4Jw#\x14\x00\x03\x00\x00\x00J>\xa1\xc5\xb6>\r'
 b'h\xf0\xbe%b\x8d\xbe\xcb\x027\xbe\xd5\xba\x02=\x85\x83#J;v\x93\xdc\x15mCfQ'
 b'\x8d|\x95"\xdf\xff%L\x00\x06\x00\x00\x00ndxs\x00,\x00P\xf7\xa2\''
 b'\xa7\xbf\x08\x8f\x15\x00\x86')

{'A1': -19039,
 'A2': {'B1': 33, 'B2': -10598},
 'A3': 14775134459037903438,
 'A4': 5887612972142058403,
 'A5': {'C1': 'dxs',
        'C2': [{'D1': -7722591752631609902,
                'D2': 2855982282,
                'D3': 40447,
                'D4': 17714,
                'D5': -312848918,
                'D6': -1898215027,
                'D7': [3656, 19838, 44340]},
               {'D1': -1467181062501707660,
                'D2': 2135969942,
                'D3': 19443,
                'D4': -4706,
                'D5': -1762957644,
                'D6': 1249321748,
                'D7': [40838, 28971, 24705]}],
        'C3': -140367961,
        'C4': -0.5334332585334778,
        'C5': {'E1': 1245410963,
               'E2': [-9195, 27971],
               'E3': 1716620668,
               'E4': -1792876545,
               'E5': 37,
               'E6': 76,
               'E7': [0.3159615397453308,
                      0.13809561729431152,
                      -0.16150875389575958,
                      -0.3965012729167938,
                      -0.4174347519874573,
                      0.06519152969121933]}},
 'A6': 46801,
 'A7': -7756407201988951211}

Вариант №28

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

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

(b'SQON\x8d\x00\x03\x00\x00\x00%\xbf\xb2\x17uT\xe4\xba@\x00L\xd9\x97\x00'
 b'\x00\x00h\x00\x90\xe3\x9a2\xde,\x1d\x8fQatf\xe8\x932H\xe5\x00X"\x98l\xc1\x92'
 b'\x0bs\x01\x98\xd6\xe7\xc7\\\xb7o6o\xc0\x89l"4lt\xa0\xb64U.\x00\x00\x00('
 b'\x00\x00\x002\x00\x00\x00<\x00\x03\x00FG\x91N\xe8\xed\xdd\xd7l\xfdt\x95v'
 b'H\x0f\x10\x0e?\xc1y\xa65\xe3?\xa0\xbeg3\x1a?\xedV9\xcbz\xe1\x80'
 b'\x00\x00\x00\x03\x00\x00\x00\\Wcs\xb1B\x90\xc3\xfd6rL\xb6\xac49\x86'
 b'\xf9\xbf\xe3S\xae\xdcx,\xe2\x80\xe1\xab\xd6?G\tL\xf8\xa4')

{'A1': 'atf',
 'A2': -0.07067044565767677,
 'A3': {'B1': [{'C1': 59539, 'C2': 3623397689860986988},
               {'C1': 49554, 'C2': 825004912691103580},
               {'C1': 46959, 'C2': 3922565496920224876}],
        'B2': [29856, 46644, 21806]},
 'A4': -9833,
 'A5': {'D1': 5192386548766701990,
        'D2': 3883017263345251098,
        'D3': 0.9167756056040588,
        'D4': [1200705256, 3990738796, 4252276086],
        'D5': 6297003909157274621},
 'A6': {'E1': 3923282572849985926,
        'E2': 249,
        'E3': -0.6039652162593507,
        'E4': -2132694058,
        'E5': 0.7774856090545654,
        'E6': 63652},
 'A7': -2046267150882205871}

(b'SQON\x8d\x00\x03\x00\x00\x00%?\xb8\x04\xfc\xea"v\xa0\x00Jq\x13\x00'
 b'\x00\x00r\x00\x9a\xb8\xdeL\x10T\x84\xd6\xd3bdw\x9a\xad\xcfJS\x0f\xe7\x8d'
 b'\x18(q+\xee\x18\xc9\xcf\x06.\xd6\x98)\x1c\xc7\xabJM\x88\x11&\xabgO'
 b"F\x05\x00\x00\x00(\x00\x00\x002\x00\x00\x00<\x00\x02\x00F\xd0\xf8L\xaa'\x19"
 b't9\xf71\xde\x8e3i\xb6\x19\xa3\xdc!\x88\xe0#Ps\xb1,\x18\xfcc\x9avo\x96\x96'
 b'\x0f\x83\x90\x18\x0ej\xbf\xd0\x83\xe5\x99\x8fo\xf8\x00\x00\x00\x06\x00\x00'
 b'\x00Z\x8f\xa7w\xc7\xd3_\xd3^\xb8\xc5\xf9\xe2\xfc}\x9d\x19\x97?'
 b'\xe9\xb8\x11\x94m\xd7\x86\x8ce\xe8\x7f\xbf\r8\xf6\xf7&')

{'A1': 'bdw',
 'A2': 0.09382611004044827,
 'A3': {'B1': [{'C1': 39597, 'C2': 14936842441902069800},
               {'C1': 28971, 'C2': 17156684671467050648},
               {'C1': 10524, 'C2': 14387675131420944043}],
        'B2': [26447, 17925]},
 'A4': 28947,
 'A5': {'D1': -5680137557739145617,
        'D2': 10850877409928416874,
        'D3': -0.2580503463375403,
        'D4': [3505933482,
               655979577,
               4147240590,
               862565913,
               2749112712,
               3760410739],
        'D5': -8095370105046707362},
 'A6': {'E1': -5132421447024796391,
        'E2': 151,
        'E3': 0.8037193202023765,
        'E4': -1939478401,
        'E5': -0.5516504049301147,
        'E6': 63270},
 'A7': -5125575692879866157}

Вариант №29

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

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

(b'XFGZ\x10\xa8#Z4\xf0\x83n\xb1$7\x04\x00\x00\x00G\x00\xba\x1fY\xc5\x17P\xb7'
 b'H\x05\x00\x00\x00O\x00\xf4P\xa8\xbd!\xd3\xd9?X\x00\x00\x00\x03\x00n\x00\x03'
 b'\xb5\xad\x9f\x14\xa7j6|?|K\x97[\xa1x\x16~\x90\xc03\x008\x00=\x00B\x00aczhp'
 b'\xbe\x98\x14\xf3\x19\xdc\xbb\xe7\x9c\x9f\x9a\xf1E\x9a\x81\xe7\xfc7r0'
 b'\x02\x00T\x00\x00\x00\xab\xc6\xcd\x0b\xe3\x08')

{'A1': -22512,
 'A2': 35,
 'A3': 3973495859465696346,
 'A4': [{'B1': 3, 'B2': 346009013},
        {'B1': 167, 'B2': 1065105002},
        {'B1': 124, 'B2': 2707134283},
        {'B1': 120, 'B2': 3230694934}],
 'A5': 5239744754494283706,
 'A6': 'aczhp',
 'A7': {'C1': 0.4035114624141578,
        'C2': {'D1': 25,
               'D2': 5039979468327205852,
               'D3': 33178,
               'D4': 231,
               'D5': 14332,
               'D6': 12402,
               'D7': [-26434, -3308]},
        'C3': [50859, 3021, 2275]}}

(b'XFGZ\xc1ng\x14\xa4\x84\xf9\xc0\x05c\x80\x03\x00\x00\x00B\x00\xb1\xc3T'
 b'\xc2\xbb\xf0h\x8c\x02\x00\x00\x00H\x00\x08[\x12\xaaHn\xe4\xbfP'
 b'\x00\x00\x00\x02\x00f\x00\xdc.N/^\xddh\r\xeaCc\x001\xbcc3\x008\x00=\x00'
 b'bl5\x00l\x8a\x8dk\xcf \xca\xd4\x92 \x98\xca\xed\x7fB\xc2\x8e\xe1I\xd1'
 b'\x03\x00J\x00\x00\x00\xdd\xbd&\xd5')

{'A1': 28353,
 'A2': 103,
 'A3': -9195499687782341612,
 'A4': [{'B1': 220, 'B2': 1580158510},
        {'B1': 221, 'B2': 1139412328},
        {'B1': 99, 'B2': 1673277696}],
 'A5': -8329142821611846735,
 'A6': 'bl',
 'A7': {'C1': -0.6384623834336205,
        'C2': {'D1': 207,
               'D2': -1312069075755283936,
               'D3': 17023,
               'D4': 194,
               'D5': 57742,
               'D6': -11959,
               'D7': [53, -30100, 27533]},
        'C3': [48605, 54566]}}

Вариант №30

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

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

(b'FEC\x90W\xf5#s.\x00\x00\x00\xc1\x96\x80\tV\xad\xa3\x1f\xe3\xbf\xb7\x8a'
 b'\xba>\x19\x1d\xf5\xb6\xf9\x9d\xfa\x9c\xbb6\xe6\x03\xb5\xf9 \xa5v\x1c\x95wNw'
 b"I\xe79\xb8'\xa1\xc3\x02\x00\x00\x00\x1a\x00\x00\x00)\x84\xce\xa1\xe7"
 b'\xdc\x02\xeaW\n\x9d\x9d\xb2\xf7\xa7\xf5g\xe0P1\xdd\xc4o!\xac\xf9\xc1\x82\xa8'
 b'\xc33\x07\xafK\x97<J\xfbc!t\x18\x02\x00\x00\x00\x1c\x00\x00\x00+\x00$'
 b'\xb2T,\x83\xf4\x90J\xfb\x9dD\xa7c\xedw\xba\x9fN0\xe22\r\x85\n\x85b\xa6\xa5\t'
 b'y\x82\x954?\xfe\xe0\xe49r\x08\x00\x1e\x00\x00\x00\xe7\xbe')

{'A1': 1931736407,
 'A2': {'B1': 78,
        'B2': [{'C1': [18807, 14823, 10168, -15455],
                'C2': [25, 29],
                'C3': [-1584461231470771159, -745354866785973673],
                'C4': 827383911,
                'C5': 560973021,
                'C6': 518973510593411500,
                'C7': 19375},
               {'C1': [15511, -1206, 8547, 6260],
                'C2': [-11, -74],
                'C3': [-827769164228460501, -1341044350876169584],
                'C4': 1319090807,
                'C5': 221438512,
                'C6': 8721684287415716485,
                'C7': 38274}],
        'B3': -520208588,
        'B4': -28,
        'B5': 57,
        'B6': {'D1': 114,
               'D2': [-25095, -25350, 14011, 998, -1611, -23264, 7286, 30613],
               'D3': -25},
        'B7': -66},
 'A3': 38593,
 'A4': -0.5976122270079003,
 'A5': 0.36433956027030945}

(b'FEC\x90\xb6f\x86\x91$\x00\x00\x00\xceB\x18N\x93\xfa\x08\x11\xde?6\xaa%\xbe75'
 b"\x81R\xc6L\xe3\x80;iJ'40\xee\xd4M\x92,\x02\x00\x00\x00\x1a\x00\x00"
 b'\x00\xe43\x8c+7>\xb2\xe2\x86\xb2;i\xfe\xad\x9d\x8c\x1e&\x9a3\xb6\xfe\x8c'
 b'\xde_\xde\xf3\x18\xdd\x02\xbcn\xc6\xf5G2;\xf6\xa3h\x14O\x02\x00\x00\x00\x1c'
 b'\x00\x00\x00\xcfz\x19\x07\xd9\x1a\x10\xb6\x9e\xe9\x9arJ"\xb2?;\x83\n\xb8\xd5'
 b'*\xce\xa4\x8e\xcc\xf3\xad\xe7u\x98\xfcu\xb8<\xaf\xe8v\xa5"\x03'
 b'\x03\x00\x1e\x00\x00\x00\x1f5')

{'A1': -1853462858,
 'A2': {'B1': 74,
        'B2': [{'C1': [13351, -4560, 19924, 11410],
                'C2': [55, 53],
                'C3': [-2111556868608609308, -8314298028857249146],
                'C4': 865740318,
                'C5': 3733782198,
                'C6': 7979255788423339615,
                'C7': 62918},
               {'C1': [12871, -2501, 26787, 20244],
                'C2': [-127, 82],
                'C3': [-5327728839749961009, 4589768673389635998],
                'C4': -1207270597,
                'C5': 2764974805,
                'C6': -245316541775360882,
                'C7': 47221}],
        'B3': 1994960700,
        'B4': -91,
        'B5': 34,
        'B6': {'D1': 3, 'D2': [19654, -32541, 26939], 'D3': 31},
        'B7': 53},
 'A3': 17102,
 'A4': 0.46978973837141913,
 'A5': -0.16178211569786072}

Вариант №31

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

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

(b'\xc3ZEXT\xa2\xfd\x94z\xa2+\xef\xbfH\x1a0\xa2\x97.\x83\xf4\x03\x00\x00'
 b'\x00A\x00\x00\x00;\xd1#(\x03\x00\x83\x00\x00\x00\xf7\x1aN\x8ex\xed\x1f?I'
 b'0-\xda\xbfP\x8f3\xb6e\xcd\xa2-?\x94\x00\x00\x00lt-\xae\xc0\xb1\x9b'
 b'\x8c\xbe\x9fV\x8c\xf2\xb9s\xf5q\xd7\xe3\r\xe7(=N\xfd\x0bp_h.0\x10.\xd8v'
 b'\xdd\x01s\xfd\x89,G|9\x83\xd4P1,\xbb\xb2\xf06\x1a\x12u\x95K\x19>m\xde\x06'
 b"\xcb\xe1\xccuvf1\xbdV\xd9\xaa\x90\x94i\xfa\x1d\xb7\x0c'\xcf\x90w\xf4p"
 b'\xadd\xd5V\xa6\x80_W\x1c\xe80\xabFe\x86\x00\x00\x00')

{'A1': -0.9740764993838875,
 'A2': -827766677710038456,
 'A3': [{'B1': -8314856845895437204,
         'B2': 40894,
         'B3': -1175286698,
         'B4': 2947339753360586099},
        {'B1': 3344027658164719165,
         'B2': 4144,
         'B3': -579413970,
         'B4': 4142264013893235457},
        {'B1': -1102613160272014205,
         'B2': 6710,
         'B3': 1268086034,
         'B4': 14763304283859140121}],
 'A4': 53563,
 'A5': {'C1': 10275,
        'C2': 'uvf',
        'C3': -1907483913,
        'C4': 0.6247172355651855,
        'C5': 3715277002533318729,
        'C6': 26038},
 'A6': 0.678265392780304,
 'A7': {'D1': 30608,
        'D2': [28916, 25773, 22229, 32934, 22367, 59420],
        'D3': [48, -85, 70, 101],
        'D4': {'E1': 48433, 'E2': [-9898, -28502], 'E3': -3519830603145254508}}}

(b'\xc3ZEXT\xc8(:~\r\x16\xef\xbf\xdei\xe6\xf74\xe9\x04\xd5\x03\x00\x00'
 b'\x00A\x00\x00\x00\xa5\xb3\xde2\x02\x00\x83\x00\x00\x00JT\xf3\x14\xc6'
 b'\x01|?\xefP\xf5|Oe\x95\xcd\xe2\x95,\xdf\xa5>\x93\x00\x00\x00ID\x85\xee^b\x08'
 b'\xa8\xb5\xe4\xbfh\xdc\xe9g\x98\x15H\n"-\xb2Ugd\xd5\x04\xcc#\xc9|0\x84\xc8\t'
 b'\xdd\xc7\xfbPS9$\xbc\xfd\xefW+W\xe2\x89\x95\n\x14\x1bO\xacV3)\x91%/\x9e'
 b'\x16U\xfaoiEb\xa5J\xa8\t\xf46\xb2\xf9a\xd1M\x14\x16\x89\x1e\xaa\xdb'
 b'\x9b\xf0Q=\xdbT\x1de\xd2\x8c\x81\x01\x98\x85\x00\x00\x00')

{'A1': -0.9714419808745101,
 'A2': -3097094230017414690,
 'A3': [{'B1': -6338708315655814071,
         'B2': 58549,
         'B3': -371431233,
         'B4': 12838955540257544295},
        {'B1': -3953091726769100971,
         'B2': 12412,
         'B3': -586561404,
         'B4': 18283528415846923207},
        {'B1': 762667317127239663,
         'B2': 6932,
         'B3': 861318223,
         'B4': 18038348751154024745}],
 'A4': 45989,
 'A5': {'C1': 13022,
        'C2': 'oi',
        'C3': 351491146,
        'C4': 0.984402060508728,
        'C5': 14813857941378388207,
        'C6': 38370},
 'A6': 0.3239682912826538,
 'A7': {'D1': -30442,
        'D2': [43550, 39899, 20976, 56125, 7508, 53861],
        'D3': [-116, -127, 1, -104],
        'D4': {'E1': 25157, 'E2': [19109, 2472], 'E3': 1463055672696518388}}}

Вариант №32

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

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

(b'GFRS+\x8a\x02\x00;\x00\x00\x00\xb4\x1e\xac\xbe+R\xda\xd4\xd2xnmE\x00hj'
 b'shh\x05\x00\x1a\x00\x00\x00\x11:\x7f\nzpheqwlg\x08\x00)\x00\x00\x00)'
 b'\xe3\xce\x84\x1f\x001\x00\xb1[\xab\x83/\x03\x03\x00?\x00\xc0\xb4\x81'
 b'\xea\x9b\x06\nw')

{'A1': -118,
 'A2': [{'B1': 'hjshh', 'B2': 176110097},
        {'B1': 'zpheqwlg', 'B2': -2066816215}],
 'A3': -0.3361717462539673,
 'A4': {'C1': 43, 'C2': 3537164882},
 'A5': 'xnm',
 'A6': {'D1': [23473, -31829, 815], 'D2': 8577675707004597440}}

(b'GFRS+9\x02\x008\x00\x00\x00/JS\xbf;\xbb\xcf\xc7\x7fnigB\x00kootia'
 b'm\x07\x00\x1a\x00\x00\x00\xd8\xce\xd7\xaatga\x03\x00+\x00\x00\x00'
 b'\x08\xb9\xfcY!\x00.\x00\xe0\xe1\x9e[Gx\x03\x00<\x00cb\x05\xa6\xf8e\xd1\x04')

{'A1': 57,
 'A2': [{'B1': 'kootiam', 'B2': -1428697384}, {'B1': 'tga', 'B2': 1509734664}],
 'A3': -0.8253507018089294,
 'A4': {'C1': 59, 'C2': 2143801275},
 'A5': 'nig',
 'A6': {'D1': [-7712, 23454, 30791], 'D2': 347170764895904355}}

Вариант №33

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

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

(b'ELZ\xd5pfyuu&*2\x1a\x00\x81\x00\xd7\xf9<%pL\x1d*\xdb\xbf\x90Q\xee@\xa7o'
 b'\xe6\xbfG\xd8\xe8\xba)^\x10\x00\x00\x00\xb6|\x8c\xcbi&Y|\t\xd7 \xd0'
 b'>\x96\xb8$3\xc3&.\xfcE8\xff\x93w\tE\xb4\xb8\xcfK}\\\x1e\xb5\xfdt\xd0\xc6'
 b'\xdc>\t>\xda\xab\xa2>`\x9b\x04\xa9\x93\xf8>I?\xbb\x1f&U\xd2FB'
 b'\x17\xd9\x08\x81\xe2<\xf3VLQ\x03\x1c\xb8\xbdQ,\x93\xa5g\x89\xa2-\x00W'
 b'\x00\x85_\xbc\xe4\x99\xc8\x86\x9bv\xa3R,\xa3H\xdc[X\x97\xbf\xdb\x1ej\x99'
 b'\xcf\xe3+5=s>$ys\x91<\xa4[\xf9M\xa1')

{'A1': 'pfyu',
 'A2': 841623157,
 'A3': {'B1': -0.7011295574362055,
        'B2': 3135821895,
        'B3': 24105,
        'B4': {'C1': 63959, 'C2': -0.4244454618897924},
        'B5': -74},
 'A4': {'D1': [{'E1': 683519264972049532,
                'E2': 0.40650054812431335,
                'E3': -275239907404498794,
                'E4': -1811990459,
                'E5': [2423, 46149, 53176, 32075, 7772, 64949, 53364],
                'E6': 155114694},
               {'E1': 331964819675273790,
                'E2': 0.48550155758857727,
                'E3': 5103234949993676617,
                'E4': 148444994,
                'E5': [57985, 62268, 19542, 849, 47132, 20925, 37676],
                'E6': 2726913957}],
        'D2': 3837550469,
        'D3': 51353,
        'D4': -25722,
        'D5': [743613302,
               1541163171,
               3686766424,
               3482937886,
               1026894819,
               2032418419],
        'D6': 11623220385305891187}}

(b'ELZ\xd5sqfw\xc2\xd1\xad\xa1\x1a\x00\x81\x006\x80\xec4\x06\x00\xaa\xa7\xe2?n)'
 b'ou\xec\x0b\xe4?\x98\xb0\xd6\xa1Z\x01\x10\x00\x00\x00\xeeQ?\xbd\x86K\xebH'
 b'\xb5\xe5\x1dv\xbf2\xa1\xd1n\xb45i4\xa0\xc3\xa2"\xd1\x1b\xe1\xe6\x15yL'
 b'\x07\x12\xae\xae\xd7*\x16GFs{\xd8\xa2\xe10B\x81\xfa\x13\xed\x94(\xbfA'
 b'\xa2\xd3\xe1\xb0\xab\xd6{M:\x91\x06Kxx\xb4\xf8\xc3\x8d5]"\xd5\x0c\xdf'
 b'\xed>\xdb3j-\x00W\x00\x85\x8c\x0b\xcex\xdf\x0b\x90\xa2\xc5\x8f\x06J`f'
 b'0\x0b\xbe\nr\x9b\xaeR;*w0\xed\xd0\x8b\xdd\xbaEg\xb6n\xe6I5g')

{'A1': 'sqfw',
 'A2': -1582444094,
 'A3': {'B1': 0.6264555257451272,
        'B2': 2715201688,
        'B3': 346,
        'B4': {'C1': 32822, 'C2': 0.5829668045495544},
        'B5': -18},
 'A4': {'D1': [{'E1': -5383794644905803951,
                'E2': -0.9613936543464661,
                'E3': 3776608811596489010,
                'E4': 581092256,
                'E5': [7121, 59105, 30997, 1868, 44562, 55214, 5674],
                'E6': 2071152199},
               {'E1': 1439605152186213080,
                'E2': -0.6585224270820618,
                'E3': 8923508487872553537,
                'E4': 110180941,
                'E5': [30795, 46200, 50168, 13709, 8797, 3285, 60895],
                'E6': 1781783358}],
        'D2': 3456863365,
        'D3': 57208,
        'D4': -28661,
        'D5': [110085538,
               812015690,
               1913306635,
               995274395,
               3979376426,
               3135081424],
        'D6': 7436931613720995653}}

Вариант №34

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

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

(b'HCSAUA=\xf1\x07[w\xad\xb1\xb5\x00\x03\x00K\xbe\x98t\x9c?E)\x9d\xb0?'
 b'\x14\xab\x02?C\xcc\xe8\xba>\x92-\xbc\xbe\x11\x19\x86u\x0c\xfa\xd8r\x8fD\x18'
 b'v/\xebZ{2N\r\xdc\x00\x00\x00\x02\x00\x00\x00N\x00\x00\x00\x06\x00Vs'
 b'ke\x88\x15W\x00F\x03,\x8a\x14\x9f\x8b\xb17\n')

{'A1': 65,
 'A2': 0.11768981069326401,
 'A3': 2007871925,
 'A4': {'B1': 'ske',
        'B2': [{'C1': -0.2977646589279175, 'C2': 0.7701662182807922, 'C3': 176},
               {'C1': 0.580734372138977, 'C2': 0.7648453712463379, 'C3': 186},
               {'C1': 0.28550517559051514,
                'C2': -0.1416989266872406,
                'C3': 117}],
        'B3': {'D1': 935297859174275190,
               'D2': 3452953024481070556,
               'D3': [2283099904, 1174613130]},
        'B4': [20, 159, 139, 177, 55, 10]}}

(b'HCSAUI\xbd\xa5\x1b\xcbQ\xa8\xe4\x82\x00\x04\x00K>\xea\xd8G>k\xa4,\xd0\xbf'
 b'\x00\xcd\x08?\x16\xdfF\xe3\xbe\xcd\xf2\x08\xbd\t\xc3\x03\xd7\xc6\x98\t'
 b'/\x9f\x0cV\xe4\x01\xb1\x11\x12\xc0\x8c=\xff\x00\x00\x00\x03\x00\x00\x00'
 b"O\x00\x00\x00\x03\x00[wnbw\xdd\x1e\x95\xff\xb4'\x8e\xcb\xf0\xec-\xa7\xe5"
 b'\x1c.')

{'A1': 73,
 'A2': -0.08061941713094711,
 'A3': 1370023042,
 'A4': {'B1': 'wnbw',
        'B2': [{'C1': 0.4586813151836395, 'C2': 0.23011845350265503, 'C3': 208},
               {'C1': -0.5031285285949707, 'C2': 0.5893443822860718, 'C3': 227},
               {'C1': -0.4022371768951416,
                'C2': -0.033633243292570114,
                'C3': 215}],
        'B3': {'D1': 14310197916106249956,
               'D2': 121897437153213951,
               'D3': [3709769215, 3022491339, 4042010023]},
        'B4': [229, 28, 46]}}

Вариант №35

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

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

(b'KVY\x19\xbe\xf7\xbd+\x00o\xe6a\xa2\xa0\x0c\x90\xffc\x00\x94\xb0\xad\xc5N'
 b'\xba:#Z\xc2\x06\xab3\xbf\x956\xe2>\x92&\xaaA\xc7\xc8#\x00ecdwv\x9d\xa8'
 b'\xab\xdeZ\xb6d\xd5\x0e\x07\xa3\xca\xc2\x87\x8e\x0c\xb5\xa1\x83R\xfd\x8c'
 b'\xdb \xff\xac\x02\xd5\x9f\xec\x86c\x02\x00L\x00\xb0\xd7\xc0?\xa1\xc8'
 b'\xfa\xa9\x84\x15[b\xd2?\r\x15\x14\x02\x002\x00\x00\x00-\xad,\x7fP\x00\x00'
 b'\x00')

{'A1': -0.1209680512547493,
 'A2': {'B1': {'C1': 647118562, 'C2': 3368501674}, 'B2': 'ecdwv'},
 'A3': 18415232760376583791,
 'A4': {'D1': 336923967,
        'D2': [{'E1': 157,
                'E2': [168, 171, 222, 90],
                'E3': [182, 100, 213, 14, 7, 163, 202, 194]},
               {'E1': 135,
                'E2': [142, 12, 181, 161],
                'E3': [131, 82, 253, 140, 219, 32, 255, 172]}],
        'D3': 2133634349,
        'D4': {'F1': 25478,
               'F2': [54530, 60575],
               'F3': 176,
               'F4': -1589657385,
               'F5': -3286964630048867640}},
 'A5': 2538546187463405716,
 'A6': -15782,
 'A7': -0.7018283605575562,
 'A8': 13973}

(b'KVYk\x1eA\xbf+\x00\xa3\x8dm\x9b\x8aww\x19g\x00c\xda>\x00\xc0\xa9p&\xa5/I!}'
 b"?5w\x80\xb3\x84\x89\xf0b\xdeu#\x00goxyu\x0f\xfb\xc1\xe7\x92>{\xe8'\x84"
 b'n\xc7l3\xe2\xf40N\xb2\xe76\xb7iV\x1e\xe2\x87\xd9k2\xf9\xde\xbewAl\x04\x00'
 b'L\x00\x83\xc8\xec\x9dT\xb97\x8f\x05\x06\x1eKz\xc0\xbe\xb1u\x02\x002\x00\x00'
 b'\x00)\x930\x96T\x00\x00\x00')

{'A1': -0.754370391368866,
 'A2': {'B1': {'C1': 2307175296, 'C2': 1977508592}, 'B2': 'goxyu'},
 'A3': 1835066810373606819,
 'A4': {'D1': 1974582976,
        'D2': [{'E1': 15,
                'E2': [251, 193, 231, 146],
                'E3': [62, 123, 232, 39, 132, 110, 199, 108]},
               {'E1': 51,
                'E2': [226, 244, 48, 78],
                'E3': [178, 231, 54, 183, 105, 86, 30, 226]}],
        'D3': -1775201495,
        'D4': {'F1': 27713,
               'F2': [55687, 12907, 57081, 30654],
               'F3': 131,
               'F4': 1419635912,
               'F5': 8812170107092416441}},
 'A5': 2769900412935789155,
 'A6': 12197,
 'A7': 0.9887891411781311,
 'A8': 30517}

Вариант №36

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

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

(b'\xe6LBHK\x0c\x02\x00\x00\x00%\x009\x001\x16\xba\x00\xdd}\x00,t\x19'
 b'\x918\x12\xaf\xae1\xde5\xa6\x00\xa7\x98\x8b=\x9a)\x06\xa6s\xcc\xed\xfb%_'
 b']\x1e\x92TLx|#\x86\xc0\xe8\x94\xbf\xcd\x9a\xe2H\x0f\x9f\xdf\xbe=\x937?p\x82w'
 b'\xbf0\xc1\x1f\xbeO\x05\x12\xbf\x1e\xb8\x06?L\xd6\xb3>?y\x1e?\x8dbt?`\xf7\xf0'
 b'>\n\x0bL?\xf1\xef<\xbf\x7f\xbcz\xf34\xefD\xc8\xa5\x1e\xca\x82\xc2D\xf7'
 b'\xb3\xd3<J\xb6\x05\x00]\x00nx`\x9c\xbaK\xff\x1f\x03\x00\x00\x00q\x00\x00'
 b'\x00')

{'A1': {'B1': 12,
        'B2': [{'C1': -1311546234566501827, 'C2': 9723},
               {'C1': 8969002584020770143, 'C2': -31197}]},
 'A2': {'D1': 5251930323940600000,
        'D2': [-0.43676039576530457,
               0.7170904278755188,
               -0.9668340682983398,
               -0.15601038932800293,
               -0.5703935027122498,
               0.5262469053268433,
               0.35124433040618896]},
 'A3': 49,
 'A4': {'E1': -587154922,
        'E2': {'F1': -5311365930574986046,
               'F2': [0.6190375685691833,
                      0.9546287655830383,
                      0.47063732147216797,
                      0.7970434427261353,
                      -0.7380362153053284],
               'F3': -1671399314,
               'F4': 536824762,
               'F5': [4084907135, 3359960884, 2194284197]}},
 'A5': 12587299517685658668,
 'A6': [-8655, -22987, -22784, -29800]}

(b'\xe6LBHK\x82\x02\x00\x00\x00%\x009\x00\xb6\xf1q\xdc"}\x00z\nw\xd2]\x1b\x1d'
 b'Kz\xbb\xfb\x13\x8a/\xe6v\xe4G\xc8\x17\x00\xc5\xfb\xc6w/\xa8&GS\x18'
 b'Z\xb7\x7f\x9b\xe0\xf0\x82\x19\x86\xe2\xedep\x19\xcc&\xbf~\xebi\xbfz\x90\x0c'
 b"?\xd9\x11\xeb=\xa0\tJ?;\xb6'\xbf\x8d\xefY\xbe%\x17\xfc\xba\x00\xdfM"
 b'\xbf\xa3\xba\xfb\xa3\xee\x81\x7f\xe1|\xc7!\x0b\xca\xc1\x17\xa4\x11yi'
 b'\x00\xc3\xdb\x7f\xb0\x18\xa6`\xe1HN\xe8\x03\x02\x00]\x00\n\xd8\x89\xcd\x94Ec'
 b'G\x06\x00\x00\x00e\x00\x00\x00')

{'A1': {'B1': -126,
        'B2': [{'C1': -4108473630855772188, 'C2': 12151},
               {'C1': 9202923424077784744, 'C2': -8037}]},
 'A2': {'D1': 8099141062063915760,
        'D2': [-0.6515517830848694,
               -0.9137495756149292,
               0.5490795373916626,
               0.11478013545274734,
               0.7892093658447266,
               -0.6551243662834167,
               -0.2128278762102127]},
 'A3': 182,
 'A4': {'E1': 584872433,
        'E2': {'F1': 281561051636475416,
               'F2': [-0.0019232971826568246, -0.8041839599609375],
               'F3': -846604278,
               'F4': 1197688212,
               'F5': [2751183523,
                      3783229934,
                      186763132,
                      2753020362,
                      6912273,
                      2961169347]}},
 'A5': 5412512416946129530,
 'A6': [-17542, 5115, 12170, 30438]}

Вариант №37

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

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

(b'VVV\x00,\x00:?\xd6\x14\xa6\x83\x118\xf0a\x9e\x00H\xbe\x9f\x06x\x00'
 b'f\x88\x14\xc1\xe5"<\x8b~\xe2Z\xf8\x81]\xab\x1a\x01\xa9\xc0!?\xde\xf6>'
 b'\x1cU\xc0\x98>;\x97\xcc\x9b\xe9?\xe9\x9f\xcd\x83A\x854>\nD\x82w\x93'
 b'>\xb0\x03\x0e\x91\xed0\xd0\xc9g~-1\xd3\xff\xb2#\xea\xb3_\xc3\x97\xcat\x8bc",'
 b"WB\xbe\x888\x94,\xf6\xe0\x91G\x99\xd6Z'^\xaa\xb9\x81\xe0f&\x00\x02"
 b'\x00^\xbe\x08\x04\xbe^\xe5\xb7\x06\x9dW\xe1\xf5v\xd4\xfbV^a\x99\x9b\x94\x01'
 b'#\x04\x90\x95\xdd\x02\xa6\x94\xf0\xf2')

{'A1': [{'B1': 0.4837794567784015, 'B2': 0.18319624662399292, 'B3': 39913},
        {'B1': 0.8007571757881693, 'B2': 0.1350269615650177, 'B3': 30611}],
 'A2': 0.3450104026750429,
 'A3': {'C1': 24990,
        'C2': {'D1': 0.3437733054161072,
               'D2': -28179,
               'D3': 12496,
               'D4': 201,
               'D5': 26494,
               'D6': 45,
               'D7': 3590494468516262751,
               'D8': -15465},
        'C3': -0.310596227645874,
        'C4': {'E1': [-1098368876,
                      754376849,
                      1201264218,
                      660515513,
                      -2116000218],
               'E2': [-898331805, 573331266],
               'E3': -0.13283059000968933,
               'E4': [1592112902, -1655184907, 1993669462, 1583454619],
               'E5': -1811864828,
               'E6': 10418476316445962482}},
 'A4': 9805675478558477182,
 'A5': -30,
 'A6': 6555131496940306857,
 'A7': -16351}

(b'VVV\x00,\x00:\xbf\xda\xcaP\x88\xcd\x1c\xa8 \xca\x00H\xbf\x04\x9b\x98\x00'
 b'j`\xc8\x9f\xdd0\x19\n4zv\x92\xe1\x1f^\xc53y\x0b\xad\xbf\xd8\xa1\x85'
 b'3\xfa\x83\xd4?,K\x1d\x07D?\xcc\x17\x06R\xe6M\x98\xbd\xb1\xb3\xa1\xb7\x91'
 b'?\x1b\xbaN\x1b9\x9e\xaa7\x93\xbdl\x81\xcf8\xa0\xe3\xc0zgK\x10\x9c\xbb'
 b'\x96\xd46F\x8b\x05&\xba\xa0\xf8\x94t\xb8\x19\x02\xfe\xaeF6\x80\x16\xd5/\x14'
 b"'\xac\xf9X\xe7\x90\x00\x03\x00^\xbf6gI\xadn\x91{\xb7f\x8f\xa2\xfd\xa8"
 b'\xa7-\xb9Nu\xb8\x9a&6Q,\xff\xc3pC\xdc#\x19')

{'A1': [{'B1': -0.3848584182360899, 'B2': 0.673021137714386, 'B3': 1860},
        {'B1': 0.21945265815575676, 'B2': -0.08676839619874954, 'B3': 46993}],
 'A2': -0.41859830245489116,
 'A3': {'C1': 8394,
        'C2': {'D1': 0.6083115339279175,
               'D2': 6969,
               'D3': 40618,
               'D4': 55,
               'D5': -27715,
               'D6': 108,
               'D7': -9092986858970776985,
               'D8': 19216},
        'C3': -0.5179991722106934,
        'C4': {'E1': [-1804290023, 50245190, 914364117, 789850028, -111614064],
               'E2': [-1665427756, 910592773, 649765112],
               'E3': -0.7125135064125061,
               'E4': [-1385262725, -1218015326, -39278803, -1186040392],
               'E5': -1708771759,
               'E6': 3242525143672300313}},
 'A4': 6973999795326749236,
 'A5': 122,
 'A6': 8544138967925470073,
 'A7': 2989}

Вариант №38

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

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

(b'~OBRK\x17\x00\x00\x00\x02\x00\x00\x00L\x00\x00\x00\x10\xfeq_\xd1\xd7cfc8\x99'
 b'ncjzcslg\xb5\xcd\xf0/B\xca!\xf7\xf5\xfb\xeb\x81\x87\xa7$\xb3KLT\tt\xc7\t\xba'
 b'"\xb6q=\x80NKi\x12\xb2\x14\xd8\xbe$no\x02\x00\x00\x00$\x00\x00\x00'
 b"\xd2\x12\xad\xe4Kq\xb6\xd9\x03\x00\x00\x004\x00\x00\x00\xa1\xf90'e,J\xaa")

{'A1': {'B1': 'cfc', 'B2': 39224, 'B3': 'ncjzcslg'},
 'A2': [{'C1': [17807736787220614581, 12908626632392834037],
         'C2': -2758893150944816430},
        {'C1': [13405465067031645259, 7587244309929375266, 8029395587735794194],
         'C2': -6176075126024373855}],
 'A3': {'D1': -496, 'D2': 3620822897}}

(b'~OBRK\x17\x00\x00\x00\x03\x00\x00\x00d\x00\x00\x00\xc8\xc2?\xe4\x9c\xa1k'
 b'si\xab?jgdnbhfd.\xda\xde\x87/7\xc43\xa3G\xc4[\x9b\x98\x91\xdb\xcd4\xc9\xa9'
 b' \xc5\x9b\xff\xe2X\x1c<!&\x13\x19H\x96\x18\xf3\xbf\x15\x9e\xc1\x8f0\xd1\xe1'
 b"\\\xdaU'a\x14\xbe\xad\x93\xd5\x95,*\xc2K\xac.\xbd\x86+\x03\x00\x00\x00"
 b'$\x00\x00\x00{CA\xb0\xb1\xe6\xd6\xcc\x03\x00\x00\x00<\x00\x00\x00\x8aqt\xc6'
 b'}E\x94[\x02\x00\x00\x00T\x00\x00\x00^t\x98A\xeb\xbd`\xbb')

{'A1': {'B1': 'ksi', 'B2': 16299, 'B3': 'jgdnbhfd'},
 'A2': [{'C1': [3730167068652132910,
                15821594758956205987,
                18418531845139936461],
         'C2': -3686505594115505285},
        {'C1': [1806829799689967842, 13951612609801786952, 2834411632960024719],
         'C2': 6598975760507367818},
        {'C1': [3212708739450541153, 3136402198666920490],
         'C2': -4944743572737330082}],
 'A3': {'D1': -15672, 'D2': 2711413823}}

Вариант №39

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

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

(b'CFRVd\xfb\x18)I?(U\xbd1\xa2\x02\xba\x86\xc4y\xe8\xf2`.F@op\xe6\xdc\xa8R'
 b'a\xb3?9\x00\xf9\x91\xa3\xbe\xfa\xc5s\xbf\x92\xc8\r\xbf\xad!J\xbe\x9b\xd2\x9b'
 b'>x|w\x18m\xb4t\xbf\x03\x00%\x00\x00\x00\x97\x02\x001\x00\x00\x00\xfb\x17'
 b'hV\x9b8\nQgl\xf1\xb1Q-\xc1\xca\x8e!\x93\xc4\xb9\x1f ')

{'A1': 251,
 'A2': 0.7857832908630371,
 'A3': [21800, 12733, 674, -31046, 31172, -3352],
 'A4': 1078341216,
 'A5': 111,
 'A6': 0.07570377943638973,
 'A7': {'B1': 410483832,
        'B2': -0.9558780789375305,
        'B3': [{'C1': [-0.3194730579853058,
                       -0.9522396326065063,
                       -0.5538417100906372],
                'C2': 151},
               {'C1': [-0.19739408791065216, 0.3043411672115326], 'C2': 251}],
        'B4': [23, 104, 86],
        'B5': -5624595268611983205,
        'B6': {'D1': 11601, 'D2': 2286074422069480129},
        'B7': 32}}

(b'CFRVd\xac\xd0\xa4)\xbf\xbf\xf2\x04W\xc5Ka\xd8\xf1V\x131y\x94(\xcd\xb1@'
 b'\xe1MZ2\xc7\xb6\xbf=\x00\xa9\x86&\xbf\xca\x07"\xbf\xe1\xca\x8f=q\xb3\x10'
 b'\xbf\xb1\x12F>+IH>\x994\xd3\xd8\xbbNc\xbf\x04\x00%\x00\x00\x00}\x02\x005\x00'
 b'\x00\x00\x13\x1f\x10\xe7\xfcC\x8a\xd7A\x99\xb8F\xe5\x8d\x0c\xa7\xc5\x9a'
 b'\r\x90\tc>')

{'A1': 172,
 'A2': -0.6626710891723633,
 'A3': [-3393, 22276, 19397, -10143, 22257, 12563],
 'A4': 3441988729,
 'A5': 177,
 'A6': -0.08897700028126554,
 'A7': {'B1': 3637720217,
        'B2': -0.887920081615448,
        'B3': [{'C1': [-0.650492250919342,
                       -0.6329313516616821,
                       0.07021117955446243,
                       -0.5652380585670471],
                'C2': 125},
               {'C1': [0.19343067705631256, 0.19559161365032196], 'C2': 19}],
        'B4': [31, 16, -25],
        'B5': 5095991486437803004,
        'B6': {'D1': -29211, 'D2': 7136393472650880780},
        'B7': 62}}

Вариант №40

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

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

(b'IJYNYD\xd6\xa30\xec\x14\xb2\x93K\x00\x00\x00^\x00\x00\x00q\x00\x00'
 b'\x00\x84\x00\x00\x00\x97\x00\x00\x00\xaa\x00\x00\x00\xc3\xecqk\tW\n'
 b'$E\xa3\x9a\xdb&\xbe\xb49k\xba\x03\x9c\xe0&\x08\x96\xc3=\xf7\xab\x8ey,'
 b"\xc2\xa4Skvp\x8d\x96\xb6\x91?\x19Z\xa09\x86\xbb\xde'p\xce2\n?"
 b'\x0f\x7f\xa3\xbe"c@\x16^[F\xd7)\x87K\xd1\xae!\xbf\xaa\xc7r\xa0\xa5'
 b']\xc6\xd3\xb6\x19\xb0\xc5\xc8\xf28b\xcb\x8e>\xf8\x8a\xdec\xec\x11\x8d}A.'
 b'\xb72\xf7\x1d\x0cV\xe4\xeb\xbd\xe2\xdb\xfcM\xb7\x8es\xdf_\xb4\xedZXd\xa7'
 b'\x11w\x19?C-\x97\xef\x85\x83\x87[\x9d2\xb3\xc0\xf8\xf0\x97\xd0\x05+\xbf\xb8'
 b'\xfd')

{'A1': -7804152199618767292,
 'A2': {'B1': [{'C1': 1066514070,
                'C2': 966810137,
                'C3': [134, 187, 222, 39, 112],
                'C4': 0.5398377180099487,
                'C5': 32527},
               {'C1': 1663221411,
                'C2': 1532892736,
                'C3': [70, 215, 41, 135, 75],
                'C4': -0.6315737366676331,
                'C5': 51114},
               {'C1': 1571135602,
                'C2': 431412166,
                'C3': [176, 197, 200, 242, 56],
                'C4': 0.27889543771743774,
                'C5': 35576},
               {'C1': 300704734,
                'C2': 776043917,
                'C3': [183, 50, 247, 29, 12],
                'C4': -0.11518160998821259,
                'C5': 56290},
               {'C1': -1900589572,
                'C2': 3026182003,
                'C3': [237, 90, 88, 100, 167],
                'C4': 0.5994730591773987,
                'C5': 11587},
               {'C1': -2088374377,
                'C2': 849173383,
                'C3': [179, 192, 248, 240, 151],
                'C4': -0.6680574417114258,
                'C5': 64952}],
        'B2': {'D1': [1802628291,
                      604657417,
                      3684344645,
                      968146470,
                      2617490027,
                      2517116640,
                      2885107139],
               'D2': [31118, 49708, 21412, 30315, 36208]}}}

(b'IJYNY*\xb6\xc7\xef(5\x01uK\x00\x00\x00^\x00\x00\x00q\x00\x00\x00\x84\x00\x00'
 b'\x00\x97\x00\x00\x00\xaa\x00\x00\x00S\xc6\xa5\xa7\xc9\x84&>U\xf3w'
 b'7\xe7\x06\xb4Q(S=\x1f\x85\xaf\x86\xb2\xdf\x15X\xa5\xe2\xa5\xff\xb6\xbf\x17}'
 b'\x8d9v\xae\xf4Kq\x0c\xa0\xe5\xec\xcc\xc2\xe7\xdaF\xa3\xdbM?\xb3\xd2\xa3\xc2'
 b'\xbe\xb01X\xc7\xa4\xff\xb4\x8d\xf7y\xff\x13\x9c=+\xcb\x11\x15E,][\xd4'
 b'\x12\xf6\x7f m\x00\xae\x8c&?\xa1\x1a\xb1\xa56\n\x07\x9e\xf3\x04'
 b'\xa0\xb6\x08\x05Jgh\x0f\xbf>\xd1\x99\xec\x0c,)(u\x1b\xeaL\xfc\xb3\xaf'
 b'u\x84c\xbf\xef:6\x9c\xb3\xc9\x11\x06\xe7!\x82\xc1=\xe2\xa2\xbcs\x98\xbd\xcf'
 b'{')

{'A1': 8431078427352086058,
 'A2': {'B1': [{'C1': 1900803246,
                'C2': 3974471692,
                'C3': [204, 194, 231, 218, 70],
                'C4': 0.8041326403617859,
                'C5': 53939},
               {'C1': -1329675613,
                'C2': 2764527665,
                'C3': [255, 180, 141, 247, 121],
                'C4': 0.07621001452207565,
                'C5': 52011},
               {'C1': 742724881,
                'C2': 315906909,
                'C3': [246, 127, 32, 109, 0],
                'C4': 0.6505841016769409,
                'C5': 6817},
               {'C1': 171353521,
                'C2': 83074567,
                'C3': [160, 182, 8, 5, 74],
                'C4': -0.5601868033409119,
                'C5': 53566},
               {'C1': 739044505,
                'C2': 460662825,
                'C3': [234, 76, 252, 179, 175],
                'C4': -0.8887398838996887,
                'C5': 15087},
               {'C1': -910975946,
                'C2': 568788497,
                'C3': [130, 193, 61, 226, 162],
                'C4': -0.07443949580192566,
                'C5': 31695}],
        'B2': {'D1': [2812659283,
                      1042711753,
                      930607957,
                      1370752743,
                      524112680,
                      2995171205,
                      2774013407],
               'D2': [42466, 46847, 6079, 36221, 30265]}}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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