ИКБО-36-22

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

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

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

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

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

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

(b'\xeePBGp\x00\x00\x00Y\xd0\x02\x00\x00\x00\x97\x00\x00\x007\xf0'
 b'\x00\xca\x16\x86r_\xe9\xe2\x84\x02\x00\x00\x00\x9b\x00\x00\x00\x05\xe2a'
 b",A\xfd\x1e\xfe\xd0'W\xf4EK@\xabs[(<{1\xeek\xd8\xbb858\x1f5\xbe\xe7\xd2\x9a"
 b'\xd3:\x06v\x95>\xcdt\xfb\xc5\xff\xd8u_\x06\xc0>\xbb\x86\x1djO\xda\xb8'
 b"\xc69\x00\x00\x00M\x00\x00\x00ptwkptq\xfb\x16'\xbaj\x86E&\x02\x00\x00\x00"
 b'a\x00\xd0O\xcf6\x07\x00\x00\x00i\x00\x00\x00\xb0\xaek\x0b\xf9{\xb2?\x1bJ'
 b'B\x10\x80Q\xf2y\xec\x94\xd0c\xf7')

{'A1': {'B1': 2757758139782076155,
        'B2': [{'C1': 3835021620904079739,
                'C2': -0.17687690258026123,
                'C3': 3550139111,
                'C4': 2507540026},
               {'C1': 8491818323199446334,
                'C2': 0.37504860758781433,
                'C3': 1780319931,
                'C4': 3334003279}],
        'B3': 20432,
        'B4': 14031,
        'B5': 'ptwkptq',
        'B6': 0.0722041752703102,
        'B7': 272779803,
        'B8': -128},
 'A2': 89,
 'A3': [{'D1': -48,
         'D2': [62033, 60537],
         'D3': 61495,
         'D4': -2096039206083704320},
        {'D1': -124,
         'D2': [53396, 63331],
         'D3': 57861,
         'D4': 2869072371686386785}],
 'A4': 6589798972402299991,
 'A5': 15400}

(b'\xeePBG\xa0\x00\x00\x00\xd9}\x02\x00\x00\x00\xc7\x00\x00\x00\x9d\x0f'
 b'\xbfS\xfe\xa4\x82\x07\x14,\xdc\x02\x00\x00\x00\xcb\x00\x00\x00\xe9\x08A'
 b'\xc5\xf1\xe4\xc6\x7f\x1dcg\x94~\x84\x06\x07.\x18\xfe\xf2\x1fs\xc6'
 b"\xe6\xfc\xd7{\xf4y\xb75\xbf\x9f\xe0\xff \xe9\xb5\x05\xef'\xef\x92\xe1#:\xe3"
 b'\xde\x82ZB\xbd\x16Q\xad\xd4!"88w\x9c\xcc\xbaI\x9a\x17\xa1.\x81<>M\x1e\xfd'
 b'D\xa1\x9f\xf5\x10q\xa7z\xe48\xfbV#\x19\xa9\xa8>6\x15LLOl\x91\xee9\x00\x00'
 b'\x00M\x00\x00\x00a\x00\x00\x00u\x00\x00\x00netpsdm\xa2\x9b/C,\x19\xc4\xc1'
 b'\x04\x00\x00\x00\x89\x00\x89\xe1\xbb\xaa\x07\x00\x00\x00\x99\x00\x00\x00zY'
 b'r@\x931\xe2\xbf\xa8\x8ap\xc5WNa/\xb0\xa8yk\x8b')

{'A1': {'B1': -4484431651057722462,
        'B2': [{'C1': -829832225116228833,
                'C2': -0.7098308205604553,
                'C3': 553640095,
                'C4': 4010128873},
               {'C1': -2385999451793461465,
                'C2': -0.04744959622621536,
                'C3': 3568128278,
                'C4': 943202849},
               {'C1': -6838827867681547145,
                'C2': 0.18408653140068054,
                'C3': 1157439053,
                'C4': 284532641},
               {'C1': 2546498861094578033,
                'C2': 0.32941511273384094,
                'C3': 1280054582,
                'C4': 4002507855}],
        'B3': -7799,
        'B4': 43707,
        'B5': 'netpsdm',
        'B6': -0.5685516604160477,
        'B7': -982480216,
        'B8': 87},
 'A2': 217,
 'A3': [{'D1': 125,
         'D2': [24910, 45103],
         'D3': 3997,
         'D4': 3176171894898316223},
        {'D1': -36,
         'D2': [31144, 35691],
         'D3': 2281,
         'D4': 7142005076300776769}],
 'A4': 1742337830413046887,
 'A5': -3330}

Вариант №2

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

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

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

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

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

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

(b'\x14VLW\x87\x00\x03\x00\xa5\x00\x0c\xb7t\xbf\x91\xceB?=T\xd3\x99AK\xbbi\xf7H'
 b'P\xe8\xdc\xd4\x05c2!\x01\xe3\xaf\xe5\xf5\xddl\xa0\rv\xf6/\xc7\xaaD\x1c'
 b'\xa5U-\x04\x00\x00\x00\x1b\x00\x00\x007\x16\x10.\xa2y\xbb2\x02\x00\x00\x00#'
 b'\x00\x00\x00$"\xe8\xca\xf8HR\x11\x04\x00\x00\x00\'\x00\x00\x00d\xc8M\xfe\x0c'
 b'0\x8fc\x02\x00\x00\x00/\x00\x00\x00\xb2\x1dD\xe0x\x86\xff\xf7\x02'
 b'\x00\x00\x003\x00\x00\x00Y\x864\x16D\x17<Sf\xb4|\xbdB\xd9\xbb\xe2\xbf'
 b'\x05\x00\x00\x007\x00\x9a\xee\t\xf2\xb8\x84\xea\xfa\x0f\x98\x91\xd4?W'
 b'P\x1a\x15}\xff\xabP')

{'A1': {'B1': 102,
        'B2': -0.5854307464141102,
        'B3': [{'C1': [20552, -8984, 1492, 12899],
                'C2': 772806199,
                'C3': 851147170},
               {'C1': [289, -20509], 'C2': 3404210724, 'C3': 290605304},
               {'C1': [-2587, 27869, 3488, -2442],
                'C2': 4266510436,
                'C3': 1670328332},
               {'C1': [-14545, 17578], 'C2': 3762560434, 'C3': 4160718456},
               {'C1': [-23268, 11605], 'C2': 372541017, 'C3': 1396447044}],
        'B4': -4454,
        'B5': [9, 242, 184],
        'B6': 0.3213863521629394,
        'B7': 20567},
 'A2': [5402, 65405, 20651],
 'A3': {'D1': -0.9559180736541748, 'D2': 0.7609644532203674},
 'A4': 61,
 'A5': 17827986531820360532}

(b'\x14VLW\x9d\x00\x05\x00\xbb\x00\xa3\xc6k?\x02\xa3<?\xbc\xfa\xd4QQ&'
 b'\x19\xfa\r?R\xbb\x1f\xb4/\x1e\x9e\x17\xaa?\xd3O\x8ar\xb5Uh\xe2\xeb\x847C?R'
 b'\xe9\xa6\xdc\x1d\x90\xfdo~\xd9\x02\x00\x00\x00\x1b\x00\x00\x00\x9c\x02\xc0'
 b'\x18\xf0{\xda\xec\x02\x00\x00\x00\x1f\x00\x00\x00\xf9SF\x8a\x05Z\xf0'
 b'N\x04\x00\x00\x00#\x00\x00\x00\xa24\xfc\r\xd1\xc9a\xd8\x03\x00\x00'
 b'\x00+\x00\x00\x00\xac\xd2\x04j\xb0T\x9c\x0b\x03\x00\x00\x001\x00\x00'
 b'\x00@\xb6\xf4\xb3r\x1f\x89\x08\x03\x00\x00\x007\x00\x00\x00\xc7\x10\x96'
 b'\xbc\xf0\xa1\xe0>\xbcvO{(\x10\x80\xea?\x06\x00\x00\x00=\x00\xdf\x07u\xc3'
 b'\x1c\x1cH\x05\xf4\x89\x94\xef\xbf\xec%I\x8b\x12\x01C\xe3/5\xf6T')

{'A1': {'B1': -68,
        'B2': 0.8281327047975384,
        'B3': [{'C1': [21055, 8123], 'C2': 415236764, 'C3': 3973741552},
               {'C1': [12212, -25058], 'C2': 2319864825, 'C3': 1324374533},
               {'C1': [-21993, -11457, -30129, -19086],
                'C2': 234632354,
                'C3': 3630287313},
               {'C1': [26709, -5150, 14212], 'C2': 1778700972, 'C3': 194794672},
               {'C1': [16195, -5806, -9050], 'C2': 3019159104, 'C3': 143204210},
               {'C1': [-28643, 28669, -9858],
                'C2': 3163951303,
                'C3': 1054908912}],
        'B4': 2015,
        'B5': [117, 195, 28],
        'B6': -0.9868821874645195,
        'B7': 9708},
 'A2': [35657, 274, 58179, 13615, 21750],
 'A3': {'D1': 0.9209997057914734, 'D2': 0.736862301826477},
 'A4': 188,
 'A5': 1007145119034496250}

Вариант №3

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

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

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

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

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

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

(b'QUM\x17\x00=\x00\x00\x00\x83\x00\x00\x005\xcd\x1e=\xf2l\x04\x00\xb8\x00\xb9'
 b'\xdd\x0f\xcdo\xbf8\xd6\xc6\xb5Lq\xcbB\x16}\xc7~{\xfb\x88\xc3q\xff\x11'
 b'\xf6r\xf7\x13L\xb8\x11\xf2\xf5\xfe\xb8qj.\x00\x00\x00\x04\xb4*\xfeF\x02\x00'
 b';\x00\x00\x00\x1aA\xc8\xb7\xbc\xaf\x80\xf9\xdb\xbf\xac\xe3M\xb5\xc92'
 b'\n\xda\x97\xb8\x8a*\xf4\xd6\xf1WmW\xebw\x81q\xef\xab\xc8c\x91\xfb\xec\xc7'
 b'\xac~2\xfbI\n\x8e\xad(\x16.dwjcr\x00\x00\x00g\xa3\xca\x91#\x04\x00\x7f\x00'
 b'\x00\x00\x0f\xa7\xd8\xc6\n\xebk\x17\xea\xbf\xfb-N/\xbb\x98\x19\xb0\xc2\x90 %'
 b'\xc4\xb8"\xb4\x9f\xfa\x0f\xd2e5\xe5.\x9e\xf38\xe3\xf5\xea\xf7\xf4')

{'A1': {'B1': 15436298209715019193,
        'B2': 46534,
        'B3': 76,
        'B4': 373476209,
        'B5': 8197546360434509693},
 'A2': [{'C1': {'D1': -1, 'D2': -143460847, 'D3': -5116381706618123245},
         'C2': 4,
         'C3': 1191062196,
         'C4': 'qj',
         'C5': 16666,
         'C6': -0.43710343515237726,
         'C7': [-1253186644,
                -636865847,
                713734295,
                1475466996,
                2011912045,
                -1410371199,
                -74357816]},
        {'C1': {'D1': -20, 'D2': 847162567, 'D3': 3320886501109811707},
         'C2': 103,
         'C3': 596757155,
         'C4': 'dwjc',
         'C5': -22769,
         'C6': -0.8153590765634489,
         'C7': [793652731,
                -1340499781,
                622891202,
                -1272792892,
                -770704737,
                786773349,
                -482806882]}],
 'A3': 0.0387699194252491,
 'A4': 27890,
 'A5': [-11, -22, -9, -12]}

(b'QUM\x17\x00>\x00\x00\x00\x83\x00\x00\x00\xc3\xf0\x16\xbf\xefp\x02'
 b'\x00\xb8\x00\xed3\xe2\x87\xf5\x0e\xed\xf0*7\xab\x81\xa14<\x81\xd7Q\xfbC\xdc'
 b",\xc8h\xaf\xca\xe9\x88+W$Ix\xff\x0b\x11ugw.\x00\x00\x00'\xf3\xc2'\x93\x03"
 b'\x00;\x00\x00\x00\x93y\x10\xdb\xce\x89\xd4M\xcf\xbf{Wy\x9dO\xab!\xa8\xc8'
 b'\x87\xd3\x1fpI\x1b\x1c\x97\xdf\x1f\x12\xd2\xc1~/\x0b,k \xa2\x93\xe5\xe5\xba'
 b'8\xc4\xcbk\x06\x9b\x03]erzs\x00\x00\x00\x0e\xf1/{n\x03\x00\x80\x00\x00\x00%@'
 b'\xe0\x99\x8da\xd2\xed\xbd\xbfQ\x97\xa6V\xa8L\x07v\xef\xc5\xcc\\\x15\xd5!\xa3'
 b'=\xa0{\x89a\xbd\x1a\x84{Z\xcd\xc7\xb4@')

{'A1': {'B1': 17360548586292655085,
        'B2': 14122,
        'B3': 171,
        'B4': 1010082177,
        'B5': 14424145891098220417},
 'A2': [{'C1': {'D1': 104, 'D2': -1997944145, 'D3': 1228356215476868907},
         'C2': 39,
         'C3': 2468856563,
         'C4': 'ugw',
         'C5': 31123,
         'C6': -0.24456269005687448,
         'C7': [-1652992133,
                -1474188465,
                533956552,
                471550320,
                304078743,
                796836306,
                543894539]},
        {'C1': {'D1': -94, 'D2': -1159338605, 'D3': 6702371122338055224},
         'C2': 14,
         'C3': 1853566961,
         'C4': 'erz',
         'C5': 16421,
         'C6': -0.1169101226965732,
         'C7': [1453758289,
                1980189864,
                1556923887,
                -1558063851,
                -1988386755,
                -2078622367,
                -942843269]}],
 'A3': -0.5896112322807312,
 'A4': 28911,
 'A5': [-76, 64]}

Вариант №4

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

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

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

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

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

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

(b'FRSOm=\x94\x14}\x92\x10\xc7\x04\x00\x00\x000\x00\x00\x00\x04\x00@\x00'
 b'\x00\x00T\x00T\xf4\x96\xd5C7?\x04\x94\xa1\xd1\x82\x82\xec\xcf\x12'
 b'\x1a\x97\xa4\xd0 \x00\x00\x00$\x00\x00\x00(\x00\x00\x00,\x00\x00\x00lkfc'
 b'\xeeb\x8b\xba\x1a\xa8\x9b\x8b\x19\xe7\xd7`\x90\x02\xe5\x88\x1bb\xae\xc2'
 b'\x86\xb0\xb8\x94\xae\xad;[\xbb\x9f\x1bDS\xe6W\x08S[\xf0\xea?\x90\n\xd4'
 b'>\xef\x10}Ka\xd0\x0f\xb7?\x1bU"\x04\x00\x00\x00D\x00')

{'A1': -4102618194620695187,
 'A2': [{'B1': 14147, 'B2': 1087},
        {'B1': -24172, 'B2': 33489},
        {'B1': -4990, 'B2': 4815},
        {'B1': -26854, 'B2': 53412}],
 'A3': 'lkfc',
 'A4': {'C1': 27,
        'C2': [98, 174, 194, 134, 176, 184, 148],
        'C3': 174,
        'C4': 5999950976421411757,
        'C5': {'D1': 0.8418404218416498,
               'D2': 0.41414308547973633,
               'D3': 239,
               'D4': 0.09008505225527963,
               'D5': 21787,
               'D6': 34,
               'D7': [-1165270290, -1952733158, 1624762137, -1998257520]}},
 'A5': -711527340}

(b'FRSO\x02\xbb\xb6\x90\xab\x08\xeb\xe0\x02\x00\x00\x00(\x00\x00\x00'
 b'\x03\x000\x00\x00\x00;\x00\xb0gS\xb43_\xecu\xc0\xe4x\xa2 \x00\x00\x00'
 b'$\x00\x00\x00gip\xc0\xc40\x01\xe9\x03\xe0d\x9a\xb28\x94\xcd\x04\xeeEvQvw\x89'
 b'\x0f\xe3\r\xb3\xc8\xb1\x8b9\xec\xd8\xeb?\xf6E0\xbf\x1b\xe4\xe8\xf8'
 b"'\xc7\xbf\xe9\xbf\x1e~\xf7\x02\x00\x00\x003\x00")

{'A1': -2239686856726365438,
 'A2': [{'B1': 24371, 'B2': 30188}, {'B1': -6976, 'B2': 41592}],
 'A3': 'gip',
 'A4': {'C1': 154,
        'C2': [178, 56, 148, 205, 4, 238, 69],
        'C3': 118,
        'C4': -5544525910352890287,
        'C5': {'D1': 0.8702298282565204,
               'D2': -0.6885675191879272,
               'D3': 27,
               'D4': -0.8046603947361999,
               'D5': 32286,
               'D6': -9,
               'D7': [19973312, 1692402665]}},
 'A5': -1269602384}

Вариант №5

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

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

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

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

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

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

(b'YOE\x07\xb9\xec\x18ST\x00\x06\x00I\x00W\xbfX\xec\x0b\xbf\xe7\xe0"\xdd'
 b'R\x87,\x00\x00\x00t\x00\x05\x00y\x00\x8e\xbe_\x1f\xc7\xbf\xd7\xfe'
 b'\xe7\xbf\xe20\xd0\x00\x00\x00\xab\xbf\xed\xc7\x9d\xf1\x90\x0flA\x9dL'
 b'L\xbf\xdfr-\xfe\x07\xe5Drtjuok\xbd\x90\xe14\xbc\xadp?\x86\xdf!\xf3\x93'
 b'T\xf5\x1cf\x96\xa3f\x90m\xb4<\xe7L`\x00\x02\x00\x00\x00O\x13<9 W\x8e\xc0\xd1'
 b'\x9fycdse\xfbn\r\xf2Q\xcb-\xe6\xfbw\xa6\x87\xd9\xb2M\x96\x08f3$\xd8\x99'
 b'\xf5\x9a\x1dGv\xbe}\x9b0\x8dV{\xb3\x00\x04\x00\x00\x00~\x19|R#,xs\x19\xd6')

{'A1': 129625112,
 'A2': 21332,
 'A3': [{'B1': 'rtjuok',
         'B2': {'C1': 34527,
                'C2': [33, -13, -109, 84, -11, 28, 102, -106],
                'C3': -93,
                'C4': 7390527609398316128,
                'C5': [3180388660, 3165483071],
                'C6': 322713888},
         'B3': -0.8473517298698425,
         'B4': -0.7461103747084272,
         'B5': {'D1': 87, 'D2': 2395001247}},
        {'B1': 'ycdse',
         'B2': {'C1': 2150,
                'C2': [51, 36, -40, -103, -11, -102, 29, 71],
                'C3': 118,
                'C4': -4720446201582421069,
                'C5': [4218293746, 1372270054, 4218922631, 3652341142],
                'C6': 427577891},
         'B3': -0.21789465844631195,
         'B4': -0.3749331830847611,
         'B5': {'D1': 44, 'D2': 2020809174}}],
 'A4': -0.9306173055669951,
 'A5': 1100827724,
 'A6': -0.49134397323321743}

