ИВБО-07-22

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

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

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

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

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

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

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

(b'mCBVU.\x00\x9d\xa9\xb8\x0cwV\x08\xaa\x81\xa2>Z\xb6X\xab\x96b\xc8le\xb9'
 b'\x9cwo\xf8*\xb0\xf9\xe8\xbf8\x18\xc7\xdec\xb6/\xe9\xeal\xca;6\xcaw'
 b'\xdc\xbf\xcfSI?$;Vt\x84\x00\xe2\xbf\xc7\xc5I>4\xc3\xf3\x9b9Ww/\xf3x'
 b'\xb4V\xd7\xa8!\x1a\x17\x8a\x01_\x84\x8cU\x01*9\x02\x16\x1dB\xb1\x945\xbc'
 b'\xa0\x84L\x03\x00"\x00')

{'A1': {'B1': {'C1': [{'D1': -0.4448113946556649, 'D2': 0.786435067653656},
                      {'D1': -0.5625631591991334, 'D2': 0.1970435231924057}],
               'C2': -15564,
               'C3': -25613,
               'C4': {'E1': 57,
                      'E2': [87, 119, 47, 243, 120, 180, 86],
                      'E3': [-22313, 6689, -30185, 24321, -29564, 341],
                      'E4': 14634,
                      'E5': 2,
                      'E6': 7446,
                      'E7': 66,
                      'E8': -0.011082814075052738},
               'C5': 160,
               'C6': 19588,
               'C7': [952101113, 1675544344, -353816650]},
        'B2': [-99, -87, -72, 12, 119, 86, 8],
        'B3': 0.31739550828933716,
        'B4': 7838623550697682522,
        'B5': 2006759781,
        'B6': 63599},
 'A2': -20438}

(b'mCBVU*\x00\xfd\xd4\xfa\xb7\xaa\t\x8e\xcb@\xca=\x00\x1ek\xd5*\xb7V\xa7%\xf3'
 b'\xdc\xf6\xc4\x00W\xb7\x89\x8e\xa7b\x18\xd9\xe8:\x0e\x0fE\x9d\xd6k'
 b'\xea?\x9c\xb9\xea\xbc\xaaS}-m1\xe9\xbf\x8b\xbc[\xbf\xa7\x06\xcb\x19\x03\x17'
 b'\x04\xea\xa1-q\x8eF\xe4OS\xcd\xedm\xa0\x82\xd2\xab\xda)\x93M\xd1G\xeb'
 b'\xb5\xa3\x86\xbe\xd5\xf0\xa9\x02\x00"\x00')

{'A1': {'B1': {'C1': [{'D1': 0.8256638595271129, 'D2': -0.028652958571910858},
                      {'D1': -0.7872835052936484, 'D2': -0.8583456873893738}],
               'C2': 1703,
               'C3': 6603,
               'C4': {'E1': 3,
                      'E2': [23, 4, 234, 161, 45, 113, 142],
                      'E3': [-7098, 21327, -4659, -24467, -11646, -9557],
                      'E4': 37673,
                      'E5': 77,
                      'E6': 18385,
                      'E7': 235,
                      'E8': -0.2629677355289459},
               'C5': 213,
               'C6': 43504,
               'C7': [1655148169, 988338456]},
        'B2': [-3, -44, -6, -73, -86, 9, -114],
        'B3': 0.09875639528036118,
        'B4': 12058026446928158208,
        'B5': -153291995,
        'B6': 196},
 'A2': -18601}

Вариант №2

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

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

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

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

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

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

(b'CDC\x11\x00\x00\x00\x02\x00\x00\x00A\xe2+/\xcf\xfb\xe9\xe1\\\xbfvF\xb8'
 b'?\x19\xc7\xb2\xbe\xe2\r\x8a?\x01\x121\xbfH\x00s\xb3\xbf\xd3\x01\xfaU+\xbd'
 b'\xf4\xbf\xc1s\x0b\xe2\x03t`?\xd1\xcf\x9e\xc3W4\xc8<\x80\x94\x8bm\x8b\x99'
 b'\xcaj\xdb8\xc7+\xa6n\x85ZoH\x0b\x16\x04\xe3\x04\xb6\x9f4&\xcb\xd4\xdf'
 b'\x92S\xf0\x1dD\xc3Zu W\xce\n\xc1)\x8a\xaa"\xda\x959\xe0\x18.\x96'
 b'\x00\x08\x00\x00\x00S')

{'A1': [{'B1': 1015059595, 'B2': 1837865418, 'B3': 106},
        {'B1': -617035989, 'B2': 2792260954, 'B3': 111}],
 'A2': {'C1': -2149571826808135332,
        'C2': [-0.9620165824890137,
               0.6007033586502075,
               -0.44150954484939575,
               0.504183828830719],
        'C3': 48968,
        'C4': {'D1': 970987566,
               'D2': -106,
               'D3': [1208686084,
                      -486230369,
                      874957780,
                      -544058384,
                      491045722,
                      1965053902,
                      180431242,
                      -1440556395]}},
 'A3': -77,
 'A4': [-0.2969957191225767, -0.13632343803229485, 0.2782971294044043]}

(b'CDC\x11\x00\x00\x00\x02\x00\x00\x00A\xa4\xfb\xda\x84\xd3\x8a\x98X'
 b'\xbe\xb0\x12(\xbe\xec%\xa1>\xd5\x88\xc8?\n\x0c \xea4\x00k&?\xa7\xeb'
 b'\x19\xb7\xff\xf3`?\xe8\x8c\x02\x83R\xb5\x16?\xee\xf1*\x11\xbbL'
 b'\xb6\x08\x1f\xba\x99|@\x91#\x9e\x9d\xc6$,c\x11a\x9c\xa7>\xec_\x85\xd5'
 b'\x12\x9b\x1d\x99\xe3\xb1\x8f\xbb\xa3\x87nHB\xaah\xe1\x1c\x8c\xcb\xcd'
 b'\xf6\x07\x15}\x00\x06\x00\x00\x00S')

{'A1': [{'B1': 136297113, 'B2': 2084606243, 'B3': 158},
        {'B1': -1647958996, 'B2': 1662083484, 'B3': 167}],
 'A2': {'C1': -6558408168315381672,
        'C2': [-0.343888521194458,
               -0.46122458577156067,
               0.41705918312072754,
               0.5392475128173828],
        'C3': 59956,
        'C4': {'D1': -839514347,
               'D2': 125,
               'D3': [1055678341,
                      -720200931,
                      -1713131121,
                      -1146910866,
                      1212328552,
                      -518222645]}},
 'A3': 38,
 'A4': [0.04671554919330023, 0.7670910420326063, 0.9669390055008964]}

Вариант №3

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

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

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

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

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

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

(b"\xd9SSM\xec\xa6$\x00'\x00*\x00-\x000\x00Uo\x04nqrX\x93|\xd6?\x00\x88\xa6<^"
 b"'\xc9\xf7x\xe3\x83\xbeX\xbb\xa7\xd5\xc0\x0f\x9f\xf1\x87\x9f.l\xb8"
 b'\xd1\xfc\xf6\xd0>#jrD1\x8bayggrmgp\x03\x00\x00\x003\x00\x05\xb7.\x8ef\xc6U'
 b'\xcb@\xb8\x91\xf9\x04\x9c\x97\xcf\xf4\xe3g\x9d\x1c\x94\xd6?\xe0\x94\n'
 b'\xed\xb5\xb5\xb3\xbfT\x84\xff\x06oA\xd5\xbf\xdc\xad\xee,P\x99\xea'
 b'\xbf\x8e\xd2U!\x01G\xe4?\xacjI?\xbcf\xe5\xbf\xa0\xca\x14D6\x82\xd5?\x1fx\xc5'
 b'[\xc45\xafp')

{'A1': 42732,
 'A2': [{'B1': -31773, 'B2': 190},
        {'B1': -17576, 'B2': 167},
        {'B1': -16171, 'B2': 15},
        {'B1': -3681, 'B2': 135},
        {'B1': 11935, 'B2': 108}],
 'A3': 85,
 'A4': 1903035503,
 'A5': 114,
 'A6': 3598488408,
 'A7': {'C1': 'ayggrmgp',
        'C2': [-151203400, 1780694736, -1959705486],
        'C3': {'D1': -3794908967215384827,
               'D2': -107890624,
               'D3': 3482819588,
               'D4': [0.3527900254408103,
                      -0.07699143445150325,
                      -0.3321187561360308,
                      -0.8312149884781621,
                      0.6336675311163888,
                      -0.6687909351415633,
                      0.3360725083213456],
               'D5': 8119767770641823775}},
 'A8': 8716656774720824968}

(b"\xd9SSM\x12\xcf$\x00'\x00*\x00-\x000\x00\xcfl\x97<\x81^\x85v\x1f&C\x00"
 b';\xf3\xfaaXG>s\xe6\xc7U\x83yiz+\xaa\x8a\xa2\xb0^\xa1\x9e\xef\xd5\x96\xcf\xa7'
 b'\x08\xddY\xd8\xb8\xd8\x81F\xa0,-wmxaluok\x04\x00\x00\x003\x00\x8d\xc7\xca'
 b'\xfc\x812\x8c\xa4{\x04-\xebU\xa8\xe4\xc80\x98o\xc3\xc5\x05\xb2?\xfe\x96\xce'
 b'\x9b\x85\xfa\xe0?\x80\xec\xbc?\\g\xa0?\xc8\xa6dh\x8a\x90\xd8?@\xc3:'
 b'\xab\xd0\xb8\xda?\xb0\xb8(h\xdd\xf5\xea\xbf\xc0\xabR\x96\x8f.\xcb?K\xc9\xec'
 b'\x89s\x98\x1f\x92')

{'A1': 53010,
 'A2': [{'B1': -14362, 'B2': 85},
        {'B1': 31107, 'B2': 105},
        {'B1': 11130, 'B2': 170},
        {'B1': -23926, 'B2': 176},
        {'B1': -24226, 'B2': 158}],
 'A3': -49,
 'A4': -2126735508,
 'A5': 94,
 'A6': 639596165,
 'A7': {'C1': 'wmxaluok',
        'C2': [-812198417, 1507657895, -2116503336, 757899334],
        'C3': {'D1': -6589836620876560499,
               'D2': -349371269,
               'D3': 3370428501,
               'D4': [0.07040058156380335,
                      0.5305812876801779,
                      0.0320385768704563,
                      0.38382206148763176,
                      0.4175302192843908,
                      -0.8425128015858458,
                      0.21235842552172635],
               'D5': -7917441997891385013}},
 'A8': 8304153207844303675}

Вариант №4

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

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

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

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

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

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

(b'NAYWW\x00\x03\x00w%MR\xe1\xdb\xfd\xbe\xd5O[\x01\x1a\x00\x00\x00\x84U\xad\x03'
 b'\x18\x8b\x88\x05sF\xbd\xcd1u\x8e\x96\xf7\xbf\x08\x1c,?z^B?QP\xf3\xbd\x90\xb0'
 b'\xc2\xbe-\x86&\xbf\xea|\x9b3>\xd0\xf8?\x00\x00\x00\x9b\x1c\xe7\xe1JU6t\xb1Vp'
 b"\xafwHA\xb7\xec>H\xd2\x06\xbfL\xeaM<\x8e\x7f'?~\x14\xac?\x1f\xe4\x8e\xbf\xe2"
 b'\xad\x0c\xe9!\x92\xf6\xf8oyb\x04\x1e\xbe\x18L\x8arE\x90\xb0\x00\x03\x00z'
 b'u\x00\x00\x00\x02\x00\x00\x00\x80P{\xce\x88\xd3\xac\xc0\xd0\xbd\xa3\x00'
 b'\x03\x00\x91\x15\x00\x00\x00\x02\x00\x00\x00\x97')

{'A1': 'oyb',
 'A2': 2687895682622013141,
 'A3': 20315,
 'A4': 282,
 'A5': [{'B1': {'C1': [1054, 48664, 19594], 'C2': 117, 'C3': [29253, 37040]},
         'B2': {'D1': 21933, 'D2': 51940232},
         'B3': 91440829,
         'B4': -13007,
         'B5': 1972279031,
         'B6': [-0.5316798686981201,
                0.9780007600784302,
                0.8176414370536804,
                -0.0706496387720108,
                -0.16945704817771912],
         'B7': -0.8277107239614727,
         'B8': 63},
        {'B1': {'C1': [20603, 52872, 54188], 'C2': 21, 'C3': [49360, 48547]},
         'B2': {'D1': 7399, 'D2': -515222218},
         'B3': 1957779056,
         'B4': -20617,
         'B5': 1212266476,
         'B6': [0.1961136758327484,
                -0.8004501461982727,
                0.017394615337252617,
                0.9925029277801514,
                0.6245812177658081],
         'B7': -0.5836243203490017,
         'B8': -8}]}

(b"NAYWW\x00\x03\x00w\xe2E\x1b\xf4\x8f\xb7\xae'a\x97\xd3\x8a\x00\x00\x00"
 b'\x82\x8e\xd1\x8e\xa7\xb3\xa8\xce\xcc\x15\x05\xca\xf7|\xea\xc5\x02\xbf`^'
 b'/?\x05fO\xbd\x00\x90\x9a?o\xc0O\xbfB\x1d[?\xca\xbe\xe1\xdc\xfbm'
 b'\xf8\x1c\x00\x00\x00\x97/\x80\xb1db\xe7\xf0\x8eB\xfd\x97\xf2u\xa5u+\xbf\x13'
 b'i\x9d>\xe8L\xaf?`\xf8\xfe\xbe\xd4]%\xbd\xd51\xec?\xe0Y\xc0z\xf2@\xfa\x11c'
 b'fpP\x15id\x95\xd2\xc8t\x00\x02\x00z\xbb\x00\x00\x00\x02\x00\x00\x00~P'
 b'\xf7\x86\xea\x822\xf2\x8b\x00\x02\x00\x8fC\x00\x00\x00\x02\x00\x00\x00\x93')

{'A1': 'cfp',
 'A2': 16304468763161898535,
 'A3': 24983,
 'A4': -11382,
 'A5': [{'B1': {'C1': [20501, 26980], 'C2': 187, 'C3': [38354, 51316]},
         'B2': {'D1': 36561, 'D2': -1901612120},
         'B3': 3469481221,
         'B4': -13577,
         'B5': 2095760642,
         'B6': [-0.8764371275901794,
                0.5210923552513123,
                -0.03138790279626846,
                0.9365281462669373,
                -0.7582604289054871],
         'B7': 0.20895026483672985,
         'B8': 28},
        {'B1': {'C1': [20727, 34538], 'C2': 67, 'C3': [33330, 62091]},
         'B2': {'D1': 12160, 'D2': -1318821145},
         'B3': 4035855101,
         'B4': -26638,
         'B5': 1973777707,
         'B6': [-0.5758302807807922,
                0.45371004939079285,
                0.878799319267273,
                -0.4147731363773346,
                -0.10409912467002869],
         'B7': 0.5109560395522117,
         'B8': 17}]}

Вариант №5

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

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

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

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

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

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

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

(b'UYNRXD\x8a\x91,\x0f\xda\xd9\xb4+Gxs@\xf9\xbe\x01R\xdbs\x00\x02\x00\x00'
 b'\x00|\xbfc\xe5\xc8(\x05\x06\x00\x1a\xfa\xee\xbc\x14\x8a@{\xe6\xc7N\xca-\xa3'
 b'\x9a\xde\x81\xf5\x00\x04\x00\x84\xce\xd9\x88r\x1e5\xbf\\.e\xbe\xd7\x8eP\xbfz'
 b'RI\xc6\x0b\xa5,\xcc\xd3"p\x05\xbf\xcc\xe6\x98b_:\x08\xdcy\xdas\x89'
 b'\xd7\xce\x93e\x19\xc3\xb2\x83\xbf\xc02A \x0c\xa2p\x1b[\xda%Sl\x18\x88'
 b'\x00\x00\x00R\x00\x00\x00g\x96\xab(l5i\xaeA')

{'A1': 22596,
 'A2': -30063,
 'A3': 11279,
 'A4': 218,
 'A5': {'B1': -2759533085707779847,
        'B2': -0.1262926310300827,
        'B3': 115,
        'B4': [{'C1': 52435,
                'C2': 8816,
                'C3': 5,
                'C4': -0.2257872085887842,
                'C5': 15886969350294851219},
               {'C1': 25881,
                'C2': 50098,
                'C3': 131,
                'C4': -0.12653364243421406,
                'C5': 1971409115752962184}],
        'B5': -0.002428904466939441,
        'B6': {'D1': {'E1': 6906,
                      'E2': 17202647260668356295,
                      'E3': [20170, 11683, 39646, 33269],
                      'E4': [-26965, 10348, 13673, -20927]},
               'D2': [206, 217, 136, 114, 30, 53]},
        'B7': [-0.8600829243659973, -0.4210076332092285, -0.9778180718421936],
        'B8': -972315348}}

(b'UYNRS\x16\x90\xac\\\x9f0e\xe3J\xae>vg\xe6\xbe/C%\xbd\x00\x02\x00\x00'
 b'\x00|?\xea\xc6\x8c\xaa\r\x08\x0c\xa4\x15\xb45N\xc3* }/@\xb2\xeb\xd1'
 b"\xc0\xcfM<\x00\x02\x00\x84L\xf7\xd2\x97+y?b,#?/\xe9\x1d\xbe*@\xc4Z'"
 b'\xd1\xc3qm\xab\x02\x8c?\xe6\x19sk\xefE\x02\x96z\xfe\x05\x08\xdc\xfb3\x96'
 b'\xc6\xb9\xeb\xbf?\xcd\xcc\x9d\xb8\x1ct\x982r\xcb_\x05\xd8\xcb\xee'
 b'\x00\x00\x00R\x00\x00\x00g\xa9g]q')

{'A1': 21270,
 'A2': -28500,
 'A3': 23711,
 'A4': 48,
 'A5': {'B1': 7341793929776752614,
        'B2': -0.17115457355976105,
        'B3': -67,
        'B4': [{'C1': 29037,
                'C2': 43778,
                'C3': 140,
                'C4': 0.6906067951296395,
                'C5': 10843258350424881971},
               {'C1': 38598,
                'C2': 47595,
                'C3': 191,
                'C4': 0.2328068875293965,
                'C5': 3635191458221837294}],
        'B5': 0.83673699582164,
        'B6': {'D1': {'E1': -23531,
                      'E2': 12985371700725054767,
                      'E3': [16562, 60369, 49359, 19772],
                      'E4': [-22169, 23921]},
               'D2': [76, 247, 210, 151, 43, 121]},
        'B7': [0.8834859728813171, 0.687150776386261, -0.166262686252594],
        'B8': 1512559043}}

Вариант №6

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

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

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

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

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

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