(b'YOE\xe5K\xef\\\xe2\xba\x00\x05\x00I\x00^?{\xbaJ\xbf\xefp\xd4z:\xd0\x9a\x00'
 b'\x00\x00{\x00\x04\x00\x80\x00\x94\xbf:F\x14\xbf\xe53G9\xbea\x8c\x00\x00\x00'
 b'\xb1?\xe3Bl\x03\x05\xf7\x1aZ)\xa0\xbc\xbf\xb5\x02\xdd5\xcdJ\x00grjeodh'
 b'\xcb\xcc0)\xea\x94\xec\xf9\x07\x91\x96\xa9@\x978{sY\x1da\x9c\x08\xe4"'
 b'\x85LJ\xeb\xa6V\x7f\xd3\x12\x00\x04\x00\x00\x00NG\xdc\x90\xdfpUq\x97\xc6odvw'
 b'\rrsc\xab\xd6\x9b[_a|\nsY\xacii\xea\xfe\xe6\xc1\x84\xce\xf0\xbbwP\x8d'
 b';\xd6\xfe:\x19\xd4$\x00\x04\x00\x00\x00\x84\x85\x0bD\x02n\x96A\xdcL')

{'A1': -448008356,
 'A2': 58042,
 'A3': [{'B1': 'grjeo',
         'B2': {'C1': 14459,
                'C2': [115, 89, 29, 97, -100, 8, -28, 34],
                'C3': -123,
                'C4': 5497465394807427858,
                'C5': [1684589516, 808053396, 3975743377, 2527674519],
                'C6': 1205637343},
         'B3': 0.9833112955093384,
         'B4': -0.9825231921481816,
         'B5': {'D1': 112, 'D2': 1433507782}},
        {'B1': 'odvw',
         'B2': {'C1': 27114,
                'C2': [-2, -26, -63, -124, -50, -16, -69, 119],
                'C3': 80,
                'C4': -8269779903350975452,
                'C5': [225604451, 2882968411, 1600224266, 1935256681],
                'C6': 2232108034},
         'B3': -0.7276318073272705,
         'B4': -0.6625095489317103,
         'B5': {'D1': 110, 'D2': 2520898636}}],
 'A4': 0.6018581446694242,
 'A5': 1512677564,
 'A6': -0.08207495273135379}

Вариант №6

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

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

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

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

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

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

(b'FKCR\x02\x00\x00\x00n\x00@\xe3\x02\x00v\x00\x00\x00\xc0C\xa0\xb2\x94T'
 b'\xa3\xbf\x10\x13T\xbe\x81V\xb1aFeE\xcc\xe8U\xbb5-\xf2x\xa6\x05\xb5'
 b'\xbfS\x16\x93\\HN0;\x07\x06\xe8\xe5\xbf\xc4\x95\x17\x7f\xda\x0b\xdc\xbf\xfcX'
 b'\xc9\x84"]\xdc?\xb2%\x9a\x9f\x92S\xe5?\xf8\xf9\x01H\xcbo\xc4\xbf\xf3\xc8'
 b'%\xbf\xe2`R \xc3\xec\xed\xbf\x01\x1f\x0e?V\x00\x00\x00b\x00\x00\x00hz')

{'A1': [{'B1': -0.15966168418886162, 'B2': -0.6475974917411804},
        {'B1': -0.9351516371998765, 'B2': 0.5551605820655823}],
 'A2': 58176,
 'A3': {'C1': 'hz',
        'C2': -0.03775467567914559,
        'C3': -0.20710396766662598,
        'C4': -3727461763618089343,
        'C5': {'D1': 11995603883490235880,
               'D2': [5, 181, 191, 83, 22, 147, 92],
               'D3': 72},
        'C6': [-0.6845731869921197,
               -0.4382234803327629,
               0.4431844994300176,
               0.6664517514447452]}}

(b'FKCR\x02\x00\x00\x00n\x00HW\x02\x00v\x00\x00\x00\x04\xb20\xc1\xcfa\xe9?\x8cj'
 b'\n?\x1d\xdc\xf2A\x87\x83\xc4\xa9$\xfcm\x80\x0f\xc9\x07/\xdfz\x99X\x93\xb1'
 b'\x8e\x808b\x02U\xe5\x11\xd6\xbf@\x97\x89\x18\xf6\xd6\x95?.\xc3|\x85\xa6v'
 b'\xec\xbf\x00\xa1\xb4\x10\xa3\x97\x86?\x18\x81\xeb\x10\xf2\x92'
 b'\xdd\xbf\xa6\x89-?\x88~\xec\xd4\x02_\xc9?\x80R\x10\xbeV\x00\x00\x00b\x00'
 b'\x00\x00oe')

{'A1': [{'B1': -0.4620938458665633, 'B2': 0.6778815984725952},
        {'B1': 0.19821200749082757, 'B2': -0.14093971252441406}],
 'A2': 22344,
 'A3': {'C1': 'oe',
        'C2': 0.7931898854490673,
        'C3': 0.5406882762908936,
        'C4': -6213696968914183139,
        'C5': {'D1': 3388898313035971620,
               'D2': [223, 122, 153, 88, 147, 177, 142],
               'D3': -128},
        'C6': [-0.34484227468195483,
               0.02132782482876583,
               -0.8894837004828327,
               0.011031412074388403]}}

Вариант №7

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

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

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

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

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

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

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

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

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

(b'\x0fQUX\x9f\xfc\x00\x00\x00\x03\x00??\xe5\x8eE\x98\xf7\x1f>\xa4\x85\x8d&'
 b'\x9a\x05\x94{\x07\xa3\xab\xd2\x04\xdf5\xbf\xec6U\x97\x1f\xa8H\x00'
 b'\x00\x00B\x00s\x00u\x00w\x00y\x00{\x00}\x94\xa7\x1cnzmk\x91\xbc'
 b'\xb8\xe6\xda\xe6\x14\xbfX\xcb.\x8cX3\xc2\xc4\xaf5\xdb!W\x8b\x84z5.'
 b'.\xd1\x94\xeb\xd1j;i{\x93f\x13\xad8\xf5\xf9\x81\xc1\x82\xaer\x0c9\xef'
 b'\x0c\x13\xcf\xb4<k\x8e\r\xcc\x15\xee')

{'A1': {'B1': -24580,
        'B2': 'zmk',
        'B3': 0.6736171710590282,
        'B4': 164,
        'B5': -2054347110,
        'B6': {'C1': 402081539483750916, 'C2': 57141}},
 'A2': -0.8816326095232023,
 'A3': {'D1': 10501471732775654591,
        'D2': 6398258875920007876,
        'D3': -1355424991,
        'D4': {'E1': 22411,
               'E2': {'F1': -8900743241074109205,
                      'F2': -11926,
                      'F3': 59,
                      'F4': [27003, 37734, 5037, 14581, 63873, 49538, 44658],
                      'F5': 3129}}},
 'A4': [{'G1': -17, 'G2': 12},
        {'G1': 19, 'G2': -49},
        {'G1': -76, 'G2': 60},
        {'G1': 107, 'G2': -114},
        {'G1': 13, 'G2': -52},
        {'G1': 21, 'G2': -18}],
 'A5': [38055, 7278]}

(b'\x0fQUX*\x1d\x00\x00\x00\x02\x00??\xedF\xb1\x84\xbe\x94\x1eH\xe6\xf7#Tq \xa1'
 b'\x9ai\x88Z\xd5\xa2\xad\xbf\xeb;z\xbd@\xe7\xb2\x00\x00\x00A\x00r\x00t\x00'
 b'v\x00x\x00z\x00|\x8bU|?mqQ\x94\x1d\x8f\x9c\x18\xdb\x06\x82/j8\xc7\x0c\xfd'
 b'm\xeb\x82\xed\xd6(\x9aLh\x1892\x19)\xaf\xabx$\x14\t<\x9c\x0b \xd3\xd0\n4'
 b'\x04_\x03\xec\xc7\xa2\xe6\xfe\xdc\xbf\xd1)\xa0\x90T\xbc\xae\x8c')

{'A1': {'B1': 10781,
        'B2': 'mq',
        'B3': 0.9148795693078033,
        'B4': 72,
        'B5': -420011180,
        'B6': {'C1': 8151693010108177109, 'C2': 41645}},
 'A2': -0.8510106750829805,
 'A3': {'D1': 5878355916261743366,
        'D2': -9065910732783288979,
        'D3': -343740970,
        'D4': {'E1': 10394,
               'E2': {'F1': 5505677178393143727,
                      'F2': -21640,
                      'F3': 36,
                      'F4': [5129, 15516, 2848, 54224, 2612, 1119, 1004],
                      'F5': -14430}}},
 'A4': [{'G1': -26, 'G2': -2},
        {'G1': -36, 'G2': -65},
        {'G1': -47, 'G2': 41},
        {'G1': -96, 'G2': -112},
        {'G1': 84, 'G2': -68},
        {'G1': -82, 'G2': -116}],
 'A5': [35669, 31807]}

Вариант №8

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

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

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

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

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

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

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

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

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

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

(b'KUHY\xb1\x05,S\x00\x00\x00Y\xec&V\x00\x00\x00\r\x18\xd7Y\x00\x00\x00z\x1fm'
 b'\x00\x00\x00\x83\x00yrfvzs\x92\x00\x00\x00k\xb3D\x90\x1d\x0f\x8e\xb3\xfe'
 b'\xd6\xc3\x1d\xf5\xd4\x16\xb2\xbb\x15\xfb\xa0\x1fo9\x9e\xe1\x8fT"2i\x9d\x8ew'
 b'\x94@\x11\x0c\xdb\xa6\xfdq\xe0.\x92|\x97\xb2D\xe5.\x80\xa7\xc0Ynq\xe8\x9csui'
 b'\xc7\x99\x1a}1\xe3\xbc\xbd\xc8\x80\x19\xa6BF(\x80\xbf\\\x00B\xf0\xfe\r\xd6'
 b']\xe2?\xa8>\xcd>\xb0\x93S\xf7(\x0b\xe8\xbf\xfc\x12\xbf<\x08\xa1\xbed\x83')

{'A1': 1457,
 'A2': [{'B1': 44, 'B2': {'C1': 113, 'C2': 12000}, 'B3': 60505},
        {'B1': 38, 'B2': {'C1': 146, 'C2': -26756}, 'B3': 6157},
        {'B1': -41, 'B2': {'C1': 178, 'C2': -6844}, 'B3': 8058}],
 'A3': {'D1': -17181,
        'D2': 51389,
        'D3': -0.007889317425690434,
        'D4': {'E1': [32814, 49319, 28249, 59505, 29596, 26997, 39367, 32026],
               'E2': 49},
        'D5': 0.5739546082836642},
 'A4': {'F1': 0.40086865425109863,
        'F2': -0.751362307605282,
        'F3': 252,
        'F4': 18,
        'F5': -65},
 'A5': 'yrfvzs',
 'A6': {'G1': -0.31451594829559326, 'G2': 33636},
 'A7': [2420421483,
        3012431645,
        499373822,
        2987840757,
        2700809659,
        2654564127,
        575967201,
        2392680754],
 'A8': {'H1': -27529, 'H2': 3675001152, 'H3': 64934}}

(b'KUHY\xbeG\xaeS\x00\x00\x00\x07)\xdaV\x00\x00\x00.(\xe8Y\x00\x00\x00\x83sm'
 b'\x00\x00\x00\x83\x00kjoiwu\x92\x00\x00\x00\x10,8;\x16\n^\x8c\xff\x96c\xe5R'
 b'\x0e\x07\xec\x1d\xf8\xc2\xdfb\xbfQ5C\xa1c\x8e\x8e|@\x8c6Z5$w\xdbL\x89\xfa'
 b'\x83c\xb5n<\xcd7\x06\xd8\x0f\xc3\x00\xdc\xaf\xf3-m\xb3F\x1dD~g@1\xeeE\x07'
 b'\xce\xe8\xc1\xb8\xb3qG\xe6?\\\x00\x02z!\xc6\xa8\x14\xed\xbf\xb2&V?Z'
 b'\x99l\xaf\x17\x9d\xe4\xbf$\xe1r\xc1\xd0X>qo')

{'A1': 18366,
 'A2': [{'B1': -82, 'B2': {'C1': 250, 'C2': 25475}, 'B3': 10503},
        {'B1': -38, 'B2': {'C1': 181, 'C2': 15470}, 'B3': 10286},
        {'B1': -24, 'B2': {'C1': 205, 'C2': 1591}, 'B3': 29571}],
 'A3': {'D1': 17902,
        'D2': 52743,
        'D3': 0.696221209544146,
        'D4': {'E1': [4056, 195, 45020, 11763, 45933, 7494, 32324, 16487],
               'E2': 49},
        'D5': -0.908771883939892},
 'A4': {'F1': 0.836527943611145,
        'F2': -0.6441763330702017,
        'F3': 36,
        'F4': 225,
        'F5': 114},
 'A5': 'kjoiwu',
 'A6': {'G1': 0.2117338329553604, 'G2': 28529},
 'A7': [993537040,
        2354973206,
        3848509183,
        3959885394,
        3754096669,
        894549858,
        2388894019,
        2353036430],
 'A8': {'H1': 23094, 'H2': 3682018357, 'H3': 35148}}

Вариант №9

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

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

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

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

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

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

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

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

(b'ZFTVch\x9c\x00\x03\x00K3#\x98`\x9cW\x00\x02\xe4\xb6SK>\x7f\x11\x1a\xf0'
 b'\x86\xd6\t\xa2\x00\x00\x00r{:\xd6\xa0\x9a\x91\xf0\xd0K\x07e\x04\xd4\xfd}6'
 b'\x9a\x87\xf0\x8b\xb2\x03\x88\x81\xe2\x07\x95\xc4Y\xa0K\xc6\xdfC\xf4,'
 b'\xb2q\xc2\x00\x00\x00$\x00\x00\x001\x00\x00\x00>\xbe\xc4\xfd\xb6?8\xe8l;'
 b'\x02\xf4\xb1}4\xa4M8\xb1\xdf\x98\x94\xd6]=][\xdd\xe2/\xf9\xc4\xbe\x84'
 b'\xd1*\x93\xaaE\x0b\xbc\xa0\x18%O\xc3\xf8\x89\x00\x02O\x06\x00\x02'
 b'\x00\x00\x00W\x00_\x00\x02\x00n?$T\x9c')

{'A1': 26780,
 'A2': [{'B1': 2067453600, 'B2': 11137948130866586884, 'B3': -44},
        {'B1': 4252841626, 'B2': 9795482786210546146, 'B3': 7},
        {'B1': 2512673184, 'B2': 5460297081185677937, 'B3': -62}],
 'A3': 13091,
 'A4': -26528,
 'A5': {'C1': -100,
        'C2': {'D1': 22272, 'D2': [2, -28, -74, 83, 75]},
        'C3': 62,
        'C4': 9156129137777576354},
 'A6': {'E1': 3794794948,
        'E2': -0.25940829515457153,
        'E3': [-1817557749, -1130358747, 1338243209],
        'E4': 151302,
        'E5': [-0.3847481608390808, 0.7222964763641357],
        'E6': {'F1': 59,
               'F2': 49590653,
               'F3': 13476,
               'F4': 5564392913511962205},
        'E7': [15709, 23517],
        'E8': 0.641916036605835}}

(b'ZFTVc\xe9\x7f\x00\x03\x00K\x92\xad\xee \xc3\xa9\x16\xb3H\xb3\xc7\xf8\xa758ia'
 b'\xc1\xefF\t\x00\x00\x00r\xed\xfaE\xa5D\x04\xa6L\x88\nh^\xb7\xd0\x97\xe4'
 b'\xbdi\xe2\x82\xee\xcd\x02\xd4#\xab^ \xe9M\x19\xc0\x90B\xda\xc4j"\xc0\x00'
 b'\x00\x00$\x00\x00\x001\x00\x00\x00>\xbe\xde\xfc\xd3\xbe[6\xfc\x06'
 b'\x1d\xba\x07\x02f\xd9\xdb\xb2f\x11\xee\x0f\x835h\x1c?\x7f\x97kd\xac>\x8d'
 b'\xdc\xbb/\x8b\xb2Sl\x1ax\x88\xc3m\xb9\xf8\xac\xbd\x99\xb9\x00\x02'
 b'\x00\x00\x00W\x00_\x00\x02\x00n\xbeju2')

{'A1': -5761,
 'A2': [{'B1': 3992602021, 'B2': 4901225142116051038, 'B3': -73},
        {'B1': 3499615421, 'B2': 7629804680872383523, 'B3': -85},
        {'B1': 1579215181, 'B2': 1855641663289190946, 'B3': -64}],
 'A3': 37549,
 'A4': -4576,
 'A5': {'C1': -61,
        'C2': {'D1': 43286, 'D2': [-77, 72, -77, -57, -8]},
        'C3': -89,
        'C4': 3834930951292405257},
 'A6': {'E1': 2540397740,
        'E2': 0.2770746648311615,
        'E3': [797684307, 1813674120, -1016219144],
        'E4': 2898106809,
        'E5': [-0.4355226457118988, -0.2140769362449646],
        'E6': {'F1': 6,
               'F2': 498730754,
               'F3': 26329,
               'F4': 15830827867355185973},
        'E7': [26652, 16255],
        'E8': -0.22896268963813782}}

Вариант №10

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

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

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

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

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

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

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

(b'UPSC\x10\x00\x8f\x00\x00\x00\x04\x00\x00\x00\xa7\x00\x14.\xf4>\xe6\\\xa7\x10'
 b' CT\xa8p\xdc\xbf\x7f^\x89>\t\xd0\xf1\xfb\\\xc4\rRF\xe1\xba\xe3\\/\x1f\x9aC'
 b'S2U}\xbe+\\%R\xcb\xa8\xae8\x1f\x00\x17.$\xe5\x83\x93\x91\xc4+'
 b'\x00\x9d\xdb\xd3=\xc6\xb4\xc1\xc9x\xc5\xf3\xa4\x81nb\xa4{\x15\r\x84\x0e}\xc9'
 b'\x88e\xe5\r\x0e\x17\xe2N\xc8\xd7\xaaM\x00\x1fle\xb2\xb7y\x1aDY\x00A'
 b'\x00o\x006\xb8~\xbf\x0f9(\xbd\xad\xae\x1f\xbe\x8c\xc7k\xbe\x02\x00{\x00\x04'
 b"\x00\x7f\x00;\x07\xd6\xc2Km\xb7\x0bHt)\xcc'\xc7\xc4?\x91\xac\xd7\xad")

{'A1': {'B1': 0.47691404819488525,
        'B2': 23782,
        'B3': -89,
        'B4': -0.44437607029658555},
 'A2': {'C1': [{'D1': {'E1': 0.26829907298088074, 'E2': 5912597789450293257},
                'D2': 11799,
                'D3': 58660,
                'D4': -27773,
                'D5': 50321,
                'D6': {'F1': 57670,
                       'F2': 5999808587316913082,
                       'F3': 5919238628197618994,
                       'F4': [203, 168, 174],
                       'F5': 56}},
               {'D1': {'E1': 0.10344622284173965, 'E2': 11886060964132533446},
                'D2': 27679,
                'D3': 45669,
                'D4': 31159,
                'D5': 17434,
                'D6': {'F1': 28289,
                       'F2': 9011285096144807010,
                       'F3': 16291505629882058953,
                       'F4': [78, 200, 215],
                       'F5': 170}}],
        'C2': [-0.9949983358383179,
               -0.04107004031538963,
               -0.15593977272510529,
               -0.2302533984184265],
        'C3': 844263627314038587,
        'C4': 0.16232774227947488},
 'A3': [145, 172, 215, 173]}