(b'ZWJP\xc2J\x00O\x00T\x00Y\x00^\x00c\x00h\x00m\x00\xb1\xe1\xa7b\x13sO'
 b'\x03;\xba6\xdb\x07\xc6\xe7C\xcf\xea\xca\xda\xdd\xc6\x8a\xc5\x07\x8a\xac'
 b'0\xe1\x07\x00r\x00\x00\x00\xa3\xc5\xe3>\x1al<?\x02\x00y\x00\x00\x00{\x00'
 b'e}\xa8#\x89,uMZzl\xa4\xd0\xba\xb0\x1e\x1a\xb3\x0c\xf6\xbf\x83C\xed\xa57+\xbb'
 b'K\xdf,\x8celoQZw\xcc\xc8\xe5mjaglcgvrf\xf3\xed_Lp\xb4\x8d\xe4j\xeep\x8d\xa2'
 b'\xde\x85\x0b\x01\xfd\x87\x80\xf6pMw\xad\xee\xe9\x0c\xfe\xa3u9\xb12y\xf9\x9c'
 b'\xbd\x9eV\xf7\x0e\xb0pX0\xa1\x16\xc8~f4R\xd0Y\x06\x9e\xb5O\xbb\xea\x81}f\x91'
 b'++o')

{'A1': {'B1': [{'C1': 747185064, 'C2': 117},
               {'C1': 1819957837, 'C2': 164},
               {'C1': 514898640, 'C2': 26},
               {'C1': 3220573363, 'C2': 131},
               {'C1': 933621059, 'C2': 43},
               {'C1': 752831419, 'C2': 140},
               {'C1': 1366256741, 'C2': 90},
               {'C1': 3855142007, 'C2': 109}],
        'B2': 1655169457,
        'B3': 19,
        'B4': 566106351647018867,
        'B5': -2460431136556062778,
        'B6': -2220084907457803578},
 'A2': 'jaglcgv',
 'A3': 0.44486722350120544,
 'A4': 0.7360244989395142,
 'A5': 'rf',
 'A6': {'D1': 1281355251,
        'D2': 3834492016,
        'D3': [830314496058781290,
               8596651467740806401,
               4140395743970717357,
               6241634615480103601,
               1630637696490671863,
               457625888639844040,
               7385201809122375070],
        'D4': 1865100177},
 'A7': 32101}

(b'ZWJP\xc2J\x00O\x00T\x00Y\x00^\x00c\x00h\x00m\x00`\xf2\x00\xff\xc3\x84e^7}F'
 b'p\x16x\xa5\xd3\x12\x82h\xde\xdd\xba\xab\x16\xf8z\xb1\x07\xb8\x06\x00'
 b'r\x00\x00\x00\rj\xc5\xbe\x07e\xc0\xbe\x02\x00x\x00\x00\x00z\x00\x03HK\xde'
 b'\x1d+,[Y\xcf"\xb6dtS)\xc2\x07\x8701Xu8^/w~H\x95K/\x92\xcb\xaa\x95'
 b'y\x9c\xbd\xf6\xd5lsczbiqrs\xe0nM$@\x1f\xed\xe6+\x93P\xe2eO\xd2A\xd9.'
 b'\xf3Y\x9aY\x84Yd$\x1eZ\xbeA\x96\xde^\xfd_\xa1\xb8s\x93\x1a,\xd3'
 b'\xda\xee\r\x8d\xfaI{\xda\xf6\x00\xd3Pn\xe9\xb0\xa7\xcc\x8d\x82\xf4'
 b'\xe3\x12\xe8\xce\xc1\x9e')

{'A1': {'B1': [{'C1': 723377739, 'C2': 44},
               {'C1': 584014171, 'C2': 182},
               {'C1': 693335140, 'C2': 194},
               {'C1': 825263879, 'C2': 88},
               {'C1': 794703989, 'C2': 119},
               {'C1': 1268074622, 'C2': 47},
               {'C1': 2510998418, 'C2': 121},
               {'C1': 3589717404, 'C2': 108}],
        'B2': -16715168,
        'B3': 195,
        'B4': 1616869769839797636,
        'B5': -2459413438626814600,
        'B6': -5185981304187475014},
 'A2': 'sczbiq',
 'A3': -0.38557472825050354,
 'A4': -0.37577077746391296,
 'A5': 'rs',
 'A6': {'D1': 609054432,
        'D2': 3874299712,
        'D3': [4742940656581776171,
               6450379085770338009,
               -2407664664971434908,
               1915001503381192030,
               5330728199927812908,
               -1626273548249671045,
               1361200353957947312],
        'D4': -1631465752},
 'A7': 18435}

Вариант №7

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

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

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

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

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

Поле	Описание
1	uint16
2	uint8
3	double
4	int16

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

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

(b'CIH\x86\x00\x00\x00\x9c\x1d\xf0\xaa\xf8\xd5?\xea\xdc\x844\xb4\x9c'
 b'\xe8\x91\x13\xe0\xc5\x1fc+3N-f\xb8\xdaQ>\x8e\xf4I>\x03y\xf4\xbfl}\x84\xbe'
 b'\xa5\xbfx=\xef\xce`\xe3\xcd\x00\x00\x00\x03\x00\x00\x00\x175\x1d\x8c'
 b'\x8a\x00\x00\x00\x05\x00\x00\x00#\x07\xcdj\x86\xbf\xb6\xbd\xae\xcd\xe0\xc2'
 b'\xe0,%\xd9S3\xb8i\xe3\xe6\x9d\xbe\x9fz\xba\xbf\x06*\x8a?Jw4\xfbz\x00\x00\x00'
 b'\x02\x00\x00\x00[\xd7\xbe29\x00\x00\x00\x03\x00\x00\x00c\xe8\xb29-\x8eN\xd7'
 b'\xa6\xa0\x9b\xa3\xf5\xd7\xc6>?\xd0\x12\x88\xa9X\xbf\xc4CxJ\x12\x00\n\x95\xd8'
 b'J\x007E\x07Jo\x00N%\x8d\x97\x00o^\x00\x03\x00\x00\x00\x86\xab\x00\x00'
 b'\x00\x92')

{'A1': {'B1': [{'C1': 67,
                'C2': 120,
                'C3': 18962,
                'C4': {'D1': 43768,
                       'D2': 213,
                       'D3': 0.8394185094265625,
                       'D4': -28397},
                'C5': -27176,
                'C6': 74,
                'C7': {'E1': -7219,
                       'E2': [-523952285, 724782637, 1723390545],
                       'E3': 13597,
                       'E4': 35978,
                       'E5': [0.2792074978351593,
                              0.12839490175247192,
                              -0.9237902164459229,
                              -0.3237264156341553,
                              0.11709284782409668],
                       'E6': 7}},
               {'C1': 69,
                'C2': 7,
                'C3': 19055,
                'C4': {'D1': 52586,
                       'D2': 134,
                       'D3': -0.08883183027570452,
                       'D4': 11301},
                'C5': 9613,
                'C6': 151,
                'C7': {'E1': -1158,
                       'E2': [-648858696, 1776543389],
                       'E3': -10306,
                       'E4': 12857,
                       'E5': [-0.3114832043647766,
                              -0.524086594581604,
                              0.7908813953399658],
                       'E6': 232}}],
        'B2': 94,
        'B3': [2990091662, 1322755744, 2611213783],
        'B4': -85,
        'B5': {'F1': 50750, 'F2': 0.2511312154556402}},
 'A2': 7664}

(b'CIH\x86\x00\x00\x00\x8c\xd2\x93^hJ\xbf\xeb\xc8\r\xf9G\x1c\x00\xaa\xbf\x99'
 b'=\xb2\n[%\xb1\x85\xbe\xf8q\x07\xbe\xfc\xab\x9e\xa8\xbf\x00\x00\x00'
 b'\x02\x00\x00\x00\x17Z\xc4J\xa7\x00\x00\x00\x02\x00\x00\x00\x1f\xfa\xcds'
 b'\xac\xbf\xbd\xbb\xd0\x8a\xbes\xb0\x11y\xfa/G\x8d/Ros\xbf|\x15\r\xbf~v@?'
 b'g\x0f\xa7\x81+\x00\x00\x00\x02\x00\x00\x00K\xfc7\x99\xa0\x00\x00\x00'
 b'\x03\x00\x00\x00Sj4\xdf\xcb\xae\x8e\xb8\xf6\xb2\x0e\xa5\x89\xbfQ\xfc'
 b"\xbf\xe0(\xc7\xd5\xea\xa3\xc4/\xbf \x88\x00\n\xd4O\xda\x00'\x8e\x11\x1b2\x00"
 b'>\xe8\xf9\x8d\x00_\x1e\x00\x03\x00\x00\x00vm\x00\x00\x00\x82')

{'A1': {'B1': [{'C1': 47,
                'C2': -65,
                'C3': 8328,
                'C4': {'D1': 24168,
                       'D2': 74,
                       'D3': -0.8681707256990876,
                       'D4': -21825},
                'C5': -11185,
                'C6': 218,
                'C7': {'E1': -22337,
                       'E2': [-1724009974, 1529196933],
                       'E3': 23236,
                       'E4': 19111,
                       'E5': [-0.48523733019828796, -0.493496835231781],
                       'E6': 250}},
               {'C1': 142,
                'C2': 17,
                'C3': 6962,
                'C4': {'D1': 52595,
                       'D2': 172,
                       'D3': -0.1161470736246446,
                       'D4': 4473},
                'C5': -5895,
                'C6': 141,
                'C7': {'E1': -32469,
                       'E2': [-97564787, 793931635],
                       'E3': -969,
                       'E4': 39328,
                       'E5': [-0.9846962094306946,
                              -0.9939918518066406,
                              0.902582585811615],
                       'E6': 106}}],
        'B2': 30,
        'B3': [887081902, 2394486450, 245729727],
        'B4': 109,
        'B5': {'F1': 20988, 'F2': -0.5049781015451278}},
 'A2': 53907}

Вариант №8

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

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

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

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

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

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

(b'\xeeDKZH\x9caT?\x15:\x17\xa3\xd4\x9f\xdb\xeb.\x00\x00\x00z\x03\x00'
 b'\x00\x00\xb1\x00\x00\x00u:\xa9>\xa8\x9b\xd2\xbb\x08\xb1\xe0?df6\xb1\xe0\x02'
 b'\x00\x00\x00*\x00\x00\x008\xd5uJW\x9b\xda\xbfm\xa8\x81$\xf9\x9e\x84\xbe<'
 b'\xfc]l$\xc6\x90\xbe\xddv\xc0\x7f\xb2\xce\xa3>\x91\x9eN\xc5\x8d\xf8_\xbf\xa1'
 b'\xa5\xfb\x16j\xfc\x03?Dx\xec\xbe\x02\x00\x00\x00,\x00\xea\xa4R.\xa2\x84\t'
 b'\x0cj\x92`\xcd}O\xbb\xf2l\t1\x13K\xe7\x9f3Pc\nA\x8dc\xbc\x05\xde\xd9x'
 b'E\xfd<\xe9\x14\xae\xb3\xc3^;*\xde\xac\x99\xe6\xf9!!\x82\x0e\xe2\xc7D\xeb'
 b'\xfa|\xe5YI\xcd\x81\x9c\x88\xb5\x96')

{'A1': 0.8296144008636475,
 'A2': 16995353354430790165,
 'A3': {'B1': -32,
        'B2': 'df',
        'B3': -0.4157312609816759,
        'B4': [{'C1': 612477037, 'C2': -0.25902536511421204},
               {'C1': 1818098748, 'C2': -0.28276169300079346},
               {'C1': 2143319773, 'C2': 0.3199363350868225},
               {'C1': -984703343, 'C2': -0.8748863339424133},
               {'C1': 385590689, 'C2': 0.5155702829360962}],
        'B5': -0.46185505390167236,
        'B6': [54, 177],
        'B7': {'D1': 42218,
               'D2': -2069746094,
               'D3': 5727960115742116873,
               'D4': [158134971,
                      3880457009,
                      1666200479,
                      1670201610,
                      3655206332,
                      1023231352,
                      3014530281],
               'D5': 708533955,
               'D6': -426136354,
               'D7': 4956178466885149177,
               'D8': 64235},
        'B8': 1230628220},
 'A4': 122,
 'A5': [-32307, -30564, -26955],
 'A6': 0.33052411675453186,
 'A7': 0.5216106098567836}

(b'\xeeDKZH\t\xc9\xb3\xbd\x9byo\xc0\x1b\x876\xe2.\x00\x00\x00\xf8\x03\x00'
 b'\x00\x00\xb1\x00\x00\x00\xb7z\x9e\xbe<\xc6\xf7P\xef\xed\xdd?qnj\xf8\xc7\x02'
 b'\x00\x00\x00*\x00\x00\x008\xf7\xeb\xc2e\x02\xe4?\xf1\xcb<\xa2\xb9{\x03\xbfk'
 b'\xce\x95\x8d\xa5\xbc\x8a>\x12Jv\xaea\x10F?xM\xc9y\xe2[$\xbf3\x02\x97O\xe3'
 b'WQ?iI\x84\xbd\x02\x00\x00\x00,\x00#\x97\xd5\xd1\x8dA\x8a\x9cNu\xd2'
 b'\xf42\xe8\xe5\xf95\x11\xaa(h?\xcb\x8epZ\xd4\xc1D\xd0;\xb8\xb8\x01\x1d'
 b'\x03\x16\x95\xb9\xc5\x99\xb0\x8b\x855\xe8$\x01W1\x8eigO/\xc3+\x95\x9c'
 b'\xac\x15\xb9s#w\x80HRT\x86')

{'A1': -0.08778578788042068,
 'A2': 16300364454576486811,
 'A3': {'B1': -57,
        'B2': 'qn',
        'B3': 0.6252926642480139,
        'B4': [{'C1': -1573073935, 'C2': -0.513606607913971},
               {'C1': -1919562133, 'C2': 0.27097049355506897},
               {'C1': -1367979502, 'C2': 0.7736874222755432},
               {'C1': 2043235704, 'C2': -0.6420270204544067},
               {'C1': 1335296563, 'C2': 0.8177472949028015}],
        'B5': -0.06459314376115799,
        'B6': [106, 248],
        'B7': {'D1': 38691,
               'D2': 1099813333,
               'D3': 16731704750383209610,
               'D4': [288750053,
                      1063790762,
                      1517326027,
                      3494166996,
                      28883003,
                      2501247773,
                      2962867641],
               'D5': 3895821707,
               'D6': 827785508,
               'D7': 10748899543612877198,
               'D8': 44188},
        'B8': 594786581},
 'A4': -8,
 'A5': [-32649, 21064, -31148],
 'A6': -0.30952998995780945,
 'A7': 0.4676473894788591}

Вариант №9

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

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

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

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

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

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

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

(b'\x07GGCV*\x1b\x00\x00\x00[>\x0f?\x19\xa1\xa1\xbf\xcduC\xc5\xcd)p\x8aC\x00'
 b'tf\x97\xbf\xd84\xa4\xf4\xf9#\xb4\x00\x00\x00\x02\x00\x00\x00\x81\xbf'
 b'*\x83\xc4\x00\x00\x00\x06\x00\x00\x00\x89gicshufb\x07\xbf\xd68\xb9\x15\x87-X'
 b'>\x9c&Q\xbf\xe95\xc28\xda\xc0r\xb0\x86!\xefy\x00\x08\x00\x00\x00;\x06'
 b'\xb8M\x00\x02\x00\x00\x00C\xafE\xec\x06F\x9a\x13a\xbe\xa9\xd1+N{\xdcs'
 b'\xc7\xef)M4>\xa6z\xbf\xbfO\xac$\xa3j\x97^\xaf\xa1')

{'A1': 10779,
 'A2': {'B1': 61305,
        'B2': 'gicshufb',
        'B3': 6,
        'B4': 47181,
        'B5': [{'C1': 7, 'C2': -0.34721209623667937, 'C3': 16028, 'C4': 38},
               {'C1': 81, 'C2': -0.7878123388709481, 'C3': -20346, 'C4': 33}],
        'B6': -20667,
        'B7': 3959834266,
        'B8': 4961},
 'A3': 15887,
 'A4': {'D1': 0.6001225113868713,
        'D2': -0.23014113577148576,
        'D3': -30141,
        'D4': {'E1': -0.3316739499568939, 'E2': 78, 'E3': 8925135864089627956},
        'D5': 26263,
        'D6': -0.37821315692104496,
        'D7': [0.32515522837638855, -0.8112204074859619],
        'D8': -0.6660730838775635},
 'A5': [163, 106, 151, 94, 175, 161]}

(b'\x07GGCV,\x14\x00\x00\x00X\xe5\x0c\xbe7>\x80\xbf\xe2\xf4\xe3r\xf6^2\x12m\x00'
 b'q\xcb\x1f?\xe7\xba\xfe\x94\x86\xead\x00\x00\x00\x02\x00\x00\x00~?r\x97S\x00'
 b'\x00\x00\x04\x00\x00\x00\x86zurde\x87\xbf\xe9\xb4\x9e-\xb4\x15\x16\xf8^S'
 b'\xc7?\xde-,_\x0c\x9f\x10\x05\xd5\x96\x11%\x00\x05\x00\x00\x00;'
 b'\x8d\xe6\xd3\x00\x02\x00\x00\x00@GU:+a\xe1\x80\xdd?9\x81\x95\xf3Aa'
 b'\x9d\xde\x1f\xa6\x10\xc6\xbf\x01\x17#\xbc\xa8G\xb8_\x1f\x14\xce')

{'A1': 11284,
 'A2': {'B1': 4389,
        'B2': 'zurde',
        'B3': 141,
        'B4': 59091,
        'B5': [{'C1': 135, 'C2': -0.8032980816502995, 'C3': -1954, 'C4': 83},
               {'C1': 199, 'C2': 0.4715071609702912, 'C3': 1493, 'C4': -106}],
        'B6': 18261,
        'B7': 975921633,
        'B8': 32989},
 'A3': -6900,
 'A4': {'D1': -0.17894935607910156,
        'D2': -0.5923936124190219,
        'D3': 4717,
        'D4': {'E1': 0.724633514881134, 'E2': -13, 'E3': 4711220262545526982},
        'D5': 51999,
        'D6': 0.7415764714163058,
        'D7': [-0.5042592883110046, -0.02054201066493988],
        'D8': 0.9476215243339539},
 'A5': [95, 31, 20, 206]}

Вариант №10

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

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

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

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

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

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

(b'\x89JEPX?gE\x80\x00\x00\x00\x02\x00\x00\x00O2\x0b\xdeQ\x7f\x17\xa3'
 b'\xb7\x17\xce\xdfSz\x8e\xff\x95\x0cR\x0e\x191\xf2 x\x9b.)\xe7~\x9f\x8b'
 b'\x89\xc2\x16\xf2\xe6\xa3\xb6\xc9Vt\xcd\x17\xb8\xb1u\xb7\xe3\x00\x00\x00'
 b'W\x00\x00\x00\x02\x00z\xbe\x1f\x18Lmj\xc7\xb3\xdbV?k\x11\xd3\xcb:\xad'
 b'\xfdE\xec\xe4\xf7 \x03\xdd\x06\x97N\xbb$\xcf#\x1d=\xd9\x80g\xbd\x7fb\xb9'
 b'\x00\x03\x00\x00\x00Q\x0e\xea')

{'A1': {'B1': 0.9034042358398438, 'B2': 'mj', 'B3': 3606220368246186935},
 'A2': 1715554057706209173,
 'A3': 887787577920331896,
 'A4': -1691473433,
 'A5': [{'C1': 9124164793858978534, 'C2': -23626},
        {'C1': 14507911673835729269, 'C2': -18461}],
 'A6': {'D1': [299092794, 2919056876, 3841400835, 3708196686, 3139751715],
        'D2': 29,
        'D3': 4456734489309045433,
        'D4': [-14413, -9386, 16235]},
 'A7': [14, 234],
 'A8': -0.15536612272262573}

(b'\x89JEPX\xbf\t\xac\x92\x00\x00\x00\x02\x00\x00\x00O\xc5\xd8\xbf\\f\xf94'
 b'\xa8\x1e\xab\xdfc\xb4\xf6\x8bw\xe51\xd6\xe0\\N\xff<\xf4H`4hr\x8b'
 b'\xd3\x0e\x1f\xe1A\xe8+ZeK\xeb\xe3h\xa76$\x05\x00\x00\x00Y\x00\x00\x00'
 b'\x02\x00|>\xe3Nvuu\xf96\xb1\x1a\xaa<X\x16\x9c\xe3\x07\xbcp\x9f\xd2'
 b'\xc3\r\xdab,\x0cJ\x17\xa8g^\xfb&\x06\xbd\x08H\xa6\xce[\xcab\x00\x04'
 b'\x00\x00\x00Q\x90C')

{'A1': {'B1': -0.5377894639968872, 'B2': 'uu', 'B3': -4190389049682742104},
 'A2': 2210105661486173047,
 'A3': 16515217567654018876,
 'A4': -196583372,
 'A5': [{'C1': 7526231665880850753, 'C2': -6101},
        {'C1': 6513695912565974838, 'C2': 9221}],
 'A6': {'D1': [2632124348, 1889522371, 232415788, 206182312, 1734277926],
        'D2': 6,
        'D3': -4825527119463593374,
        'D4': [-1738, -20198, -21956, 22550]},
 'A7': [144, 67],
 'A8': 0.44395798444747925}

Вариант №11

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

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

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

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

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

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

(b'VYYTdH[\xcaG\xc5\x0eO\x03\x00\x00\x00Q\x00\x00\x00\xfd\x9e%\xe0_\x08\x04R'
 b'\xb1\xcdi\x00\x00\x00Z\xe5\xb34k\xc2\xd3\xf4\x98\x91=E\x16\xdey\x19;\xbd'
 b'\xd9\xd2\xf6\xbd`\x9d*\xe41#\xc1!\xf6\xf9~\xc5\x13\xba\xad|\x0b\xa4\xaf\xae'
 b'\xe5M\xc8FM$\x00\x00\x003\x00\x00\x00B\x00\x00\x00\xed\xa7\x0fWz\xcb\xf3'
 b'\x9e\xf0\x9a\x8e4\xf8\xe8\x12\xfb\x12\xb7\xd5\xbf\x9e\xdeSu\x03\x00]'
 b'\x00\x00\x00\xd5GQ')

{'A1': 5696707490798585956,
 'A2': [{'B1': 13491,
         'B2': [107, -62, -45],
         'B3': 39156,
         'B4': 4258568917418851729},
        {'B1': 55741,
         'B2': [-46, -10, -67],
         'B3': 40288,
         'B4': 18011620873117754410},
        {'B1': 50558,
         'B2': [19, -70, -83],
         'B3': 2940,
         'B4': 5568358226181664676}],
 'A3': -3,
 'A4': {'C1': [-98, 37, -32, 95, 8],
        'C2': -844017148,
        'C3': {'D1': -0.33929895895893436,
               'D2': 1968430750,
               'D3': [1460643821, 2666777466, 881761008],
               'D4': 18389,
               'D5': 81}},
 'A5': 58714}

(b'VYYT:]\x82~\x9eMb\xdc\x02\x00\x00\x00B\x00\x00\x00n`\xf2\xab"\xffDk'
 b'\xee8R\x00\x00\x00\xa7c\x84\xfe\xa7R@*\x14\x8dbE\x1d\xe1+m\x8b\xd8'
 b'\xc9\xdd"\xf9\xa0\x9e\xe7\x8bd)\xe4)\xc2\xa2$\x00\x00\x003\x00'
 b'\x00\x00\x97\x0f\\\xef\xc4\xf5\x1dfR\x1e\xa8j\x05\x9e\xe7\xbfyio\xcd\x02\x00'
 b'J\x00\x00\x008\xdb\xa0')

{'A1': 15880340579184434490,
 'A2': [{'B1': 65156,
         'B2': [-89, 82, 64],
         'B3': 5162,
         'B4': 10046734589592167053},
        {'B1': 51672,
         'B2': [-35, 34, -7],
         'B3': 40608,
         'B4': 11727982439549930471}],
 'A3': 110,
 'A4': {'C1': [96, -14, -85, 34, -1],
        'C2': 955149124,
        'C3': {'D1': -0.7380396922243995,
               'D2': 3446630777,
               'D3': [4015787927, 1713239492],
               'D4': 56120,
               'D5': -96}},
 'A5': 25511}

Вариант №12

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

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

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

(b'nNUD(\x00\x00\x00\xeb\xc4G$\x03\x00r\x00\xa8\xf0H\xdd\x17\x85*\xe3'
 b'\xeb\xa2\xe3\xbe\xf7\xaf\xbe>+\x80\x90=\xf00\x14?\xb4\xbe\x17\x0e'
 b'\xc4\xfe\xac\x97\xab:\xef\xee\xbb\x91\t\x8f\x98\xbf5\xbc\x04\xe9\x05>'
 b"\xc6\x97\xb9m\x04\x99\xef\xbe\n\xa5\xc1'\x93\x84P\x89\x9f\xb5\x8c\x9e"
 b'\x1b\xe9!\xc2\xb2\x98\xb6I;\xf6\x88\xe2e\xea\xe8\x11\x04\x00\x18\x00'
 b'\x00\x00C=\xab\x02p\x7f\xd0F<N7\x8c\xca\xfdZ$\xd1\xfbdD')

{'A1': {'B1': {'C1': 180,
               'C2': [{'D1': -1005709378, 'D2': [254, 172, 151, 171, 58]},
                      {'D1': -1849954577, 'D2': [9, 143, 152, 191, 53]},
                      {'D1': 99157180, 'D2': [62, 198, 151, 185, 109]},
                      {'D1': -1091593980, 'D2': [10, 165, 193, 39, 147]},
                      {'D1': -1618390908, 'D2': [181, 140, 158, 27, 233]}],
               'C3': 49697,
               'C4': -26446,
               'C5': -1556589018312128074,
               'C6': 4584,
               'C7': [-0.4446023404598236,
                      0.3724362552165985,
                      0.07055696099996567,
                      0.5788717269897461],
               'C8': [15683, 683, 32624, 18128]},
        'B2': 608683243,
        'B3': [2352434748, 609942986, 1147468753]},
 'A2': 16369042133174775976}

(b'nNUD(\x00\x00\x00[ /\x17\x03\x00r\x003\xd1\x04\xa7\xaa\x07-\x99\x18#\xe8='
 b'E\x13\xf5=\x86\xc4\x04\xber\x15.\xbfP~\xc9j\xa5\x92\xfeg\xd2\xb4\xedS'
 b'\x16\x96\x9bUo\xc4\xaa\xbf \xa2\xb4\xdc\x95E\xd8wr\x1d\xdd\xfc\x11\xaf%\x9e'
 b'\x83\xads\x151\x8b\x08\xb5G\x12ZBa\xef\xe6Bd\xef\xbe\x05\xd4\x7f\x8b\xea'
 b'\x04\x00\x18\x00\x00\x00\n\xb5%\x91<b|an)\xbd~U\x14d"p\xaa\xac\xce')

{'A1': {'B1': {'C1': 80,
               'C2': [{'D1': -1519728258, 'D2': [146, 254, 103, 210, 180]},
                      {'D1': -1776921619, 'D2': [155, 85, 111, 196, 170]},
                      {'D1': -1264443201, 'D2': [220, 149, 69, 216, 119]},
                      {'D1': -52617870, 'D2': [17, 175, 37, 158, 131]},
                      {'D1': 823489453, 'D2': [139, 8, 181, 71, 18]}],
               'C3': 16986,
               'C4': -4255,
               'C5': 9210993455497757414,
               'C6': -5493,
               'C7': [0.11334818601608276,
                      0.11966565996408463,
                      -0.12965592741966248,
                      -0.6800147294998169],
               'C8': [-19190, -28379, 25148, 24956]},
        'B2': 388964443,
        'B3': [2126326126, 576984149, 3467422320]},
 'A2': 11037486691282899251}

Вариант №13

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

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

(b'XHHM\x02\x00\x00\x00\x96\x00\x00\x00\xe4\x1b3\xc6\xba4\x0c\xa0\x11Qj\x9c'
 b'\x1f\xb0=\xec\x9c_\x11\xdd\xeb\x8b\xd4\x13\x93\xc0\xc4y\xde\xe6s=g7\\;'
 b'\xd1h\x0f`\xe1\x1dZ\xe0h\xc9\x05\x1b\xd4?\xff\x83\xd5]$or\xe15TWWB\xef'
 b":\xbcr\x82\xc2\xdc|\x88!\xde\x1a\\'\xd2\x13\xbepK\xe7\xbci\xe9\xbf\x98"
 b'T\x14a\x84<\xdf\xbfaoki\xa6\x1d\xfc\x1f\xb7s\xef\xbf\x9f3\\\x04\x00'
 b'k\x00\x00\x00\x84pye\xb0\xe3*"\xc8\\\xb7?\xbf<Q\x03\x00\x81\x00\x00'
 b'\x007o\x00\x00\x00\x84\x00\x00\x00')

{'A1': [{'B1': -0.9828754067138348,
         'B2': 13215,
         'B3': 92,
         'B4': 'aoki',
         'B5': -124},
        {'B1': 0.09125948747795465,
         'B2': 15551,
         'B3': 81,
         'B4': 'pye',
         'B5': 55}],
 'A2': 11532650722582797284,
 'A3': {'C1': 17,
        'C2': 81,
        'C3': [106, -100, 31, -80, 61, -20],
        'C4': 24476,
        'C5': 56593,
        'C6': 8774349711949990891},
 'A4': 4277354662647293662,
 'A5': 26833,
 'A6': {'D1': 14513096476854411279,
        'D2': 5,
        'D3': [2620485321099301915,
               4780385548669907567,
               8997280021105883887,
               1428247308371108232],
        'D4': [-0.7941574590181728, -0.48806867103969287]}}

(b'XHHM\x02\x00\x00\x00\x96\x00\x00\x00\xa1b.\xf1p\x1b2\xd0Ye\x163\xc2C\xdb\xff'
 b'|x\xbdF\xab\x0ey\xe6RU\n\xb2\xc8\xd4\x12\xef\x8c\x96b#\x08M\xd1yX\x89E\xe7'
 b"\r\x82\xe6 \x9e\xbd\xcd\x1b\xdb\xc9\xcd\xe8\xf4A'\xb4\xf2%/\x8aA\xeb\xfdx"
 b'c\xe33\x9b?o\x9c4\x1a\x9e\x90\xae)\xfe\xe4j;\xe9?Hmmw\xbc\xd2\xc1?aaju\xa2'
 b'\x06&\xa2Q\xbc\xec?7\x8e\xe2\x04\x00k\x00\x00\x00\xc7rqvX\xb7\x82\x89'
 b'\xf0F\xdf\xbf\x98O\xb7\x03\x00\x81\x00\x00\x00\xaco\x00\x00\x00\x84\x00'
 b'\x00\x00')

{'A1': [{'B1': 0.8979881445850035,
         'B2': -29129,
         'B3': -30,
         'B4': 'aaju',
         'B5': -57},
        {'B1': -0.4887048094632198,
         'B2': 20376,
         'B3': -73,
         'B4': 'rqv',
         'B5': -84}],
 'A2': 15002083480621179553,
 'A3': {'C1': 89,
        'C2': 101,
        'C3': [22, 51, -62, 67, -37, -1],
        'C4': 30844,
        'C5': 18109,
        'C6': 12829160303060651691},
 'A4': 2549765871095698632,
 'A5': 19720,
 'A6': {'D1': 9371400685470906833,
        'D2': -26,
        'D3': [14828624160556424736,
               3397388349487576296,
               3738941486954922378,
               10420795401047064475],
        'D4': [0.7885031197086414, 0.13924365836542507]}}

Вариант №14

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

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

(b'HRJm!\x9c\x08\t^M\x9f\x95N\x00\x00\x00\x85\x03\x00\x00\x00[\x00^'
 b'\x00\x00\x00\xd0\xc0\xed@\xc0U\xea\xbf\xf5\x8c\xa7\x81\x8d\xcb$\xd8?"0p\xb0'
 b'\xe6)\xe2?\xae\xeeT\x8f\xaf\x16\x13\xe4\xbf\xa6\xfeB\xfd\x8b_\xe3'
 b'\xbf8\xe0\xb2p\xcb\x87\xd1\xe5\xbfki#\xca\x1a?\x1b\x00,\x00=\x00\xc7a'
 b'fj\x14\xe9\x1b\xaeyK\xea\xbf\xe5\xfcE\xb3\xebw`j\x9e\xe3\xa0[\xe3a\xdbA,\x86'
 b'\xb0\xd6~\x05\x89od\xad\xaei\xdb7\xacWEW\xf9\x17\x03\xaa\xb6A\x93>')

{'A1': 11478934418129428845,
 'A2': 149,
 'A3': {'B1': 'ki',
        'B2': 0.6046468615531921,
        'B3': [{'C1': -0.8229676502360466, 'C2': -11, 'C3': 0.3772457963847209},
               {'C1': 0.5676148840007083, 'C2': -82, 'C3': -0.6273301533607574},
               {'C1': -0.6054134317891637,
                'C2': 56,
                'C3': -0.6818274472658139}],
        'B4': -57},
 'A4': -123,
 'A5': 'afj',
 'A6': {'D1': -0.8217132950369739,
        'D2': 7665258419993312485,
        'D3': 1537270686,
        'D4': 15470012244659233251,
        'D5': 7615214666809673086,
        'D6': [219, 55, 172, 87, 69, 87, 249, 23],
        'D7': 43523,
        'D8': 0.2876107096672058}}

(b'HRJ\xd9E>(\xaf\x1f\xe5\xe2\xc6N\x00\x00\x00\x12\x02\x00\x00\x00[\x00]'
 b'\x00\x00\x00^f\xb2P\xa3\x94\xe8\xbf"\xe0\xc2\x01\xb9\x16\xf3\xad?\x00A\t\xed'
 b'c)\xcc?d\xc0\x0e\xe6\xa4\xd9\x88\xa3?0A\x17\nT\xcb\xec?f\xb04\t\rk\xdd'
 b'\xc5?fv\xf0\xa8\x06>\x1b\x00,\x00=\x00\\uw\x88\xcf\xc0^Cb\xd6?\x98\xdf~'
 b'\x9a\xcf\xc7\xde\r\x05\xb7\xb5\x18\xa5\\,{\x98+1\xd6\x07\xa1\xfb'
 b'\xda$\xe9\x14Ps\xe6_\x07\x94]\xc6\x0cme\xfcY\x8c\xbd')

{'A1': 16349508859393361369,
 'A2': 198,
 'A3': {'B1': 'fv',
        'B2': 0.13150382041931152,
        'B3': [{'C1': -0.768144281016429, 'C2': 34, 'C3': 0.05849524505982173},
               {'C1': 0.22001313280134838, 'C2': 100, 'C3': 0.038153458956939},
               {'C1': 0.8998203465544403,
                'C2': 102,
                'C3': 0.17081964622994894}],
        'B4': 92},
 'A4': 18,
 'A5': 'uw',
 'A6': {'D1': 0.34974750760306295,
        'D2': 999455861786992536,
        'D3': 414562053,
        'D4': 15434165331876928677,
        'D5': 5770493367070466311,
        'D6': [115, 230, 95, 7, 148, 93, 198, 12],
        'D7': 25965,
        'D8': -0.06853100657463074}}

Вариант №15

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

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

(b'MKMJ\xdf@\xc0\xe8\xf2\xb2\xa4\xe8?\x03\x00\x00\x00\x16\x00W\x00\xdadx'
 b'w!\x1e\xecJ\xd0\xbf\xdc`\xb0\xe9\x10HSc6\xf4\xb9h*\x8a\xd8\xdfR=7\xa0S'
 b"v'\xd39\x95\xbcY\xa3\xb2\xe0\x9b\xa8\xc1cA\x07\xcb\x1ePQLq\x07Q\x82P\xe7\xee"
 b'\xe8\xe4\xcf\xddB\xfe\xf9\xf0\xf4!\xbf\x05\x00\x00\x00\x19\x00\x02\x007'
 b'\x00\x00\x00s\xad\x18\xd5\xb2\xf9\x9cF\x81\x1b\xd5\xbaR\x14\x91\xf5;'
 b'\x00\x03\x00\x00\x00K\x00\x00\x00S.\xe4\x81')

{'A1': -33,
 'A2': 0.7701048607177725,
 'A3': 'dxw',
 'A4': {'B1': -0.6326436996459961,
        'B2': [{'C1': 7713, 'C2': -1076868372},
               {'C1': 24796, 'C2': 1209067952},
               {'C1': 25427, 'C2': 1757017142},
               {'C1': 35370, 'C2': 1028841432},
               {'C1': 41015, 'C2': -752388525}],
        'B3': [-27335, 22972],
        'B4': [-719803021, 1184692658, -1160438911, -175041454],
        'B5': {'D1': 4711822565073531555,
               'D2': -13561,
               'D3': 1280397342,
               'D4': 113,
               'D5': 7},
        'B6': [3880813137, 3487885550, 4194190045],
        'B7': -2115752365},
 'A5': 218}

(b'MKMJ\xae\xb4\xd2\x9fH\xbe/\xd0\xbf\x03\x00\x00\x00\x16\x00S\x00\xdaix'
 b'c\xbbr\xd5\xc2\xa5M\x01\xd3/\xa6:d\xb3\x92j\xdcu\x9f\xecF\xe5ih'
 b'\xe4\x7f\xcb\x1dUF=\x1d)\x9b\x1a2{P\xfd\xee\x95\xed\xe4E\xe5\xd3\x00<'
 b'\x04\x0e\xc7\x03\x89\x9a\xf7W\x84J\x8f\x95O\x9e>\x05\x00\x00\x00\x19'
 b'\x00\x02\x007\x00\x00\x00\x99z\x88\xdb\xfaf\xc9\x88X\xac.$\x86\xd7\xaa\xb3;'
 b'\x00\x02\x00\x00\x00K\x00\x00\x003\x00nd')