(b'UPSC\x10\x00\x93\x00\x00\x00\x08\x00\x00\x00\xab\x00\xf6m\x1c\xbf'
 b'e\xe9\xf2\xd4\xca[\xcbEK\xe2?\x00G\xbf>\x10?\xef\xe1\xd6\x03\x9e?\x9f'
 b'\xc3q\x91\xaf+\x93-\xe1y\xd2\xc8](\xe1\x9e\x94\xb8\xca\n\xbe\xfb\x1f\x00S'
 b'|\xe7E\xc0\x15Z\x07+\x00\x0c\xc3i\xbe7\xe5$\xfe\x0f\xc4\x198\xbe\xd5R'
 b'\xd1\xbb\xe9t\xd4z\x0f\xab}\xf99\xd2\xc6\x8a\xf6(\x88\xc3\x95M\x00\x9f@]'
 b'\xef\x9aW6\x1eY\x00A\x00o\x00\x9aK\xdf>\x95c3?0\xed\t\xbe\xe9\x927>\r'
 b'\xcb\x0e\xbf\x02\x00{\x00\x05\x00\x7f\x00ik%"\xd1@O\xeb\x0cr|K\xe6%\xe7?\xa7'
 b'\xbdJ\xab\x12\x9d\\\x85')

{'A1': {'B1': -0.6110528707504272,
        'B2': 59749,
        'B3': -14,
        'B4': 0.5716885539862582},
 'A2': {'C1': [{'D1': {'E1': 0.37358856201171875, 'E2': 4584105692158181136},
                'D2': 31827,
                'D3': 17895,
                'D4': 5568,
                'D5': 1882,
                'D6': {'F1': 50079,
                       'F2': 8782350858465546609,
                       'F3': 13300430289413982418,
                       'F4': [202, 10, 190],
                       'F5': 251}},
               {'D1': {'E1': -0.2282831072807312, 'E2': 4042477713509115191},
                'D2': 16543,
                'D3': 61277,
                'D4': 22426,
                'D5': 7734,
                'D6': {'F1': 54718,
                       'F2': 1115437456330314066,
                       'F3': 17765230286334426539,
                       'F4': [40, 136, 195],
                       'F5': 149}}],
        'C2': [0.43612366914749146,
               0.700738251209259,
               -0.13469386100769043,
               0.17927135527133942,
               -0.5577858090400696],
        'C3': 16955842389038426985,
        'C4': 0.7233764147127331},
 'A3': [167, 189, 74, 171, 18, 157, 92, 133]}

Вариант №11

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

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

(b'BWUH\xb1\x00-\x004\x00;\x00B\x00\x00\x00\x03\x00I\x00\x00\x00l\x0c'
 b'%\x97\xc4\x00\x05\x00\x00\x00\x8b\xd60-\x86\xbf\xe3\x14\xa6\x94\x19S'
 b"N\x9b\xbe\xb8\x1b\xcc]\x15\xf9?W\xd4\xdcM\x19\xed?'\x15\x11Y\xfe\x9c?"
 b'L\xee\xb5S\x92iyc\x86\xa6>\xcc\xd7\x1c\xc4\xd9\x90\xbdo\x92R\x92\xd7\xa0'
 b'z\r\xdfP\xf6\x91\xe7-m\xf5\xd0\xc64x_\x0f\x02\x00\x00\x00\x03\x00\x00\x00'
 b'L\x0bX\xfe\xa7\x88\x18\x98\x15\x00\x05\x00\x00\x00X\xbf\xe6\xcd\x06\xbb'
 b"'\xce\x16-\xa3N\xef\x9b")

{'A1': [{'B1': -101, 'B2': -0.35958707332611084, 'B3': 23829},
        {'B1': -7, 'B2': 0.8430917263031006, 'B3': 19737},
        {'B1': -19, 'B2': 0.6526651978492737, 'B3': 23038},
        {'B1': -100, 'B2': 0.8005173802375793, 'B3': 21394}],
 'A2': 'iyc',
 'A3': {'C1': {'D1': 2,
               'D2': [2259041996, 3608986841, 2428333970],
               'D3': 817683327864051733,
               'D4': [1385355168,
                      2047729488,
                      4136757037,
                      1844826310,
                      880303887],
               'D5': -0.7125276236897118},
        'C2': 203790276},
 'A4': [45, 163, 78, 239, 155],
 'A5': -701485690,
 'A6': -0.5962708370740104}

(b'BWUH\xb1\x00-\x004\x00;\x00B\x00\x00\x00\x02\x00I\x00\x00\x00s\xec\x13:K\x00'
 b'\x03\x00\x00\x00\x92#\xa9\xd8=\xbf\xec\xe3\xa5^e9tx?I\xf7\xbc\xa8\xda'
 b'v\xbf[\xc76\x89M\x94?@\xa5\xd6\xe0\xb9w?1\x08\x0b\x95\rss\xebM\xad\xc3<'
 b'\x1bE\xb6\x9e\xd4\x9cK\x8d\xb4\xb9\xd47\x1e)L+\x17\x84\x1d\x16\xc9rk\xa6'
 b'\xb07F\xbe\xbe+h\x07\x92\xe0<2\x00\x00\x00\x04\x00\x00\x00K\x8e\xc6\xd9\x95'
 b'\x94\x04\xb2\x15\x00\x06\x00\x00\x00[?\xe5\xa8\xf8\xda{+dU\x8c\xc5')

{'A1': [{'B1': 120, 'B2': 0.7889363765716553, 'B3': 43226},
        {'B1': 118, 'B2': -0.8585084676742554, 'B3': 35149},
        {'B1': -108, 'B2': 0.7525304555892944, 'B3': 57529},
        {'B1': 119, 'B2': 0.6915289759635925, 'B3': 38157}],
 'A2': 'ss',
 'A3': {'C1': {'D1': 50,
               'D2': [3947736515, 1008420278, 2664733771, 2377431508],
               'D3': 10288149635231166997,
               'D4': [924723532,
                      722961437,
                      382300779,
                      2796566342,
                      3200133992,
                      127066172],
               'D5': 0.6768764750680529},
        'C2': 3960683083},
 'A4': [85, 140, 197],
 'A5': 598333501,
 'A6': -0.9027888148937522}

Вариант №12

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

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

(b'VWQJ\x00\x03\x00\x00\x00\x19\xfa\x82\x00\x1c\x004\xae=\xfbJ[\x00\x00\x00dddj'
 b'\xedY\x8cUfWe\x01x\xaa\x16\xbe\x9f\xb1>=\x85\xc9j\n\xbfFY\xf1\x8eg\xdf9'
 b"'\xb5\xdfN\xfb\x15\x0cH~r`\xbfY\x1c\xdat\xbd\x98\xb5\x17\x88X;9\xb0d\t<"
 b'\xc2*\xcb8\x0eyp\x04b>6\xbcG\xc5\xcb\xad\r-*f\xd1\x9c\x01\x7f\x00\x06\x00L'
 b'\xc8F\x86\x18-\x02H:$')

{'A1': 'ddj',
 'A2': 64130,
 'A3': [{'B1': 237,
         'B2': [22924, 21862, 22373, 376, 43542, 48799, 45374],
         'B3': {'C1': 0.06532557308673859, 'C2': 10},
         'B4': -0.7748098969459534},
        {'B1': 142,
         'B2': [26591, 14631, 46559, 20219, 5388, 18558, 29280],
         'B3': {'C1': -0.848096489906311, 'C2': 116},
         'B4': -0.07456415146589279}],
 'A4': 44605,
 'A5': -1206,
 'A6': 91,
 'A7': {'D1': 949461717536735615,
        'D2': [-2007483591,
               -1335621316,
               -1037382856,
               242839556,
               1648244412,
               1204145069],
        'D3': -4015374579361757126,
        'D4': 36}}

(b'VWQJ\x00\x07\x00\x00\x00\x19.\x12\x00 \x008s\x10r\xc16\x00\x00\x00Xndredes'
 b'\t\xeb\x8b\xf3NhR\x97*\x84v\xeb\x14\x10%\xbd\xe2{\xb1\x95\xbf}\xf6\x0c'
 b'\x8f\x96\xd3\x87\x89;\xc0\x9b\xdcu\xfd;\xa7\xc9\xc9\xbe\xbc\x8f\x1f\xca'
 b'\xbfH\x1c\xfcy\xdd\xdem\x10\xef~\xd5p\xed+4\x93]9\xe7\x00\x02\x00PE\x8di\x89'
 b'\xda\xac\xe9}c')

{'A1': 'ndredes',
 'A2': 11794,
 'A3': [{'B1': 9,
         'B2': [60299, 62286, 26706, 38698, 33910, 60180, 4133],
         'B3': {'C1': -0.11058748513460159, 'C2': -107},
         'B4': -0.9920356273651123},
        {'B1': 143,
         'B2': [38611, 34697, 15296, 39900, 30205, 15271, 51657],
         'B3': {'C1': -0.36827942728996277, 'C2': -54},
         'B4': -0.7816922664642334}],
 'A4': 29456,
 'A5': 29377,
 'A6': 54,
 'A7': {'D1': 8137207606539008487,
        'D2': [2044583533, 284131029],
        'D3': 5011778001133431165,
        'D4': 99}}

Вариант №13

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

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

(b'CRSb[\x00\x00\x00\x03\x00\x00\x00n\x00\x00\x00\x18%\xc2f\x9c\xb6\x96\xa1'
 b's\xd4\x02\x00\x00\x00q\x00E\x86\x8f<\x18\xf9)\xbf_C \x00\x86\xe8\xcfL'
 b'\xde>\xa2Z^F?\x88z~?]S1=\xbf&%o\xbf\xc5Q\x1c\x03\xbfr\x97\xd5>u&4\x9d>Al'
 b'\x9a>DS\xfdE?(\x00y)hybcerr\xb8\x19\x1c\xf3\x06I\xcb?kcn\xb7\x8b\x93\xa1')

{'A1': {'B1': {'C1': 17247,
               'C2': {'D1': 0.017520079389214516, 'D2': -0.6639571189880371},
               'C3': 59526,
               'C4': [{'E1': 0.43417975306510925,
                       'E2': -94,
                       'E3': 0.7748771905899048},
                      {'E1': 0.9940571784973145,
                       'E2': 93,
                       'E3': -0.7390338778495789},
                      {'E1': -0.934160590171814,
                       'E2': -59,
                       'E3': -0.5121508240699768},
                      {'E1': 0.41717106103897095,
                       'E2': 117,
                       'E3': 0.30703848600387573},
                      {'E1': 0.3016071617603302,
                       'E2': 68,
                       'E3': 0.7733966708183289}]},
        'B2': 10617,
        'B3': 'hybcerr',
        'B4': 0.21316611166566957},
 'A2': 'kcn',
 'A3': 9496,
 'A4': 15308757227043317442,
 'A5': [-29769, -24173]}

(b"CRSb[\x00\x00\x00\x02\x00\x00\x00n\x00\x00\x00\xa0'g\xec\x8c\xf3\xc6$"
 b'\xad\xe9\x02\x00\x00\x00p\x00\xe7\xaa\xbf>\xe0\x0b\xc5\xbe\xaf\xfd \x00'
 b'W\x89=\xe9\r\xbe\x8e?\x00\x11\xbf \x93>?\xbdS\x85\x88>\xa3\xdfL<\xcd[\x02A'
 b'\xbf7Y\xb1\xbe\x8a\x81\x85W\xbe\x82\xc5\xe4\xbev\xb3\xd2\xc3>(\x00\x92\xa6j'
 b'jkbjhq\xf4Er\xcd\x88\xc5\xed?ci\n\xf7\x0b|')

{'A1': {'B1': {'C1': 64943,
               'C2': {'D1': 0.37435075640678406, 'D2': -0.3848562240600586},
               'C3': 35159,
               'C4': [{'E1': -0.13858504593372345,
                       'E2': -114,
                       'E3': -0.5664100050926208},
                      {'E1': 0.7444324493408203,
                       'E2': -67,
                       'E3': 0.26664218306541443},
                      {'E1': 0.01250449102371931,
                       'E2': -51,
                       'E3': -0.7539421916007996},
                      {'E1': -0.3463837802410126,
                       'E2': -118,
                       'E3': -0.21047021448612213},
                      {'E1': -0.44681936502456665,
                       'E2': 118,
                       'E3': 0.3824668824672699}]},
        'B2': 42642,
        'B3': 'jjkbjhq',
        'B4': 0.9303630840897186},
 'A2': 'ci',
 'A3': 10144,
 'A4': 16838155018716376167,
 'A5': [-2294, 31755]}

Вариант №14

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

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

(b'LHA\x84\x1ed\xbf\xd1qblc\xae|\xfd\xf2\x86\xb5\xec?6\x00\x00\x00P\x00\x00\x00'
 b'k\x00\x00\x00\x86\x00\x00\x00\xa0\x00\x00\x00\xb8\x00\x00\x00;\xdd\xe5>'
 b'\x8e\xbc\x17?u\x86\x02\x00,\x00\x00\x00\x02\x004\x00>\x0e4\x8a\x134\xb7G'
 b'n\xbf\x91\xde\x19>%\xa8\x02\x00F\x00\x00\x00\x02\x00N\x00\x10\x92\xf0\x01xr'
 b'\x9e\xa8\x1c?\xd8ML>![p\x02\x00`\x00\x00\x00\x03\x00h\x002\x8c\xc7i)s\xb4'
 b'\xaf\xd4>\x07KQ?\xcc\xcc3\x02\x00{\x00\x00\x00\x03\x00\x83\x00\xb2\xdd\xdco'
 b'0\xde\x18\x1a\xab\xbe\xf3:\xa8\xbcZ\xb5\x02\x00\x96\x00\x00\x00\x02\x00'
 b'\x9e\x00\xfe\x11|,\xaf\x1azw\xc2>"\xed\xdeX\x02\x00\xb0\x00{\xd2\xa1\x98'
 b'\xf1\x0b\x823\xfa')

{'A1': -0.8910906314849854,
 'A2': {'B1': 209,
        'B2': 'qblc',
        'B3': 0.8971590753461862,
        'B4': [{'C1': [0.4489534795284271, 0.5927208662033081],
                'C2': [117, 134],
                'C3': 3646,
                'C4': 873695796},
               {'C1': [-0.9307817816734314, 0.15026308596134186],
                'C2': [37, 168],
                'C3': -28144,
                'C4': 1920467440},
               {'C1': [0.6119478940963745, 0.199515700340271],
                'C2': [33, 91, 112],
                'C3': -29646,
                'C4': 1932093895},
               {'C1': [0.41540300846099854, 0.8175510764122009],
                'C2': [204, 204, 51],
                'C3': -8782,
                'C4': 3727716316},
               {'C1': [-0.3341834545135498, -0.020535921677947044],
                'C2': [90, 181],
                'C3': 4606,
                'C4': 447687804}]},
 'A3': {'D1': [1052931962, 1491004706], 'D2': 123, 'D3': 18028896721103790546}}

(b'LHAM)q?4vsxi\xc8\t\x90H\x1a}\xeb\xbf7\x00\x00\x00R\x00\x00\x00l\x00\x00\x00'
 b'\x86\x00\x00\x00\xa0\x00\x00\x00\xbc\x00\x00\x00\x11-^>\xf5\x05D\xbf'
 b'\x9de\xb0\x02\x00,\x00\x00\x00\x03\x004\x00H{\x0cz\xfaP.\\\x9b>\xf1'
 b'\xf3\x0b?g\x0f\xdb\x02\x00G\x00\x00\x00\x03\x00O\x00\x98N7.\xd4\x85R\xc8'
 b'!\xbfGl\x08\xbe\x11\x93\x02\x00b\x00\x00\x00\x02\x00j\x00|\x12{kzr'
 b'I\xb8\x8e\xbe\xa5Sa\xbf8\x12\x02\x00|\x00\x00\x00\x02\x00\x84\x00'
 b'\x88\x92.\xb4\x9f\x16\xa2\xd1I\xbf\xf7]\xe9\xbe\xa4F\x02\x00\x96\x00'
 b'\x00\x00\x02\x00\x9e\x00/3\xf9\xdc0\xb6X\xa9\xf7\r\x0b?f\xaa>\xf2g7'
 b'\x03\x00\xb0\x00\xc6\x893`RET!\x15')

{'A1': 0.9420364499092102,
 'A2': {'B1': 52,
        'B2': 'vsxi',
        'B3': -0.8590213219870799,
        'B4': [{'C1': [0.21696878969669342, -0.7657158970832825],
                'C2': [157, 101, 176],
                'C3': 31560,
                'C4': 1358592524},
               {'C1': [0.30343765020370483, 0.5466910004615784],
                'C2': [103, 15, 219],
                'C3': 20120,
                'C4': 2245275191},
               {'C1': [-0.6319628953933716, -0.13322554528713226],
                'C2': [17, 147],
                'C3': 4732,
                'C4': 1920625531},
               {'C1': [-0.2787497341632843, -0.8801825642585754],
                'C2': [56, 18],
                'C3': -28024,
                'C4': 379565102},
               {'C1': [-0.7883549928665161, -0.455795019865036],
                'C2': [164, 70],
                'C3': 13103,
                'C4': 3056655609}]},
 'A3': {'D1': [234334552, -1436139765, 929559102],
        'D2': 198,
        'D3': 1522590805739451273}}

Вариант №15

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

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

(b'ASOJ\x92\x00\x00\x00\x90\x86\x0b\xcb\xb0/\xd1\x83\xafbb\xe8\x02\xb6IB'
 b'7\xba\x98\xd2\xd5\xd2\xb3?&\x1ck\xe4=\xa2\x94nI\x00\x03\x00\x00\x00\x97\x7f'
 b'\xcd?\xd4\x89\x1a\xe3\xf3\x8a\xa8?\xd9\xf2\xa3\x1c\x96\xcb,\xbf\xe3['
 b'\xf2\x83\xa8\x18\xd8r\xc6\xf0\x89\x1b\xb1\xcf*\xe0\xce!E O\xf67hi\x9e'
 b'\xa2\xcc\x06z\x16dd\x92\x10\xc4\xc0x\x0f+A\x9fu\x00I\x00R\x00[\x00d>\x05q'
 b'5\xbfY"\xbb_\x00\x04\x00m\xe2\xf9\x82\xfd\xce\xc9\x8f\xd1\xbd\xdd\\\x07o\xea'
 b'\xf2\x00\x00\x00u\x89Talr')