{'A1': -82,
 'A2': -0.25291401951043757,
 'A3': 'ixc',
 'A4': {'B1': 0.3092009127140045,
        'B2': [{'C1': 29371, 'C2': 1302708949},
               {'C1': 54017, 'C2': 1681565231},
               {'C1': 37555, 'C2': -1619665814},
               {'C1': 18156, 'C2': -462919195},
               {'C1': 52095, 'C2': 1028019485}],
        'B3': [10525, 6811],
        'B4': [-611812711, -2000066822, 607038552, -1280649338],
        'B5': {'D1': 16496005863812660018,
               'D2': -6843,
               'D3': 71041235,
               'D4': 14,
               'D5': -57},
        'B6': [4154099971, 2404025431],
        'B7': 1684930611},
 'A5': 218}

Вариант №16

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

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

(b'\xa3DAW\x00\x02\x00\x00\x00,\xd8/\xf9\xca\xc3)\xe7D\xbf\xda&[[\xb1t\x882\x07'
 b'ww\x00\x00\x00\x02\x00\x00\x00\x90[\xc7rGJxcv\xd3\x9c\xb4\xe2\xbf-'
 b'\x00\x00\x00\x03\x00\x00\x00.\xd8\x85\xb2Ak\x03\xc1&\x19\xbf\xadI'
 b'\x9d\xff\xa93X\xea\xab#\xb5\xcdZ\x19\x8e2\x1c\xdb\xb9lX\x00\x00\x001\xb6'
 b'@\xd6 \xf6s\x00\x00\x00\x03\x00\x00\x00_\xfa\x18\x98r\xc4\xb7N\xef:u\xcc'
 b'\xdd%N\x87\xe9\xfds$\x13\x88\x15\xe5-D`\xaa\xe3\x87\xea\xde\x00\x00\x00b'
 b'\x00\x00\x00<\x00\x00\x00m')

{'A1': 'cv',
 'A2': 15577944285350848324,
 'A3': -0.4085911174241308,
 'A4': 839350135,
 'A5': [{'B1': {'C1': [3632640577, 1795408166],
                'C2': 6591,
                'C3': 173,
                'C4': 18845,
                'C5': 18422312207722947509},
         'B2': -51,
         'B3': 90,
         'B4': 428749340,
         'B5': 3686362200,
         'B6': {'D1': -30, 'D2': 48941, 'D3': [211, 156, 180]}},
        {'B1': {'C1': [4195915890, 3300347631],
                'C2': 14965,
                'C3': 204,
                'C4': 56613,
                'C5': 5658748731582059400},
         'B2': 21,
         'B3': -27,
         'B4': 759455914,
         'B5': 3817335518,
         'B6': {'D1': 32, 'D2': 63091, 'D3': [182, 64, 214]}}],
 'A6': 23495,
 'A7': 1917274744}

(b'\xa3DAW\x00\x02\x00\x00\x00,\r\xf2\x1b\xf1\x8b\xca(\xee\xbf\xdc\xa8v\xaa\x82'
 b'\xe2\xa4\xcd\xfa\x91\xd2\x00\x00\x00\x02\x00\x00\x00\x90\xd1[\x8a\x8c\t\xc2'
 b'nz\xf7\xbe\xfa\xf4\x9d\xcd\x00\x00\x00\x03\x00\x00\x00.w\x7fS\xa9'
 b'\xccH\xcd\x91\xfbP,\xaf\x84m:\x91\x1d \x00\x96\xd3\xa7\xabc\x0c\xaaw\x1a'
 b'\xf4\xcb\xfd\x00\x00\x001\xd9^\x0fHYH\x00\x00\x00\x03\x00\x00\x00_\x9ev\xc2'
 b'I\\\xef\xd1\x15\xb1s\xa5\x9d\xa2\xfa\x18F\xfeb\x9b\x8al"yv\xaet\xe5'
 b'\x83fm\x1e\x00\x00\x00b\x00\x00\x00<\x00\x00\x00m')

{'A1': 'nz',
 'A2': 1004896391103391982,
 'A3': -0.44778219844332967,
 'A4': -839216686,
 'A5': [{'B1': {'C1': [2004833193, 3427323281],
                'C2': 64336,
                'C3': 44,
                'C4': 44932,
                'C5': 7870762853060351699},
         'B2': -89,
         'B3': -85,
         'B4': 1661774455,
         'B5': 452250621,
         'B6': {'D1': -12, 'D2': 40397, 'D3': [247, 190, 250]}},
        {'B1': {'C1': [2658583113, 1559220501],
                'C2': 45427,
                'C3': 165,
                'C4': 40354,
                'C5': 18021231967313037932},
         'B2': 34,
         'B3': 121,
         'B4': 1991144677,
         'B5': 2204527902,
         'B6': {'D1': 72, 'D2': 22856, 'D3': [217, 94, 15]}}],
 'A6': 53595,
 'A7': 2324433346}

Вариант №17

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

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

(b'NML.\x0eo\xb5\x03#\x9do\x04\x00\x00\x00\x03\x00Ho_\xba\x8f\x8b\x82'
 b'\xd2\xf8\x00K\x00Q\x00W\x00]\x00\x00\x00\x04\x00\x00\x00c0H\r\x8eK!'
 b'\xc1\xf2\x9a\xe8\x83\xdb9\xc2\xd4P\x92\x14`\xa6fs\x00\x00\x00\x02'
 b'\x00\x00\x00guue>\xef\xa3\xa3An\xbejA+\x9c\x02?;\x8f?\xe2\x8a\xbe\x06:'
 b'"\x8bR\x04\xa9\xdd\xab\xd6\xae\xecNH\xccV\x8b\xfa\xeda\xa5\xb9\xca8\x13')

{'A1': 1040249064032923396,
 'A2': 'uue',
 'A3': 8025338186681209592,
 'A4': {'B1': [{'C1': 0.46804532408714294, 'C2': 16750},
               {'C1': -0.22876422107219696, 'C2': -25598},
               {'C1': 0.7326545119285583, 'C2': -7542},
               {'C1': -0.13108113408088684, 'C2': -29870}],
        'B2': [4, -87, -35, -85],
        'B3': 3479045616940728818},
 'A5': {'D1': -1696037925, 'D2': 14786, 'D3': 15298888550396094067},
 'A6': [-2977182482672363893, -365528630332606445]}

(b'NML.X\x86e\xc1|K\xb2\x12\x00\x00\x00\x02\x00H\xfaI\xdfq\x1a\xc6\xac\xf0\x00J'
 b'\x00P\x00V\x00\\\x00\x00\x00\x02\x00\x00\x00bv\x07\x13\x93o\x11'
 b'\xad\xb1\x87\xa7\xe5:\x922YG\x0e\xe6d\xcd\x18\x0c\x00\x00\x00\x03'
 b'\x00\x00\x00ddk\xbf\x0e\x87\x89\x03\xff\xbe\xfdK\xd9v\x0c\xbf2\x01B\x11\x1d'
 b'\xbe\x93+\xbe\xa2\x078\xdf\xca;B\xc8\x8d.C\x03\xc8(}D\x9b?F\\\x19\x07W\xf4'
 b'\xb7\xfa`-')

{'A1': 6378897803905315346,
 'A2': 'dk',
 'A3': -411552214054163216,
 'A4': {'B1': [{'C1': -0.5567556023597717, 'C2': 1023},
               {'C1': -0.4947192966938019, 'C2': 30220},
               {'C1': -0.6953316926956177, 'C2': 4381},
               {'C1': -0.2874431014060974, 'C2': -24057}],
        'B2': [56, -33],
        'B3': 8504787945257020849},
 'A5': {'D1': -2019039942, 'D2': 37426, 'D3': 6433126975418472460},
 'A6': [-3874429625292668157, -4023828533439674788, 1803506884355448877]}

Вариант №18

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

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

(b'GAFO3\x0bn\x00\x02\x00\x00\x00&nqluljm\x95\x91^g7\xd6~\xa1\x00,\x00\x00'
 b'\x00\x03\x00\x00\x00]\xbd\xcf\x8677\x836\xba\x02\x80"F\xa5\x97'
 b'\x15\x9e\xe6\x94(<\x8e|Tz\xa3\xceb\xdd\xe6\xcbD\xd5\xdb:>\xd9\xdbt\x98!.\x0e'
 b'\x1a\xf4g\xad\xa8\xb5"9\xb6S\xfew]\xea\x95\xa3\xc8\xbf\x0f~\x9b\x01\x14\xc8'
 b'\xb2\xea\xb6^\x82\xfeW0nbp\x1e ')

{'A1': 2926,
 'A2': [{'B1': 48591, 'B2': -122}, {'B1': 14135, 'B2': -125}],
 'A3': 'nqluljm',
 'A4': {'C1': -7669244893023797599,
        'C2': {'D1': [918160000,
                      575055255,
                      362735252,
                      675057276,
                      1417323470,
                      1658709707,
                      1154865978],
               'D2': 62,
               'D3': 15698269122870513178,
               'D4': [-12, 103, -83, -88, -75, 34, 57],
               'D5': 182,
               'D6': 1409185629},
        'C3': [16903596858999275163, 77907764339695234, 18327170459263573536]}}

(b'GAFO3\x00\x99\x00\x03\x00\x00\x00&taxusmx\x9b\xf1\x10JW~\x0e\x90'
 b'\x00/\x00\x00\x00\x02\x00\x00\x00`\xc0ni\xb2\xe0.\xeb!\xa7\xbb\x10$_\xde'
 b'\xf5\xc2\xbd\xff4e\\\x1ef\x00\xe3~D\xb1W\xe8\xf1\xdfi\x0c*v\xe4\x92'
 b'\x97\xe2\xc0\xbe\xaek"\xbcps\xbb\xab~D\x84\xc2Z\xceN\xe9\xab\xda\xc9\xd1'
 b'Y\x0e\xa7Cl\xa6N\xfcd#C_')

{'A1': 153,
 'A2': [{'B1': 49262, 'B2': 105},
        {'B1': 45792, 'B2': 46},
        {'B1': 60193, 'B2': -89}],
 'A3': 'taxusmx',
 'A4': {'C1': -7209963616961950064,
        'C2': {'D1': [3138397279,
                      3740648125,
                      4281623900,
                      510001379,
                      2118431063,
                      3908165481,
                      204109540],
               'D2': 146,
               'D3': 10944521969666302652,
               'D4': [112, 115, -69, -85, 126, 68, -124],
               'D5': 194,
               'D6': 1523470057},
        'C3': [12383432026388080451, 7829031848148943711]}}

Вариант №19

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

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

(b"2NQWN\xd7\xbd?%\x00\x8cf'\x8b\xbc\xdah\x84Q\x00\x04\x00\x00\x00#\xd0\xef\xc0"
 b'\xe2\x00\x03\x00\x00\x00\x98lbvv\xf6W8Q\xf6\x90}\xa6\xb3K\x1c\x8c\xd4'
 b'p\xe9\x85\x18\xc2\x89\x83)\xc1\x88\xa2H\xba\xa0\x0blu\xff\x00\x02'
 b"\x00\x00\x00'\x05>\xcbh V\x8fc\xa4G\x1c\x14\xf8\x14w\xf9\xb0\n\xd7\xf6"
 b'FA\xba\x80g\xe5\xa3B}\xe8m\x00\x02\x00\x00\x00L\x9b\xb1\xce\xaf\xd6\xc9\xab'
 b'x,\xdb,F$n\xee\xa71q\xfe\xe1\x8b9\xffm\xbf\xe0Z\x88\xcfp\xc0e\x80\x00\x04'
 b'\x00\x00\x00q\x00)\x00N\x00u')

{'A1': 55229,
 'A2': 0.6445395946502686,
 'A3': {'B1': 7361005759194760273, 'B2': 'lbvv'},
 'A4': -12049,
 'A5': -16158,
 'A6': [{'C1': 944895632,
         'C2': {'D1': 125,
                'D2': [-1498199268,
                       -1932234519,
                       -2061974903,
                       -2094415480,
                       -1572291936],
                'D3': 2924},
         'C3': 117,
         'C4': -1,
         'C5': [246, 87]},
        {'C1': 3412598870,
         'C2': {'D1': 143,
                'D2': [1671710492,
                       351802487,
                       -105903401,
                       -163167814,
                       -2140674653],
                'D3': 17021},
         'C3': -24,
         'C4': 109,
         'C5': [5, 62]},
        {'C1': 3603540856,
         'C2': {'D1': 44,
                'D2': [-617855452,
                       1861134129,
                       1912529291,
                       973041087,
                       -530937649],
                'D3': 28864},
         'C3': 101,
         'C4': -128,
         'C5': [155, 177, 206, 175]}]}

(b'2NQWN\xd8\x13?!iq\xc9\xba\xe1\x81f\\\x95\xb3\x00\x05\x00\x00\x00#.\xdc\xb0'
 b'x\x00\x02\x00\x00\x00rllazyE0\xd33\x88`5\x10\x10&\x89\x18\x9f_\t\xb5'
 b'\xe1\x84\xf2B\xa8\x884\xcc\xee\x1cP;k\xaft\x00\x02\x00\x00\x00(\x93\xc3\x8b'
 b'K\x83?\xd8E\x1b;\xad!J\xf5>ph\xc60\x8fK\xf0\x03U\xca$wr\xee(\xfc'
 b'\x00\x02\x00\x00\x00M\x00*\x00O')

{'A1': 55315,
 'A2': 0.6305151581764221,
 'A3': {'B1': 14536178693176071603, 'B2': 'llazy'},
 'A4': 11996,
 'A5': -20360,
 'A6': [{'C1': 3543369824,
         'C2': {'D1': 53,
                'D2': [269493897,
                       413097737,
                       -1243511566,
                       1118341172,
                       -856810416],
                'D3': 15211},
         'C3': -81,
         'C4': 116,
         'C5': [69, 48]},
        {'C1': 2336981823,
         'C2': {'D1': 216,
                'D2': [1159412653,
                       558560574,
                       1885914672,
                       -1890848765,
                       1439310967],
                'D3': 29422},
         'C3': 40,
         'C4': -4,
         'C5': [147, 195]}]}

Вариант №20

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

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

(b'CDXo%0yvygcg4\xe5uguqujp\xdc\xcb\x82nbbuffh_\xe4ghbfijN\x00\x9di\x17=&\xe58'
 b'\x82\xce\xf4\xe9\xf6\x14\xf7\xc0\xb3f[\xb4\xdc\xda\xedB\xb0\xc9\xe3\xbf'
 b"\x1c\x8e\x86e\xe7.\xe2?\xee\x99\xec\xb4'\xbe)\x00\xb44\xdbp<p\xbfN/z\x9c\xd7"
 b'\x04cI\xd8')

{'A1': [{'B1': 9583, 'B2': 48, 'B3': 'yvygcg'},
        {'B1': 58676, 'B2': 117, 'B3': 'guqujp'},
        {'B1': 52188, 'B2': -126, 'B3': 'nbbuff'},
        {'B1': 24424, 'B2': -28, 'B3': 'ghbfij'}],
 'A2': {'C1': -0.16377609968185425,
        'C2': {'D1': [157, 105, 23, 61, 38, 229],
               'D2': 4107174456,
               'D3': 4145346281,
               'D4': [192, 179, 102, 91],
               'D5': 180,
               'D6': -0.6183701808175459,
               'D7': 0.5682255728647223,
               'D8': -26130},
        'C3': 5674377460403877044,
        'C4': -2861647215768864209}}

(b'CDX-o\xe1vyvvas\x8a.nzmpfgk]\x06\xacchupmd\r`\xd9naqaxuN\x00\xbb\xbf)'
 b'\xf5A\xc6\xe7\xccy\xde\xfd\x15\xbas\x93\xe7\x15\xc4\x05`\xf2\xdbc'
 b'\xcf\xd9\xb3\xbf@\x9d\x15\xb0qb\xe8\xbfm~\xf7_\x03\xbd)\x00l\xa9\xa3\xcd'
 b'2c=\xcf\xb4\x91\x1bbL(C`')

{'A1': [{'B1': 28461, 'B2': -31, 'B3': 'vyvvas'},
        {'B1': 11914, 'B2': 110, 'B3': 'zmpfgk'},
        {'B1': 1629, 'B2': -84, 'B3': 'chupmd'},
        {'B1': 24589, 'B2': -39, 'B3': 'naqaxu'}],
 'A2': {'C1': -0.032073941081762314,
        'C2': {'D1': [187, 191, 41, 245, 65, 198],
               'D2': 3732524263,
               'D3': 1941575165,
               'D4': [147, 231, 21, 196],
               'D5': 5,
               'D6': -0.07754226863830516,
               'D7': -0.7620171012066876,
               'D8': 32365},
        'C3': 14933201009280002412,
        'C4': 6936432159609295284}}

Вариант №21

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

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

(b'RJVT\xc9\x05\xbe1i\xa5|:fs\x00\x03\x00\x82\x00n\xca\x9a\x00\x00'
 b'\x00\x02\x00\xa0\x00?\xa3J\xe4bK\xbe\x14\xf1\\-\xff\xc2\x87\xc7\xc5\x15N\xab'
 b'\x07\xf9\x08M\x90Nt\xef\x1c\x03\x00\x00\x00)\x00\xcf\x06\xb7\xe5Z'
 b'\xb3s\xa1\xe6\xc9P\xa0\x16m\xe3D\x03\x00\x00\x00?\x00\xcd\x0e\xea'
 b'\x00\xd8j\xcd=H\xf1\x1eb+\x00\xbd\xaa\xbev\x04\x00\x00\x00U\x00/\x00E'
 b'\x00]\x00\xa0\x9fw\\\xe0j\xc5\xbf@:\x03\x00m\x00?\xe8\x841\xf2\x11\x91'
 b'\xce?\x88\xed\xb0\xf6\x97\xb2\xeb\xbf\x90\x03\xb2}r\x8e\xb1?\xf3\x0b\x0b+(r'
 b'}D')

{'A1': 201,
 'A2': 7366337190394183173,
 'A3': {'B1': -0.16732410922054175,
        'B2': 14912,
        'B3': [{'C1': [-85, 7, -7, 8, 77, -112],
                'C2': 485454926,
                'C3': [-30782, -14905, 19989]},
               {'C1': [115, -95, -26, -55, 80, -96],
                'C2': 1155755286,
                'C3': [1743, -6729, -19622]},
               {'C1': [72, -15, 30, 98, 43, 0],
                'C2': 1992207037,
                'C3': [3789, 234, 27352, 15821]}],
        'B4': 63},
 'A4': [0.23880218816615373, -0.865550977533915, 0.06857982224211256],
 'A5': -13714,
 'A6': {'D1': 3059, 'D2': 11019, 'D3': 40, 'D4': 114},
 'A7': {'E1': [125, 68],
        'E2': 41791,
        'E3': 74,
        'E4': -0.19861942529678345,
        'E5': 761065748},
 'A8': 255}