{'A1': {'B1': 242,
        'B2': {'C1': 0.1303146630525589,
               'C2': -0.848186194896698,
               'C3': 95,
               'C4': [{'D1': 8270562237378318122, 'D2': -32},
                      {'D1': 14853229051127412584, 'D2': 105},
                      {'D1': 11430923132409898084, 'D2': -110},
                      {'D1': 1208302221925237151, 'D2': 117}],
               'C5': 16355247548380319697,
               'C6': -0.10808568447828293,
               'C7': 28650},
        'B3': 35156},
 'A2': {'E1': -31221,
        'E2': 203,
        'E3': [-5751147835615452440, 195424182588840146, -3039169714717955100],
        'E4': 0.07938466966152191},
 'A3': 73,
 'A4': 'alr',
 'A5': [127, 205],
 'A6': [0.32086822758553035, 0.4054343966665097, -0.6049740382593667]}

(b'ASOJ\x92\x00\x00\x00\xa6\x89\x96O\xf7\xb2\xd3\xc0p\xe0\xa2\xadz#\xd3\xf0'
 b'7\x9a\x05\x84\xd2\xd9s\xa9Q\xbb\x10x\xbf\t\xb7a\x8c\x00\x03\x00'
 b'\x00\x00\xad\xf6\xbd\xbf\xd9\xff\xfc\x1f\x82_\x04\xbf\xe28\xc8~\x8a\x85'
 b'@?\xdaM\xbev\xd8td\x1b\x03\xc0z\xcbp\x06\xe7?\x9c\xe7kb\x99%Y\xc9@\x8f'
 b'\x82\xae\xebn\xa7\x94\x8aTU\x8ca\xaf\xc4v\xc5]=\x06p\xb4\xa3\x00\xc5\x92'
 b't7_\x08\xca\x9b2\xde\x8cv\xa4\x00I\x00R\x00[\x00d\x00m\x00v\xbe'
 b'\xe5\x00\x16\xbe\xd2\xe2L\xd3\x00\x06\x00\x7f\xee7\xf6\x1d\x93\xfek\x17'
 b"\xbf\x17\th'\xc2\x84\x00\x00\x00\x8b\x88\x01xxh")

{'A1': {'B1': 132,
        'B2': {'C1': -0.44726628065109253,
               'C2': -0.41188275814056396,
               'C3': -45,
               'C4': [{'D1': 1946611097585845991, 'D2': 63},
                      {'D1': 11306123460757248457, 'D2': 64},
                      {'D1': 10341020020593104010, 'D2': 84},
                      {'D1': 6164409397506655581, 'D2': 61},
                      {'D1': 464069373804778100, 'D2': 55},
                      {'D1': 6847946001339026550, 'D2': -92}],
               'C5': 17165459111643343639,
               'C6': -0.5899872779846191,
               'C7': 10178},
        'B3': 34817},
 'A2': {'E1': -30314,
        'E2': 79,
        'E3': [-598182977005903187, 8801111125490533764, -3253442084740591496],
        'E4': -0.5379543900489807},
 'A3': 140,
 'A4': 'xxh',
 'A5': [246, 189],
 'A6': [-0.4062490756709709, -0.5694315406327988, 0.41099511724480053]}

Вариант №16

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

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

(b'!HVZ?$\xea\xda\xaei\x8b\x9a\xc0:\x98\xf6\xc6f\x00\x00\x00.zm\x00\x00\x00\x02'
 b'\x00\x00\x00A\x00\x02\x00Q\xde\x91?\xe80\x15R\x99\x03\xe89B\x08\x14ovcxd\xfb'
 b'\rc&\x12H\xce\xdb\xa3t\n\xb1T\xca\x00\x02\x009\xff\xa6\x99Y\x00\x02\x00'
 b'=?\xe4:J[\xcex\xd6\xbf\xe91\xa8\x172\xa2\xac')

{'A1': 0.644208550453186,
 'A2': {'B1': 12567729731920369910,
        'B2': 50790,
        'B3': {'C1': 14658, 'C2': 2068, 'C3': 'ovcxd', 'C4': 64269}},
 'A3': 'zm',
 'A4': [{'D1': 179393738, 'D2': [25382, 4680]},
        {'D1': 4289108313, 'D2': [52955, 41844]}],
 'A5': [0.6321155350776972, -0.7873115971643379],
 'A6': 56977,
 'A7': 0.755869542430557}

(b'!HVZ\xbe\x90np\xc9;\xff*%\x06\xd7\xf9\xf7\xa3\x00\x00\x00.hr\x00\x00\x00\x03'
 b'\x00\x00\x00G\x00\x02\x00_\x8d\x19?\xd9d\x856\x03\x1bLp\xc6\x01\xa6zgejs^'
 b'\x80\x1d\x9c\x92\xd0\x16\x1d\xb9\xb4\n\xab\x0c\tKr\xf4\xdcQ\xe3\x00'
 b'\x02\x009{\tg\xea\x00\x02\x00=Rqlc\x00\x03\x00A\xbf\x8f-A\xb8\x0e\x8d\x80?'
 b'\xd2\xa2\xecT\xa1\x04\xcc')

{'A1': -0.2820925712585449,
 'A2': {'B1': 14500463981724358649,
        'B2': 63395,
        'B3': {'C1': 28870, 'C2': 422, 'C3': 'zgejs', 'C4': 24192}},
 'A3': 'hr',
 'A4': [{'D1': 4108079587, 'D2': [7580, 37584]},
        {'D1': 2064213994, 'D2': [5661, 47540]},
        {'D1': 1383165027, 'D2': [2731, 3081, 19314]}],
 'A5': [-0.015223039082974621, 0.291194040914047],
 'A6': 36121,
 'A7': 0.3967602755987414}

Вариант №17

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

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

(b'OGID\x00^\xcdc\xab\x12\xfe[eJ>h2\xc3?\xba\x03\x0e\xf1\x12\xfe`\xbf\xd0'
 b'\x0fJ\xd4C\xdb\x8c?\xe2957T \xfa\xc1\xd3#\xbfF\xeb\xc7\xae!\xeb'
 b'\x7f\x13\x00\x00\x00\x02\x00\x0eM\x1b$\xce\x00\x00\x00\x02\x00\x10\xd1P'
 b'\xe54\x00\x00\x00\x03\x00\x00\x00\x12\xfc\x00\x02\x00\x00\x00*\xf1\xea\xab'
 b'\xd1\xcc\x00.3D\x0b\xde\x00\x00\x00\x05\x00\x00\x00Y?\xecQ\x91$\xf3\x02\x90')

{'A1': {'B1': {'C1': 1189857198,
               'C2': 569081619,
               'C3': [{'D1': [62, 104], 'D2': 1293624526},
                      {'D1': [50, 195], 'D2': 3511739700}],
               'C4': [0.1016091669616741,
                      -0.25093336800585386,
                      0.5694833832394857],
               'C5': -4,
               'C6': [-15917, 9151]},
        'B2': 13124,
        'B3': 3038,
        'B4': [-15, -22, -85, -47, -52],
        'B5': 0.8849569055237954},
 'A2': -849106158,
 'A3': 4267402570}

(b'OGID\x00]S\xa7W\xcb\x82k>\xc3\xbe-\xcc\x18\x8a\x8e?\xd6bN\xd2_Sl'
 b'\xbf\xc1A\xcb,\x1c"8\xbf\xb9\xc1\xc5\xb5\xaaE\xe0\xfc\'\xc2\x8cc\x8fM0\rFi%'
 b'\x00\x00\x00\x03\x00\x0ek\x0cS\x11\x00\x00\x00\x03\x00\x11\xf9\xe5\x13H'
 b'\x00\x00\x00\x03\x00\x00\x00\x14\xb5\x00\x02\x00\x00\x00,\xebN\x000\x9f'
 b'\xd6\xe8x\x00\x00\x00\x02\x00\x00\x00[?\xeb\x11\x86m\xb0\xa38')

{'A1': {'B1': {'C1': 1670335792,
               'C2': 222718245,
               'C3': [{'D1': [190, 45, 204], 'D2': 1795969809},
                      {'D1': [24, 138, 142], 'D2': 4192539464}],
               'C4': [0.3497502378862041,
                      -0.1348203626041753,
                      -0.1006129807012921],
               'C5': -75,
               'C6': [-985, -15732]},
        'B2': -24618,
        'B3': 59512,
        'B4': [-21, 78],
        'B5': 0.845889295805228},
 'A2': 1403475915,
 'A3': 2188066499}

Вариант №18

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

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

(b'XULQe\xbf}\x04\x9b(\x06\xc4\xc2`\x00b\xeaZ\x97K\x82\x91 \x93\x90q\xbfT'
 b'\xe0\xb6\xc3c\xb8`\x8dH\xdb[>\xc5\x88\x02\x00\x19\x00\x00\x00H\xee\xf1Y-'
 b'W\x85gR\xb1\x1d\x02\x02g\xc5\xbe9c\x02\x001\x00\x00\x00\x9b\xc4\x80\x89\x1f'
 b'\xc6\xb7=\x8a\xdc\x000\x8f\x90,\xae\r\xe9\xbf\x02\x00I\x00\x00\x00ocR\xd6'
 b'\xf5\x13!\x009\x00K\x00\x00\x00')

{'A1': -4412394963447022145,
 'A2': {'B1': 'oc',
        'B2': 334878290,
        'B3': [{'C1': 36192,
                'C2': 0.21470367908477783,
                'C3': 35013,
                'C4': [-531316879, -1201421386],
                'C5': -4536},
               {'C1': 541,
                'C2': -0.3855515122413635,
                'C3': 25401,
                'C4': [1462589937, -1319999611],
                'C5': -15205}],
        'B4': {'D1': 0.08973335474729538,
               'D2': -118,
               'D3': 220,
               'D4': -0.7829199667362214,
               'D5': [-128, -119]}},
 'A3': {'E1': 2346800142010215010, 'E2': 147, 'E3': 144}}

(b'XULQe\xe70\xcc@\x9et\rLb\x00\r\xe9\xccS\x859\xc9\x0bk$\x95\xd3\xea'
 b'n\xb0\xe4\x95\xac\x13\xd3\x88\xcc\xf0>=\xb8\x02\x00\x19\x00\x00\x00\xd2'
 b'B\xd5\xa1N\xaf\xa3j\x14X*|\xdacR\xbfn\x7f\x02\x001\x00\x00\x00V\x84\xc0\xcd%'
 b'\xf8k\xf9\x03\xbf;I-8\xbc3\x19]\xce\xe6\xbf\x04\x00I\x00\x00\x00oy\xa6\x83Ql'
 b'!\x009\x00M\x00\x00\x00')

{'A1': 5480164544620540135,
 'A2': {'B1': 'oy',
        'B2': 1817281446,
        'B3': [{'C1': 54035,
                'C2': 0.4703104496002197,
                'C3': 47165,
                'C4': [1860883349, -1399462736],
                'C5': 17106},
               {'C1': 31786,
                'C2': -0.8218361139297485,
                'C3': 32622,
                'C4': [-1353801259, 1477733027],
                'C5': -31658}],
        'B4': {'D1': -0.5155245661735535,
               'D2': 59,
               'D3': 11593,
               'D4': -0.712690877173265,
               'D5': [-64, -51, 37, -8]}},
 'A3': {'E1': 849273249535420685, 'E2': 107, 'E3': 36}}

Вариант №19

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

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

(b'SZT\xbf3\\\xdel\xf7\xdb\xa4\x1ak\x89\xe5\x0f\xf2|\x86\x83\x81\xafi\xa7'
 b'5y\xa5\xc1\xe6`\xb3\xfc9\xad\x96h\xdb\xe7v\x1e\xea\xfb\x02#\x95\xe2,\\'
 b'\xfb?\xe6\xd7\x14+E\x9f\xda\x00\x00\x00\x02\x00?\xce\xaeD\x9b|>\xd3+\xe4'
 b'\xad}c\xb0i%4\xf7=\xafL\xa4\xc7\xa5\x8a\x15\xe3\xa0D\xf4\xfa.\xcah(\xb7\xb87'
 b'\xa82\xb2?\x19[rSr\xb58\xfa\x97\xb2\xfd\xd9\x1c\xf0\x8b\xa9\xf7\x91N\x03'
 b"\x8d-'wv\xa6\x8f\xe1\xb6")

{'A1': -0.7006357908248901,
 'A2': 1828182948,
 'A3': 1903766884402232454,
 'A4': {'B1': 33665,
        'B2': 44905,
        'B3': 42805,
        'B4': 8765625444955585593,
        'B5': [12508300308758535914, 18087058180124990715]},
 'A5': 0.7137547345309898,
 'A6': [{'C1': 3467527323,
         'C2': {'D1': 124, 'D2': 0.41244423389434814, 'D3': 44413},
         'C3': [25520, 26917, 13559, 15791],
         'C4': [76, -92, -57, -91, -118, 21, -29, -96],
         'C5': 4968871367767763127},
        {'C1': 3090655282,
         'C2': {'D1': 178, 'D2': 0.5990515947341919, 'D3': 21362},
         'C3': [-19144, -1385, -19715, -9956],
         'C4': [-16, -117, -87, -9, -111, 78, 3, -115],
         'C5': 3253700607282766262}]}

(b'SZT\xbeIE\x8d\xd9\xf1S\xc6\xee\xb2\x04VL\xf3\x1b]f\x05FX1(\x94U\x9a'
 b'\n%\xba\x94\xcb\xf5\xec3n\xd98T\xc2\x98v\x9f\xcd\x0e\xa2\xa2\xd5?\xca\x10'
 b'\xdfl.\xf6x\x00\x00\x00\x02\x00?4\xb9>\xae\x82?<!\xf9\xf9\x95A3'
 b'\xe9\xde\xfd\x1dQ\xc2\xe0D\x88}\xb0\x9aZ.\xee\x95Q\xdcaI\x84\xee^\x01'
 b'\x81\xb8P=\x85S\xd1~\x0fu-.G\xfa\xfb\xa2\xd6\xb6\x80\x1c\xe9A3zq\xdcX\x9f'
 b'Z\x99\xac\x0bW')

{'A1': -0.19655437767505646,
 'A2': 3656471494,
 'A3': 17199814695586044765,
 'A4': {'B1': 26117,
        'B2': 18008,
        'B3': 12584,
        'B4': -7758125414702476085,
        'B5': [17720595184979825858, 10986144044079555285]},
 'A5': 0.20363991529841363,
 'A6': [{'C1': 884555438,
         'C2': {'D1': 130, 'D2': 0.7348933815956116, 'D3': 63893},
         'C3': [16691, -5666, -739, 20930],
         'C4': [-32, 68, -120, 125, -80, -102, 90, 46],
         'C5': 17191737159523599598},
        {'C1': 1577157048,
         'C2': {'D1': 80, 'D2': 0.0651012733578682, 'D3': 32271},
         'C3': [29997, 11847, -1285, -23850],
         'C4': [-74, -128, 28, -23, 65, 51, 122, 113],
         'C5': 15877615697768745815}]}

Вариант №20

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

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

(b'MZXS\x00\x00\x00Lh?RON6\x11\xcc\x9e*\n\xd8,/\xd9\x00\x00\x00\x83!\xbfs&F'
 b'\x01z\xe3\x17\xf8i\xc5\xae\xcdC\xd8>$,m\x8b@yAx\xbeu\x93\xdc\x07\xcem\xfc'
 b'\xbfki\xdd\x00\x00\x00\x02\x006\x00\x02\x00\x00\x00:.\xbf\xddhx\x01L\x1b'
 b'P\xbeb!,\xab\xb4B\x9fZ\xfe=\xd2^v\x00<\xbe>\xb7iK\x18[\x99\x80\xb1E'
 b'\xcc\x90\x8f?\x11\xf3\x9f\x00\x00\x00\x02\x00i\x00\x06\x00\x00\x00mH'
 b'\xbf\xcb(\x83\xb3\x89q\x80=\xea\xd3~0\xd2\xfb\xa7C\x8d\xc3\x81\xb9O\x00s'
 b'\xbe\xca\x07\x0c')

{'A1': [{'B1': {'C1': {'D1': 46,
                       'D2': -0.4595012676876893,
                       'D3': -0.22082966566085815},
                'C2': -21580,
                'C3': 4800655775805628022,
                'C4': {'E1': -0.9195840954780579,
                       'E2': [-27684, 1998],
                       'E3': [109, -4]},
                'C5': -0.18624652922153473},
         'B2': 104,
         'B3': 0.82152259349823,
         'B4': [54, 17, -52, -98, 42, 10, -40, 44],
         'B5': 12249},
        {'B1': {'C1': {'D1': 72,
                       'D2': -0.2121739031453096,
                       'D3': 0.11466120183467865},
                'C2': 12498,
                'C3': 18133536700780099919,
                'C4': {'E1': 0.5701236128807068,
                       'E2': [19224, 23449],
                       'E3': [-128, -79, 69, -52, -112, -113]},
                'C5': -0.3945850133895874},
         'B2': 33,
         'B3': -0.9498027563095093,
         'B4': [1, 122, -29, 23, -8, 105, -59, -82],
         'B5': -12989}],
 'A2': 3627951148,
 'A3': 7893473661430578805}

(b'MZXS\x00\x00\x00N\x17>\xbe\xe0m\xa3\x16\xee\xc5A\x87\x82\x12l+\x00'
 b'\x00\x00\x81\xb3>\xcc\xf9\xe2\x81 \xc5r \x9a\xd6+b\x86\x97W\xb3\xa6\x06\xdd'
 b'x\x9d\x9e3\x9a\x92=\x96\x04\x1a\xe5\xdc\x93z\xbe\xba\x18\xa2\x00\x00'
 b'\x00\x02\x006\x00\x04\x00\x00\x00:\xf8\xbf\xe0.6Hg\xddn>\xe8\x9c\x1c\xc6'
 b'\xa5\xe8\xcf\xc9a\xd9\x1e\x18\xb1\x00>?C\r\xabi!\x0ep\x03\x81>\x8b\x07'
 b'\xdc\x00\x00\x00\x02\x00k\x00\x02\x00\x00\x00o\x83\xbf\xe9/\xd7\x1f\xd3'
 b'mj>\xc3P\xe0\x92X\t\xf5T\xd1\xb1\xc8\xf1Z\x00q\xbe\xc1\xe9.')

{'A1': [{'B1': {'C1': {'D1': 248,
                       'D2': -0.5056411184477108,
                       'D3': 0.45431602001190186},
                'C2': -14683,
                'C3': 16775848559070025905,
                'C4': {'E1': -0.3634691834449768,
                       'E2': [15766, 1050],
                       'E3': [-27, -36, -109, 122]},
                'C5': 0.7619273066520691},
         'B2': 23,
         'B3': 0.37280598282814026,
         'B4': [-93, 22, -18, -59, 65, -121, -126, 18],
         'B5': 27691},
        {'B1': {'C1': {'D1': 131,
                       'D2': -0.7870898839568501,
                       'D3': 0.38147640228271484},
                'C2': -28072,
                'C3': 717572975243096410,
                'C4': {'E1': 0.27154433727264404,
                       'E2': [26913, 3696],
                       'E3': [3, -127]},
                'C5': -0.3787321448326111},
         'B2': -77,
         'B3': 0.40034395456314087,
         'B4': [-127, 32, -59, 114, 32, -102, -42, 43],
         'B5': 25222}],
 'A2': 2539107238,
 'A3': 494684152440003218}