(b'RJVT\xb7\x99E\xa8\xcb5\x93\xbc\xe1m\x00\x05\x00|\x009D\xa4\x00\x00'
 b'\x00\x03\x00\xaa\x00\x9e|\x06Nm\xe0\xbeY\xda\xf2\xa3\x88\x08\x03\xff'
 b"\x15\xb7 \xe9\x9c\x82B\xad\x866}\x02\x00\x00\x00)\x00\x87Z7'\t\xcc\xb3"
 b'\xc8\xf4o\x0f\x87\xa2\xf12\xb1\x03\x00\x00\x00=\x00\xb3?\xf9X\x83'
 b'm\x9c\xb8\xea\xf0\x15!\x9a\x81\x02\x00\x00\x00S\x00-\x00C\x00W\x00\xf0x\xb3'
 b'2\xc5q\xc7\xbf7h\x03\x00g\x00\x0f\x90\xb7\xa2A\xd1\xfc\xb8?\x0efT\xd4'
 b'\xa0\x13\xe3?\xf0\x8a@\xe6]\xdd\xb4?"\x8e\x12@\xb7\xdc\xe9\xbf`qv\xee'
 b'\xd7\xb3\xd1\xbfN\r4\xee\xa8\xbd\xba\x7f\xec')

{'A1': 183,
 'A2': -2180706260294810215,
 'A3': {'B1': -0.18315949416768929,
        'B2': 26679,
        'B3': [{'C1': [-73, 32, -23, -100, -126, 66],
                'C2': 2100725421,
                'C3': [776, 5631]},
               {'C1': [-77, -56, -12, 111, 15, -121],
                'C2': 2972905890,
                'C3': [23175, 10039, -13303]},
               {'C1': [-125, 109, -100, -72, -22, -16],
                'C2': 2174361877,
                'C3': [16307, 22777]}],
        'B4': 15},
 'A4': [0.09760768749649018,
        0.5961460253776651,
        0.08150278922452592,
        -0.8081928492942476,
        -0.27660177504892225],
 'A5': 17465,
 'A6': {'D1': 3406, 'D2': -4556, 'D3': -88, 'D4': 189},
 'A7': {'E1': [-70, 127, -20],
        'E2': 31902,
        'E3': 6,
        'E4': -0.4383339285850525,
        'E5': 2750601817},
 'A8': 136}

Вариант №22

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

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

(b'FKN|O\x00\x02\x00i\x00k\x00lk\xd0VJ^\x02\x00\x00\x00t\x00\x00\x00bq^?"X'
 b'\xbf\xd7\xd0A?8\xd3\xbc\xaba\x1f\xc2\xcb\xc9\xbe\xd38\xb1\x00\x81\xbe\x9b\n%'
 b'\xff\xac\xc7\x86Y\x81\xbe\xf4\xf1\x97\xb4\x1b?\xb1z\xef\xf0\xbezr'
 b'\x06\xb3=\x89\xdbfuhivg\xf6\x93\x03\x00\x1f\x00\x00\x00\x19\x0c5\x0c\xa7'
 b'\x01\xc7\x96\x01\xd1$\xc94#\x0b=\xd3\x12>7\x9c\x9e\xfe\xc3\x10R*\x19,\xbc!~5'
 b'[$\xc4\xa0')

{'A1': {'B1': -119,
        'B2': 219,
        'B3': 'fuhivg',
        'B4': 37878,
        'B5': [{'C1': -16552,
                'C2': 0.7570928931236267,
                'C3': [56, -45, -68, -85, 97],
                'C4': 31,
                'C5': -0.39413267374038696},
               {'C1': 14547,
                'C2': -0.2519584000110626,
                'C3': [-101, 10, 37, -1, -84],
                'C4': -57,
                'C5': -0.2526361346244812},
               {'C1': -3596,
                'C2': 0.6082243323326111,
                'C3': [-79, 122, -17, -16, -66],
                'C4': 122,
                'C5': 0.08741463720798492}],
        'B6': -7582089630678971367,
        'B7': 1,
        'B8': 209},
 'A2': [36, 201],
 'A3': {'D1': 52, 'D2': -7190210029499380957},
 'A4': {'E1': 27500,
        'E2': 1581930192,
        'E3': [3177617544043560606, -6862319958047710788]},
 'A5': 0.8689175844192505,
 'A6': 34}

(b'FKN|?\x00\x02\x00Y\x00[\x00\xfaX!-G\n\x02\x00\x00\x00d\x00\x00\x007_'
 b'\x1b\xbfv\x90C\xc6\xebx\xbf\x8f\x9d\xa7\xf4\x1f\x8a\x1fc&\xbf\xcf'
 b'\xfcB\xfa\xfe\xbe?\xca\x1d\xef\xb8\x168\x19\xc9=w\xddvipbknO\xfd\x02\x00\x1f'
 b'\x00\x00\x00\xfc_\x0f\x9b\x8c\xae\xec\xd4xr\xc9\x1c&\x90u\xc9G-H\x96\xe6'
 b'<}\xf2\xbf&\xf2\xc7>\xf4\x97\xb3\x8d\x90\x18KS')

{'A1': {'B1': 119,
        'B2': 221,
        'B3': 'vipbkn',
        'B4': 64847,
        'B5': [{'C1': 17296,
                'C2': -0.972347617149353,
                'C3': [-113, -99, -89, -12, 31],
                'C4': -118,
                'C5': -0.6499499678611755},
               {'C1': -817,
                'C2': -0.4980030655860901,
                'C3': [63, -54, 29, -17, -72],
                'C4': 22,
                'C5': 0.09819263219833374}],
        'B6': -3103914124244983812,
        'B7': 120,
        'B8': 114},
 'A2': [201, 28],
 'A3': {'D1': 38, 'D2': -1831196839164414576},
 'A4': {'E1': 22778,
        'E2': 172436769,
        'E3': [4523850598959971644, 6001917937533032436]},
 'A5': -0.6069216132164001,
 'A6': 118}

Вариант №23

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

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

(b'FVEX#\x00)\x00.\x003\x008\x00=\x00B\x00n"O\x00\x00\x00\x1aU\xe2\xea'
 b'\xc8\xd6\x9e\xf9RB5kqsz8\x16\xb2\xed&\xb8\xb9R\xce\x91\xa9x\xb3=c\xc4o'
 b'L\xb9*\xb6\xe3\xe59\xee#\x1cU\x8d\x8b\x85$\xd9\xea\x8f\x03\xafF\xe5\xac\xc8'
 b'I2xp_\x8b\xf7\x91\xf5\xbc\x04[\xe5\x88\\\xd8\x03\xab\x91\xe3\xa1\xe7\xf4\xa5'
 b'\xfe\xa9\xe5Q\xb1J6T\x80\xb7IB\x03\xa6c\x08\x00G\x00\x00\x00')

{'A1': {'B1': 'kqsz', 'B2': 5688},
 'A2': [{'C1': 60850, 'C2': 38, 'C3': 47544},
        {'C1': 52818, 'C2': 145, 'C3': 30889},
        {'C1': 15795, 'C2': 99, 'C3': 28612},
        {'C1': 47436, 'C2': 42, 'C3': 58294},
        {'C1': 14821, 'C2': 238, 'C3': 7203},
        {'C1': 36181, 'C2': 139, 'C3': 9349}],
 'A3': 8814,
 'A4': {'D1': [17837455685788518856,
               6667831427406296465,
               17647251663648130008,
               3912134191628287653,
               7180430239128322132],
        'D2': [-39, -22, -113, 3, -81, 70, -27, -84]},
 'A5': 26,
 'A6': 3370836565,
 'A7': -24874,
 'A8': 893539065}

(b'FVEX#\x00)\x00.\x003\x008\x00=\x00B\x00\x97\xadI\x00\x00\x00\xb4\x98v)'
 b'\xf9\xb4(x$\xb9WzrfaF! \xc6G\xc6A\xb4\x939\xb2\xe4\x15\xdd\x9c\xa7\x86'
 b'\xc27n\xc7\x8c%b\x98\xf2l\xcc\x89\x95\x00\x0f\xcd\\S\xc2\xf6\x80\xfe`\xc8'
 b'\xd1{A\xf6\x8e\xd7\xc3\xaa5\xff_\xb5\xb3L\x92\xaf%\xec\xb8U\xc4y\x90\xed'
 b'\x058i\xf4\x81\xa4(v\x9a\x02\x00G\x00\x00\x00')

{'A1': {'B1': 'zrfa', 'B2': 8518},
 'A2': [{'C1': 50720, 'C2': 71, 'C3': 16838},
        {'C1': 37812, 'C2': 57, 'C3': 58546},
        {'C1': 56597, 'C2': 156, 'C3': 34471},
        {'C1': 14274, 'C2': 110, 'C3': 36039},
        {'C1': 25125, 'C2': 152, 'C3': 27890},
        {'C1': 35276, 'C2': 149, 'C3': 3840}],
 'A3': -21097,
 'A4': {'D1': [15116438795470684755,
               3867118560634880379,
               2715549958457876479,
               427156392329459948,
               11130128216112785720],
        'D2': [-51, 92]},
 'A5': -76,
 'A6': 4180244120,
 'A7': 10420,
 'A8': 1471751288}

Вариант №24

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

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

(b'bMYBP\x00K\x00V\x00a\x00l\x00w\xab+\xd8n\xc2\x9c\xbb\xcc\xbf\x03\xa1\xd2\xf2'
 b'\x1fGV\x90o\xf0z\x84O\x1b\xbey\x9b\xfa\xd1\x80^\xbf\xb7O\x8a\xef\xb6\x9a'
 b'P\xb5\xbf\xe8M\xb8e\x1d\xc36\x8b\nu%\x00\x00\x00\x82\xed=\xc8\xe0\xd5i'
 b'cnp\x00F\x05\xbe\x8f\x88Asnkl\x00Q|\xbe\xaf{Smgwv\x00\\\x96<\xc7\x9cIxueb'
 b'\x00g\xa7>\xf4e`ukgt\x00rpI\x1b\xf2\xfeh\xb4\xf6\x94=\x9e\x98\n?\xc6'
 b'\x9cpW\xef\x8b8^,\x00\x05\x00}')

{'A1': [{'B1': 'icnp', 'B2': {'C1': 237, 'C2': 0.09808508306741714}},
        {'B1': 'snkl', 'B2': {'C1': 5, 'C2': -0.2803364098072052}},
        {'B1': 'mgwv', 'B2': {'C1': 124, 'C2': -0.34273776412010193}},
        {'B1': 'xueb', 'B2': {'C1': 150, 'C2': 0.02436651475727558}},
        {'B1': 'ukgt', 'B2': {'C1': 167, 'C2': 0.47733592987060547}}],
 'A2': {'D1': [43819, 55406, 49820, 48076],
        'D2': -0.5141879320144653,
        'D3': [-3553, 18262, -28561, -3974, -31665, 7102, 31131],
        'D4': 4208033886,
        'D5': -0.0910574755895166,
        'D6': 181},
 'A3': -0.7594873404433204,
 'A4': 35594,
 'A5': 29989,
 'A6': {'E1': 1756690068,
        'E2': 1033803786,
        'E3': 0.17664913457618936,
        'E4': 94,
        'E5': 44,
        'E6': [112, 73, 27, -14, -2]}}

(b'bMYBP\x00K\x00V\x00a\x00l\x00w{_\x0e\x9fxA\xfa\xd0\xbfP\x03tv'
 b'\xed\xe9\x95\x7f\x1f\x02\x08\x92\xe7@g\x11:\xdd\xfa\x05\x80\xbf\xea\xb9'
 b'\x896\xe1\x16\xec1\xbf\xc1@$\x1c\xc2\xf9\xf0\x96\x08\xba#\x00\x00\x00\x82U?'
 b'\x1e\x12\x80mlbt\x00F\xe0>\x9c\xc5\xa0gell\x00Q\x17?6\xe8Gcvhv\x00\\\xce'
 b'\xbeI\t\xa2wvtk\x00g\xff\xbe\x9e7\x1acwki\x00rf\xe6\xd7\xd3\x7f\xa3/\x8eJLN'
 b'\x1f"\xbf\xe3\xed%5U\x13*z-\x00\x05\x00}')

{'A1': [{'B1': 'mlbt', 'B2': {'C1': 85, 'C2': 0.6174697875976562}},
        {'B1': 'gell', 'B2': {'C1': 224, 'C2': 0.3061952590942383}},
        {'B1': 'cvhv', 'B2': {'C1': 23, 'C2': 0.714481770992279}},
        {'B1': 'wvtk', 'B2': {'C1': 206, 'C2': -0.19632580876350403}},
        {'B1': 'cwki', 'B2': {'C1': 255, 'C2': -0.30901414155960083}}],
 'A2': {'D1': [31583, 3743, 30785, 64208],
        'D2': -0.8125526905059814,
        'D3': [30445, -5739, 32543, 520, -27929, 16487, 4410],
        'D4': 3724150144,
        'D5': -0.8351484367237538,
        'D6': 49},
 'A3': -0.13476992992759973,
 'A4': 38408,
 'A5': 47651,
 'A6': {'E1': 2737802826,
        'E2': 1280188194,
        'E3': -0.6226984063765475,
        'E4': 122,
        'E5': 45,
        'E6': [102, -26, -41, -45, 127]}}

Вариант №25

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

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

(b'JPTH\xc1\xbc\xd7n\x90?_t\x85=\xcd\xa7\xbeT_?\xc4I\x8c\x83LY\x98\x00'
 b'\x00\x00\x8e\xd2\xd6\xe9\xe5\x0c\x04\xf9\xad\x1e\x9f1\xc8F\xedO\xb1~'
 b'\xa1\x96\xbe\x94\xb6U\xc0\xa9\xed\xfez\xc03E\xb9*\xfe\x1dh\x00'
 b"\x80\xa5\xc4\x85\xb3\xff[\x10\xe7V'hm\\\xcbMd\xa8q\x1a\x0b\xd4\x05p"
 b'\x94\xc6\x9emt\x06\xafKBlGw\xee\xd4\xe9\xa9\xe17l\x9c\x0c\xf6\x03\xce'
 b'\xf6\xbb\x16\xdal,\x8f\xa8\xd1\xa31\xb7\r\xbbA]\xb7\x00\x07u\x11\x83\x06]'
 b'\xba\xa9\xd7\xad\x07\xcaw\x03|7ulldvbry\x00#\x00OR\x04L\xec\x93P8W\x00\x04'
 b'\x00\x00\x00{\x00\x8b')

{'A1': 3250378606,
 'A2': 144,
 'A3': 0.8728716969490051,
 'A4': {'B1': 0.1004175990819931, 'B2': 21599, 'B3': 0.15849453364417054},
 'A5': {'C1': 3618441162,
        'C2': 1996717111,
        'C3': 'ulldvbry',
        'C4': [{'D1': [201652653, 513749448, 1189957553, 2124519102],
                'D2': 148,
                'D3': -74,
                'D4': [21952, -22035, -390, -16333, 17849, 11006, 7528, 128],
                'D5': -23100,
                'D6': -8812419279243225561},
               {'D1': [1751997643, 1298442353, 436982789, 1888798366],
                'D2': 109,
                'D3': 116,
                'D4': [1711,
                       19266,
                       27719,
                       30702,
                       -11031,
                       -22047,
                       14188,
                       -25588],
                'D5': -2557,
                'D6': -3533431150797378417}],
        'C5': 5909933189984434263,
        'C6': [-1462656207, -1223836863, 1572274183, 1964081926],
        'C7': {'E1': 93, 'E2': -70, 'E3': 169}},
 'A6': -757667355}

(b'JPTH\xb2\xddV=(?Y\x98\x12\xbf`\x97\r\xfe\x84\xbf\xe2q\xd0\xef\xce0\xd4\x00'
 b'\x00\x00\x8e\xdc\xd2\xb9W\x91n\xbdI\x19U\x10\xa3\xff\xefH\xe6\xca^c6\r'
 b'\x9f\xb3\x0b\x97!^\xfc\x836\xd8\x8e\xac\xc4\x97\xb55\xb4\xc6\x8d&\xf8KX|'
 b'\x85\x02+G\xaa\x9d\xc8\xa0\xc1\xcb%\xb7?^0T\x05\xed\x9d\xd1\x04\x82k\xfc'
 b'M\xe3\xcb>\xf5\xcfy#B\x1a\xc6n\xc4\xd3gwB\x0f2\x02n\xa0l\xf7\xd4CxE'
 b"\x92\xdbD\x9a\x1c\x91\xa1\x9e\xb3\x0c]!G\xe4\x07i\xba\xbb'\xd5\xd4\xfdfmalkr"
 b'ct\x00#\x00O\xc6\xaa\xc8\x9a\xb7\xa6\x87\x8d\x00\x04\x00\x00\x00{\x00\x8b')

{'A1': 3000849981,
 'A2': 40,
 'A3': 0.849976658821106,
 'A4': {'B1': -0.8773048520088196, 'B2': 65156, 'B3': -0.576393574113832},
 'A5': {'C1': 124369595,
        'C2': 668325117,
        'C3': 'fmalkrct',
        'C4': [{'D1': [2439953737, 425005219, 4293871846, 3395183414],
                'D2': 13,
                'D3': -97,
                'D4': [-19701,
                       -26847,
                       24316,
                       -31946,
                       -10098,
                       -21308,
                       -26699,
                       13748],
                'D5': -14707,
                'D6': 2808077211083801131},
               {'D1': [1202363848, 2697055013, 3074383408, 1409674653],
                'D2': 209,
                'D3': 4,
                'D4': [-32149, -947, -7221, 16117, -12423, 9026, 6854, 28356],
                'D5': -11417,
                'D6': 8593447746439913580}],
        'C5': -4131269141327345779,
        'C6': [-137084040, 1167252292, -1709403743, -1632433059],
        'C7': {'E1': 33, 'E2': 71, 'E3': 228}},
 'A6': -590169769}

Вариант №26

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

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

(b'YIQ\xbeosgyiwlrpwh\xc5\x02\x00\x00\x00R\x00Z\x00\xc2AB>\x8d\x00oz_\x97-\x14'
 b'\xebx\x11\xbf\xa4\x0f\xe1\x18\x1a\xed\xbc\x1f3\xfb\xe1\x989\xf7\x0c\xcd'
 b'\xf0"|\xfcq\xe9\x0b\x90\xe4=\x9b\x11\xb0\xb8"\x94\xac\xee\x1f\xcc\xb8\xc6e"'
 b'41\x1e\x00\x00\x008\x00\x00\x00\x9a\x11(`*.\xb5G\xb8}\x98`A\x1e\xf0?J\xb7'
 b'?\xc0Pk*\x19\x03\xef\xbf\x80\xdb\x16\xceqa\x95?\xc6D\x9a\xed\xef(\xeb'
 b'\xbf,@\xe5=\xe1\x0b\xe2?\x03\x00\x00\x00b\x00\xb7\xaa\xaf\xd9\x1b_\xb2b\xdc'
 b'\x9a\xd1\x05\x00\x00\x00e\x00\x00\x00<@\x13P\xf5\xbd\x9e\xa9\xd0<'
 b'\xe7\xf2J\x10\xe3\xbf')