Вариант №21

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

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

(b'#PDONJF\x06\x00!\x00\x00\x00\xecrD\x8dE\xbc\xec?\xa6U\x00\xa7\x13\xd6\xef'
 b'\x95Pg\xbe\x87iyapni\xd7\x82\xc5p\x03\x90\xbf\xa1g\xf0\xdb%%\xcd\x99\xcf\xa7'
 b"w'\x00\x00\x000\x00\x00\x00\x9a\nj?\xcce\xae>`x%\xbf\xb0\x8c\xf9"
 b'\xaf\x04\x94S`\x02\x009\x00\x00\x00(\x828\xf6\x03\x00\x00\x00A'
 b"\x00\xa7\x8e\xf5\xb3p\\\x80'\xd9\xc5\xf0\x93\x03z.W\xe9\xbf\xf1"
 b'\x8d\x02\x00\x00\x00M\x00\x8a~,\x1d')

{'A1': 17994,
 'A2': 'iyapni',
 'A3': 0.8979823836449135,
 'A4': 166,
 'A5': {'B1': [{'C1': -6791551368600124713, 'C2': 103},
               {'C1': -6354691442825896976, 'C2': 119}],
        'B2': 4130898472,
        'B3': {'D1': [0.9142242670059204,
                      0.34062039852142334,
                      -0.6463680267333984],
               'D2': 2846376603623460519,
               'D3': -14887,
               'D4': -0.7918922789655181,
               'D5': 36337,
               'D6': [-1342600016, 1616090116]},
        'B4': 489455242},
 'A6': 167,
 'A7': {'E1': 2515523091, 'E2': -2017564848}}

(b'#PDON\x12\x94\x08\x00!\x00\x00\x00\x00z\x11*V\xcb\xba?$\x86\x00\x9c=\x8d\xd8'
 b")l\n&zydnojhum/\x99\xb32\xea\xda])\x89'\xef,\xd8\xe8b\xdd\xa2\xe2\xd6"
 b'\xd6\xd6\xfcS_%P!CS\xdf\x8a\xf8\x86;\xf7\x1cQ\xd4f\xca\x08\xfc\xe3\xa9a)\x00'
 b'\x00\x002\x00\x00\x00;\x00\x00\x00D\x00\x00\x00M\x00\x00\x00)}Y>lH\x08>+\x03'
 b'}\xbfD\xd6\xf8>,\\f?^\xf6)\x13{\x1a\x1bq\x05\x00V\x00\x00\x00\xf3ib\x96'
 b'\x05\x00\x00\x00j\x00\x11:BQ\xdcG\xab\x80u\x80\xc4s\xc2\x84\x8a\x84\xdb?'
 b'\x98\xcd\x02\x00\x00\x00~\x00Q\xf1\x1c\xdc')

{'A1': -27630,
 'A2': 'ydnojhum',
 'A3': 0.10466516997392006,
 'A4': 36,
 'A5': {'B1': [{'C1': 2980779227796969775, 'C2': -119},
               {'C1': -6711099117513412825, 'C2': -30},
               {'C1': 5775126911501391574, 'C2': 33},
               {'C1': -631762920675519677, 'C2': 28},
               {'C1': -6204838746900736943, 'C2': 97}],
        'B2': 2523032051,
        'B3': {'D1': [0.21239151060581207,
                      0.13308876752853394,
                      -0.9883295893669128,
                      0.48600971698760986,
                      0.8998439311981201],
               'D2': 9271583269453969937,
               'D3': -32651,
               'D4': 0.4299646660309089,
               'D5': 52632,
               'D6': [321517150, 1897601659]},
        'B4': 3692884305},
 'A6': 156,
 'A7': {'E1': 702057789, 'E2': 2049313388}}

Вариант №22

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

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

(b'LYSB\x00\x00\x00\x03\x00\x00\x00O \x01\xcc\xd8\xf2\x8e\x03\xbb'
 b'\x99\xe9\x9d\xa3\xaa\xed\\\xd3S\xf2U\x85 \xb1\xbf\xc4\x12|&?\xa9\xd8\x00\x00'
 b'\x00\x02\x00\x00\x00R\xcb\xf8\x89a\xef\xf6\x8b\xbf\xe5\xf4\x8d[9\xf9'
 b'\xcc\xe9\xbc\xb0\x97\x00\x00\x00\x03\x00\x00\x00T\x00~zcxF"\xfd\xf4\xee\xbe'
 b'\xce2\r+tl\xfc"K\x8d\xea\x8e191zs\x02d\xed\xca=\xe7\xab\x91x\xe4H'
 b'\x06\xdd\x97\x14\xd2)\xa5A\r\x901\xd0\x8e\xabzW')

{'A1': {'B1': 'zcx',
        'B2': 8193,
        'B3': -3685929603240846871,
        'B4': -1650218259,
        'B5': 6688782171857297585,
        'B6': -0.15681411616908636,
        'B7': {'C1': [70, 34],
               'C2': -13320,
               'C3': 137,
               'C4': 25071,
               'C5': -2421,
               'C6': -0.6861025602118445},
        'B8': 3921457303},
 'A2': [{'D1': [-524, -4418, -12750, 3371, 29804], 'D2': 4230105997},
        {'D1': [-5490, 12601, 12666, 29442, 25837], 'D2': 3393054635},
        {'D1': [-28296, -7096, 1757, -26860, -11735], 'D2': 2772503952}],
 'A3': {'E1': 835751595, 'E2': 31319}}

(b'LYSB\x00\x00\x00\x05\x00\x00\x00O\x1c&\xb2s\xdb\xc7\xb7y)\xe7 \x04\xd7<\xbel'
 b'\x8eA\xbd\xf8\xea\x02?\xc1\xefm\xad\x16C0\x00\x00\x00\x04\x00\x00\x00TN\xc8'
 b"\x07\\\xe7\xe4\xd3\xbf\xea\x13'\xee~\x18\xe4\x80\xb9\x06\x8c\x00\x00\x00"
 b'\x03\x00\x00\x00X\x00\x82rnkbq\xff\xd9v\xbd\xf6\xf7\x92\xd9pD\xffy'
 b'+\xfb\x86\xcf\xa6[\xe2\xb8\xcb2\xafZ\x94\xd8\x0c\x11\x1a@y;\x17\xc91\xd9'
 b'\x18\x8f\x87F5\xcd8\xb1z\x84["eus\xf4')

{'A1': {'B1': 'rnkbq',
        'B2': 7206,
        'B3': -5587881061813507609,
        'B4': 537188156,
        'B5': -4725245496007267838,
        'B6': 0.1401192755843339,
        'B7': {'C1': [-1, -39, 118, -67],
               'C2': 20168,
               'C3': 7,
               'C4': 23783,
               'C5': -6957,
               'C6': -0.8148383768136935},
        'B8': 2159609484},
 'A2': [{'D1': [-2313, -27943, 28740, -135, 11259], 'D2': 2261755483},
        {'D1': [-7496, -13518, -20646, -27432, 3089], 'D2': 440432955},
        {'D1': [6089, 12761, 6287, -30906, 13773], 'D2': 951155332}],
 'A3': {'E1': 1528980853, 'E2': 29684}}

Вариант №23

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

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

(b'TLYGRQ\xb0-\x00\x00\x00\xcd\xea\xef\xdd@\xd0\xac\x00\x04m\x8f[F\x00\x00\x00v'
 b'\x00\x00\x00q\xa0\xb37W}\xdb\xcf\x07\xe0\x07O.\x98\xeb\xe9j\\0\xd7Z'
 b'\x900\xdfFc\x99@\x0bE\x88^\x03)Z*\xa7\x1c\xfe\xa3\xc8Z\x97A\xf6\xea\x97\xa5/'
 b'\xf3\x98\x18\xf6IBB\\\x9b\xbe\x8b\xa0\x97\x82\xb9\x98\x11\x96\x81\x9b'
 b'\x00\xd0\xd2/\x1a\xffk\xc7\xf2\xbeT\x81n?\x0c\t-?\x0e\xc5xk\x03\x1c'
 b'\xe4s\x8bi\x12\xc0j\xe8,\x8c\n,\x9c\xe2\x86>@\x95\xd3\xe8\xf6\x8d\xa7d'
 b'`\xc0V\\\xcb\x1fC\x872?\xb8H\xc8>\x1b\xb6\xc5\xbe')

{'A1': 45137,
 'A2': {'B1': 1550510571,
        'B2': -1873094864,
        'B3': 48,
        'B4': -8627477139079084321,
        'B5': 1512637278,
        'B6': 4263290666},
 'A3': [-5427, -8721, -12224, 172],
 'A4': 1536126212,
 'A5': [{'C1': 51363,
         'C2': {'D1': -26790,
                'D2': [2548758081,
                       2566074277,
                       1112143384,
                       3197852738,
                       2190975115],
                'D3': 14988150540759832761,
                'D4': 4279906258,
                'D5': -0.47417768836021423},
         'C3': 0.9316608905792236,
         'C4': 0.6759192943572998},
        {'C1': 50446,
         'C2': {'D1': 27512,
                'D2': [1944329219,
                       3222432139,
                       2351753322,
                       3801885706,
                       2504015494],
                'D3': 13862190323850471635,
                'D4': 533421142,
                'D5': 0.6973764300346375},
         'C3': 0.39117980003356934,
         'C4': -0.38615497946739197}],
 'A6': -24463,
 'A7': [2102867891, 3758608347],
 'A8': 2553171719}

(b'TLYGR\xd1\x8d-\x00\x00\x00FW\xff\x9a\xbc\xa2\xf6\x92\xd8\xbb\x81\x10F'
 b'\x00\x00\x00v\x00\x00\x00\x16+\xb0]\x12\\\x84O\x03F\x0e\xb7`X\x1f;\xcf'
 b'\x8f]\x19O\x97\xf8\xba\xdf\xbf\x05\xb7d\x05\xc3\xe4\xfd.\xd8\xba\xbe'
 b'\x7f\xd5\xc2y\x1d\xd69\xb2ab\x9fv\xab\xa6:Zp\xbb:\x12\xa0\x0c\xd0PAI\x88\xe1'
 b'\xb4^\x03l\xa6C\xab\x06J\x15W\xc8s\xbf\xae\x8c:\xbffX\x97\xbe\t3\x07N\xecp'
 b'\r\x86\x13F\x930d\x06H\xd2\xbb\x9a\x1e\xb8\xee(?Q\xeao\xd3k\xb6q'
 b'\x1b\x19#\x95E\x16]\x04n\xbf\xe3\t3\xbfv}i\xbf')

{'A1': 36305,
 'A2': {'B1': 2412722975,
        'B2': -1756423843,
        'B3': -8,
        'B4': -4393995124191797318,
        'B5': -668008988,
        'B6': 3581918906},
 'A3': [22342, -25857, -23876, -27914],
 'A4': 276937688,
 'A5': [{'C1': 31170,
         'C2': {'D1': -10723,
                'D2': [1650569785,
                       2796254879,
                       3144702522,
                       211817018,
                       1229017296],
                'D3': 4874702408404754824,
                'D4': 357172907,
                'D5': -0.9522756934165955},
         'C3': -0.7287091016769409,
         'C4': -0.29559630155563354},
        {'C1': 13065,
         'C2': {'D1': 19975,
                'D2': [2249027820,
                       814958099,
                       3527935588,
                       3089013435,
                       1363093742],
                'D3': 1809164703626391530,
                'D4': 373658915,
                'D5': -0.9297540783882141},
         'C3': -0.6993696093559265,
         'C4': -0.912070631980896}],
 'A6': 11030,
 'A7': [1544707504, 1174622084],
 'A8': 1482733326}

Вариант №24

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

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

(b'EYX\xd8Sp\xe6\xbc\xa6y:k\x1by7\xa2l\xf3\xa9C\x9eR\xe0\x1a\xad\xd3\xec\x8c'
 b';\x9c5\x87\xec\xe6\xbf\x0fj\xc6\xe58sfllr\x0c\xf0\x98\x08\x9fC\x05_\x08\x00M'
 b'\x00\x02\x00\x00\x00\x8d\x00\x00\x00\xdd7>\xfd\x85\x95H\xe2\x86X\xee'
 b'w\xacy\xaf\x9e\x93\xa9Tue\xa2?6; \xeb\xbc\xa1\x86\x1cQ[\x87\xca\xe21+\x1e'
 b'u\xad8\x04\xc4\x84\xf4\x97C\xdaL\x14\x16\x0fj\xe0[\x85\r\xad\x07\x95a^'
 b'JT\x9d\r\xe3\xde\x0b\x0f\x966\xffr\xdd<Q$\x8c\xd3\xc4\xf2\xf1ERS\xcbp\xb4F'
 b'\xa0')

{'A1': [{'B1': 83, 'B2': 112, 'B3': 48358, 'B4': 31142, 'B5': 58},
        {'B1': 107, 'B2': 27, 'B3': 14201, 'B4': 27810, 'B5': -13},
        {'B1': 169, 'B2': 67, 'B3': 21150, 'B4': 6880, 'B5': -83}],
 'A2': {'C1': 60627,
        'C2': -0.7163730666232921,
        'C3': 3854985743,
        'C4': 56,
        'C5': 'sfllr',
        'C6': 6846953158809808908,
        'C7': [8454568851968850348,
               -4833734336366796187,
               -2104721049569687903,
               -4322267424723424463,
               1590981068689241220,
               553113195659684367,
               -2085838067052158571,
               -2489647034071577634]},
 'A3': [17434213520372945212, 11549116690978787909],
 'A4': {'D1': -35, 'D2': -2047001033, 'D3': 149},
 'A5': 57928,
 'A6': 2012108934}

(b'EYX\xd8\x8cU\xb5\x9acI\xa1\xaa\x97\x1db;\x1e-0\xa0\x19@0\xeb\xc0=z\xa8'
 b'\xc6I\x80\xfd\x19\xe6?\xf5\xf4\xc8G\xd2lvxic\xed\xe3\xed;xF\xd3\xd9\x08\x00M'
 b'\x00\x02\x00\x00\x00\x8d\x00\x00\x00\xfc\xee\xd8\x04\x1b\x02g'
 b'\x0f\xf8\xca\x19\xd0\xf4\xa53\x9e\xb4C\x1c`b]\xc59\xc62\x1e6\xee\xf9\x93'
 b'\xf3@\xe7~V\xe3I\xb6\xb3\xf4\x08\xc3\x7f\x12I-.\x80\x84\xb7\xf2\x1b\xa7\x8a'
 b'2%b^\x03\xa3\x19\xcc\xb0e\xcc\x83\xbcY\xc5\xd5-V|O~y\x19h\x15\xb3\xc9\xfd'
 b'\x9a\xb1\xdcD\x00\x16\x9euD')

{'A1': [{'B1': 140, 'B2': 85, 'B3': 39605, 'B4': 18787, 'B5': -95},
        {'B1': 170, 'B2': 151, 'B3': 25117, 'B4': 7739, 'B5': 45},
        {'B1': 48, 'B2': 160, 'B3': 16409, 'B4': 60208, 'B5': -64}],
 'A2': {'C1': 31293,
        'C2': 0.6906726365688955,
        'C3': 1204352245,
        'C4': -46,
        'C5': 'lvxic',
        'C6': 15695966608531776493,
        'C7': [6925484770016339444,
               3899610154303577442,
               6232673200477829614,
               9206211910355536355,
               -957150709727540974,
               242739341825845019,
               -4862818435500074589,
               9101630081517077849]},
 'A3': [11168304421944170873, 4933022784185228465],
 'A4': {'D1': -4, 'D2': 453302510, 'D3': 2},
 'A5': 3943,
 'A6': -803616008}

Вариант №25

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

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

(b'\xecNVY&i\x08\xc1ngbd\xb4\xb1.9s\xe3P\x80_\x05\x1dI\x16\xae\xff\xc9'
 b'\xc1\xbc\xa3&7?H\x008\x81\xe0\x0e\xfcs\xd7\x19\xee\x1c\xe2?\x00\n4\xd1'
 b'#O\x86?\xd4`0\xeckh\xe3\xbf\xf8\x18=?\xe5$\xc1=$\x00\x08F#\x02\x00\x00'
 b'\x000\x00\xef\x02\x00\x00\x00@\x00\x00\x00')

{'A1': 38,
 'A2': 2153,
 'A3': -63,
 'A4': 'ngbd',
 'A5': -76,
 'A6': {'B1': [{'C1': 1933127345, 'C2': -29},
               {'C1': 90144848, 'C2': 29},
               {'C1': 4289599049, 'C2': -55}],
        'B2': 48321},
 'A7': 0.7154332995414734,
 'A8': {'D1': {'E1': 249594168, 'E2': 0.5660315041274084},
        'D2': 17928,
        'D3': 35,
        'D4': {'F1': [0.010893134900929802, -0.6064967740121809],
               'F2': -17,
               'F3': [0.7386622428894043, 0.09430865198373795]}}}

(b"\xecNVY\\q~xrxgx\xf9\r\xe9\xe0\xc7\xca\x83\xb6U\x7f\x7fg\xffm\xa6'"
 b'\xee\xb5\x04,K\xbfP\x00\xea\xb7hod\xfe\xb6Nph\xd9\xbf(\x9e&5\xcd\xc1\xed?'
 b'\xc0\xf2?\xbd\xebF\xe9?B\x02\xa0<\xaf\x88\xee\xbf\xe3W ?y\x1b\x91\xbe$\x00[q'
 b'?\x03\x00\x00\x000\x00\xcb\x02\x00\x00\x00H\x00\x00\x00')

{'A1': 92,
 'A2': 32369,
 'A3': 120,
 'A4': 'rxgx',
 'A5': -7,
 'A6': {'B1': [{'C1': 3353405709, 'C2': -54},
               {'C1': 2136323715, 'C2': 127},
               {'C1': 2792226663, 'C2': 39}],
        'B2': 46574},
 'A7': -0.7936403751373291,
 'A8': {'D1': {'E1': 1869133802, 'E2': -0.39699943243974745},
        'D2': 29019,
        'D3': 63,
        'D4': {'F1': [0.929907420931106,
                      0.7899073311123956,
                      -0.9541851219256119],
               'F2': -53,
               'F3': [0.6263410449028015, -0.28341272473335266]}}}

Вариант №26

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

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

(b'SQTQV.BU\xa8\xe9hh\'\xa3\xa4"\x00\x02\x00\x84\xcbC>\xe2C!\xd6\xe6'
 b"J\xcb\xbe\xbaZ@'\xc3s+\xf7\xa9\xe6\xeaC\xd8\xd5>j\xd6a\xb9\xe5\\\xd3\xc8 ."
 b'^\xdbdydc\n\xc8\x99\xab\xf7`H\xf4)\x9aW\xcc\x00\x00\x00\x04\x00\x00'
 b'\x00:\xbf\xd6\x0e\xb3\xb5\xb7\x04\x98\x00\x00\x00>;[zi\xddd\xf4\xbc\xbf:'
 b'\xfbr\xd5\xbd=\x12\x00\x00\x00\x02\x00\x00\x00`\xbf\xe1\x97\xe5G\xf5'
 b'rr\x00\x00\x00b\xa7\x8b\x00J\x00n')