{'A1': 'osgyiwlr',
 'A2': 'pwh',
 'A3': 197,
 'A4': [{'B1': -1755350417,
         'B2': 45,
         'B3': 20,
         'B4': -0.5682513117790222,
         'B5': 2286963407139704740,
         'B6': 2564946739,
         'B7': 3440179001},
        {'B1': -58973456,
         'B2': 113,
         'B3': -23,
         'B4': 0.11160286515951157,
         'B5': 17198283953869427099,
         'B6': 3333999647,
         'B7': 825500261}],
 'A5': {'C1': 4506, 'C2': 24616, 'C3': 1203056170},
 'A6': 0.18970397114753723,
 'A7': {'D1': [-72, 125, -104],
        'D2': 7111851334792358583,
        'D3': -25892,
        'D4': -47,
        'D5': [0.09097671139011743,
               -0.9691282108783739,
               0.020879533961955854,
               -0.848747219150163,
               0.563950177087468],
        'D6': 1343438908,
        'D7': -1449214475,
        'D8': -0.5957388633923077}}

(b'YIQ\xbetbkvfxixpvn\xdd\x02\x00\x00\x00R\x00Z\x00\xc9e\x01\xbf~\x00\x11\x92'
 b'\xd7\xff>r\x8e\x8d\xea\xbe\xc2\xc5\x80\xc1\xc3\xdf\x9a$\x84\xab\xe5#^\xc6 T'
 b'yIr\x9c\xb9\xae\xdd\xa4\xa0\xbc76d\x08\x8cy\x17@\xf1\xf5+\xe7,\x08'
 b'\xf2\xf2\x1e\x00\x00\x008\x00\x00\x00Ae\xedF\x07A?\xea8q\xcc\xb5*Y\x13E&%'
 b'\xe3\xbf\xd0!\x96d\x82\xd6\xdd\xbf\xa0\xf5*\x1fd\n\xcc\xbf\x04\x00'
 b'\x00\x00b\x00\x97\x85B\x1d\xd5\x07g\xe6\xd5\xfb%\x03\x00\x00\x00f'
 b'\x00\x00\x00B\n\xf6Zn\xdfr\xc9|:\xac\xc2\xcbz\xe3?')

{'A1': 'tbkvfxix',
 'A2': 'pvn',
 'A3': 221,
 'A4': [{'B1': -2649583,
         'B2': 62,
         'B3': 114,
         'B4': -0.4581112265586853,
         'B5': 2637666563636905410,
         'B6': 602254212,
         'B7': 1411434078},
        {'B1': -1670231687,
         'B2': -71,
         'B3': -82,
         'B4': -0.019609862938523293,
         'B5': 4618293585234900535,
         'B6': 3878417905,
         'B7': 4075948076}],
 'A5': {'C1': 25921, 'C2': 18157, 'C3': -364953337},
 'A6': -0.5054593682289124,
 'A7': {'D1': [56, 113, -52, -75],
        'D2': 16602247163224950167,
        'D3': -1067,
        'D4': 37,
        'D5': [-0.5982848500378044, -0.466217611531218, -0.2190671112238478],
        'D6': 1526073922,
        'D7': -915218578,
        'D8': 0.6087397386744011}}

Вариант №27

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

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

(b'YKA\xce\x00\x00\x00\x04\x00^\x00\x00\x00b\xbf\xdd6\x9f\xf3\x96v\xf8a1'
 b'G\xe8O\xb2\xe0\xf2\xdbh\xbe\xcdxQI\x03\x95\xb9\x00\x00\x00n\x00\x00\x00t'
 b'\x00\x00\x00z?\xe0\x91\xe9\xfe\xd6!*p\xcb\x07\xc4\xbf\xc3\xba\xb5i\xff\xc7p'
 b'\x00\x04\x00\x00\x00\x80Nu>y\x1e)\xc7\x97\xbe\x1fk\xfc\xbb\xd7\x98 \xf1\xd5'
 b'\xeb,\x19\x1c\xd6\xa1Z\xa8\xbd\xacz\xd2\x90\xd7\xccNwZ\n=\x1a\xedx\x12'
 b'iL%\xaep\x8fx\x10[\xac, ')

{'A1': [241, 213, 235, 44],
 'A2': {'B1': {'C1': 421320353, 'C2': 6532679807993549015},
        'B2': -0.45645903385035025,
        'B3': 24881},
 'A3': {'D1': 5181479000986540904,
        'D2': -0.4013085663318634,
        'D3': 1224971705,
        'D4': [{'E1': [204, 78, 119, 90], 'E2': 10, 'E3': 61},
               {'E1': [26, 237, 120, 18], 'E2': 105, 'E3': 76},
               {'E1': [37, 174, 112, 143], 'E2': 120, 'E3': 16}],
        'D5': 0.5178117730402267,
        'D6': 1892353988,
        'D7': -0.15413539577235325,
        'D8': [91, -84, 44, 32]},
 'A4': 1316306553,
 'A5': 506054551,
 'A6': -0.15568536520004272,
 'A7': 3151468576}

(b'YKA\xce\x00\x00\x00\x02\x00^\x00\x00\x00`\xbf\xd1\x8ef\x9e\x94\xb1\xac"\xf5'
 b'\xe3\xdf\x8b5\x81\xfc\xd2\x17?Sp\xee\xbf\xa0\xa0\x9f\x00\x00\x00l'
 b'\x00\x00\x00r\x00\x00\x00x\xbf\xe8Wdk\x7f\xb8.\x19\xb2q\xd6\xbf\xc7\xb3h'
 b'\xd0`L@\x00\x02\x00\x00\x00~\xe2~\xcc\xf3\xc2#"\xad?0\xc8\x85\xca\x04'
 b'\xc3\xae\x9cs\xaa\x15\x05\xf0\xa5\xdc\x01?\xc9!\x08z\xd6Pq\neP\xf3\x8b'
 b'\xce_?\x05/\xd8\xb8\xab)\x7f}\xbc')

{'A1': [156, 115],
 'A2': {'B1': {'C1': -1441462800, 'C2': 11951428884603406458},
        'B2': -0.2743164585724809,
        'B3': 8949},
 'A3': {'D1': 16419995828346475031,
        'D2': 0.8259419202804565,
        'D3': 3214975135,
        'D4': [{'E1': [214, 80, 113, 10], 'E2': 101, 'E3': 80},
               {'E1': [243, 139, 206, 95], 'E2': 63, 'E3': 5},
               {'E1': [47, 216, 184, 171], 'E2': 41, 'E3': 127}],
        'D5': -0.7606680011356326,
        'D6': 431124950,
        'D7': -0.1851626412832008,
        'D8': [125, -68]},
 'A4': 3799960819,
 'A5': -1037884755,
 'A6': 0.6905596852302551,
 'A7': 3389309870}

Вариант №28

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

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

(b'\x1eTKPZ\x00\x00\x00a\x00\x00\x00\x06\x00\x00\x00\x99\xe2sOZW\xc4#\xd8\x80+P'
 b'\x10\xd0\xfc\xe4Wz\xa45\xef\xd0)\xe1\xce\x01+}o\xb8\xbc\xa8\x86\x05w\xff'
 b'\x14\x9a\xd6\xc8\x93\xc2C\x00\xcc\xf9\xccb\x07\x12H\xa2\xeb\xcfc\xf6'
 b"\xf2\xdbZ\x8a9\xa9(\x83\xb9\x1e\xc7=e\xcf\x8b]\xaat\xc3\xa4(\xd1y<\xa4'r\xa7"
 b'\x11\x8fN\x00\x00\x00\x11\x92\xc2D\x90xNq\xe3^\x00\x03\x00\x1d8\x97}\xf0'
 b'\x0f\x00\x00\x005\x8e\x14\x8bq\x88\xb5vKO\x00\x04\x00A\x05\xf4\x89?\xe9V'
 b'\x10\x95\xc6 \xc4\xbd7\x97;\xc8\t\xdbi7\xe7\x9c\xf0')

{'A1': {'B1': 39,
        'B2': [{'C1': 29351,
                'C2': 17,
                'C3': 36686,
                'C4': {'D1': 3799207770, 'D2': 6324219189505249296},
                'C5': [2462205072, 2018406883],
                'C6': 94,
                'C7': [15059162318390965743,
                       14999768308833287535,
                       13311699892171177748]},
               {'C1': 14487,
                'C2': 125,
                'C3': 61455,
                'C4': {'D1': 2597767315, 'D2': 13998032947161883143},
                'C5': [2383711089, 2293593675],
                'C6': 79,
                'C7': [1317482024686319346,
                       15806097822465950649,
                       2217808848986267050,
                       8413749024078249124]}],
        'B3': 1524,
        'B4': 137,
        'B5': 0.7917559552452293},
 'A2': [48439, 38715, 51209, 56169, 14311, 40176]}

(b'\x1eTKPZ\x00\x00\x00i\x00\x00\x00\x04\x00\x00\x00\xa1\xfb2.\x8a\xe8j\x02'
 b'\x02\xc9;w=r\x15\x10k\xcf\xb2\xa2\x0f\x8e.i\x9at\x8d9\xd0\x80Sf\xa4\xabL\r'
 b'\x9b\xf8\xe7o\xea\x10a\xd6}g\xb9*\x80\xf9\x1c\xc6\x05\xe1\x15b\x047B\xda'
 b'^\xb3\xb5\xdd\x98-\x03\xfe*q\x8e\x0e\x1a\xda\xac\xe7\xfb\xaa\x9f\xd9'
 b'\x9eo\x8c\xe8\xf1\x89\x0b\x93j\xc0-\xf3\xda)P\x00\x00\x00\x11\xc0'
 b'\xa5\x0e\xb3\x8ev\x07\x8e\x00\x00\x04\x00\x1d]qhTQ\x00\x00\x00=\x91\x91\x1b'
 b'\xe2\x12b\xec\x19\x16\x00\x04\x00IU\x04\xeb?\xeb\xbc\x0f\xd8\xe2\x89'
 b'\xa873\xb7\xed\x9b\xfb\x18*')

{'A1': {'B1': 192,
        'B2': [{'C1': 11763,
                'C2': -38,
                'C3': 10576,
                'C4': {'D1': 4214369930, 'D2': 16747200375319918397},
                'C5': [3232042675, 2390099854],
                'C6': 0,
                'C7': [8220494750066844175,
                       10245242314415749584,
                       9246847317356318107,
                       17935427092114167421]},
               {'C1': 23921,
                'C2': 104,
                'C3': 21585,
                'C4': {'D1': 1740188288, 'D2': 17950439943345365508},
                'C5': [2442206178, 308472857],
                'C6': 22,
                'C7': [3981985120825761176,
                       3243715614884105754,
                       15757224264347933086,
                       8038055559033492330]}],
        'B3': 21764,
        'B4': 235,
        'B5': 0.8667067752870041},
 'A2': [14131, 47085, 39931, 6186]}

Вариант №29

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

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

(b'\x89CNBV\xb6\x11\xdf>\x88\xef`>\xed\xa91\xa5o\xf6\x19"W)\x86\xa1\xf2nO'
 b'\x00\xbe\xee\xfa\xbel\x00\x00\x00|z\xcf\xe3\x8a\xfd\x12\x1b\x12=\xb1'
 b'9q\xa6\x83xrak\xa0\x02\x9f\xab\xfd\xe9\x9d\xbf\x8e\x16Ws\x0e&\xd0\xef'
 b'\xc3\xe6\xa4;\x00C\x00\x8b\x9cV\x87\x1c\x06\x91\xf4\x03\x00\x00\x004'
 b'\x00\x00\x007\x00\xb4\xd1\x02\x00K\x00\x16G\x80\xda\x16\x0bl\x05\x00'
 b'g\x00\xaf\x98r\x95~\xaa\x16i\xcc}_\xfd\xf1\x90\x8c\xab\xe7\xa9\xe9id\xe9'
 b'\x02C\xbf\x97\x1c\xdd\xaa\x85\xb2\xf2\xecgH\xf11\xef\xe9y\xb0}E\x04\xd9\x97'
 b'\xa4;\x12`z')

{'A1': 0.4356819987297058,
 'A2': 0.21966373920440674,
 'A3': -22035,
 'A4': 4134511921,
 'A5': 7994629886127317529,
 'A6': {'B1': 17622873536476912779,
        'B2': 'xra',
        'B3': {'C1': 107, 'C2': -96, 'C3': -24830},
        'B4': -11852,
        'B5': [{'D1': 2649357739, 'D2': 1461096127},
               {'D1': 3492154995, 'D2': 2766586863}]},
 'A7': {'E1': -1090851138,
        'E2': {'F1': 11,
               'F2': 108,
               'F3': [22, 71, 128, 218, 22],
               'F4': 39087,
               'F5': 9064735696060585330,
               'F6': [-1863189153,
                      -1444435060,
                      -379295255,
                      -1749073150,
                      -2052399844,
                      1743581874,
                      -281939640,
                      2108717545],
               'F7': 69,
               'F8': 8818068117765216516},
        'E3': 1950900361574185596,
        'E4': 967916818,
        'E5': 113},
 'A8': 33702}

(b'\x89CNBV\xc9\xeb\xf9\xbd\x16\x9c1\xbf\xb08Y\xaf\x9d&\xd7n\x80\xfa\xfa'
 b'\xac\xef\xf8X\x00\x8d\xc5\xf1\xb0t\x00\x00\x00\xe4\x7f&\x08\xf5&\x9e'
 b'\x80]\xe1\xaf\xf4\xbe Xty{\xa9L\xbf\xb6uH\x9e\x82\xba\x8f\xf1\x14\x8e'
 b'\xb35\t\x834\xe7E\xe2\xdf\xa0\x8b\xb83\x19:\x00B\x00J\x00;\x9f\x8fr'
 b'\x98\x7f\xc0N\x02\x00\x00\x004\x00\x00\x006\x00\x18\xd2\x03\x00R\x00'
 b'\xcc`Q\xf7T/\x04\x00p\x00\xbc\x16\x12\x17\x04&\x19.|5\xd9\xe3\x16c'
 b'?\xe7\xab\xeei\xbc?\xf0\xe1\x8b\xc0|@q\x1c\x86Y\xa7\x0e\xbe\xb1\x03\xb0\xc8'
 b'{ N_0v\x08\x8dn\x808\x96r')

{'A1': -0.12203175574541092,
 'A2': -0.6937879323959351,
 'A3': 14512,
 'A4': 647868249,
 'A5': 17937746034784497367,
 'A6': {'B1': 5674675823220596539,
        'B2': 'ty',
        'B3': {'C1': 123, 'C2': -87, 'C3': -16564},
        'B4': -11752,
        'B5': [{'D1': 2655548854, 'D2': 4052728450},
               {'D1': 900959764, 'D2': 3878978313},
               {'D1': 2699027013, 'D2': 422819979}]},
 'A7': {'E1': -1326332531,
        'E2': {'F1': 84,
               'F2': 47,
               'F3': [204, 96, 81, 247],
               'F4': 5820,
               'F5': 3854006066669164306,
               'F6': [1662444505,
                      -290724033,
                      -264258455,
                      2092993505,
                      -2044956352,
                      -1106335911,
                      -927988815,
                      1598955643],
               'F7': 48,
               'F8': 8256849091092088950},
        'E3': -9178856156688908316,
        'E4': -189800099,
        'E5': -66},
 'A8': 22560}

Вариант №30

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

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

(b'LXE<D\x00\x00\x00\xacKic\x02\x00\x00\x00\x85\x00\x00\x00\x98\xa5[QWj\xc1\\'
 b'1\x80\x7fqokbd\xda8\xb8>f\x9c\xe9\xbc\xeeE\xe1\xbfF\xa9\x93\xbe\xe0\xa1\xd4v'
 b'\xf7?\xc4?$\x00\x00\x000\x00\x00\x00\xdb\xa4\x18?\xd4\xed(?\x05\x00\x00\x00'
 b'\x1f\x00\x92\x1a\xef\x86J\x12Pn\x02\x00<\x00\xc2h\t?X\x80e(\xd73|\x85\x872'
 b"\x07O\x96\xcfM\x9e\x07\xbd\xc1..\xf5\x82\n\x1c\x17\xd4\xd0\xc6',\xf7f\xeb"
 b'?zV\x13\xf6\xab2\xc2\xd7')

{'A1': {'B1': 0.5962654948234558,
        'B2': 0.6598789691925049,
        'B3': 'qokbd',
        'B4': 7948873453609622162,
        'B5': [{'C1': 0.3598087430000305, 'C2': -0.5397866906831836},
               {'C1': -0.2884008288383484, 'C2': 0.1582021074512019}],
        'B6': {'D1': 0.5367547273635864,
               'D2': 9618619903345262680,
               'D3': 135,
               'D4': 1842,
               'D5': [79, -106, -49, 77, -98, 7, -67, -63],
               'D6': -3164029381732127186},
        'B7': 0.8563190328988757},
 'A2': 1667845036,
 'A3': [-166504838, -675138901],
 'A4': 6683740245254186392,
 'A5': 49,
 'A6': 32640}

(b"LXE<U\x00\x00\x00\xdb'\xe5f\x02\x00\x00\x00\x96\x00\x00\x00\xfd\x05\xb5\xb0"
 b'9l\xb2k\xcd\xa8\xe2rfpxdk}7l?H\x07r\xce\xd1\xda\xd5?\xe7Z\x04\xbf\x10$!'
 b'\x8c\x0b\xfd\xeb?\x9aT\xe6\xbd\xc0\xe9\x99<T9\xc1\xbf%\x00\x00\x001\x00\x00'
 b'\x00=\x00\x00\x00\x9dw\x01?\xa3\xf1\xde>\x06\x00\x00\x00\x1f\x00~'
 b'\x17\xf8\xea^\x0c\xdah\x03\x00I\x008o\x91=\x9dVY\x18Z\xa8\x1dd\xca'
 b'\xff\xd9\xc2\t\xe4D\xbb\xbf\x03\xb0cn\xa7g\x82\xa4}\xbf@>j\xc4\xb23'
 b"\xd9\xbf\xf0'B\xcf\xda\x02t\xb6")

{'A1': {'B1': 0.5057314038276672,
        'B2': 0.43543729186058044,
        'B3': 'rfpxdk',
        'B4': 7555364926676014974,
        'B5': [{'C1': 0.9227216839790344, 'C2': 0.34148068581281565},
               {'C1': -0.5170120596885681, 'C2': 0.8746392952826927},
               {'C1': -0.11246605217456818, 'C2': -0.13456204375309078}],
        'B6': {'D1': 0.07101291418075562,
               'D2': 7214107283026433693,
               'D3': 202,
               'D4': 55807,
               'D5': [-62, 9, -28, 68, -69, -65, 3, -80],
               'D6': -4648378360384754077},
        'B7': -0.3937804144015651},
 'A2': 1726293979,
 'A3': [-817747984, -1233911078],
 'A4': 7760384102946375165,
 'A5': -51,
 'A6': 58024}

Вариант №31

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

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

(b"FDJD\x00\x03\x00T\x00\x00\x00d'\x140v\x96\xbe>\x9d\xf6#J\xad\xcelK\x91"
 b'X\x94q\x98R[\xa95_\xd9,\xddP\x8e\xbf \xa5\x1b\xcd\x98\x14\xec\xc8t\x94\xebm;'
 b'#\xafD\x7f\x98h\x96\x8b\x92\xc4?g\xaaK\xa0\xbe\x86\xf1\xdcO\xdf0\xab+'
 b'\x15\xcf\xd1\xdb\x00\x00\x00\x0c\x00\x00\x00$\x00\x00\x00<%\x82\xfaH'
 b'\xd7?F\xcf(V\xde\xd3U\xe1\x00\x00\x00\x04\x00`\xbf\xed\xc6k\r\xed\x91\xb8'
 b'\xbe\xec\xfc4\xbe1\xe7\x1f\xc7\xa7\xbf\xefb\xf9c\xa0\x1b~')