{'A1': 6209973871864014952,
 'A2': 10147,
 'A3': 42018,
 'A4': [{'B1': 'dydc',
         'B2': -0.3446473383483606,
         'B3': {'C1': 10,
                'C2': -56,
                'C3': 153,
                'C4': [-85, -9, 96, 72, -12],
                'C5': [41, -102, 87, -52]},
         'B4': 15195},
        {'B1': 'zi',
         'B2': -0.5497919469303965,
         'B3': {'C1': -35,
                'C2': 100,
                'C3': 244,
                'C4': [-68, -65, 58, -5, 114],
                'C5': [-43, -67, 61, 18]},
         'B4': 42891}],
 'A5': {'D1': 52035, 'D2': 0.44191840291023254, 'D3': -689550645},
 'A6': -0.3639698028564453,
 'A7': [2865260420613662442, 4888891859567796665, -1919426484679844133]}

(b'SQTQ\t\xc3\xf2\x85\x01\x7f\xcfS\xe2G.\x0b\x00\x02\x00\x88\xd3\xef?['
 b'\xac\xdcp\xac\xf0\xda?E=\xe4P#\xb9\x05=\xa5w\xd5\xab\x83\xdd\xed@xZ\xa2K\x1a'
 b"\x94'\xbby\xd61jnmlcf$\\\xbf\xb5s^\xde\x94\x94\x14\xcd\xe4\x00\x00\x00\x06"
 b'\x00\x00\x00:\xbf\xe2l6\xd4\xd7\xaap\x00\x00\x00@\xdc\xeemjfr\xd3\xdf'
 b'\xe4\x12M\xf0\xe2\xa2\xdd\x8f\xeb\xcd\x00\x00\x00\x04\x00\x00\x00b\xbf\xcc'
 b'E\xe3\xa6m\xd8`\x00\x00\x00f-\xd4\x00L\x00r')

{'A1': 703672619869654867,
 'A2': -7609,
 'A3': 11787,
 'A4': [{'B1': 'jnmlcf',
         'B2': -0.5757097394064896,
         'B3': {'C1': 36,
                'C2': 92,
                'C3': 191,
                'C4': [-75, 115, 94, -34, -108],
                'C5': [-108, 20, -51, -28]},
         'B4': 56558},
        {'B1': 'mjfr',
         'B2': -0.220882850898934,
         'B3': {'C1': -45,
                'C2': -33,
                'C3': 228,
                'C4': [18, 77, -16, -30, -94],
                'C5': [-35, -113, -21, -51]},
         'B4': 11732}],
 'A5': {'D1': 54255, 'D2': 0.8581063747406006, 'D3': 1890382042},
 'A6': 0.7704756259918213,
 'A7': [5774662579379337173, -6087778260216161630, 5411800800609031729]}

Вариант №27

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

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

(b'ZQECriq\xceK\xc7tct\xf3bNgzzr\x8f%hsw\x88\x8a\xd9djuiG\xe8cyj\xf7\x02\xe9'
 b'fS\x1b\x91\xec\xef\xcd\xf3L\xc1\xf8\x02\xc4t\xd4\xbfS\x00\x00\x00'
 b'\x88\xff\xd4\xef\x0e\xc2\xb2\xe0\x1c\x938\xf3\xabaWKZk`W\xb1\x957\x10'
 b'\xecK\x00\xde_\xceA\xdf\xe8\xef?}k\x7f\x9b\x7f\xa0\x83U\x98\xce\xdf\xb3\x01'
 b'\x9do=`1>xbY\x1c<a\x10^|W\xed;EzZ!)T>\x10\x9f}\xbb\x9d\x87\xde[')

{'A1': [{'B1': 'riq', 'B2': 206, 'B3': 51019},
        {'B1': 'tct', 'B2': 243, 'B3': 20066},
        {'B1': 'gzz', 'B2': 114, 'B3': 9615},
        {'B1': 'hsw', 'B2': 136, 'B3': 55690},
        {'B1': 'dju', 'B2': 105, 'B3': 59463},
        {'B1': 'cyj', 'B2': 247, 'B3': 59650}],
 'A2': 17567961520767980390,
 'A3': -0.3196268109341147,
 'A4': {'C1': -5104,
        'C2': {'D1': 1617648203, 'D2': 932557143},
        'C3': {'E1': 0.997176769759786,
               'E2': [6161945185103080317,
                      4426929589366804120,
                      4331435221082583392,
                      4988841972247433313,
                      -6985014490863412614],
               'E3': [125, -69, -99, -121]},
        'C4': 23518},
 'A5': 65416,
 'A6': -1039208492,
 'A7': {'F1': -78, 'F2': 6296502815155231968}}

(b'ZQECkrw\xbfN\xf8rmnP+\xdaqumz\xa6pskrL\xd4\x99fzc\x80\xf4\\pqe\xff\x91('
 b'$\x12\x1f\xf5EO_\xfd\xbcOB\xfe_\xd4\xe1?S\x00\x00\x00\xb1 \xfdr'
 b'\x88\x1f\xd6\xf5\xf3\xa7\xf9UM\x0e\x1f2\x9d\xb7\xc0o\x14\xe0\x84\xa8DK\x00x'
 b'<\xe4Pk\x14\xe3?_M\xd3\x11\xe8[_\xe1;r\xa8v\x9e\xdf\xf2\xf3]\x1d\xc1>3'
 b'>\xafG\xcb\x0f\x9ajD\x98\x9c\xb4\xdb]\xda\x95Q9ET\xd92\xe2\xa9~,')

{'A1': [{'B1': 'krw', 'B2': 191, 'B3': 63566},
        {'B1': 'rmn', 'B2': 80, 'B3': 55851},
        {'B1': 'qum', 'B2': 122, 'B3': 28838},
        {'B1': 'skr', 'B2': 76, 'B3': 39380},
        {'B1': 'fzc', 'B2': 128, 'B3': 23796},
        {'B1': 'pqe', 'B2': 255, 'B3': 10385}],
 'A2': 18257398576267072036,
 'A3': 0.5571746793743766,
 'A4': {'C1': 17576,
        'C2': {'D1': -1061708494, 'D2': -2065689489},
        'C3': {'E1': 0.5962425784981766,
               'E2': [-2206944240098652833,
                      -868385906440506821,
                      5165415687434345821,
                      -5432299630901981237,
                      6072322695148232155],
               'E3': [-39, 50, -30, -87]},
        'C4': 11390},
 'A5': 8369,
 'A6': 529036029,
 'A7': {'F1': -42, 'F2': 2237811096505807861}}

Вариант №28

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

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

(b'>DSQ\x9b\xc5`7\xdbYd\xd3\x03\x15R*\x85\x89\xc4\xcb\xbc\x98\xbf^'
 b'\xa1\x16\xd4\x0f\x96)\xac\t\xaed\xf9I\xb4\x8aL\xf0o\xa8\x05\xea\xaf3\xff\x8b'
 b'\xfb\xf7\x9c^[\x11%\x80\x18\n\x88f\xa7\x0c\r5$\xd2\xb1\xbe\x00\xbb\n\x0e'
 b'\x15e\x93-\x93\x8a_\x06\x00\x00\x00\x02\x00\x00\x00b\xe1\xdf\x00\x04'
 b'\x00d\x89\xed\x00t&M\xa0\xf3-b\xc5{-\x13)\x05\xcf\xadIE@\x82:\x96\x83\x03'
 b'\xe4,{2\xafz\xc8\xbb,\x95\x98*\xbf\xe0\xe5\x0e\x9b\xfaV\xba\xcd\xe6w\x9e'
 b'\xc6p\xe8\x10')

{'A1': -7222260634399185709,
 'A2': {'B1': 789,
        'B2': 82,
        'B3': 713394628,
        'B4': -53,
        'B5': -0.018645938485860825,
        'B6': -1592339441},
 'A3': {'C1': {'D1': -106,
               'D2': 41,
               'D3': -1408651676,
               'D4': [{'E1': [249, 73, 180, 138, 76, 240, 111],
                       'E2': 168,
                       'E3': 5},
                      {'E1': [234, 175, 51, 255, 139, 251, 247],
                       'E2': 156,
                       'E3': 94},
                      {'E1': [91, 17, 37, 128, 24, 10, 136],
                       'E2': 102,
                       'E3': -89},
                      {'E1': [12, 13, 53, 36, 210, 177, 190],
                       'E2': 0,
                       'E3': -69},
                      {'E1': [10, 14, 21, 101, 147, 45, 147],
                       'E2': 138,
                       'E3': 95}],
               'D5': 6,
               'D6': [38, 77],
               'D7': -7713,
               'D8': [2700291426, 3313184019, 688246701, 1229275266]},
        'C2': -30227,
        'C3': {'F1': 982942467,
               'F2': [58412, 31538, 44922, 51387, 11413, 38954],
               'F3': -0.5279610678141673,
               'F4': -3610066527473047536}}}

(b'>DSQX\x83\x9a\xa0\x06\x91\xdc\xda\x9a\xbb\xfd\x91\x89\xc3QR\xbf;\xbcm'
 b'%/\xa4\x98\x9d\x9b\xd8z\r\xa0\x01k\x94/\x873jOd\xf6\r\x84s\xdb\xc4|^V'
 b'T0\x91\x98\xfc\xdb|\xf5\\27\xef#\x9d*\xca\xa6I\x1bh\xf9\xe2\xa0\x90'
 b'9\xba\x86\x87\x00\x00\x00\x02\x00\x00\x00b\xa1\xbc\x00\x03\x00d\x8bD\x00pD7'
 b'O\xe9H\xb7\x9c\xfb\x97\x8e\x9e\xa4\xb3\x85i\x1bFEA\xcf;\xdblr\xcf?'
 b'\xac\xc7\xa9\x94?\xd0\xc5u=y4\x80\xec\xec\xe0?\xfa\x81I\x0e')

{'A1': 6378111509382421722,
 'A2': {'B1': -25925,
        'B2': 253,
        'B3': 2441724753,
        'B4': 82,
        'B5': -0.7333438992500305,
        'B6': 623879320},
 'A3': {'C1': {'D1': -99,
               'D2': -101,
               'D3': -663089760,
               'D4': [{'E1': [1, 107, 148, 47, 135, 51, 106],
                       'E2': 79,
                       'E3': 100},
                      {'E1': [246, 13, 132, 115, 219, 196, 124],
                       'E2': 94,
                       'E3': 86},
                      {'E1': [84, 48, 145, 152, 252, 219, 124],
                       'E2': 245,
                       'E3': 92},
                      {'E1': [50, 55, 239, 35, 157, 42, 202],
                       'E2': 166,
                       'E3': 73},
                      {'E1': [27, 104, 249, 226, 160, 144, 57],
                       'E2': 186,
                       'E3': -122}],
               'D5': 135,
               'D6': [68, 55],
               'D7': -24132,
               'D8': [1340688567, 2633734030, 2661593989]},
        'C2': -29884,
        'C3': {'F1': 1763395141,
               'F2': [16847, 15323, 27762, 53055, 44231, 43412],
               'F3': 0.26205187800662344,
               'F4': -1374477220864505586}}}

Вариант №29

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

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

(b'CKF\x00\x00\x00\x04\x00\x00\x00\x86\xfe\xf2\xe4k4\x16W\xa8\xadT\x15e\xfa'
 b'9#\x02\xbf>\x81\x90\x19\x19R1\xd5_\x86\xbd\xeb\x9b\x82h\xed=\xeb\xa0\x8b'
 b'\xbf\xc9\xd8\x10\x90\xb3\x03H\xeb\xc3\xd2I\xab$K\x87\t\x00\x03\x00'
 b"\x00\x00\x96?\xefD'Y\x9d\xb0\xce\x12`F\xb9U\xa84\xce?\xfe\x01\x7f\x17"
 b'\x00\x8d\x1f*\xd7\x02\xe9\xbe%\x9c\xbe\x9b\x19&8\x07\xee+? \x8d\x8fXsvF\xbf/'
 b'\xa4\xfd\x07\x81\xa4s\xbe\x93\xc4\xa8\xf5+#\xb7\x00\x00\x00f\x00\x00'
 b'\x00n\x00\x00\x00v\x00\x00\x00~y\x91y')

{'A1': [{'B1': -0.302926242351532, 'B2': 940043819},
        {'B1': 0.6271600127220154, 'B2': 1483961926},
        {'B1': -0.6861112713813782, 'B2': 125936755},
        {'B1': -0.28860974311828613, 'B2': -181722185}],
 'A2': {'C1': 254, 'C2': 17502231923325905069},
 'A3': 6058860999071695551,
 'A4': {'D1': 0.2530525028705597,
        'D2': {'E1': {'F1': [6482, 12757, 24454, -16917, -25726, 26861],
                      'F2': 0.11505230516195297,
                      'F3': -0.2019062716044806,
                      'F4': 235},
               'E2': 14110421581902350089,
               'E3': [121, 145, 121],
               'E4': 0.9770695448219386,
               'E5': [4704, 18105, 21928, 13518]},
        'D3': 4611124713832353055,
        'D4': 42,
        'D5': -687674946,
        'D6': 37,
        'D7': 156}}

(b'CKF\x00\x00\x00\x05\x00\x00\x00\x8e\x92\xa5H\xb1C\x9bH|Xx\x02i\xa5\x0eIP%'
 b">\xd2\xb9'\x10k\xc2\xf0\x03\xbc\xd1#\xe4\xab\xce\xb3;\xf4 p?\xc3\xce?"
 b'\xd0&\xc0\x00V\x94\x01\x0e\xf7\x0f\xdd\x9b"\x00\x02\x00\x00\x00\xa2?'
 b'\xd5L\xf7\x88\xcf\x93\xb8S\xb9\x8e\xdb\xa6\xcf\xb0_\x08\xe0\xc1\xa3\x079,@a'
 b"\x84\xcar\x91\xc73\xbf9b\x94\xbd\x86\x8c\x9a?D6-'\xb4*0?K\x19\xc9\x84Z"
 b'\x8f9\xbeJ\xc4T\xc8\xcb\xa3\x85?Ba\xd0\x17<2\xf7\x00\x00\x00f\x00\x00'
 b'\x00n\x00\x00\x00v\x00\x00\x00~\x00\x00\x00\x86\xc4U')

{'A1': [{'B1': -0.7241604328155518, 'B2': -1115255654},
        {'B1': 0.7664516568183899, 'B2': 666118704},
        {'B1': 0.7933622002601624, 'B2': -2074439879},
        {'B1': -0.19801455736160278, 'B2': -926178427},
        {'B1': 0.7593050003051758, 'B2': 389821175}],
 'A2': {'C1': 146, 'C2': 11909964118507420760},
 'A3': 8647590392134979621,
 'A4': {'D1': 0.41156885027885437,
        'D2': {'E1': {'F1': [4203, -15632, 956, -11997, -6997, -12621],
                      'F2': 0.0074501559138298035,
                      'F3': 0.1547317282070253,
                      'F4': 86},
               'E2': 10664821846875937570,
               'E3': [196, 85],
               'E4': 0.33282268867906906,
               'E5': [21433, 36571, 42703, 45151]},
        'D3': 639724053031627840,
        'D4': 97,
        'D5': -2067107183,
        'D6': 199,
        'D7': 51}}

Вариант №30

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

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

(b'\xa8HYSEx\xca8\xc4lpc\xe5\x14\xb7\xa3X\xbf:\x00\x04\x00P\x00T\x00\x86`'
 b'8u\x81\xcc\xb6\x0exR\xb3\xac\xf4MA|i\x7f![\x10\x8a\x12\xf21\x10\t\xf9.\xb1'
 b'/\xa8\x06\x00\x1a\x00\x00\x00&\x00\x00\x00+\x00\x00\x000\x00\x00\x00'
 b'5\x00\x00\x00epzb\xee6:\xea\xd2:j\xd9~L\xad\x02\xbc\xb5\xf7s\xb6\xfd\x1c\x01'
 b'\x81\x97\xb6\x19\xf3\x9e')

{'A1': -1917565403878864264,
 'A2': 20,
 'A3': -0.8462480902671814,
 'A4': {'B1': [24710, 30008, -13183, 3766, 21112, -21325],
        'B2': [{'C1': -12, 'C2': 1769750861},
               {'C1': 127, 'C2': -1978639583},
               {'C1': 18, 'C2': 152056306},
               {'C1': -7, 'C2': -1473269458}]},
 'A5': 'epzb',
 'A6': {'D1': 3929683694,
        'D2': 192894466744007378,
        'D3': [188, 181],
        'D4': 29687,
        'D5': -586,
        'D6': -6993217524359692004}}

(b'\xa8HYSEUh\xbc\xe8\nH\xbbNg\x1e\x9f2>6\x00\x03\x00L\x00O\x00\xbd\xfb'
 b'\xea\xff\x0f\x9e\xbf\x08\x93u\xf0\xc8\x81\xff\x99`v\x0f\x04s}\xa2'
 b'\xc7\x14\x1dS\xd6\xe3\x04\x00\x1a\x00\x00\x00"\x00\x00\x00\'\x00\x00\x00'
 b',\x00\x00\x001\x00\x00\x00mwx\xda\x8f_,\xba\xb6\rO\xcd<~\xe2\xad\xe2\x93n4'
 b'\x1b\xd8\xa8\xad\xdf\xc4\x18\x1c:')

{'A1': 5673207367294806101,
 'A2': 103,
 'A3': 0.1744351089000702,
 'A4': {'B1': [-1091, -22, -25073, 2239],
        'B2': [{'C1': -109, 'C2': -2117537675},
               {'C1': -1, 'C2': 259416217},
               {'C1': 4, 'C2': -945652365},
               {'C1': 20, 'C2': -472493283}]},
 'A5': 'mwx',
 'A6': {'D1': 744460250,
        'D2': 16320548952129517242,
        'D3': [173, 226],
        'D4': 28307,
        'D5': 6964,
        'D6': 4187248987393075416}}

Вариант №31

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

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

(b'rNJN\xa8\xafL\x11b\xa3\xd0?t\x980\x00\x9c\x92/\xb3\x8d\xf7\x80\xbe\xa9E0"'
 b'RJK\x97`8\x00\xb7G\r[gepZ\x00l\x00~\x00v\xa48\x89ijzd\x03\x00\x00\x00'
 b'5\x00\x00\x00\xba\x91\xbc\xde\x84\xc9\x12I`\xebLL\xea&yu8g\x9b\xbc,M\xabT'
 b'C:,\xf7!e\xa7(\xe1\xcb\xc9>\x9d\x9e\x80`S\xac\xcb\x87\xc7I\xb8n\xb4x\xba\x89'
 b'm>=i\xe9Y\x17\x90d\xf9\x85\xb0\x17\x89M\xcc\xcd0\x1e\xbf\x92zIy\xff<\x1cQ')

{'A1': 0.25997211160096834,
 'A2': 116,
 'A3': {'B1': {'C1': -104,
               'C2': {'D1': 118, 'D2': 1770600612},
               'C3': 156,
               'C4': -110,
               'C5': 47,
               'C6': 179,
               'C7': -0.2518886625766754,
               'C8': 573588905},
        'B2': -1756673454,
        'B3': 96,
        'B4': {'E1': 'jzd',
               'E2': -70,
               'E3': 6938097357667875985,
               'E4': 4068291046445698283,
               'E5': 750558055,
               'E6': 77,
               'E7': 977491115},
        'B5': 18359,
        'B6': 23309},
 'A4': 'gep',
 'A5': [{'F1': 63276,
         'F2': 25889,
         'F3': [-89, 40],
         'F4': 0.394133597612381,
         'F5': 9785104089493839517},
        {'F1': 18887,
         'F2': 28344,
         'F3': [-76, 120],
         'F4': 0.23197069764137268,
         'F5': 17970646843082238269},
        {'F1': 45189,
         'F2': -30441,
         'F3': [77, -52],
         'F4': -0.617932140827179,
         'F5': 5844613484369246866}]}

(b'rNJNp\x03\x16\xf2I\xd4\xcf\xbf\x92\x0b0\x00\xd2\x8c)%\x8e\xb5\n\xbf'
 b'=\xcc\x9fK\xb58\xc0A\x857\x00\x13\xb6#JeutY\x00k\x00}\x00\xa4\xb3]\x92'
 b'\x89on\x02\x00\x00\x005\x00\x00\x00G\x10\xc3\xc8\xced\xd3P[+\x83\x9e\xdf'
 b'\xf76\xca\xbd\x17F\xc2GA\xdc\xe9\xe0d`\x1f\xae\x94\x9cPc\xd0}?\xb4q\x965\x03'
 b'\x88\xd6\xcd\xe4\x91\xaa\x02\x06cBE\xad\xbe\x03#\r\xde\xbf\xe0\x8f^z\xd9/'
 b'\xac\xc9\xb1\xdd\xfa\x84>{$\x9b2\xd8\x0eI\x8e')

{'A1': -0.24866604157071093,
 'A2': -110,
 'A3': {'B1': {'C1': 11,
               'C2': {'D1': 164, 'D2': -1986896461},
               'C3': 210,
               'C4': -116,
               'C5': 41,
               'C6': 37,
               'C7': -0.5418328046798706,
               'C8': 1268763709},
        'B2': 1103116469,
        'B3': 133,
        'B4': {'E1': 'on',
               'E2': 71,
               'E3': 6579991485507748624,
               'E4': 13675803656700461867,
               'E5': 1203914263,
               'E6': 65,
               'E7': 1692461532},
        'B5': 46611,
        'B6': 18979},
 'A4': 'eut',
 'A5': [{'F1': 8032,
         'F2': -27474,
         'F3': [-100, 80],
         'F4': 0.9914609789848328,
         'F5': 14832191970156638644},
        {'F1': 37348,
         'F2': 682,
         'F3': [6, 99],
         'F4': -0.33841902017593384,
         'F5': 6813911875903628035},
        {'F1': 55674,
         'F2': -21457,
         'F3': [-55, -79],
         'F4': 0.2597264349460602,
         'F5': 10252742348410397819}]}

Вариант №32

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

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

(b'TRR#\x00\x00\x00>\x00\x00\x00`\x00\x00\x00\x82\x00\x00\x00\x9f\x89\xde>\x04'
 b'\x00\x00\x00\xa4\x00\x00\x00\xfaE<cohucdeep\xc0\x13g\x12\x83\xe7\x91?\x1b'
 b'\x02\x00\x1f\x00\x8d\x0c\xd0\xf8\x06@!v0\xf3\x92\xacpt<\xeehN\xb4!'
 b"\xe3\xd9\xce?7\xb2'\xbaY\xa6q\xdb\xae\xb0\xaeM\x10\xc7\x9c\x1c\xa4\xf3J`"
 b'\xbf\xbf\x19\x9b\x13%\xeep\xb6\xb5\xd6\xd8\xed\xbf\xc3\xa7\r6)\xef'
 b'\xac\x13j\xdc2\xf9\x15\x9aY\x1d\xff\x14\xfc\xb2y\x97\x17\x92\xec\xbe'
 b'^\xd8j\xe8\xbe\xc7\xec?s\xf4sJU\xdc\xa4W\xaaf\x89\xf6F\x1dk\xd5B\\\x81%')

{'A1': {'B1': 'ohucdeep',
        'B2': 0.017484710691650696,
        'B3': {'C1': 27,
               'C2': [17914, 25404],
               'C3': 141,
               'C4': 12,
               'C5': 1074198736}},
 'A2': [{'D1': 30241,
         'D2': -1280020166799592656,
         'D3': 0.2410243906566507,
         'D4': 3123163703,
         'D5': [3681658457, 1303294126, 480036624]},
        {'D1': 62372,
         'D2': 2671649538854314058,
         'D3': -0.9327195691180614,
         'D4': 906864579,
         'D5': [330100521, 4180860010, 492411413]},
        {'D1': 5375,
         'D2': -4689212481976290564,
         'D3': 0.8993830241586342,
         'D4': 1249113203,
         'D5': [1470422101, 4136199850, 3580566854]}],
 'A3': 0.4346437156200409,
 'A4': [66, 92, -127, 37]}

(b'TRR%\x00\x00\x00@\x00\x00\x00b\x00\x00\x00\x84\x00\x00\x00\x0e\x863?\x04'
 b'\x00\x00\x00\xa6\x00\x00\x00\x8e\x88Ln\xab\xacwvrqjqjqR\x8c\xca\xe6qa\xe8'
 b'\xbf\xc3\x03\x00\x1f\x00\x92\xdc\xe6\xca\xbe4F\xe6\xf5\xf2\xf2\xea\x8bp'
 b'\xb1\x17\x1c\xc3\x9e^\xc7\xba\xee\xbf\xe7\xba\xaa\xa0\x02j\xce\x90\xa1\xa4'
 b'\x04\x8b\xb8\xe3\\\x0c\x13\x9f\x0e\xeaw\xdc\xfbQ\x14\xe5<\xbe@\x15i:\xe2?'
 b'X\xab\x19@\xf9\xfbp\x82\xbd\xac2\xb5\nc\xc7\xe9\t\x83\xe8\xee\xe3Q2\x8c'
 b'\xca\x89\xc0`\xa0\x98\xf4\xef\xda\xbf\xf0\x82\x91\xa3\x7f6Z\xa5\x89\x81'
 b'\x1d&|o\xa8\x01\x9e\xe6?\xb9')

{'A1': {'B1': 'wvrqjqjq',
        'B2': -0.7618951327934929,
        'B3': {'C1': -61,
               'C2': [34958, 28236, 44203],
               'C3': 146,
               'C4': 220,
               'C5': 884919014}},
 'A2': [{'D1': 58950,
         'D2': 1707269479994684149,
         'D3': -0.9603001449632731,
         'D4': 2695543527,
         'D5': [2429446658, 2332337313, 207414200]},
        {'D1': 40723,
         'D2': -1939835397312353778,
         'D3': 0.5696301856132275,
         'D4': 1075424088,
         'D5': [2188442617, 3039997117, 3922158346]},
        {'D1': 33545,
         'D2': -8517841597467726104,
         'D3': -0.42089571862153363,
         'D4': 2744222448,
         'D5': [2774152831, 639467913, 27815804]}],
 'A3': 0.7012642621994019,
 'A4': [-98, -26, 63, -71]}

Вариант №33

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

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

(b'RPE\x11\xbb\xfd\x9a:\xe8\xfe\x15\x86_?\xc6\x04?\xc6\x81\xd3\xe8P\xec8o\xf8LB'
 b'\x0b80\x8d\x7fd~d\xb5\x9f\xd5\xbf\x0c\xfdr\xd8?r\x1e\xc2\x13\x8cpY'
 b'\x00\xa7\xf1\xbc*3?\xc5\re@\x97>@\x00\x02\x00\xab:LGz\xee8\xd7H\xf5\x84'
 b'\x80+\x9d\x97\x89t\xf59W\xd5\xbf\x97\xbb\xe2\xfe\x17\x80\x80\x00\x02'
 b'\x00\xad_z\xfe\xcf\x9bY\xb2\xf8\xca\x16H\x9e\x18(\xcc}D\x17\x893\xb5\xac'
 b'd\xe8\xc1\xe2X\x14\x00u\xa6\x8ad3\xd02\x9b\x85T\xce?0\xe95L<\xcd\x8d)B'
 b'\xe6Qw\xb0zV\xe7E\xe9^\x13\x0cq\x99\xa6\x93I\x00~\xdao\x02\xc0')

{'A1': {'B1': 1277893758144806421,
        'B2': -31137,
        'B3': 0.1720046729348319,
        'B4': 20716,
        'B5': 4066741994948081712,
        'B6': 2373936254,
        'B7': 7256882114959572338,
        'B8': 216},
 'A2': 0.9457818269729614,
 'A3': 327970905,
 'A4': {'C1': {'D1': -27831,
               'D2': {'E1': 3252836372,
                      'E2': 0,
                      'E3': 1973848676,
                      'E4': 869282459,
                      'E5': [2236927551,
                             820589900,
                             1020103977,
                             1122390391,
                             2960807655,
                             1172921875,
                             208771494]}},
        'C2': [{'F1': 4055640627,
                'F2': 0.16447129873130173,
                'F3': [-38, 111],
                'F4': 14924,
                'F5': 71,
                'F6': 8858080014377518208,
                'F7': 731748233,
                'F8': 116},
               {'F1': 4114175957,
                'F2': -0.023177668341191282,
                'F3': [2, -64],
                'F4': 24442,
                'F5': 254,
                'F6': -3487094861255272888,
                'F7': -1642583860,
                'F8': 125}],
        'C3': 17431},
 'A5': -30413,
 'A6': [181, 172, 100],
 'A7': -24}

(b'RPE\xbbB\x00F\x04\x02Z\xf4i\xd7\xbf\xe3\xd4\xa1G\x16N\xc2e\x1e\xd5'
 b'\xc0\xa8\x1ce\xf3\xcdR\xf9\x9a}\xb2\xa4\xbc\xd7\xd2=O)b\xef\xbfZ\x8c.'
 b'E\xcf\xa1\x9b\x00\xa7\x8c\x9d\xeb\x90?\xcb\xa5\xe2N-\x1c\x18\x00\x02'
 b'\x00\xab\x03(\x98K1\xbc\x90\x18\xd2\xb0\xc3q\xcd\x15\x98\xe6\x83\x9a'
 b'\xe5\x0f?\xddDU:\xb7\xfd \x00\x02\x00\xad\x15^\xa9\x1a\xbe\xd9\xcef\xf8\x84'
 b'\x97G\xe0\xea\x90*b\x942\xc6\xbd*\x8a\x01\xafk\x80\xdb-.\xcc\xd5\xb3T'
 b'\xb3\xf9\xc3\xdb\x94h-\xd8i\xa1\x06\xd1H\x01\xdd*]Q\x06\xd4\xa8I\xc5$'
 b'\xd8\xdc\xa1)\x7f\xef\x11\xa4\x04\x00~\x96\x90\xf3D')

{'A1': {'B1': -4953396339439150348,
        'B2': 27095,
        'B3': -0.6197058094425858,
        'B4': 25886,
        'B5': 15402495565530123602,
        'B6': 4187651506,
        'B7': -6576144057896064670,
        'B8': 239},
 'A2': -0.8537014722824097,
 'A3': 1171235227,
 'A4': {'C1': {'D1': -23548,
               'D2': {'E1': 2943058139,
                      'E2': 45,
                      'E3': 785175987,
                      'E4': 1421081027,
                      'E5': [3683936301,
                             3630801158,
                             3511157213,
                             710758662,
                             3567798725,
                             618192033,
                             696250129]}},
        'C2': [{'F1': 2359159696,
                'F2': 0.21599987809369803,
                'F3': [-106, -112],
                'F4': 808,
                'F5': 152,
                'F6': 5418319153781190851,
                'F7': 1909265816,
                'F8': 230},
               {'F1': 2207966479,
                'F2': 0.4572957108902802,
                'F3': [-13, 68],
                'F4': 5470,
                'F5': 169,
                'F6': 1927217171075204247,
                'F7': 1205922448,
                'F8': 42}],
        'C3': 25236},
 'A5': 12998,
 'A6': [189, 42, 138],
 'A7': 1}

Вариант №34

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

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

(b'MDOB\xe5P\xbd\xf4\xecglkf\x00\x03\x00\x00\x00]>\xb5>\x19\xbe\xaf=W\xb1'
 b'1\xee\xafL\xae6\xe6?\xef\xab\x9b\xc2\x80\x8a\xfeel\xbe\xe0\xb2o\xbe\xc4\r'
 b'\xb4\xbf>\xa5Hf,\x92\xf6\xbf\x87X\xd7!x7\x00\xde\x06\x15O\xa7\rz2\xd3O\x86'
 b'\x8c\x00\x00\x00`\xbf!\x97\xfa\xd8\xa2\x08Nodr\xec\xaes\xbf\xbcE\xd4\x9d'
 b'N\xf6\x18\x1f')

{'A1': 1354626284,
 'A2': 'glkf',
 'A3': 'odr',
 'A4': [{'B1': [0.3539893925189972, -0.342264860868454],
         'B2': 2972839599,
         'B3': 1286485734,
         'B4': 0.9896982954854534,
         'B5': 25964},
        {'B1': [-0.43886134028434753, -0.38291704654693604],
         'B2': 3208553800,
         'B3': 1714197238,
         'B4': -0.011399918278609089,
         'B5': -8698}],
 'A5': {'C1': 5455, 'C2': -6409332335966189940},
 'A6': {'D1': -1392047967476263779, 'D2': 1324750879},
 'A7': -0.6312252283096313,
 'A8': 3634497614}

(b'MDOB\xe5\xd0\xfdT\xc6dzmz\x00\x05\x00\x00\x00]?B\xbd\xdd>\x9b\xfa\x95X'
 b'\x90\xa8\xf5\xaa\x171]\xbf\xd1O\xb9\xef\xed\x83\x9c\xe9\x88?_\xd8'
 b'\xe6\xbf\'\x9d\xf6\xb1\xa0\xee`\xf7\t\xcc\xda?\xd7\xe5p\xcb"q\x0cf\xb9\x9a'
 b'\x89\x8f\xf8\x18\x86\xb7\xdfs!\x00\x00\x00b\xbc\n\r\xab(\xafknfowzf1\xd3'
 b'\xb4\xcf\x12\xfd\xc2m\xf9\xe9\x01,')

{'A1': -788704058,
 'A2': 'dzmz',
 'A3': 'fowzf',
 'A4': [{'B1': [0.7607095837593079, 0.30464616417884827],
         'B2': 1485875445,
         'B3': -1441320611,
         'B4': -0.2704911082310504,
         'B5': -5752},
        {'B1': [0.8744033575057983, -0.6547540426254272],
         'B2': 2980114016,
         'B3': -150352678,
         'B4': 0.3733789428458898,
         'B5': 26297}],
 'A5': {'C1': 39561, 'C2': -8072675365172055263},
 'A6': {'D1': 3590412129414267501, 'D2': -102170324},
 'A7': -0.00842611026018858,
 'A8': 682584942}

Вариант №35

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

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

(b'VGO\xc0\x06\x00\x00\x003\x00"\xd3f\x00\x00\x00\xd6(|?(\xe4\xc5>\xb6\'^?'
 b'\xe1\xf2\x8a*\xf8\xb7\x08\xb1\xe4\xbf\xc4+(\x1a\xcb\xce\x99\xe3Y\xcd'
 b'\xba\xd8\xcfqmyttd\x1e\x0e\xb9I\xfa{BP\xb8\x94h}kA\xe8\xa3/\xdb\x0f'
 b'-F\x90\x0b\xfc\xd4\x95\x03y_\xf20\x97\x9f\xa5U\xd9\x1b\xbc\xf5E5\xa0x'
 b'\x82<\xa79\x00\x00\x00F\x00\x00\x00S\x00\x00\x00\x06\x00`\x00\x00\x00')

{'A1': -64,
 'A2': {'B1': 'qmyttd', 'B2': 54050},
 'A3': {'C1': 167,
        'C2': [{'D1': 30, 'D2': 13281188401363138830, 'D3': 1803380884},
               {'D1': 65, 'D2': 10396046335956460520, 'D3': 2513763339},
               {'D1': 3, 'D2': 6171514336091201401, 'D3': 4122745817}],
        'C3': [69, 53, -96, 120, -126, 60]},
 'A4': {'E1': [0.9849981069564819, 0.3865063190460205, 0.8677934408187866],
        'E2': -3359,
        'E3': -0.6466106026794745,
        'E4': 11204,
        'E5': [40, 26, 203, 206, 153],
        'E6': -1160947229},
 'A5': -12328}

(b'VGOu\x03\x00\x00\x003\x00\xe6\xa2`\x00\x00\x00\x0cy\x12?\xb6\x019>'
 b'\xc1\x95#\xbf\xcd\x17t\r\xa4|\x9a\x97\xd0?7\x11o\xd1\xa8<m\xb8\x84\xb8'
 b"\xac5\x02lec\xa1\n\xb2\x97\xc8\xb2\xca6\xb72y'&\xc5r%\xc5\x8e7\xc2Y,"
 b'V\x05r\x1e#\xc7\xecK\x0bf_\xf2)\x9b/\x86=\xee\xaf\x02H6\x00\x00\x00C\x00\x00'
 b'\x00P\x00\x00\x00\x03\x00]\x00\x00\x00')

{'A1': 117,
 'A2': {'B1': 'lec', 'B2': 41702},
 'A3': {'C1': 72,
        'C2': [{'D1': 161, 'D2': 13201962226901561866, 'D3': 640121138},
               {'D1': 197, 'D2': 3195798954470352242, 'D3': 510788950},
               {'D1': 35, 'D2': 3022583191799852231, 'D3': 1032204187}],
        'C3': [-18, -81, 2]},
 'A4': {'E1': [0.5721595287322998, 0.1806705892086029, -0.6390038132667542],
        'E2': 6093,
        'E3': 0.2592531411357506,
        'E4': 4407,
        'E5': [111, 209, 168, 60, 109],
        'E6': -1397193544},
 'A5': 565}

Вариант №36

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

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

(b"UAT\x04\x00y\x00%N\x085\xf3\xcd^\xfe\xc3\xcb\x98\x89\x00|\x1e'a\xb9\xdb\x0c}"
 b'\x1d\xbb\x11\x91\xb1y\xb4dv3:\xc2\x9f\xc5{\x95(\xbb@\x91!\x151\xbdv\xa8\x86#'
 b'\x1b!\xdeoaw\xd4\n\x82\xa3`\xd3\xca9\x90\xc0\xf7\x8e\xaa\xa0\x80\xa4\xdd\xfd'
 b'\xb9{\xc3\x84*\xc7\x90\xd6\xc3@\xd4\xfd&\x92\xda\x0f\xe6Q\x97T'
 b'\x08\x9a\x99\xc6\xe5O\xc1\xe4\xbf0&O\xd7\xd1\xc6$\xd9\xbc\xab\x0bim\x00\x00'
 b'\x00p\x00\x00\x00s\x00\x00\x00v\x00\x00\x00\x10\x95Q\x07W\xf1\xa0F\x9a2\x01'
 b'\xad\xa0\x13\xeb7\xe3\x90e\x00\xf39\xe4\x8d\xd8\xc3\xd4c')