{'A1': [{'B1': {'C1': [39, 20, 48, 118, 150, 190], 'C2': 0.30851849913597107},
         'B2': 1252904556,
         'B3': 75,
         'B4': 10473284149057837993,
         'B5': 53},
        {'B1': {'C1': [95, 217, 44, 221, 80, 142], 'C2': -0.6275193095207214},
         'B2': -845671188,
         'B3': -56,
         'B4': 8400598059328974660,
         'B5': 127},
        {'B1': {'C1': [152, 104, 150, 139, 146, 196], 'C2': 0.9049422144889832},
         'B2': -1598126351,
         'B3': -36,
         'B4': 5755372360523173841,
         'B5': 219}],
 'A2': {'D1': 215,
        'D2': 0.7765984535217285,
        'D3': 86,
        'D4': {'E1': -556575263,
               'E2': [37, -126, -6, 72],
               'E3': -0.9304709693938582,
               'E4': [-0.46286165714263916, -0.17373321950435638]},
        'D5': -14425,
        'D6': -0.980831808644197}}

(b'FDJD\x00\x04\x00l\x00\x00\x00~f\xc2\x7f\xe3\xd2\xfc\xbe\xf8%~\xc8\x00'
 b'\xfa)\x18*?\x14\xd9}\xd0\xad<\x86xf\xd4\xdeN3\xbd\x91\xe26-Dg\xa0Z\x1d'
 b'\xe3C\x01\xd4\xa5e\xd4\xc4\xebYsV\x8c\x87=\xc8\x18\x90\x88\x19'
 b'\xc3\x08\xf0\xadSWjn\xe7\xd3\xe2)\xce\xdf&\xa8\x18C?\x1d\xeb2{J\xc5!\x8c\xbf'
 b'\x15\xf0|Y\xd7\xd3\xeb$\x00\x00\x00\x0c\x00\x00\x00$\x00\x00\x00<'
 b'\x00\x00\x00T8mJ>5\xb6\x1e\xf6\xe1u\xc03\x00\x00\x00\x02\x00|?p\xbcP\x16)'
 b'\xcf\x00\xbf_\x9c*>\xfe\xd889\xdc?\xe69g\x00\x96u\xd2')

{'A1': [{'B1': {'C1': [102, 194, 127, 227, 210, 252],
                'C2': -0.4846610426902771},
         'B2': -939460055,
         'B3': 24,
         'B4': 3044174797477031228,
         'B5': 134},
        {'B1': {'C1': [120, 102, 212, 222, 78, 51], 'C2': -0.07123224437236786},
         'B2': 759457696,
         'B3': 90,
         'B4': 2153638721954866644,
         'B5': 196},
        {'B1': {'C1': [235, 89, 115, 86, 140, 135], 'C2': 0.09770309925079346},
         'B2': -2011577592,
         'B3': -16,
         'B4': 12489422306267354082,
         'B5': 41},
        {'B1': {'C1': [206, 223, 38, 168, 24, 67], 'C2': 0.6168700456619263},
         'B2': 2068497697,
         'B3': -116,
         'B4': 13769175852629087211,
         'B5': 36}],
 'A2': {'D1': 74,
        'D2': 0.17745253443717957,
        'D3': -10,
        'D4': {'E1': -512376781,
               'E2': [56, 109],
               'E3': 0.00408583911722693,
               'E4': [-0.8734766244888306, 0.4977433681488037]},
        'D5': 14812,
        'D6': 0.6945071231345372}}

Вариант №32

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

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

(b'DHTO\x16\xaaywyogs\x9d\xb0\xde$\xa5&V\x11\xca\xe1?\xa1tW\x95\xf3i\x1d\x18k'
 b'\x7fX\x00\x00\x00\x81\xc6\xb5\xb2\xbe\xc3\xe5dW)\xfe\x07IR\r\xbd\xa45W'
 b'\xf6\x82\x00\x00\x00\xb9&\x03L\xbf\x1an\xa8P\xa0\xf1\x18\xda\xa9\x89'
 b'\xdd\xd9 P&\xa0\xf8\xff\xc4\xa8:\xc9\xdcS\xcd\xc6G\xbe\xe9?Fr\x13\xce'
 b'\xb5k\x02\x00\x00\x00N\x00\x96ec\x06\x00\x00\x00R\x00g\xd5\xab9qe\xd2'
 b'O\x14\xcdW\xe6\n\x18j 0\x92\xef\xc9\xbfP\x06\xb1\xc0\xf6/\x03\x00\x00\x00'
 b'w\x00\x9a\xb0\xe7\x05\x00\x00\x00}\x00\x884')

{'A1': 43542,
 'A2': 'ywyogs',
 'A3': {'B1': 45213, 'B2': -34, 'B3': 0.5559164698253523},
 'A4': -1789430623,
 'A5': 243,
 'A6': [{'C1': [105, 29, 24, 107, 127],
         'C2': {'D1': 0.8044775851109267,
                'D2': -837586362,
                'D3': 27573,
                'D4': [20512, -24538],
                'D5': 150,
                'D6': 25445,
                'D7': [-8, -1, -60, -88, 58, -55],
                'D8': -10905},
         'C3': 129,
         'C4': -0.349043071269989,
         'C5': 58819,
         'C6': 959909969261057892},
        {'C1': [-67, -92, 53, 87, -10],
         'C2': {'D1': -0.2026236281388527,
                'D2': -1062140336,
                'D3': 12278,
                'D4': [14763, 25969, 20434],
                'D5': 154,
                'D6': 59312,
                'D7': [20, -51, 87, -26, 10],
                'D8': 13448},
         'C3': 185,
         'C4': -0.796923041343689,
         'C5': 28186,
         'C6': 9919699454928113832}],
 'A7': 55773}

(b'DHTO=\xfdtvkcui"\x8f\x9b0\xf44\xed0:\xdd\xbf\xca\xe4~\xb6\xae\xa4d\xa4\x18'
 b'%\\\x00\x00\x00w|}\xf7>#\xbd&T\x92r\xde\xf6\xf5\x03\xba\xa0\x15\x16'
 b'M\x87\x00\x00\x00\x83\xdb\xfa\x95>\xbc\xb4\xbf\x0e@L\x98\xb6d\xacu\x1b7P'
 b"\xae{\x9e{e7'X\xa6\xd5}/\xa8u\xca\x98\x00\xf2\xe7?\xb3%\xd4\xd9"
 b'\xe3\x07\x04\x00\x00\x00N\x00\xd3\xbeZ\x06\x00\x00\x00V\x00\x9e\x9f7'
 b'\xf6\xd1\xda\xef\xe7\x8f\xd6#\xb1l}\xc6\xed\xc6&f\xc5\xef\xbf\x99\n1\xa9\x9b'
 b'\xb3\x03\x00\x00\x00{\x00\x85[\xc0\x06\x00\x00\x00\x81\x00\x9f\xb2')

{'A1': 64829,
 'A2': 'tvkcui',
 'A3': {'B1': 36642, 'B2': -101, 'B3': -0.45667670407039207},
 'A4': -1233197878,
 'A5': 174,
 'A6': [{'C1': [-92, 100, -92, 24, 37],
         'C2': {'D1': 0.7482913002201501,
                'D2': -640408141,
                'D3': 2019,
                'D4': [20535, 31662, 31646, 14181],
                'D5': 211,
                'D6': 23230,
                'D7': [39, 88, -90, -43, 125, 47],
                'D8': -24674},
         'C3': 119,
         'C4': 0.4833792448043823,
         'C5': 48419,
         'C6': 285405586673259558},
        {'C1': [-70, -96, 21, 22, 77],
         'C2': {'D1': -0.9928465611805499,
                'D2': -1456403815,
                'D3': 45979,
                'D4': [-2505, -9519, -6161],
                'D5': 133,
                'D6': 49243,
                'D7': [-113, -42, 35, -79, 108, 125],
                'D8': -19809},
         'C3': 131,
         'C4': 0.2929295003414154,
         'C5': 46268,
         'C6': 12422254437425221311}],
 'A7': 7029}

Вариант №33

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

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

(b'BJH\x00K\x00\x00\x00z?\xc0\x92\x02\x93\x9d\x1c\xa8?\xd0\xa1K,<\xa7'
 b'\xa0\xbf\xe8nl1\xe3\x91\x88\x00\x00\x00\x03\x00\t\x01[\xc6\xbf\xde'
 b'\x82\x15)\x90H\xd0?\xc2\x95\xde\xae\xec\x00\xc0\x00\x00\x00\x02\x00*'
 b'\x8f\xce\xcf\x00\x00\x00!\x00\x00\x00:\x8c\xba=\x1c\xc8\x9f\x00\x00\x00'
 b'\x02\x00\x00\x00C>\x90(k\xa6\xfb\xb6\xcb7\xcf\x97\x7f\xe1\xec\x11I)\xe5\xba'
 b'\x8e6\x91\xa8L8 t`\xef\xc0\x8f\xb9\x95K3\x00\x00\x00\x02\x00]\x00\x03'
 b"\x00\x00\x00_Z\x00\x00\x00\x03\x00w\x16\xf4r]\xc5'\xe1\xf7\x14t5?\xbf"
 b'C\xc5Y\x1d\xd5\x80')

{'A1': {'B1': 140,
        'B2': 186,
        'B3': 0.038277264684438705,
        'B4': [{'C1': [0.1294558735628233,
                       0.2598445827485367,
                       -0.7634793257134769],
                'C2': {'D1': 1, 'D2': 23494}},
               {'C1': [-0.47668961581179037, 0.1451986650572561],
                'C2': {'D1': -113, 'D2': 52943}}],
        'B5': 0.2815583646297455},
 'A2': {'E1': 75,
        'E2': {'F1': 51,
               'F2': [166, 251],
               'F3': [-5275061173794905620,
                      1245572838598784657,
                      -6319614465065029696],
               'F4': 90,
               'F5': [143, 185, 149],
               'F6': 22,
               'F7': -2958,
               'F8': 1573201889},
        'E3': {'G1': -149654475, 'G2': 0.12212785173126939}}}

(b'BJH\x00K\x00\x00\x00\x86\xbf\xef(\x96"\x83JJ?\xe0\x07\x9e\xf2\x87\xe1'
 b'\xdc\x00\x00\x00\x02\x00\tj\x86\x13\xbf\xb4*\x8d\x8f${\xe0?\xd4\x93I\xfcO'
 b'TP?\xd7\x01\xb5\x1fc$H\x00\x00\x00\x03\x00"\xb5iz\x00\x00\x00\x19\x00'
 b'\x00\x00:|\x89\xbe\xc4Q\x84\x00\x00\x00\x02\x00\x00\x00C>\x89\xfe'
 b'\xbf\x92\x14\x10\xc4\x12\xe7\xe44\xb1X\xbbr\xe8\x8b\x00q\x84\xd2\x0f'
 b'\x89{;\xb8a\xa0\x16\xebf\x9b\xf7\xe9\x96N9\xb4\x8d\x86\x86[\xa7\x16\xa8\x1d'
 b'\x00\x00\x00\x05\x00]\x00\x04\x00\x00\x00b\x8b\x00\x00\x00\x04\x00\x82\x98'
 b'Q\xeceka\xd9Q \\5\xbf\xd5\xbfJs\xb8<\xcc')

{'A1': {'B1': 124,
        'B2': 137,
        'B3': -0.3834344148635864,
        'B4': [{'C1': [-0.9737044023589274, 0.5009302842072958],
                'C2': {'D1': 106, 'D2': 34323}},
               {'C1': [-0.07877430672350227,
                       0.3214898075069117,
                       0.3594792181507427],
                'C2': {'D1': -75, 'D2': 27002}}],
        'B5': 0.26952168345451355},
 'A2': {'E1': 168,
        'E2': {'F1': 29,
               'F2': [146, 20, 16, 196, 18],
               'F3': [-1737205619955633432,
                      -8430613687163713157,
                      4303296784159696539,
                      -582769414048019066],
               'F4': 139,
               'F5': [134, 91, 167, 22],
               'F6': 152,
               'F7': 20972,
               'F8': 1701536217},
        'E3': {'G1': 1361075253, 'G2': -0.3398004655909517}}}

Вариант №34

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

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

(b'JFRW\x00w\xc9\xf9VM\x82\xe1?xV\xa8e\x00\x00\x00\x03\x00\x00\x00'
 b'\x89\x00\x00\x00\x9a\xbf\xc2\x0e\xc4q 7\xb8\xb7\x0bY\xc8\xd5e,'
 b'\x0e\xba\xb4\x0bn?Zl~)\xf7\xf6\x97>z\xcc,\x89\xb7\xe0D\xbf0\x0b\xe6\xcd\xcbc'
 b'&>\xfa\xc7\xac4o\x00\xd1\xbe\xbe\xe7\xc2_\x1e\xd0L\xbf&\xe4\x84-\\\xcd'
 b'\x1c\x19\xb5\xd9\x1e\xbf\xbch\x03K\x999\xf0\xbek\xa929\xae\xf6'
 b'\xa5\xfe\xc5\xab\xbd\x00\x00\x001>5\x80\xfb\x04Lq\xdb\x04Kh\xd0dzb'
 b'\xf7\x8dA\xc3\x1aj\xdcyGC\xf6,Vm\xa5Y\xf0b\x00\x02\x00\x8c:\xb3W \xb3\xbc'
 b'\xcf\xdd\x00\x00\x00\x05\x00\x00\x00\x90\xbe')

{'A1': {'B1': -21571,
        'B2': {'C1': [{'D1': 0.8532179594039917, 'D2': 704116375},
                      {'D1': 0.24491947889328003, 'D2': 2310529092},
                      {'D1': -0.6876815557479858, 'D2': 3452658470},
                      {'D1': 0.48980462551116943, 'D2': 879689937},
                      {'D1': -0.37286192178726196, 'D2': 1595854924},
                      {'D1': -0.6519243717193604, 'D2': 761056540}],
               'C2': 431347998,
               'C3': -0.11096211047809112,
               'C4': -0.23013761639595032,
               'C5': 14766,
               'C6': 4138073797},
        'B3': 0.17724983394145966,
        'B4': 72118747,
        'B5': 72050896},
 'A2': -13831,
 'A3': 6218770564412626600,
 'A4': {'E1': 101,
        'E2': 'dzb',
        'E3': {'F1': -1520832414,
               'F2': [-2163, 16835],
               'F3': 15027,
               'F4': 1461760956,
               'F5': 53213,
               'F6': [6762, -9095, 18243, -2516, 22125],
               'F7': -66}},
 'A5': -0.14107566379283099,
 'A6': -1223992888,
 'A7': 15376744944499952494}

(b'JFRW\x00w\x9fp\xfa3"Ia2\xa3\xbb\xd1\x00\x00\x00\x03\x00\x00\x00'
 b'\x89\x00\x00\x00\x96?\xcf\x7f\xf0\x81L\xef\xa8R.\x98\xcf[\x8d\xaaZ\xe7\xb6O'
 b'\xd4>\x7fp\r\x10\x91X\x11\xbf9\xe2[\t)z\n\xbe\x9f\xb0)Y\x9a\xa3\xa4\xbdI\x89'
 b'\xc3\xe5\xe3\xd3\xd5\xbe*\xc3\xb9e\x88\x82x\xbfM\x01U\x8cP\xe7X+\xd8-a?\xe1i'
 b'\xec\xa5\x04\x14\xf2>\xbd\x8f\xe7r~\x1d:\xf9\xc7\x15\\\x00\x00\x001?\x17\xb8'
 b'\xd3\xa7\xd4\xc2\x12\x19U9>hij$,\xca\x07\xf0\xab\x1c\xdc.Q\xda\xbd'
 b'\x92\xa9\x00\x02\x00\x8cR\xef\xb4\xf7*\xf1\x07k\x00\x00\x00\x03\x00\x00'
 b'\x00\x90Z')

{'A1': {'B1': 5468,
        'B2': {'C1': [{'D1': 0.24945087730884552, 'D2': 277960721},
                      {'D1': -0.7261101603507996, 'D2': 153713162},
                      {'D1': -0.3118908703327179, 'D2': 1503306660},
                      {'D1': -0.049203645437955856, 'D2': 3856913365},
                      {'D1': -0.16676224768161774, 'D2': 1703445112},
                      {'D1': -0.8008015751838684, 'D2': 2354112344}],
               'C2': 735587681,
               'C3': 0.5441802237479847,
               'C4': 0.3702385127544403,
               'C5': 29310,
               'C6': 490404295},
        'B3': 0.5926639437675476,
        'B4': 2815738386,
        'B5': 425015614},
 'A2': -24720,
 'A3': 18028791431852893115,
 'A4': {'E1': -47,
        'E2': 'hij',
        'E3': {'F1': -625110359,
               'F2': [9260, -13817],
               'F3': 21231,
               'F4': -1258870031,
               'F5': 1899,
               'F6': [-3925, 7388, 11857],
               'F7': 90}},
 'A5': 0.2460919028616193,
 'A6': 1378785487,
 'A7': 6597116336578908116}

Вариант №35

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

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

(b'JNPB\xe1lowk\x00\x00\x00,\x00\x00\x00aCff\xfc\x81\xc6\x00\x00\x00\x11\x00'
 b'\x00\x00\x14\xe6\x08\xcc\x9dC\xb6&K\xf6\x1e\xfdC\x08\x00\x00\x00\x02'
 b'\x00\x00\x00\x17\x00\x1f\xbaTS\x00\x00\x00\x05\x00"\xbe\xc1\x88}C'
 b'\xef\xbe\x8d\xfbN\xde@\xe2\x9b\xbbRo\xbf\xbd\x8a\xea\xf3\xbe\xb7 \xa9=|)'
 b'\x98?K\xb3\x1d\x9eL\xbf\xaaL\x11\xf9?\x84\x80b\x88\xe7\x8b\xd0'
 b'\x01\xa0\x87\xaa\x9c\x00\x04\x00\x00\x00Q')

{'A1': 'lowk',
 'A2': {'B1': [{'C1': 17254, 'C2': 102}, {'C1': -895, 'C2': 198}],
        'B2': {'D1': -26, 'D2': 2252},
        'B3': {'E1': -70,
               'E2': 84,
               'E3': 83,
               'E4': [-25277, -18906, 19446, 7933, 17160],
               'E5': -0.37799444794654846,
               'E6': 17391,
               'E7': -0.27730792760849},
        'B4': 16015049433420033983},
 'A3': {'F1': 40524,
        'F2': -0.051361619640155176,
        'F3': 1653139339,
        'F4': 53249,
        'F5': -1601721700,
        'F6': [-0.06783094257116318,
               -0.3576710522174835,
               0.06156310439109802,
               0.795701801776886]}}

(b'JNPB\xe1cell\x00\x00\x00.\x00\x00\x00c\x0c\xb31\x07\xa2n\x00\x00\x00\x11\x00'
 b'\x00\x00\x14P\x0b\x997\xe2\t\xd3\xeaPq{\xd2\x14\x85\xaa\x00\x00'
 b'\x00\x02\x00\x00\x00\x17\x00\x1f\xe4\x00\xe2\x00\x00\x00\x06\x00"\xbfAZ'
 b'\xd2\x88+\xbe\x90j\x0b\x19\xfb\xf8\xbb(\x03\xff\xe8>Dei\xbe\x93`\xd8\xbd'
 b' >\x99?y\xfakl\x0e\xbf\xe9\x00\t\x0ch\xa3<a\xc2\xbd3*I40"t\x00'
 b'\x04\x00\x00\x00S')

{'A1': 'cell',
 'A2': {'B1': [{'C1': 3251, 'C2': 49}, {'C1': 1954, 'C2': 110}],
        'B2': {'D1': 80, 'D2': 2969},
        'B3': {'E1': -28,
               'E2': 0,
               'E3': 226,
               'E4': [14306, 2515, -5552, 29051, -11756, -31318],
               'E5': -0.7552920579910278,
               'E6': -30677,
               'E7': -0.28205904364585876},
        'B4': 1872363552816496616},
 'A3': {'F1': 27662,
        'F2': -0.7812543146475046,
        'F3': 1640152371,
        'F4': 10825,
        'F5': 875569780,
        'F6': [0.19179309904575348,
               -0.28784823417663574,
               -0.03912219777703285,
               0.976477324962616]}}

Вариант №36

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

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

(b'\x07WQU>\xf9\xb5\x15>zNf\x00K\x00V\xfd\x81<D8\x0c\xceTN\xbc\x00\x00'
 b'\x00_%\x14\xa1sj\xfa\x0b\xe5@+\x8c\xe4\xc4N\x06\xaf/\xa4[\x85\xd7\x9f!\xf5F1'
 b'\xe3x\xa4B\xcb\x86E\x00\xff\x15\x8e\xe2\xee\x1c\x18\xb0*au\xb4G\xf4\x00\x02'
 b'\x00\x00\x00Ihx\xaa\x82\xe6\x00\x02\x00\x00\x00T\xbfU\xaa\xd3\xbf\xf9h[\x07'
 b'4\xd5\xf9\x81/\xd5\x893&\xe7\xe1Rw\xfe\xd7S\x12&8\x81(')

{'A1': 0.4877096712589264,
 'A2': 0.24443969130516052,
 'A3': [{'B1': -19385, 'B2': -12, 'B3': 'au'},
        {'B1': -21886, 'B2': -26, 'B3': 'hx'}],
 'A4': {'C1': -179796246422303148,
        'C2': 20156,
        'C3': {'D1': -0.8346378207206726,
               'D2': 191,
               'D3': -7,
               'D4': [1750796084,
                      3589898543,
                      3582538534,
                      3890303607,
                      4275524370,
                      641237288]},
        'C4': 622109043,
        'C5': 1794771941,
        'C6': {'E1': 4623944356599826095,
               'E2': 799300485,
               'E3': [-41, -97, 33, -11, 70, 49, -29],
               'E4': 120,
               'E5': 11836246548226834197,
               'E6': 142},
        'C7': -487711720},
 'A5': -20438}

(b'\x07WQU\xbe\xbb(\x91\xbe\xb5\xd9L\x00K\x00V\x07(\xa3\x9cny\x14\x1c'
 b'\xa2\xc9\x00\x00\x00_\x8e0A\xfe\xcb{\xf6\x18\xcf\xcd0\xf7e\xbb\x02t\x18\xe8'
 b'\xac\x9f\x80S\xd6|O[\x06=}\xcc\xde\x16w#_c\xc7\xe3H.e8\xa5gx\xc0l7\x00\x02'
 b'\x00\x00\x00Ila\xf0\xa1\xd4\x00\x02\x00\x00\x00T\xbe\xe2\x1co\xc4'
 b'\x80\xbc\x80\xa4\xa9\x1bFa*+\xfc\x07\xd5[\xce\x05\xdda\xde\xf1\x80M\x1d\xd9'
 b'\xe0')

{'A1': -0.3655438721179962,
 'A2': -0.3551734685897827,
 'A3': [{'B1': -16276, 'B2': 55, 'B3': 'gx'},
        {'B1': -3935, 'B2': -44, 'B3': 'la'}],
 'A4': {'C1': 515842049597576220,
        'C2': 41673,
        'C3': {'D1': -0.44162318110466003,
               'D2': 196,
               'D3': -128,
               'D4': [3162547369,
                      457597226,
                      737937365,
                      1540228573,
                      1642000768,
                      1293801952]},
        'C4': -1909440002,
        'C5': 3413898776,
        'C6': {'E1': -3473065898510974348,
               'E2': 417901727,
               'E3': [-128, 83, -42, 124, 79, 91, 6],
               'E4': 61,
               'E5': 9064864338059419491,
               'E6': 199},
        'C7': -481808795},
 'A5': 14501}

Вариант №37

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

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

(b'DLSEiujbzc\x04U\x00r\x00\x02\x00\x8b\x00\x00\x00\xacK\xb9v\x1bZ\x81'
 b'Z,\xa9\xa1(\n\x90\xf3\xe5\x02]\xd4\xb3,\xbe=qU?\xd4\xd2\xb0\xbdJ\xdd\xee>~'
 b'\xed0\xbd\x0e\xb81?\xe5\xe1\xf9>\xb2\x06!>\xa1X\xc4fI\xaf\xf8\xe11'
 b'\x03\x82\xc4\x9e\x85\xc0\xa9\xb8\x87_f\xed\xbfJ\x16\xe0\xc0\x9f\xd4\x80'
 b'\xeb\xdf\x03\x00\x00\x00O\x00\x00\x00d\x94\xce\x868\xa3\xfbvhz\xde\xbf+\xd9'
 b'T\x9f\x0f\xdc\xf1@\xb9\x02\x00\x00\x00n\x00\x00\x00\x12\x14')

{'A1': {'B1': 'iujbzc',
        'B2': 4,
        'B3': [{'C1': -0.9187467242057252,
                'C2': 74,
                'C3': 16135131740686573590,
                'C4': [817, 50306, 34206]},
               {'C1': -0.4762211954062425,
                'C2': 43,
                'C3': 13348935222983349465,
                'C4': [37988, 34510]}],
        'B4': [18, 20],
        'B5': 6521592809411660716,
        'B6': 43308},
 'A2': {'D1': 6702172029737117857,
        'D2': [-0.16865473985671997,
               0.8337591290473938,
               -0.08633962273597717,
               0.46653205156326294,
               -0.04319524019956589,
               0.6942147016525269,
               0.48805156350135803,
               0.15725210309028625]},
 'A3': 16282957182549645473}

(b'DLSEfrjldjLS\x00v\x00\x02\x00\x8f\x00\x00\x00\xea\xe3B\xff\x92\xb1px\x85e4'
 b'\x88#7=\x10_d8\xd9\x06>\xe1:\xa7=\x1a,]?\xe3\x0fk?b\xf5\xc7\xbe\x93'
 b'5\x86\xbe\xd1\x99\x98\xbe\xac\x93H\xbfg\x85\xe4Z\xa2\x19\x03\x05\xa0e3j.'
 b'eR\r\xa8"\xe7\xbf\x91\x8a/Q\x00+s\xd6\x9e\x02\x00\x00\x00O\x00\x00\x00'
 b'7\x03\xf8>\xad/[\xa2\xf6\xa0\xa0\xc4\x13\x17:A\xc4\xbf\xdd\xda\xccW\x97\xf3'
 b'f#\x12\x05\x00\x00\x00l\x00\x00\x00\xfc\xbb')

{'A1': {'B1': 'frjldj',
        'B2': 76,
        'B3': [{'C1': -0.7229805240814693,
                'C2': -111,
                'C3': 11445462131534802826,
                'C4': [26016, 27187]},
               {'C1': -0.15824056746308646,
                'C2': -35,
                'C3': 1307001513269775578,
                'C4': [823, 16120, 12205, 41563, 41206]}],
        'B4': [252, 187],
        'B5': 8678631726848861162,
        'B6': 25989},
 'A2': {'D1': 7232517381684430900,
        'D2': [0.13168799877166748,
               0.08165527135133743,
               0.8639541864395142,
               0.9182111620903015,
               -0.39054399728775024,
               -0.26212748885154724,
               -0.2980485260486603,
               -0.7835032939910889]},
 'A3': 361160580220093799}

Вариант №38

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

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

(b'PTD\x16\x001\x03\x00\x00\x00(\x00\x00\x006\x00\x85\xe2v?\xf3\xf3\x85\x9b'
 b"\x89\x8b\\'\xf0\x9b\x00\x13H\xd9\xb4\x9a\xbb\xbf.\x9fpwj\xe2\xc2\xf1E\x91"
 b'\x83P7\xcb\xceS\x03\x00\x00\x00+\x00\x00\x00[\xa0\xfa\xbe\x06l@\x1ep\xbf'
 b'0~%\xea\x15\x88\x02\x00\x00\x004\x00\x00\x00M\x99\xe8\x05\xdc\x88'
 b'n\x8a\x9f\xb9\xeb\x8b\x0c\x81[]\xf6\xbe\xcc')

{'A1': {'B1': -1953916027,
        'B2': 2616207196,
        'B3': -0.10782938294148536,
        'B4': 40750},
 'A2': 49,
 'A3': 'pwj',
 'A4': {'C1': [{'D1': -15646, 'D2': 241},
               {'D1': -28347, 'D2': 131},
               {'D1': 14160, 'D2': 203}],
        'C2': -0.4895046651363373,
        'C3': 27654,
        'C4': -0.9379615783691406,
        'C5': -366641616,
        'C6': {'E1': 34837,
               'E2': [206, 83],
               'E3': [39245, 1512],
               'E4': 10082356285672425692,
               'E5': 33036,
               'E6': -0.48118099570274353,
               'E7': -52}},
 'A5': 0.9643939137458801,
 'A6': 62451}

(b'PTD\x16\x00\xad\x03\x00\x00\x00(\x00\x00\x009\x00\x18\xedn\xbf\xd2G\x83>'
 b'\xb2\xc5\xa2\x86B&\\)[\x9f\xa4D\xdf?\xdc\x93duk\xde\x0f\xb5\xc0\t'
 b'\xe3\xe4\x1f5l\xe0\x9a\xc3\xba\x04\x00\x00\x00+\x00\x00\x00\x19\xa8!'
 b'\xbfD\xe9|\xecx>\xfe\x7f\xa5Jo\xe2\x02\x00\x00\x007\x00\x00\x00\x8b\x9c\xe2'
 b'\xed$\xa8\xe0\x1e%n\xbae\xcc4\xb6\x9b7\xbe,')

{'A1': {'B1': -978174333,
        'B2': 641894050,
        'B3': 0.48856463968390584,
        'B4': 37852},
 'A2': 173,
 'A3': 'duk',
 'A4': {'C1': [{'D1': 4062, 'D2': 181},
               {'D1': 2496, 'D2': 227},
               {'D1': 8164, 'D2': 53},
               {'D1': -8084, 'D2': 154}],
        'C2': -0.6314712166786194,
        'C3': 59716,
        'C4': 0.24308961629867554,
        'C5': 1252360190,
        'C6': {'E1': 57967,
               'E2': [195, 186],
               'E3': [40075, 60898],
               'E4': 7330292449209788452,
               'E5': 13516,
               'E6': -0.17930492758750916,
               'E7': 44}},
 'A5': -0.9333052635192871,
 'A6': 18386}

Вариант №39

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

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

(b'CFTHik\x18zp\xb1\xb61\x00\x00\x00\x04\x00\x00\x00kp\xb6\xf3\xb9'
 b'\xda\xa2\x9b\xed,\xef\x00\x00\x00\x02\x00{\xa4\xb9\r\x00\x00\x00\x7f\x00'
 b'\x00\x00\x04\x00\x96\xb6R\x87\x8e\xcb\x9b\xde\xd0\x00\x06\x00'
 b'\x00\x00\x9e\xc6\xd4\xeaBw7>^\x82=\xbf\\j\xcb5\x1b\xbfR\x02\xc1>'
 b'\xe5\x1c\xa0\x8b\xde\xbf>\x1b\xd4\xbe\xd0&C\x8dQ>\xf3\xa1q?\x14=\xd7\x00'
 b'\x00\x00C\x00\x00\x00M\x00\x00\x00W\x00\x00\x00agdJ\xaa\x00\x00\x00\x02\x00'
 b'}\xfd[\x7f\xadS\xdc\xe3D\xe2\xc9*\xa2\x8f\xfa\xef\xcfN\x95\xda'
 b'\x90\x12\xee\x1e\xf1\xde\xc7P\xa6\xef\x07\x9a\xe3\xccN\x1e\xb8Q\x0ft'
 b'\xbc\xba\\\x82n\x1d\xe4\xc8\xb6\r')

{'A1': 7596192110646244913,
 'A2': [{'B1': 30519, 'B2': 0.21729369461536407, 'B3': -0.8610045313835144},
        {'B1': 13595, 'B2': -0.8203545212745667, 'B3': 0.44748401641845703},
        {'B1': 35806, 'B2': -0.7426121234893799, 'B3': -0.4065419137477875},
        {'B1': 36177, 'B2': 0.47584107518196106, 'B3': 0.5790686011314392}],
 'A3': 28854,
 'A4': 17562308613843528943,
 'A5': {'C1': 'gd',
        'C2': 42169,
        'C3': 13,
        'C4': {'D1': [74, 170],
               'D2': -190418176820059324,
               'D3': -2105104473130340401,
               'D4': 78},
        'C5': [38362, 36882, 60958, 61918],
        'C6': -1236105330,
        'C7': -878977328,
        'C8': [-951015697,
               127591372,
               1310636113,
               259308730,
               1552051741,
               -456608243]},
 'A6': 3335842370}

(b'CFTHb\xaeT\xff\xd7\x0b\xeag\x00\x00\x00\x05\x00\x00\x00u\xf3\xf6\xc3\xf6'
 b'\xdc\xeb\xe0H\x9b\x04\x00\x00\x00\x02\x00\x89$[K\x00\x00\x00\x8d\x00'
 b'\x00\x00\x08\x00\xa4\xe1\xbc\xeeE\x92\x97\x04y\x00\x02\x00\x00\x00\xb4\x9e'
 b'\x89x9a\xde>P\xfaD=\x17X\x19:a??q#\xbeG<\\\xbe\x0b\xbfl\xd9\xba\xbf]Vn$\x17?'
 b'GB\x93\xbew\xaa\xd4\xd0D\xbf\r\xa8\x11\xbfd\x1d\xf1\x00\x00\x00C\x00\x00\x00'
 b'M\x00\x00\x00W\x00\x00\x00a\x00\x00\x00kuf\xc5\x04\x00\x00\x00\x02\x00\x8bk'
 b'\xb1M\x9d\xda\x0b\xa6\x1c`\xd3B\xa6\x0e~\xb5\xb5\xd9\xd9\x92W\xaf'
 b'z\xbf\xd5\xbf\xa3%PX\xdfk@\x1a\xf3o\xb1\x85"\x82\xe0\n')

{'A1': 7110714319465867879,
 'A2': [{'B1': 25054, 'B2': 0.20407968759536743, 'B3': 0.03694925084710121},
        {'B1': 14945, 'B2': 0.7478200793266296, 'B3': -0.19456619024276733},
        {'B1': 48651, 'B2': -0.9251972436904907, 'B3': -0.8646000623703003},
        {'B1': 9239, 'B2': 0.778359591960907, 'B3': -0.24186259508132935},
        {'B1': 53316, 'B2': -0.5533457398414612, 'B3': -0.8910818696022034}],
 'A3': -3082,
 'A4': 14120716587305048836,
 'A5': {'C1': 'uf',
        'C2': 9307,
        'C3': 75,
        'C4': {'D1': [197, 4],
               'D2': 7760068973299475996,
               'D3': 6976993528702219701,
               'D4': 217},
        'C5': [55698, 22447, 31423, 54719, 41765, 20568, 57195, 16410],
        'C6': -507711931,
        'C7': -1835596679,
        'C8': [-210783867, 579002378]},
 'A6': 2659809337}

Вариант №40

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

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

(b'YKKH\xa1r4)\xd2\xe2\xb2\xe5\x00\x00\x00:\x00\x00\x00<\x00\x00\x00>'
 b'\x00\x00\x00@rszps\r\xfd\xbb\xb4$\xd7f\xa3w\x18\x8a\xef:\xfb\x8d'
 b'\x88\x00N\x9fJ\xc9\x8ejV\x0fWO^\xaf8\x94\x91\x19e\xf8\xf8\x9b\xe8\x96'
 b'\x14\xce\xffD\xa5c\x9ejk\xf6\x13\xf6\x11\x00\x03\x00B\xcd\x88"\xf8\r\xcfP'
 b'\xd4\xa9')

{'A1': 114,
 'A2': 13353,
 'A3': {'B1': 3538072293,
        'B2': [{'C1': 87, 'C2': 79},
               {'C1': 94, 'C2': 175},
               {'C1': 56, 'C2': 148},
               {'C1': -111, 'C2': 25}],
        'B3': 'rszps',
        'B4': [3581, 48052, 9431, 26275, 30488]},
 'A4': 2330934011,
 'A5': 36232,
 'A6': {'D1': -1637192714,
        'D2': 19,
        'D3': -2543,
        'D4': [1710815387, -392817458, -12278429],
        'D5': -846716168,
        'D6': 231690452,
        'D7': -87},
 'A7': [-97, 74, -55, -114, 106, 86, 15]}

(b'YKKH\xa1\x81\xbd:\xbaf\x1cK\x00\x00\x00:\x00\x00\x00<\x00\x00\x00>'
 b'\x00\x00\x00@pjpmdS\x08\x08"\x9e\x86\xb9!\xba\x0b\xdcl\x83\x8ft\xdb\x00J\x8c'
 b'\x98\x10\x1f\x82\x1eh\x8c/\xff\xfb\x11\xe4\x86\xc9\xb4\xf3\x1d\x92\xb9l'
 b'\xdb}s^\xe5NRb<\x00\x02\x00B\x89\xf8j\xe0E*\x03_\xe9')

{'A1': 129,
 'A2': -17094,
 'A3': {'B1': 3127254091,
        'B2': [{'C1': -116, 'C2': 47},
               {'C1': -1, 'C2': 251},
               {'C1': 17, 'C2': 228},
               {'C1': -122, 'C2': 201}],
        'B3': 'pjpmd',
        'B4': [21256, 2082, 40582, 47393, 47627]},
 'A4': 3698099087,
 'A5': 29915,
 'A6': {'D1': 1935598926,
        'D2': 82,
        'D3': 25148,
        'D4': [-1259135598, -1184048259],
        'D5': -1980208416,
        'D6': 1160381279,
        'D7': -23},
 'A7': [-116, -104, 16, 31, -126, 30, 104]}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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