{'A1': [{'B1': 48, 'B2': 38, 'B3': 79},
        {'B1': 215, 'B2': 209, 'B3': -58},
        {'B1': 36, 'B2': 217, 'B3': -68},
        {'B1': 171, 'B2': 11, 'B3': 105}],
 'A2': 20005,
 'A3': {'C1': -3763885180415953656,
        'C2': {'D1': 152,
               'D2': {'E1': 122787088,
                      'E2': 1184952663,
                      'E3': 4029335872431272602,
                      'E4': [37091, 101, 14835, 36324, 50136, 25556]},
               'D3': [9010818543706906236,
                      7256558703150742301,
                      10771420223735739254,
                      13632700780942244648,
                      8060916783483627638,
                      15231353718689789793,
                      11577222986848025034,
                      9566626072223392896],
               'D4': [42, 199, 144, 214, 195]},
        'C3': 654169152},
 'A4': 600271028355062418,
 'A5': -0.6485976684387424}

(b'UAT\x04\x00y\x00\x08\xaa\xffk\x99\x7f&\xbf\xbb\x8b\xbe\x89\x00>\\feGP\xfd-'
 b'\x94\xf5\xe2\xef\xcc\x18<L\xf8:\xaf\xab\x8f1X\xd3\xc0^L:\x18\x9b\x8c\xc2'
 b'\x9a>\xa4\xc2\xa3\xa2.\x15\x92%\xb40\xd0\xb7\x89I\x83\xe4\xc4LnCu;'
 b'8\xc5\xec\x13QM\x97.\xc10\x04\x1cMip\xa0\xc4"\x9d\xf3\x8a_U\x02\xfb\x1c\x05z'
 b'\x8c\x8e\xeb\xe6\xbf\x03\xf3\xd9\xc0\xdd\x80\xc3]\xb1\xea\x81Mm\x00\x00'
 b'\x00p\x00\x00\x00s\x00\x00\x00v\x00\x00\x00~\x9dP\x10\nr\x1e:` \x97'
 b"b\xc0{\xe1\xc4bd\x15\xc4\x93\x7f\x18\xa2'\xaaq{")

{'A1': [{'B1': 3, 'B2': 243, 'B3': -39},
        {'B1': 192, 'B2': 221, 'B3': -128},
        {'B1': 195, 'B2': 93, 'B3': -79},
        {'B1': 234, 'B2': 129, 'B3': 77}],
 'A2': -22008,
 'A3': {'C1': -8377892509722252289,
        'C2': {'D1': 190,
               'D2': {'E1': 273718654,
                      'E2': 975073802,
                      'E3': -4259987706297769888,
                      'E4': [25698, 50197, 32659, 41496, 43559, 31601]},
               'D3': [3313893168388660286,
                      5493292913962186132,
                      15228976633083804408,
                      14018750268457115328,
                      1526336147954089626,
                      5298968541376292242,
                      4284404761526330499,
                      3357237057849967928],
               'D4': [193, 48, 4, 28, 77]},
        'C3': 3298848873},
 'A4': 18087112922314808610,
 'A5': -0.7162544959720978}

Вариант №37

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

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

(b'\x84KRG!\xd4{\xf8^\xdf:O\x02\x00\x00\x00`\x00\xf2\xdd\xd09<\x94;\xc43\xff'
 b'\x82%\x99\x11\x9e\x9e<\x9ci\xefNdOt\x851\xd0\xdf\xfd\xc3\\]I?'
 b'\x7f\xbf\xe4\xbf\xe6`<\nO.\x18\xef\x0b?[\xad0\x00\x00\x00\x8c\xa95\xcf'
 b'\x0c\x98\xe5?\xfb>f\xe1?\x85\xc1v\xcf\xbe\xdc=H\x00\x00\x00B\x00Z\x00')

{'A1': 5709121076634309665,
 'A2': {'B1': [{'C1': -21157,
                'C2': {'D1': -0.6483761058870345,
                       'D2': 171729126,
                       'D3': [79, 46],
                       'D4': 0.5466170310974121}},
               {'C1': 15836,
                'C2': {'D1': 0.6748107955038889,
                       'D2': -513392901,
                       'D3': [63, -123],
                       'D4': -0.4052028954029083}}],
        'B2': [-14, -35, -48, 57, 60],
        'B3': 15252,
        'B4': -60,
        'B5': [65331, 9602, 4505, 40606, 39996, 61289, 25678],
        'B6': -4324053981928786865}}

(b'\x84KRG\x91\xd7\xed\xceQM\x85\x8f\x05\x00\x00\x00\xa8\x00\xc5\x1d'
 b'\xb0|\x97\x84\x17?\xb3\x94\x836\x12\xa5\x07D%\xe5\xb6{\x01}\x94\xca\x8f\xce'
 b'\xaf\x8cL0\x909\x05\x9eT-\xb7?JE\xb2\xc0U\xc78J\x12\xbfbJ0\x00\x00\x00'
 b'>\xda\xaa\xdd\x80\xc0\xeb\xbf\xe4\xc8h\x91~\xfd`\xa2p\xbf\x8f\x87'
 b'H\x00\x00\x00n\x95\x84\xcb\xbc"\xe5\xbf\xb0\xd3\xe3\xa1\x11p\x17I!>\x80\xfb'
 b'`\x00\x00\x00\x18\xf3\xfcM\x83\x9c\xc1\xbf\xf2\x91\xf5\xf3\xee\x02\x93\x05'
 b'K>a\xd1x\x00\x00\x00\xc8\r\x9eu\x12@\xea\xbf\xe8A-h\x07M\xcf@\xb5\xbd\xe2]'
 b'\x90\x00\x00\x00B\x00Z\x00r\x00\x8a\x00\xa2\x00')

{'A1': -8104986940623956079,
 'A2': {'B1': [{'C1': 19042,
                'C2': {'D1': 0.0905354390899673,
                       'D2': -1062058678,
                       'D3': [85, -57],
                       'D4': -0.5714449882507324}},
               {'C1': -30833,
                'C2': {'D1': -0.8672489480439436,
                       'D2': -1855403804,
                       'D3': [126, -3],
                       'D4': -0.9399776458740234}},
               {'C1': -1152,
                'C2': {'D1': -0.6604904150923809,
                       'D2': -1578904656,
                       'D3': [17, 112],
                       'D4': 0.15750537812709808}},
               {'C1': -11935,
                'C2': {'D1': -0.1375888949204629,
                       'D2': -202010126,
                       'D3': [-18, 2],
                       'D4': 0.19826345145702362}},
               {'C1': 24034,
                'C2': {'D1': -0.8203213021483231,
                       'D2': 1747796456,
                       'D3': [7, 77],
                       'D4': -0.08850251883268356}}],
        'B2': [-59, 29, -80, 124, -105],
        'B3': 6020,
        'B4': 63,
        'B5': [38067, 13955, 42258, 17415, 58661, 31670, 32001],
        'B6': 3480311298763246228}}

Вариант №38

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

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

(b'IDSNU\x06`\x00\x00\x00\x05\x00\x92\x00\xe6\x93\xbb9\xfd\xd9[\x12\xd6&'
 b':\xd2{\xa3J\xb9*\x91\x84.t1\xe4\xdbk4\x12\xa1\x852N\x16\xce\x03t\x81\xe9\xd9'
 b'\xab\xaa\xa1\xe3T\xeb\xa6\xf7B\xa9&\x106\xbb\xe1?;\xb4\\x\xd2\xd7\x1e7'
 b'|\x97\x80\x03\xad5\xaeZ\x97\xbf\xe0\xdf\x81X\xa8\x00\x00\x00\x03!'
 b'\x02\x00^\x00\x00\x00o\xcb\xb8\x95\xd2\xd7\xec\xbc\xbc\xad\xd1\xafB\x87'
 b't?\xb1X\xac\x15\xbc\xe4\x0b\xbf\x95\xfb8\xd0\x96\xf0\x99\xbe\x14\xf7'
 b'\xa8r\xd4\xd4(\xbf\x05\xcdU\x85j\x00\x00\x00r\x00\x00\x00z\x00'
 b'\x00\x00\x82\x00\x00\x00\x8a\x00\x00\x00\xe7\xc8Jk\xf3\xd8\x02\x00\xa6\x00'
 b'A\xfd?\xbf\xbf\x11\x0c?')

{'A1': {'B1': 1621,
        'B2': {'C1': [3, 33], 'C2': -13457, 'C3': 38328},
        'B3': [{'D1': -0.02891150489449501, 'D2': -1345212996},
               {'D1': 0.9551888704299927, 'D2': 363616433},
               {'D1': -0.5464589595794678, 'D2': -801571947},
               {'D1': -0.30066365003585815, 'D2': 1923675924},
               {'D1': -0.6594974994659424, 'D2': -2057974523}],
        'B4': 1322890597181920230,
        'B5': -767940906,
        'B6': {'E1': -23685,
               'E2': 3563524352062961994,
               'E3': [3640492973359881188,
                      -2744520162625579442,
                      -601534750378579285],
               'E4': 0.5541029277276623,
               'E5': 46139,
               'E6': 3620894812,
               'E7': -1753467106}},
 'A2': -0.022806856180298762,
 'A3': 1484906464,
 'A4': {'F1': 27466,
        'F2': -9997,
        'F3': [-25, -56],
        'F4': -0.7499580979347229,
        'F5': 0.5471457839012146}}

(b'IDSN\xcc\xe1d\x00\x00\x00\x06\x00\x9e\x00\xc5\x13\xa4%\x8c\x9bW\x85\xe37'
 b'\x16\x13O\x8d\x9c\xf8\xc2M\x99\xb9\xb4\xf6\xe7\xa1\x03\r\xe5\x9d\x9dw/Xb\xfd'
 b'<%e\x02\x99b\xba\xec\xad\x1dG\xb8\x80\r*\xbe\xc9\x83\xa5\xbf7\xdd\xec\x06'
 b'\xe2\xadu\x01\x886dS8N\xf0N\xe8\xbf\xff4\xcae\xb8\x00\x00\x00\xc4\x1f'
 b'\x11\xbf\xd15\x06\x00^\x00\x00\x00\x93V\xca\x93\xc5O\xd8\xbe\x1d\xa2'
 b'*\xb07\x06Q?W\x8b\xea\xa3\xa1\xcbd\xbf\xae\x80\x95\x9c\xd7\xba}\xbf\xf2='
 b'g\xeb\xf0\xc6\xe0\xbe\xab\x0b>$\xb5\x80\xaf\xbd\xa3\xf9orn\x00\x00\x00v\x00'
 b'\x00\x00~\x00\x00\x00\x86\x00\x00\x00\x8e\x00\x00\x00\x96\x00\x00\x00]\x13'
 b"\x8b\xe1\xad\xc7\x02\x00\xb6\x00\x19\xff\x03>\x0f\xe7'?")

{'A1': {'B1': -7732,
        'B2': {'C1': [196, 31, 17, 191, 209, 53], 'C2': 22163, 'C3': 37834},
        'B3': [{'D1': -0.4224835932254791, 'D2': -1339383267},
               {'D1': 0.8165010809898376, 'D2': -1544909993},
               {'D1': -0.8937321305274963, 'D2': -1667923794},
               {'D1': -0.9911321997642517, 'D2': -345555470},
               {'D1': -0.43901777267456055, 'D2': 608045995},
               {'D1': -0.08569470793008804, 'D2': 1919941027}],
        'B4': 9608319356247479237,
        'B5': 320223203,
        'B6': {'E1': -29361,
               'E2': 17777037697223948444,
               'E3': [8619218868948410855,
                      172585104602978351,
                      -5168129414546169191],
               'E4': -0.04202108808842819,
               'E5': 56631,
               'E6': 2917271276,
               'E7': 914882933}},
 'A2': -0.7596360709891141,
 'A3': 1707750655,
 'A4': {'F1': 57739,
        'F2': -14419,
        'F3': [93, 19],
        'F4': 0.12890280783176422,
        'F5': 0.6558694243431091}}

Вариант №39

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

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

(b'oDLU\xf3*\x11\xd6F\xcd\xaa\x98\xd3\n\x937\x1b\xcf\x86ni?\xd1\xa5'
 b'\xbde\xf9\xe3\xb0\x08GNU\xf3?\xd9\xa8\xfe\xc5\xe9U\xd8\xeb\xf7\xc4|\x12\xbf'
 b'\xe2\xe4\x97,\x9d\xa8v\x95\x1e\x8d\xd5\n\xde\xa7(i\x12\xc3\xf7r'
 b"\xe5\xef\x00\x9e\\\x03\xe0\x0e{\x00\x00\x00\x81?\xc5MT\xd4\xfa%H?\xebv2')o"
 b'x?\xca\xc0\xfd\xb1\x90O\xc8?\xd2\x89\xd1\xda\xc7xH?\xc4\xf9f1\xe5\xc9'
 b'\xb8?\xe7\xa2\x8e\x1cO\x9fp#xtv\x94\xc2\\\xec')

{'A1': {'B1': -3286,
        'B2': 1285292592805237514,
        'B3': -27849,
        'B4': [{'C1': 27, 'C2': 3481693801, 'C3': 0.2757409568653726},
               {'C1': 8, 'C2': 1196316147, 'C3': 0.40093964888850797},
               {'C1': -21, 'C2': 4156849170, 'C3': -0.5904041167643885}],
        'B5': 2501807573,
        'B6': 783247177212412919,
        'B7': 29413,
        'B8': 4009795164},
 'A2': 65015419,
 'A3': {'D1': 35, 'D2': 'xt', 'D3': [118, 148, 194], 'D4': 23788},
 'A4': [0.16642246627115242,
        0.8581782116775534,
        0.20901461763480556,
        0.2896618496432706,
        0.16386105953604413,
        0.7385931542348612]}

(b"oDLU\xe2z\x13\x029}~WQ4\x11\x15\xe6V\xb00.?\xde'k2\x93\xf8\xb8K\x7f\x14"
 b'\xf7\xf0?\xe8;K\xd9\xe5\xe4p[\xd6\xe0B\x96?\xe0\xb3pT&`\xa8\x0f'
 b'\xd9\x97\xae\xc3\xb3\x0b\xf9I\xbcbg2`\x1b\xa9v9\xf1^\xc8X\x00\x00\x00'
 b'\x81?\xdf\x9d\xd0\xc2~\xce\xd8?\xe8\xde\xbc\xb6sc\n\xbf\xe8\x11'
 b"\x86\xb2\x82\x1a\x9e\xbf\xeb\x16\x88/>d\x9a?\xe5B\xf2_\xd9'\xd0?\xd9\xfd"
 b'\x93\x1c\x08-L\x94lt\xe5\xed\xa2\xa5\xcc')

{'A1': {'B1': -7558,
        'B2': 1369720447827398964,
        'B3': 4373,
        'B4': [{'C1': -26, 'C2': 1454387246, 'C3': 0.47115592898616},
               {'C1': 75, 'C2': 2132080624, 'C3': 0.7572383170910495},
               {'C1': 91, 'C2': 3605021334, 'C3': 0.5219041484406448}],
        'B5': 265918382,
        'B6': -4345116050170551705,
        'B7': 12896,
        'B8': 464090681},
 'A2': -245446568,
 'A3': {'D1': -108, 'D2': 'lt', 'D3': [229, 237, 162], 'D4': 42444},
 'A4': [0.49400729173360736,
        0.7771895946017093,
        -0.7521394239891668,
        -0.8465004847268063,
        0.6644222137485887,
        0.40610196816915756]}

Вариант №40

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

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

(b'!SSR\x92\x02\x00Y\x00n\xe7\xa7|\x01L\x02\x00\x00\x00]\x00\x00\x00\x06'
 b'\x00\x00\x00m\x00(Sc\xa4\xa2\x03x\xf9My\xd7`6\xb5\xfa\xb5\x98}\x08'
 b'\x1b\xe1\xc7x\x11\x9f\x81.*\x03\xa8\xc3<D\xe1\xe7El\xac\xc8ln\x12\x94'
 b'\xf8\x04:?\x01\x7f(6\xf3:E\xef\x89\x18\xdfs>?\x00L\x00\xa6\xf1,q;`\xde'
 b'z\xd1J\xc3O\xaf\xcd\xe0}\x90\xd5m}\x0e*')

{'A1': 146,
 'A2': [{'B1': [-25, 69, 108, -84, -56, 108],
         'B2': 110,
         'B3': -27630,
         'B4': 0.7266383171081543},
        {'B1': [1, 127, 40, 54, -13, 58],
         'B2': 69,
         'B3': -30225,
         'B4': 0.23815572261810303}],
 'A3': 2091378542,
 'A4': 1,
 'A5': {'C1': {'D1': 76,
               'D2': [8853619725875081638, 9070475802365348561],
               'D3': [-112, -43, 109, 125, 14, 42],
               'D4': 2757972776,
               'D5': 6978179523438707618,
               'D6': 54},
        'C2': 2562063029,
        'C3': 2173,
        'C4': 3351134495129985307},
 'A6': 810,
 'A7': 1144832936,
 'A8': 225}

(b'!SSR\xcb\x03\x00f\x00G\xd5k\xfeW\xf2\x02\x00\x00\x00l\x00\x00\x00\x08'
 b'\x00\x00\x00|\x00Cv\xd9\x91\x11\x96\rQ96\xf0\xf5\x7fE\x96\xff\x9b\xe5\xfc'
 b'\x8dM\x9fy:m\xfas\xae\x93\xe5\x9bM~\xdf\x89\xf2\n\xfc\x1a\xdf_\xf7\xf1'
 b'BS\x08?\x05\xd4dWGR\x16\xdd\xfdB\xb3>?^ \x0f\xf80i\xed\xf8b\xa2A\x8b>?\x00'
 b'L\x00Y\x00\xa8)ec\x83>\xd1\x8fn\x8bRl\xca\x83d\xd3B\x82\xbd\xf9K\x94r!')

{'A1': 203,
 'A2': [{'B1': [-119, -14, 10, -4, 26, -33],
         'B2': 95,
         'B3': -3593,
         'B4': 0.5325204133987427},
        {'B1': [5, -44, 100, 87, 71, 82],
         'B2': 22,
         'B3': -547,
         'B4': 0.7449227571487427},
        {'B1': [94, 32, 15, -8, 48, 105],
         'B2': -19,
         'B3': 25336,
         'B4': 0.27198511362075806}],
 'A3': -26487481,
 'A4': 87,
 'A5': {'C1': {'D1': -14,
               'D2': [-8083611122124117592, -3214299328611710098],
               'D3': [66, -126, -67, -7, 75, -108, 114, 33],
               'D4': 2446947907,
               'D5': -725019920205769199,
               'D6': 127},
        'C2': 2617218629,
        'C3': -795,
        'C4': 8357112156455390605},
 'A6': 37806,
 'A7': 2119015397,
 'A8': 223}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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