ИКБО-06-22

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

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

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

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

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

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

(b'IMZY:\x86<\x08\x8er5\x9d&I\xa4\x00|\xe0>2P\x1fv\x8e7+\xb6\xc7'
 b'\x93\xed\xb8\xc6\xe9\xc1\x0b\x0c]d\xe9e*\xca\xaf\xf2\x9b[\xf7yv\x05-\\'
 b'\x08\xc9Ac\xbd,\xbc$/\x02\xa2\xd1\xe4\xa0\x12\xe5n\x99l\x17\x1bn\xdcyz.-v'
 b'P\xdc\xf97\x1e\xd2\x0b\x90=\x15\xe1\xbe\x00\x11\x00*\x00C\xdc\xdc'
 b'c\xbc\x82\x1f\xbf)\xee\xb6\x00\x00\x00\x02\x00b\xc0\xba~\xd0\xd6)'
 b'\x00\x02\x00d2\xbd[\x99\x01\x00\x00\x00\x03\x00\x00\x00\\\x00h\xbf'
 b'\xdb\x17\xf5\xdc\xd6\xcaX')

{'A1': 34364,
 'A2': 143553077,
 'A3': 40230,
 'A4': 18852,
 'A5': {'B1': 50,
        'B2': -0.053612712770700455,
        'B3': [{'C1': [3762172496,
                       527863351,
                       733398931,
                       3988309737,
                       3238726749,
                       1693017386],
                'C2': 202},
               {'C1': [2951912283,
                       4151932421,
                       761006281,
                       1097055532,
                       3156487938,
                       2731664544],
                'C2': 18},
               {'C1': [3849230700,
                       387673820,
                       2038050349,
                       1985010937,
                       924766731,
                       2419922401],
                'C2': 190}],
        'B4': {'D1': -0.6637986898422241,
               'D2': [-36, -36],
               'D3': -64,
               'D4': -70,
               'D5': 2127615529,
               'D6': [25532, -32225]},
        'B5': -0.42333742681799924}}

(b'IMZY:\xbe\xf88\xe75\x1a\x00[o\xc8\x00h\xfe^\n\xde\xff\xfd:\xce\xe0U\x9c'
 b'\x12wJ!\xa2N\x03\xe4\x12\xfcTy\x1bv\x96\xd7\x89\x92*\xdeGS\xder\x8d\xfeL\x0b'
 b'[\x0c\xd3\x80\x16\x96\xf6\xc1I\xa1\x88\x00\x11\x00*mz\xe6H\x9c\xe2\xdc\x19C'
 b'jt\xe5\x01?P\xd4\x93\x00\x00\x00\x03\x00G\xa8\r\x12D\x9f\\\x00\x05\x00J'
 b'\xae\xbe\xa7\xe8\x1d\x00\x00\x00\x02\x00\x00\x00C\x00T\xbf\xeb\x0f,\x04'
 b'\t\xb5\xfa')

{'A1': 48888,
 'A2': 954676506,
 'A3': 91,
 'A4': 28616,
 'A5': {'B1': 174,
        'B2': -0.32794275879859924,
        'B3': [{'C1': [4267576030,
                       4294785742,
                       3763706898,
                       2001346978,
                       1308877842,
                       4233394459],
                'C2': 118},
               {'C1': [2530707858,
                       719210323,
                       3732049406,
                       1275812620,
                       3548386966,
                       4139862433],
                'C2': 136}],
        'B4': {'D1': 0.815743625164032,
               'D2': [109, 122, -26],
               'D3': -88,
               'D4': 13,
               'D5': 306487132,
               'D6': [18588, -7460, 6467, 27252, -6911]},
        'B5': -0.8456020430436972}}

Вариант №2

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

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

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

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

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

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

(b'\xb1JZX\xbe9\\\x0e\x00 \x00+\x008\x00C\x00N\x00[\x00g\x00t\x00\x02\x00\x00'
 b'\x00{P\xd1u\x00\x02\x00\x1e\x0bE~\x1d\xe1w\xc2\x00\x02\x00)\x82\xc2\xf3\x16'
 b'\x9dr\xd0\xb9\xd8\x00\x04\x004\x8a\xe8~\x9a\xb9<\xfa\x00\x02\x00A'
 b'\x92\x88j\xe2\xcb\xd1\x19\x00\x02\x00LC\xe5\xf9\x89\xee\xe2\x07\xcdI'
 b'\x00\x04\x00W[h\xda\x0c?\xf0\x95\xb8\x00\x03\x00d\xd7\xeb+bN\xb5\xca\xa9'
 b'\x00\x04\x00\x00\x00p|*\x91B\x86\xcf"\xc7\xd3\x06\\\xa8t\xe2\xb2\x16\x16')

{'A1': {'B1': -0.1810152232646942,
        'B2': [{'C1': 117, 'C2': [80, 209], 'C3': 189103645},
               {'C1': -62, 'C2': [225, 119], 'C3': 2193814294},
               {'C1': -40, 'C2': [157, 114, 208, 185], 'C3': 2330492570},
               {'C1': -6, 'C2': [185, 60], 'C3': 2458413794},
               {'C1': 25, 'C2': [203, 209], 'C3': 1139145097},
               {'C1': 73, 'C2': [238, 226, 7, 205], 'C3': 1533598220},
               {'C1': -72, 'C2': [63, 240, 149], 'C3': 3622513506}]},
 'A2': {'D1': [78, 181, 202, 169], 'D2': 124},
 'A3': [3067305967984232403, 458426482057942550]}

(b'\xb1JZX\xbe\x8c\xe9C\x00 \x00-\x008\x00E\x00Q\x00]\x00h\x00v\x00\x03\x00\x00'
 b'\x00}N\xcf}\x00\x02\x00\x1e\x0c\x9aW\x8e\x1c\xc01\x0c\xb8\x00\x04'
 b'\x00)\x9a\x80\x15x\t\x11:\x00\x02\x006]\x01*\x14\x08\xb9o/~\x00\x04'
 b'\x00Ab\x7f||$\xfe\x1a\xa8\x00\x03\x00Npm\xd9RY\xc0\x852\x00\x03\x00Z\x89|'
 b'\xb2u\xb3\x88\x1c\x00\x02\x00f\xa0?\x16J\xbfH\t\xe1\xa6\x00\x05\x00\x00\x00q'
 b'\x08\xc6\\\xd0\xe7\xbd\xc6\xc2\x91\xb3\x18\xbe\x01i\xa8\xc1\x16&\x1b\xdb'
 b'\x08`V\xe1\xd6')

{'A1': {'B1': -0.2752171456813812,
        'B2': [{'C1': 125, 'C2': [78, 207], 'C3': 211441550},
               {'C1': -72, 'C2': [28, 192, 49, 12], 'C3': 2592085368},
               {'C1': 58, 'C2': [9, 17], 'C3': 1560357396},
               {'C1': 126, 'C2': [8, 185, 111, 47], 'C3': 1652522108},
               {'C1': -88, 'C2': [36, 254, 26], 'C3': 1886247250},
               {'C1': 50, 'C2': [89, 192, 133], 'C3': 2306650741},
               {'C1': 28, 'C2': [179, 136], 'C3': 2688489034}]},
 'A2': {'D1': [191, 72, 9, 225, 166], 'D2': 8},
 'A3': [14293529011107054225, 12905273645507068182, 2746029226834977238]}

Вариант №3

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

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

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

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

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

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

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

(b'kCMBD\x00\x02\x00\x00\x00^pK\x145\x07\xecgH\x00\x02\x00\x00\x00\x90n[\xc5'
 b'\xe8\x1bqX\x9f\x00\x00\x00\x05\x00\x92\xe0\x0c\xb4\x89\x98\xb6\x84s\xa6'
 b'\x00\x00\x00\x02\x00\x00\x00\x97\xc1\x94:[\xb1C!\x1b\x04\x84\xbe\x98'
 b'\xef*\x9e\xeb\xde\xa7XZ\x01\x9eV\xab\xd1\x96\xbe\xce\xe5\xa6A\xc7\x8d{\xa15'
 b'_\xae\xa2\x98\x8c\x87\xb5\xbf\xb3\xeb\xa2D\xbd\xb5 \xab_2!?\xe4\r=\x7f'
 b'd\xd4\xd0\xc9r\xcc\x12\xc7?\xd8\x08\x89H\x0ex\xe4w~\x83\xfc\xbf\xe1\xe0\xf6'
 b'7vj\xbadf\xd5v\x0bM\xd5\x84(\xde\xbd')

{'A1': 68,
 'A2': {'B1': [{'C1': {'D1': -1567060857, 'D2': 181},
                'C2': -0.07781423738716287,
                'C3': 2875142689,
                'C4': 0.6266162384187286},
               {'C1': {'D1': -915223534, 'D2': 199},
                'C2': 0.37552101170321195,
                'C3': 2004780028,
                'C4': -0.5587111552479975}],
        'B2': 8091583373499983688,
        'B3': 'df',
        'B4': 1851508200,
        'B5': 460413087,
        'B6': [-43, 118, 11, 77, -43],
        'B7': -32,
        'B8': 915507913253221286},
 'A3': [33832, 57021],
 'A4': -15980,
 'A5': {'E1': 979087683, 'E2': 2385505395802697514, 'E3': 11451491287842816414},
 'A6': 1454100886,
 'A7': -0.4040958285331726,
 'A8': 4739912694955859886}

(b'kCMBZ\x00\x02\x00\x00\x00^\xb0H\xd3\xe7o\x981\xd2\x00\x02\x00\x00\x00'
 b'\x90\\\xf0\xfe\xc9\x17"Q\x11\x00\x00\x00\x07\x00\x92\x9eTN\x85\x12\x1e\xf3[#'
 b'\x00\x00\x00\x02\x00\x00\x00\x99\xacR\xd6^\x0c\xd6D\xb4\xcc\x08\x0f\xe6'
 b'\xd8p\x8a4_\x99"\x92N\xb3/\xf3\xe0\xb6\xbf\x7fZK\xb2@\\Ru\xd9'
 b'\x9a\xd6\xc0\xae\x8c\xfc\x01?\xcf\xca\x04F\x9a\x82\xa8r\x9a\xfa\x83?'
 b'KK\xdc\x84\xd6H\x00\xf7kM\x0b\xcb\xbf\xbd\xa3\xf4\x81d\xf9Puv\xa6\xd7'
 b'?\xe1\x1f\x05\x84\x08S`ph)E\xbfA!\x85\xe0\xbe\xb0\x14X')

{'A1': 90,
 'A2': {'B1': [{'C1': {'D1': -1062302468, 'D2': 1},
                'C2': 0.24835256049575105,
                'C3': 1922759299,
                'C4': 0.0008330179932036774},
               {'C1': {'D1': -143962869, 'D2': 203},
                'C2': -0.11578300627750093,
                'C3': 1970710231,
                'C4': 0.535036809803028}],
        'B2': 12702635739961635282,
        'B3': 'ph',
        'B4': 1559297737,
        'B5': 388124945,
        'B6': [41, 69, -65, 65, 33, -123, -32],
        'B7': -98,
        'B8': 6074939260244548387},
 'A3': [48816, 5208],
 'A4': -21422,
 'A5': {'E1': -698479402, 'E2': 4950806225385609328, 'E3': 9958689787337658035},
 'A6': 804511926,
 'A7': -0.9974715113639832,
 'A8': -5602376427214628138}

Вариант №4

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

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

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

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

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

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

(b'JZGS\x02\x00*\x00\xe9\xe0\xf6\xb0\xc8\x07\xe9\xd6\x02\x00\x00\x00P\x00$\x03'
 b'\xa8\xc8\x84\xf2\xcc7\xdaX\x00\x1c\xd4\xa7\x1e]s\x82Y.<\xea\xcd\x85\x08\xaa'
 b'\x9d\xc8\xb4x\xbd\xdc\x0e@\xcf*"\xc0dE5\x0b{\xe0\x7f\x14l\xaa4\x97\t\xf0?a'
 b'l%\xd6\x19.\x00\x00\x00?\x00\x00\x00\x8bn\x84\xe6;\xff\x99u\xf3\xce\xc8<'
 b'\xf3$\xb8\x0b\xb9n1\xd0\x1fEw^K\x84\xad{_T\x83\x1dw\x01\xe5|\x0f\x18*')

{'A1': [-5572, -31283],
 'A2': 15485917352233984233,
 'A3': {'B1': [{'C1': [8, 170, 157, 200, 180, 120],
                'C2': -9027,
                'C3': 14,
                'C4': 3838585033772945216},
               {'C1': [11, 123, 224, 127, 20, 108],
                'C2': 13482,
                'C3': 151,
                'C4': 1861716643382554633}],
        'B2': 4020855219451069220,
        'B3': 218,
        'B4': {'D1': 3867438731,
               'D2': 59,
               'D3': [17527104640992516607,
                      2292386561952299044,
                      6880283639450335045,
                      1116018602137191252],
               'D4': 10776}},
 'A4': 6449844460131439644,
 'A5': 46}

(b'JZGS\x02\x00*\x00[\xbfYe\xe5\xd0@\xbb\x03\x00\x00\x00a\x00Oz\xc6\xdf\x03\xb7'
 b'\xad\x8dvm\x00ur\xdfu\xf4\xaf\x81xLS-\xbc\x07\xc2\xad\n<\x14\xa6'
 b'\x96]\xc7\xe1\x1f\xf8\xca\t\x0b\x84ze.9\x95\xe0y\xd3\xba\x82X\x0c}C'
 b'\xa2j4\xe4t\x03\xab\xd4\xf0|\x03\x015E+P\xe6\xbaP\xbf\x1b.\x00\x00'
 b'\x00?\x00\x00\x00P\x00\x00\x00e\xb2\xd8<\x19\x90\xb1\xa2IwN\xbb\x10a\x95'
 b'\x80m\x0f\x06b\x1fPl%\xef:\xc8W\xcc\xd6R\xba\xb2\xf9\xf3\xdc\xbf,\xbd')

{'A1': [11603, 1980],
 'A2': 13493014167268474715,
 'A3': {'B1': [{'C1': [194, 173, 10, 60, 20, 166],
                'C2': 23958,
                'C3': 199,
                'C4': 8828193306240884705},
               {'C1': [101, 46, 57, 149, 224, 121],
                'C2': -17709,
                'C3': 130,
                'C4': 16443885384586038360},
               {'C1': [116, 3, 171, 212, 240, 124],
                'C2': 259,
                'C3': 53,
                'C4': 1999405523233942341}],
        'B2': 10209017157585893967,
        'B3': 118,
        'B4': {'D1': 1020834405,
               'D2': 25,
               'D3': [1205643599495213456,
                      2261376626224829793,
                      14724457662156991568,
                      13825193209891541718],
               'D4': -17108}},
 'A4': 8683415021031486069,
 'A5': 76}

Вариант №5

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

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

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

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

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

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

(b'cWWQ\x94e\xfdVe\x80\xab3\x00\x00\x00:\x00\x00\x00a\x00\x00\x00\x02\x00x26'
 b'\xb5\xaa\xbfM\xac\xbf\x00\x02\x00z\x00\x00\x00\x8a>\ru\xb1>\xd0f\xa5\xbeB'
 b'\x83\xf6\xbfa:\x933\xebhib\x00\x00\x00\x04\x00\x00\x00*\xb9\x92n\xcb\x13'
 b'\x03>\xae\xec\x0f>\x1b\xaf\xe5>\x80\xfb\xcf\xbf3R\x84>\x18\xb0\xabU_c'
 b'iu\x00\x00\x00\x04\x00\x00\x00QvSa\xf48.\xbf\x0e\xad\xe8\xd6\xb2a\x17'
 b';\x03\xdf\x06 \xe6t\x83^H\xd3\xf1\xe6WZJIs*\xe9\xd3\xeb\xbf\xe4\x9b9t0'
 b'\x94\x94\xbe\xcd\xcf\xf9\x93+\xb5\xee')

{'A1': -1805255338,
 'A2': 1702931251,
 'A3': [{'B1': 13291,
         'B2': 'hib',
         'B3': [0.13814426958560944,
                0.40703311562538147,
                -0.18995651602745056,
                -0.879800021648407],
         'B4': 47506,
         'B5': 1858802435,
         'B6': 0.3416447341442108},
        {'B1': 21855,
         'B2': 'ciu',
         'B3': [0.15203817188739777,
                0.251921147108078,
                -0.7004778385162354,
                0.14911143481731415],
         'B4': 30291,
         'B5': 1643395118,
         'B6': -0.5573410987854004}],
 'A4': {'C1': [-42, -78],
        'C2': 842446250,
        'C3': -0.8034171462059021,
        'C4': [6996125433956016358, 8395657797235238487]},
 'A5': {'D1': 6506093370680136683,
        'D2': -0.6439482945758237,
        'D3': -0.4019773304462433,
        'D4': 2469115374}}

(b'cWWQ\x1cb\xbarlT\xf7\xa3\x00\x00\x00>\x00\x00\x00i\x00\x00\x00\x04'
 b'\x00\x80a\x18\xff\x1e\xbf]\xe4\xc0\x00\x02\x00\x84\x00\x00\x00\x94=\xb8'
 b'\xf5^>\xd9:6\xbeg\xe6+\xbe=\xc7\xfa\xbf\x1a,/\xd2\xe7cnf\x00\x00\x00\x05\x00'
 b'\x00\x00*\xe6&\xfc)`\x8a\xbf8\xd1H?\x01EO\xbf\x00\x11<\xbf\x1dq}\xbfz('
 b'\x03=\xe1W\x1a\xd0\xeehue\x00\x00\x00\x05\x00\x00\x00U\xb4\\5\xb4\xb7,'
 b'\xbf\x16\xfa\x93R\xf4\x92\x84\xe1\xb0W>\x9ee\xb6m\x9c*]\x06 gY\x06\xd1g\x87f'
 b'\x0eO\xd90\xbf\xe7\r\x80\x19\x86\xf42?\x1e\xb6\x82,\x1a\xfe8')

{'A1': 476232306,
 'A2': 1817507747,
 'A3': [{'B1': -11545,
         'B2': 'cnf',
         'B3': [0.09031175076961517,
                0.42427223920822144,
                -0.22646395862102509,
                -0.18533316254615784,
                -0.6022366881370544],
         'B4': 58918,
         'B5': 4230570122,
         'B6': -0.7219433784484863},
        {'B1': -12050,
         'B2': 'hue',
         'B3': [0.5049638152122498,
                -0.500262975692749,
                -0.6150129437446594,
                -0.9771730303764343,
                0.11002941429615021],
         'B4': 46172,
         'B5': 901035820,
         'B6': -0.589760959148407}],
 'A4': {'C1': [82, -12, -110, -124],
        'C2': 1629028126,
        'C3': -0.8667716979980469,
        'C4': [16262594180891915885, 11252908899833436422]},
 'A5': {'D1': -3357566124784887504,
        'D2': -0.7203979967667975,
        'D3': 0.6199723482131958,
        'D4': 739966520}}

Вариант №6

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

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

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

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

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

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

(b'\xe8ZSJpwsqedr\x99\x84\x17<\xbe\x13\xaf\x1b\xd8d\xf6Y\x17\xab\xf7\xd9?'
 b'\x84q\xc0\x17g\xa7\x8e\x10\xcb?\n\xc0\xc8\x92\\\x0b\xf3C\xcc\xbf*NgC\x8dng`'
 b'\x03m\x8a\x82\x11\xdd\xbf\xaa\x9e+\xd3\xff\xe8\xbb6\x1f\x10c5W+N\xbe\xa9'
 b'\xad\xdf>\xd9\x9fG?\x04\x00[\x00H\xba\x83,g2\xc0\xe4\xfb\xe0I\x11r'
 b'\x17\xd6\x13\xe7]?v\x88\xe2u>\xa4\x00S\xe3z\xcc\xf6!')

{'A1': 'pwsqedr',
 'A2': 0.009247922338545322,
 'A3': {'B1': 5054,
        'B2': -81,
        'B3': 55323,
        'B4': [{'C1': 0.4057414749184771, 'C2': 29060},
               {'C1': 0.21144278692207585, 'C2': 49162},
               {'C1': -0.22082365088239997, 'C2': 20010}],
        'B5': 17255},
 'A4': -115,
 'A5': 'ng',
 'A6': -0.45419372099063615,
 'A7': {'D1': -86,
        'D2': 158,
        'D3': -11477,
        'D4': 3846936232952850687,
        'D5': [-0.20133720338344574, 0.43687179684638977, 0.7797828316688538],
        'D6': [16483230054885866056,
               1429355710420476155,
               4500752478353972711,
               2447368275694387364]}}

(b'\xe8ZSJcmlnmjy1;q?\x89\xf4\xfa\xc0\xaf\xc2\x0c\xc4\xac\xc5\x15\xe6?'
 b'\x95\xec\x80\xef\xeb\x974\xb6\xc4?:\x03\xe8\xb5=\x072\xed\xd8?\xc5T\x9b\xa5'
 b'\x80tv\x9e\xde\xf6\x1c8m\xe7\xbf\xa5\xa0V\xd8\xfa\x93\xc7\xe7r\xab\xacX\xcf'
 b'\x9c.\xbf\xa2\x01\x87>\xc2>!?\x04\x00[\x00<\xff\xa4\xf4/w6\x07g\x85`\x86\xca'
 b"6\xf2f\x9f\xe5\xa5~\x9c\x15\x9a\x93\x01\xee:'6\n\x10\xa4")

{'A1': 'cmlnmjy',
 'A2': 0.9423094391822815,
 'A3': {'B1': -2935,
        'B2': -6,
        'B3': 44992,
        'B4': [{'C1': 0.690157735284082, 'C2': 60565},
               {'C1': 0.16181046884582528, 'C2': 826},
               {'C1': 0.38947725970396485, 'C2': 21701}],
        'B5': 42395},
 'A4': -128,
 'A5': 'tv',
 'A6': -0.7320824208936363,
 'A7': {'D1': -91,
        'D2': 160,
        'D3': -10154,
        'D4': 6389670481335129082,
        'D5': [-0.6820802092552185, 0.26368433237075806, 0.6298638582229614],
        'D6': [519733854859493180,
               7418051779698394471,
               10635837231872730527,
               11821960249550237185]}}

Вариант №7

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

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

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

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

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

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

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

(b'\xe0VZGN\x15\x00\x00\x00N\xa1u\xa8\xf2\xfeuu\xf0\xb0\x10\xa9\xd4\x11\xd6'
 b'#+\x00\x02\x00\x00\x00\x83\x8c[=)Sn!9\xc4\xa7@^\xb7\xd4\x1c\xc2\xf3!6\xbd'
 b'Ya/ 4b\xa7\xfa\x89\x90q\xab+\xe52\x00\x02\x00;\xe8\x07o\xcf\x04C=\xfaG'
 b"Y\x1b\xbf\xdaKW\x8e\xd5\x89H\xbf\xe0{\xdc]\x03\x7f\xf0\x00\x02\x00'\x00?"
 b"\x00\x03\x00K\xaf\x92\xf9g\xad\x96{6lw^'EIT&\xbb\xcf%=\x91,A\x80\xa5F\x9bk"
 b'\xdf\xc6=')

{'A1': 19989,
 'A2': {'B1': -95987429,
        'B2': -0.4108485121597778,
        'B3': -0.5151197258637676,
        'B4': [{'C1': 969189184, 'C2': 1589105692, 'C3': -15629},
               {'C1': 557235545, 'C2': 1630478388, 'C3': 25255}],
        'B5': {'D1': 2871780658, 'D2': [-1399, -28559], 'D3': 3892801487},
        'B6': {'E1': [4, 67, 61],
               'E2': 44946,
               'E3': 4184321430,
               'E4': 31542,
               'E5': 7815819201083954214,
               'E6': -69,
               'E7': 207,
               'E8': 37},
        'B7': 0.07088518887758255},
 'A3': 41333,
 'A4': [43250, 65141, 30192, 45072, 43476, 4566, 9003],
 'A5': [-2136652133, 1809827389],
 'A6': -29605,
 'A7': 0.04133933037519455,
 'A8': 33}

(b"\xe0VZGy\xea\x00\x00\x00N[\x91x'\x06\xae\xe3\x82\xb8\n`\x83\x16\x98"
 b'\x1a/\x00\x02\x00\x00\x00\x83\xc0\x14?Q\x8c\x87\xa9\xc6\x9a*m\xb6a\x7f6\x9d'
 b'\xd7\xa0\xc1\xc3P5\x91\xd4\x8aw\xe4\x98\xa0X\x1a.i\x91\xb5\x00\x02\x00;Q'
 b'\xa3\xd3\xe4W\x18\xc5<\x0b\xe1\xa9\xbf\xebz\x97\x994\xebZ?\xd4\tn\x8c\xc1'
 b"\xdc\x0c\x00\x02\x00'\x00?\x00\x03\x00K\xd8\xb8^\x9f\x03\xeb\xe0W\xa3UhJ"
 b'\xa0|(\xc86\xbc\xb3?d\xb9\xc1\xb8f\xc0\x0eNt,g')

{'A1': 31210,
 'A2': {'B1': 1007411625,
        'B2': -0.8587148659056354,
        'B3': 0.3130756735403686,
        'B4': [{'C1': 3331992173, 'C2': -1235124426, 'C3': -25129},
               {'C1': 2697053008, 'C2': 898749578, 'C3': 30692}],
        'B5': {'D1': 778670517, 'D2': [-26464, 22554], 'D3': 1369691108},
        'B6': {'E1': [87, 24, -59],
               'E2': 55480,
               'E3': 1587479531,
               'E4': -8105,
               'E5': 11769427870932019400,
               'E6': 54,
               'E7': 188,
               'E8': 179},
        'B7': 0.8934593796730042},
 'A3': 23441,
 'A4': [30759, 1710, 58242, 47114, 24707, 5784, 6703],
 'A5': [-1201225714, 1316236391],
 'A6': -16364,
 'A7': 0.8185505270957947,
 'A8': 169}

Вариант №8

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

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

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

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

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

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

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

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

(b'PBJH\xb3\x7f\x0c\xac\xd4Jek\x00\xd2\xe9N+\xa6\xe1k?\xdah\xcd\x80\xa2BJ'
 b'\xfdq\xb14\xb8-\xc2\xeb\x89\xd0?\x19\xed\xea\xce\x85JY>M\x8e+n[\xc8\xca0\x0c'
 b'"\x1c)\x0bm\xc8\xf8\xef\xbfC.\xfa\x7f&Q\xba\xa5\xde\xfa\x02\x05\x14z\x1f'
 b'k\xc1\xfd\xf9\x7f\x8e\x8f\x9fA\x94\xb8\x02\x00\r\x00\x00\x007i\x8e'
 b'\xbe\xe1y\x96\xc8\xedAA\x00\x00\x00\xc7\x04\xe3\xf9;\xd4\x12\x0ew'
 b'/\xbc\xb2\xd9\xb1\x1f\xfb\xd8\xa1\xb3gM\x87}@\x03\x00e\x00V\x91!')

{'A1': -1408467021,
 'A2': {'B1': 19156, 'B2': 101},
 'A3': {'C1': {'D1': -6504797485985550781,
               'D2': 84081374,
               'D3': 31252,
               'D4': 10344346105797503775,
               'D5': 3096723871,
               'D6': [{'E1': 726591954,
                       'E2': 0.9214118719100952,
                       'E3': 26842,
                       'E4': [205, 128, 162, 66],
                       'E5': 2977037642,
                       'E6': 0.2584180256152451},
                      {'E1': -823464679,
                       'E2': 0.21219833195209503,
                       'E3': 36429,
                       'E4': [43, 110, 91, 200],
                       'E5': 571224266,
                       'E6': -0.9991190080411658}],
               'D7': -0.2781464755535126},
        'C2': -102562617,
        'C3': {'F1': 236115003,
               'F2': [119, 47, -68, -78, -39, -79],
               'F3': 64287,
               'F4': 4647019157038277080,
               'F5': [31201, 51350, 16877]},
        'C4': 37206,
        'C5': 33}}

(b"PBJH\xe7t\x82\xb0\xde\xcf\xf9i\x00\x95\x8f\xb7TI\r\x17?\x1aT,'`\xc5="
 b'B\xd4\x96\xb2\xf5\xd5\xdf\xfd\xf9\xe7\xbf\x06g\x04\x8a\xa8\xa8\xa0=\xc8'
 b'\xc7\x18\x13\x1e\xf8n\xf9RtP3\xff\xff\x04\xbe\xc1\xbf\xee\x98\x80ZC?\x0f'
 b'\x1b\x9bI\xc9\xe4\xbfw\x95 \xef\xd9\xdc&\xc9^,\xee\xd5\xdc\x02\x00\r\x00\x00'
 b'\x00\xe2i4?\xb7\x81w\xe8A\x00\x00\x00\xfb\x86\xafq\x1f_\x1d2G\x1d\x08[\xe7EJ'
 b'\xe6\xaf\xc8\xc2\xc1t\xbcL\xda\x02\x00e\x00+\xf5\xf8')

{'A1': -1333627673,
 'A2': {'B1': 53214, 'B2': 249},
 'A3': {'C1': {'D1': 1949846722188450030,
               'D2': 3838396827,
               'D3': 30655,
               'D4': 6830033039875055765,
               'D5': 3705007660,
               'D6': [{'E1': 1421315989,
                       'E2': 0.5900464653968811,
                       'E3': 21530,
                       'E4': [44, 39, 96, 197],
                       'E5': 2530492989,
                       'E6': -0.7492665645401557},
                      {'E1': -1979422970,
                       'E2': 0.07844668626785278,
                       'E3': 51144,
                       'E4': [24, 19, 30, 248],
                       'E5': 1951594862,
                       'E6': -0.13861143588874336}],
               'D7': 0.7047406435012817},
        'C2': 1907328763,
        'C3': {'F1': 840785695,
               'F2': [71, 29, 8, 91, -25, 69],
               'F3': 58954,
               'F4': -2716589265558255441,
               'F5': [33207, 59511]},
        'C4': 62763,
        'C5': -8}}

Вариант №9

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

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

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

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

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

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

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

(b'\xb8VJYI\x03\x00\x00\x00D\x00\x00\x00cvppf\x9d\x8a\xbch\x7fd>?J\x00'
 b'\xfbs\x9b?a\x0f \x02\x00\x00\x00z\x00\x00\x00V\xeb\xe6>\xdc\xa1L<\xe3'
 b'\xf7\xe7\xe823?X\xd8w\x91\x15\x0b?\xab\xcf\xaf/\x006\x00=\x00\xb2m\x04)ri'
 b'\xc0\xb7\xf3\xee\xe3\xbfN\x9d,\xa2\xec\xd8\xf7\x80X\xaa5\xe8G\xc8'
 b'\x05\x82\xcf\x18m1\xfb\xaan\xf7\xf6\xf7&G\x93\xd32\x96\xc8\xeaf\xe5\xb9\xf4'
 b'\x00\xda\xc0\xec1\x12')

{'A1': [{'B1': 0.012489762157201767, 'B2': -2077, 'B3': -25},
        {'B1': 0.6999955177307129, 'B2': -10152, 'B3': 119},
        {'B1': 0.5432978272438049, 'B2': -12373, 'B3': -81}],
 'A2': 'cvppf',
 'A3': -30051,
 'A4': 188,
 'A5': 104,
 'A6': {'C1': 0.7437209486961365,
        'C2': {'D1': 688156082,
               'D2': -0.6229189480684865,
               'D3': 2720832846,
               'D4': [-2131240724, -399136168, -2113550265],
               'D5': [829233359, -143742213, 1193736182],
               'D6': 16530157629544256403},
        'C3': 251,
        'C4': 115,
        'C5': -101,
        'C6': {'E1': 537878847, 'E2': [-637471559, 305261760]},
        'C7': 0.4510142207145691}}

(b'\xb8VJYI\x02\x00\x00\x00=\x00\x00\x00jmdxs\x99!\x81\xf2^\xc1\x17?A\x00'
 b'\xa3\x874M\xa9I9\x02\x00\x00\x00q\x00\x00\x00\xaa\xe6V>#>:?\x9c>\xc0\xf2\x97'
 b'9\xbf\xe1\xb6\x02/\x006\x00\x9e\xc7U7\x90\x89\xd1G\x86\xa0\xbf?\xfb\xce\xe9'
 b'\xf3\xe54\xf3%m\xad\xe5\x9c}b\x95\x95\xf6\x01\xda\xed\xa2G\x01y\x84\x06\xcd'
 b'x\x9e\x03\x1b\xfc\xf3@\\\xba\x04&e\x88\x16B\xcb\x80')

{'A1': [{'B1': 0.7275106310844421, 'B2': 16028, 'B3': -64},
        {'B1': -0.7249747514724731, 'B2': -18719, 'B3': 2}],
 'A2': 'jmdxs',
 'A3': 8601,
 'A4': 129,
 'A5': -14,
 'A6': {'C1': 0.5927942991256714,
        'C2': {'D1': 928368542,
               'D2': 0.12354315999394871,
               'D3': 4092186363,
               'D4': [636695781, -1662669459, -1785372035],
               'D5': [-304479754, 2030127010, 2026702468],
               'D6': 13428679605562835870},
        'C3': 163,
        'C4': 135,
        'C5': 52,
        'C6': {'E1': 961128781, 'E2': [-2006637052, -2134162922]},
        'C7': 0.2098642885684967}}

Вариант №10

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

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

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

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

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

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

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

(b'\xf9DGU\x00\x9e<\xce\x0fd\x9fA\x10Wk3\xc5\xdc>\x9f\xcd\x12?R\x13}\xee\xb5'
 b'\x88g5\xab\x00\x00\x05\x00\x00\x00\x1c\xbd\x97\x80\x82\xc3\x83D\xaa\x98'
 b')_\x00\x02\x00\x00\x000\t\x1c\xc9r\xfcsV\x82\x12Kg\x81\x19l\x02\xf3'
 b'<\x00\x08\x00\x00\x00A\xb9\xab\x17\xdd\xa5\xbd\xcb\x90\xf1\x00!\x002'
 b'\x00I\xbf\xda\x1ee\xb8#\x1cT\x04[mi\x7f%\xce\xe6\xe1\x84r\xc3\xb1\x00'
 b'k\x02S\x94\xe3\xf6\xb0\xc4\xf1}V\x802\xac\x89\xe0\xf76\xdb\xa5VZhr'
 b'\xfb\xe0\xdcq=~\xc0\xda\xa5\xe6y!/\x1d\xb6\x7f\xe4~\x00\x00\x00\x03\x00X'
 b'q\xe8\x04\xe5\xd5x$\xcb\x00^')

{'A1': {'B1': [{'C1': [-120, 103, 53, -85, 0],
                'C2': 13661529293765952682,
                'C3': 152},
               {'C1': [41, 95], 'C2': 656621141388121730, 'C3': 18},
               {'C1': [75, 103, -127, 25, 108, 2, -13, 60],
                'C2': 13378813358770080656,
                'C3': 241}],
        'B2': 8207815706058171595,
        'B3': {'D1': -0.4081053064550748,
               'D2': [313964898904559334,
                      -2196504533436175614,
                      6022689250368352637,
                      6233037600909752118,
                      -2619592661946663968,
                      -2562199098386373146,
                      8728309357483123838]}},
 'A2': 15566,
 'A3': {'E1': 3940,
        'E2': [2671841367, 1798555100, 1050660114],
        'E3': 0.8206098675727844},
 'A4': 61109}

(b'\xf9DGU\x00\x88\xd2{\xd8\xf4o^miA\xd4(\x0fj\x96\n-\xbf[\x15\xf6\xf4\xda'
 b'\t\xad\xf4\xfe\xbe\xfb-\x00\x07\x00\x00\x00\x1c\xc8\xed\x1bHjkd\xf66\xe2\xdb'
 b'J\x00\x03\x00\x00\x002\xa8\xa5\xa1A\xc6g,\x1b\x1d\x00#\x005\xbf\xd4+u'
 b'\xf3*\xb1\xb4\xeb}\xc8\xc3\xf3pGK"JQ\x1d\x87\xb8\xb2q\x00\x1fBww\x01\xdc"'
 b"\x9d\x9e(\xb7?.\xda\x12\xc7\xe1\x95)\xd3\xba~'\xec\xb3~w\x05\xd1\x0ec"
 b'\xde_\xfa\xb2\x02\xa2\xea\x0c\x00\x00\x00\x02\x00D\xb2IY\xe2\x83H\xb1L\x00H')

{'A1': {'B1': [{'C1': [9, -83, -12, -2, -66, -5, 45],
                'C2': 14478258374903031030,
                'C3': 54},
               {'C1': [-30, -37, 74], 'C2': 12152296473402747931, 'C3': 29}],
        'B2': -5599845832258440884,
        'B3': {'D1': -0.31515263315921094,
               'D2': [-1477804358779254965,
                      2470876532839068273,
                      8798805143182370,
                      -7089183995930420718,
                      -4043786983523582425,
                      -1390628810263556509,
                      -2422942432046683636]}},
 'A2': 53883,
 'A3': {'E1': -9996,
        'E2': [1868459369, 1104422927, 1788217901],
        'E3': -0.8558038473129272},
 'A4': 62682}

Вариант №11

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

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

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

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

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

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

(b'GIQ\xb9\x0c\xf4\xab\xd1\x97\x07\x00_x\xbb\t\xa2<\x00\xb0\x91\xe5\x92\xd5\xbf'
 b'O\x10.?\xb0\xf0p\xfaG6w\xe0?oG4L&\xa8s\xa0*\xaa\x04\xea?\xc1\x15\xaa\x9bV@'
 b'\xb9\xbf`y\xfd\xe6\xbfC\x00\x00\x00aydd}\x0c\xdeG\xed&\xab\xeb\x15d\xe2\xd44'
 b'S\xc5o\xfe\xff\x0c\x8f\xf1Gp/\x1f\x108X\xcc\xbf')

{'A1': {'B1': -1410069319,
        'B2': 497617,
        'B3': [{'C1': 95, 'C2': -1576420488, 'C3': -0.3370908663491752},
               {'C1': 79, 'C2': -1338036720, 'C3': 0.5145522504640478},
               {'C1': 111, 'C2': 642528327, 'C3': 0.8130694229654312},
               {'C1': 193, 'C2': 1453042197, 'C3': -0.7184416665675499}]},
 'A2': {'D1': 'aydd',
        'D2': {'E1': [3197, 18398, 9965],
               'E2': 1679158187,
               'E3': -11038,
               'E4': [21300, 28613, -2, -28916, 18417]},
        'D3': -0.22144223010252118}}

(b'GIQ3\x8aY\x03\xe8w\x15@\xd5[\xd5\xc4K\x00\x1c\xfe\x81\xfa1S?\xf8U\n\xbc'
 b'\x83\xa0\xd3]\xa0\xc5\xb9\xb0\xbf\xb1\xda5\xa3v\xe4\xb6\xf4\x10\xbe\x94'
 b'\xeb?\x06\x1f\xb8/\xf0(\x01\xc7oj#\xd6\xbfC\x00\x00\x00jysfU\x96Q_\xef'
 b't.V\xfb7\x16\x0cs\x05q,\xd7r\x08\xaf\x08\xd0\xf0[\x85n\xdaH\xd8?')

{'A1': {'B1': 56199731,
        'B2': 1075148776,
        'B3': [{'C1': 213, 'C2': 1271190875, 'C3': 0.001171583782680008},
               {'C1': 248, 'C2': -2084828587, 'C3': -0.06533465542982109},
               {'C1': 177, 'C2': 1990407642, 'C3': 0.8619070368929127},
               {'C1': 6, 'C2': -265308129, 'C3': -0.34591160693891476}]},
 'A2': {'D1': 'jysf',
        'D2': {'E1': [38485, 24401, 29935],
               'E2': 939218478,
               'E3': 3094,
               'E4': [1395, 11377, 29399, -20728, -12280]},
        'D3': 0.37944660943088504}}

Вариант №12

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

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

(b'\xe8VGY\xbf\xb5\xc0R\x0bJ\xb4\x80\x00J\x00\x03\x00Y\xb9\x00\x05\x00\x00\x00'
 b'_\x00\x00\x00\x02\x00\x00\x00i\x00\x07\x00m\r\x00\x03\x00\x00\x00{'
 b'\x00\x00\x00\x03\x00\x00\x00\x81\xbf\xdc\xfe\x9eGt]4\x02\xbc\x07\xe0'
 b'\xb6\xbdI0\x85;\x89X\xfe\xf8afbtguw\x925&Az:\xa6\xa7\x13tF^\xa0\x94<'
 b'\x0b\xe7\xaf-\xec\xbc\x92\xa9\x9b\xba\x15\x1c\xf9S8\xa5\xa4\x88Y\x9cddm}'
 b'`\xde\nl{\xa5\xd1\xbc\x86a\x8d\xb9;\xdc\xc0')

{'A1': -0.08496582770995253,
 'A2': {'B1': 'afbtguw', 'B2': 10535368965968537255},
 'A3': {'C1': [{'D1': [4980, 18014, 41108],
                'D2': -71,
                'D3': [15371, 59311, 11756, 48274, 43419],
                'D4': [47637, 7417]},
               {'D1': [21304, 42404, 34905, 40036, 25709, 32096, 56842],
                'D2': 13,
                'D3': [27771, 42449, 48262],
                'D4': [24973, 47419, 56512]}],
        'C2': -0.4530406663702309},
 'A4': 2,
 'A5': -0.00829332135617733,
 'A6': 13639486295255898366,
 'A7': 248}

(b'\xe8VGY?\xe1\xa5\x7f\xd1\x10\x1b\xac\x00J\x00\x05\x00Y\xe4\x00'
 b'\x02\x00\x00\x00c\x00\x00\x00\x03\x00\x00\x00g\x00\x04\x00m\xc1\x00\x02'
 b'\x00\x00\x00u\x00\x00\x00\x02\x00\x00\x00y?\xef\xcc\x1e@\xaf@\x96;?\x14\xbf'
 b'S~\xfdC\x19\xbd\xda\xf1\xd14cpbaxet}\xe94o\xb2\xb1\x99Y\xfb\x8e\x94D;\xfdV'
 b'}\xe9};\x99e\xac\xe4\x86\xb0\xc0>P\xf7@^f\xd8_1\x83o\xce\x87Ysw\xcf\xa1')

{'A1': 0.5514525492916298,
 'A2': {'B1': 'cpbaxet', 'B2': 9072840578658572633},
 'A3': {'C1': [{'D1': [64398, 37956, 15357, 22141, 59773],
                'D2': -28,
                'D3': [15257, 26028],
                'D4': [58502, 45248, 15952]},
               {'D1': [63296, 24166, 55391, 12675],
                'D2': -63,
                'D3': [28622, 34649],
                'D4': [29559, 53153]}],
        'C2': 0.9936667693491639},
 'A4': 59,
 'A5': 0.5810443758964539,
 'A6': 9150543795725201873,
 'A7': 52}

Вариант №13

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

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

(b'OCVV\x87\xf9\\z\xf6\x03\x00\x00\x00+\x00v\x00\x00\x00\x96\x07{\x11\xf8'
 b'n\xc6\x18g,\x92\xaa\xd7\xe9Jx\xca<\xeap\x1b\n\xfc6fzzPOh\xd9I)'
 b'\xae\xa7\x19\x0b.\x00\x00\x003\x00\x00\x00?\x90~\xcb|V<\xaf\x9c\x8d\xb8#'
 b'\xa2\x949c\xf7Q\xad\xe5TGD<A\x1c\x1e\xb2\xe6\xbd?\xbe\xdb\xa55\xbf'
 b'C\xc5\x14\xbf\xc4\x8bK?\x03\x00\x00\x00@\x00\xa8g\xad\xfdm\x02\x008\x00 '
 b'\x8f\xd4H%\xc5\x81\xaeL\x00')

{'A1': -159752967,
 'A2': 'fzz',
 'A3': {'B1': 109,
        'B2': [{'C1': 80, 'C2': 1238984783}, {'C1': 41, 'C2': 186230702}],
        'B3': 1221889824,
        'B4': 2927740197,
        'B5': {'D1': 16549974328619930786,
               'D2': 0.011979896575212479,
               'D3': 7233,
               'D4': 45598,
               'D5': [-0.1872478425502777,
                      -0.7095620036125183,
                      -0.5811349749565125,
                      0.7951014041900635],
               'D6': [3414069311, 2939967100, 599297436],
               'D7': 4255999912}},
 'A4': [1785236314023200662, 8667997545316887655, 3962052885153987786]}

(b'OCVV\x87\x06]5\x92\x04\x00\x00\x00+\x00w\x00\x00\x00|_m\xb92\xf4\xe7\x94\x96'
 b"\xb9\xe6\xe00'\xd5l\x8f.\x1e<-\x0f7\x9aodoj\xea\xa6\x82e\x89<\x8f\x1dU"
 b'\xe1/\x00\x00\x004\x00\x00\x00\x8f\xe2\xf5z#\x04\x81\xd0\x1f+\xfcp;\xe0A'
 b'\xdb\n8Q\xa4\xba\xcd\xb8>\x9b)]b\x8f!8>Z\xb8W?\xf4\xa8o\xbfg\xd4h'
 b'?\x03\x00\x00\x00A\x00I\xcc\xec\x18\xdc\x02\x009\x00!\x9f!\xab1\x17&OM\x00')

{'A1': -1841996538,
 'A2': 'odoj',
 'A3': {'B1': -36,
        'B2': [{'C1': 234, 'C2': 2305131174}, {'C1': 60, 'C2': 3780451727}],
        'B3': 2871107361,
        'B4': 1327896369,
        'B5': {'D1': 11840306514613100603,
               'D2': 0.36094456911087036,
               'D3': 10651,
               'D4': 25181,
               'D5': [0.17981551587581635,
                      0.8426567316055298,
                      -0.9361717700958252,
                      0.9094910025596619],
               'D6': [2062934671, 3498116131, 1895574303],
               'D7': 418171977}},
 'A4': [10729813135929991036, 7842217417020717462, 11112367292516544143]}

Вариант №14

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

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

(b'JZF\xb8\xf2\xd04\x9c\xf4\xe7\x19&\xe1?\x80Aee\xe6_\xeb?J\x00\x00\x00\x82\x00'
 b'\x83\xdf\xe2\xbe)\xb13\xc2\xc6\xcb\x06\xa3G\x1d\x9aT\xfe\xd8\x02\r@6~\x1c'
 b'd\x14>V\x91\x0c8\x9b9<Y]\xe5\xfd[\x87\x94O\xa6\x83{\xeaYS\xd2];G)`{='
 b'u\xce\x02\x00\x00\x00\x1c\x00\x00\x00[\xc8f;\xd6\xb3C\x94\xb2\x8b'
 b'\x95\xefK\xe6\xb4\x07\x05\x00\x00\x00,\x00\x00\x00\xf2\xf7\xdc1\xd3\xfb'
 b'H\xfe\xfd5\xdc\tp\x05\xf1Y\x99\x14\n\xbfG\xf7\x92\xb0>x\x02\x00v\x00'
 b'\x00\x00\x08\xd0]\x1cD\x02\x00~\x00')

{'A1': 53490,
 'A2': 0.5359010248547578,
 'A3': 0.8554565410977801,
 'A4': {'B1': 1574064985,
        'B2': 18235,
        'B3': 0.06137100234627724,
        'B4': 52853,
        'B5': [-4453020813684973693, 6096217239114402758],
        'B6': -7763163599955638181,
        'B7': 555321867889904562,
        'B8': [{'C1': 55550, 'C2': [2, 13, 64, 54]},
               {'C1': 7294, 'C2': [100, 20, 62, 86]},
               {'C1': 3217, 'C2': [56, 155, 57, 60]},
               {'C1': 23897, 'C2': [229, 253, 91, 135]},
               {'C1': 20372, 'C2': [166, 131, 123, 234]}]},
 'A5': {'D1': 1392,
        'D2': 23025,
        'D3': 12723503784794920089,
        'D4': 30782,
        'D5': [836564978, 4266195923],
        'D6': 8,
        'D7': 1142709712,
        'D8': [13821, 2524]}}

(b'JZF\xb8\xf0IN\x8dqT\x9d*\xed\xbf\x10h<"z\xfe\xec\xbfD\x00\x00\x00|\x00'
 b'\xae.\xe5R\x83\x0b4IsXy\xaa91=\x92\xdf@\x14\x83\xfa\xbb\xbbZ\xe1i\x1e\x94'
 b'\xa8#\x11]:\xac\xb1%{\xdf\x9b\xf7\xf4e\xf7\xf0\xae5\xd5>\xa0<\xfaC'
 b'\x02\x00\x00\x00\x1c\x00\x00\x00\xcf\xa6\xc4\xe7\xf5\xd2\xb2\xf9'
 b'\xed\x08\xdb\x9c\xf3_\x99\r\x04\x00\x00\x00,\x00\x00\x00\x9f\x93\xc7\xa0'
 b'\x0e+U{\xfa\xe0w\x10\x9c\xd8\xef\xf6\x10\x99J\x04s\xa7\xad\xdd'
 b'\xb8\xf2\x02\x00p\x00\x00\x00O\x9b1\xc1"\x02\x00x\x00')

{'A1': 18928,
 'A2': -0.9114519738472298,
 'A3': -0.906064097277751,
 'A4': {'B1': 4042745332,
        'B2': 13742,
        'B3': 0.01956121064722538,
        'B4': 17402,
        'B5': [5274853722217066158, -7909111246849746829],
        'B6': -454068658813753649,
        'B7': 979919893843085549,
        'B8': [{'C1': 16607, 'C2': [20, 131, 250, 187]},
               {'C1': 23227, 'C2': [225, 105, 30, 148]},
               {'C1': 9128, 'C2': [17, 93, 58, 172]},
               {'C1': 9649, 'C2': [123, 223, 155, 247]}]},
 'A5': {'D1': 55452,
        'D2': 63215,
        'D3': 15973607565788092688,
        'D4': 62136,
        'D5': [2697434015, 2069179150],
        'D6': 79,
        'D7': 583086491,
        'D8': [-7942, 4215]}}

Вариант №15

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

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

(b'ECA\x9d\x02\x00\x1d\x00\x00\x00\x93\xa18\xae=\xa1\x1f\x00^\x00*\xb7\xb3\x80'
 b'v`\xe4\x1c\x1eyn\xca\x06\x1a\x048\xcc_\x82\x99\xc2\x060\xdc\xc1`am'
 b'\xbd\x1d\xabU\xbf\x84\x8c\xc8>\xd2o\xcb>\xeb\x08\x8eWf\xf6\xea\xde\x81f\xf5'
 b'4S^+\xe5\xe1\x19\n\xa1\x16s\xb5\xe1\x9fZ\xea9dPp\xca\x80-\xda'
 b'\xdf\xd2\x0f\x06?i\xc5\x06\xdfC\xafxI\xa2\x86\xbe\x9a\xc5-\xbfF\xf52\xbf'
 b"\xda\xb0L\xbfZ\xa2<\x0fGe\xf67RwPjX\xcb\x8a\x1a\x02'\x86\x99\xc6\x04Y\xbe"
 b'\xcd?\xa1\x16v\xe7b\xfcS')

{'A1': 'yn',
 'A2': {'B1': 147,
        'B2': {'C1': 0.0850689485669136, 'C2': 161},
        'B3': [{'D1': [1738, 1050, -13256, -32161, -15719, 12294, -15908],
                'D2': [-0.05795419216156006,
                       -0.834642231464386,
                       0.3916970491409302,
                       0.39733749628067017],
                'D3': 235,
                'D4': 1717014024,
                'D5': [-2116097290,
                       1395979622,
                       -505074850,
                       379652633,
                       -1612597901,
                       1681517146,
                       -2134216624]},
               {'D1': [-9683, -11553, 1551, 26943, 1733, 17375, 30895],
                'D2': [-0.2629568874835968,
                       -0.6787964105606079,
                       -0.6990550756454468,
                       -0.799573540687561],
                'D3': 90,
                'D4': 1192180898,
                'D5': [1379399269,
                       1483362423,
                       35293899,
                       -963017177,
                       -843163388,
                       1981194559,
                       1409049319]}],
        'B4': 42,
        'B5': 2169860223441875895}}

(b'ECA\x9d\x04\x00\x1d\x00\x00\x00}\xcb\xa7u>C!\x00`\x003\x00\xf1\x01'
 b'W\xb7\xd6\xb9egprn\x02o\x1e\xbc\x07cY\xaa}\xa36\xa9\x11\x8a?\xe5\xff\xbe\xa7'
 b'\xd2z\xbf\x81eT\xbfY\xfe\xf6>&\xc6\x0f\xc3\xb6.\x81A\xe6&T\xfc\xd8\xe3s\xbct'
 b'4\xf7\xf6\xed\x91\xd6\x8e\x87\xd5\r|\xda\x16h\xb6(E:\x9a\xd9\x08W\xff\xbe'
 b'\xb3\x8fg\x96\xac)0\xb3r\xbf\xc4\xc8\x11>\x1e\x9a\xa6\xbdj\xae\x1d\xbf%\x18'
 b"\x90\x1bEl\x8eg\x08k'\xddot9\x9c\xf3\xb3\xff\xcc\x17Vo\x97\xbb\xd4"
 b'w\xbe\xf4\xb1h\xbb\xa2')

{'A1': 'gprn',
 'A2': {'B1': 125,
        'B2': {'C1': 0.23989789187908173, 'C2': 67},
        'B3': [{'D1': [28418, -17378, 25351, -21927, -23683, -22218, -30191],
                'D2': [-0.4997958838939667,
                       -0.9797767996788025,
                       -0.8296738266944885,
                       0.48240926861763],
                'D3': 38,
                'D4': -1228730426,
                'D5': [-431914706,
                       -654552026,
                       1958507491,
                       -302581964,
                       -2020682095,
                       -629404203,
                       683042838]},
               {'D1': [14917, -9830, 22280, -16641, -28749, -27033, 10668],
                'D2': [-0.9480466842651367,
                       0.142367422580719,
                       -0.08134864270687103,
                       -0.6159425973892212],
                'D3': 37,
                'D4': 1159434264,
                'D5': [141004396,
                       1876764523,
                       -207865484,
                       399310771,
                       -1147703466,
                       -188844076,
                       -1564776271]}],
        'B4': 51,
        'B5': 7330125951449297152}}

Вариант №16

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

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

(b'jPNO\xb6x\xfe\x01\xa4\x88\xeb\xbfE`C\xee\xa7:<\x00P\xa4x]\x02\x0f\xe4?'
 b'\xb8)S\xbfb\xb3E\x112\x91qfR\x93D\x88l\xa4A\x03\xff\x13Z(\x8eq\xdd\xa6'
 b'\x97\xcftg\x1c\x00\x00\x00\x94\x02\x00:\x00@\xf6z\xbf\x86\x9f\xb8'
 b'\xa9\xfdZ\xdc\xc3\xd42/o\x1aH\xce\xa9\x12\x17\xf12\xe6\xb2\xf2l\xe3,\x99'
 b"l\xe6lP\xb8q\xd3\xdc\x1a7\xbc\xeb[\xb8'\xf2WB?aC\xce=Cjw\xbe")

{'A1': -0.8604297675081145,
 'A2': 24645,
 'A3': 984084035,
 'A4': {'B1': {'C1': -0.8248553276062012,
               'C2': [{'D1': 289780578, 'D2': 50, 'D3': 7820576152462193041},
                      {'D1': -16563804, 'D2': 19, 'D3': -3488135916352034726}]},
        'B2': 148,
        'B3': 'tg',
        'B4': {'E1': -0.9803199768066406,
               'E2': [-1447518330,
                      -1008968963,
                      1865364180,
                      -1446098918,
                      854660882,
                      1827844838,
                      1821977827,
                      -1202688794],
               'E3': 54129,
               'E4': 2862138631227120348},
        'B5': [0.7591544389724731, 0.10071445256471634, -0.24161629378795624]},
 'A5': 0.6268321824656002}

(b'jPNO\xb2\x86s\xf45\x19\xe3\xbfC\xbe\x91\x04\xa5G=\x00\xcc\xd3\xce\x89'
 b'\x9d\xd8\xdf\xbf\x1eK\xdf>\xd2\\\xa2v\xdc\x87\xe7\xb9\x0ek\xe4\x8d\x08}\x90l'
 b'\x192\xbd\x96\xf6\x1d\x9f\xa1\xc6\x8exza\x1c\x00\x00\x00\x9b\x03\x00'
 b':\x00j\xc4j?_\xd8nB\x93\xe2v\xbb\xa2\xef#\x17\xb2\x91\xe6\xbcg\xaf'
 b'\x81\n\x12\xfdh\xb2\x9b\x0f\xf6.x\xac\xaa;P9\x823W\x18\x8a\xc3|@Z\xf0q?'
 b'C\xe2b?\xa2\xcb\xfe\xbe')

{'A1': -0.5968274855078646,
 'A2': 48707,
 'A3': 1201996945,
 'A4': {'B1': {'C1': 0.4361199736595154,
               'C2': [{'D1': 1990352082, 'D2': -36, 'D3': 616399872479324039},
                      {'D1': 426545277, 'D2': 50, 'D3': -8158655970160503107}]},
        'B2': 155,
        'B3': 'xza',
        'B4': {'E1': 0.9170595407485962,
               'E2': [1114560607,
                      -1149836653,
                      388231074,
                      -1125740110,
                      176271207,
                      -1301742318,
                      787877787,
                      1001041016],
               'E3': 14672,
               'E4': 4646803913420780418},
        'B5': [0.9450737237930298, 0.886264979839325, -0.49764734506607056]},
 'A5': -0.4975961538105451}

Вариант №17

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

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

(b'VKPv\x00,\x1bT\xd6j\x8f>yn\x8aR-\x11\xc2l\xe0\xbf\x00\t\xd4\xc2P\x8c'
 b'\x8d\xbfK\x89\xb9\x8e!CB\xc4\x91\t\xe7\xfe6\xe0\x01;Fu\xb9N\x00wf\x83\xf9V'
 b'Qq\x82\xd8\x1cc1%\xa2\x0b\x1e=\xf7AR\xf0\xc7\x0f\xa0w\xfd\xe9\xb5*'
 b'\x01\xdc\xc2Dx\xeb\x11"\xff\xa5\xfd+p!\x83>\x9e\r\xf5\xd8(\xbb\xb4\t'
 b'\xa5\x97\xa04\xceT8M\xd0\xa0\x86hst\x03\x00\x00\x00s\x00\xda')

{'A1': {'B1': 'hst', 'B2': -38},
 'A2': {'C1': {'D1': 44, 'D2': 21531}, 'C2': 0.28011196851730347, 'C3': 'yn'},
 'A3': -0.5132761321534229,
 'A4': -0.014427786775290219,
 'A5': -1900443317,
 'A6': [{'E1': [17185, 50242, 2449, 65255, 57398],
         'E2': 15105,
         'E3': 30022,
         'E4': 6267184832569167545,
         'E5': 81,
         'E6': 113,
         'E7': 130,
         'E8': 7384},
        {'E1': [12643, 41509, 7691, 63293, 21057],
         'E2': -14352,
         'E3': 40975,
         'E4': 14041099021186628983,
         'E5': 68,
         'E6': 120,
         'E7': 235,
         'E8': 8721},
        {'E1': [42495, 11261, 8560, 16003, 3486],
         'E2': -9995,
         'E3': 47912,
         'E4': 6110879608731929012,
         'E5': 56,
         'E6': 77,
         'E7': 208,
         'E8': 34464}]}

(b"VKPu\x00&\x03\xceO\xdeo\xbfnt\x1a3\xf3m\xf39\xe2?\x10\x18\xda\x15'\xc4"
 b'\xeb?\x801\x0b~cR\x90\x00E\x99\x86l\xd6\x9d\x8b\xc4drW\xb7S\xd2\xf2k\xde\xbf'
 b'y\xf8\xa8k\x80LWk\xe6\xc5\x079\x19\xed5@H\x01Q\xd7p\x8a\x107\xadx\x86['
 b'\x89,\xa8\xa4\xe2\xfe\xd7\xd4\x12\xc3N>\xady\xb2\xe8\x0b\xae\xa6\x8d'
 b'\xcd\xe5\x87e\xac\x00\xaf9\xb1\xfb\x83kl\x02\x00\x00\x00s\x00\xdc')

{'A1': {'B1': 'kl', 'B2': -36},
 'A2': {'C1': {'D1': 38, 'D2': -12797}, 'C2': -0.9369859099388123, 'C3': 'nt'},
 'A3': 0.5695740840397747,
 'A4': 0.8676944186015607,
 'A5': 2114662784,
 'A6': [{'E1': [21091, 144, 39237, 27782, 40406],
         'E2': -15221,
         'E3': 29284,
         'E4': 13825606596728960855,
         'E5': 121,
         'E6': 248,
         'E7': 168,
         'E8': 32875},
        {'E1': [22348, 58987, 1989, 6457, 13805],
         'E2': 18496,
         'E3': 20737,
         'E4': 9689685050299936983,
         'E5': 91,
         'E6': 137,
         'E7': 44,
         'E8': 42152},
        {'E1': [65250, 54487, 49938, 15950, 31149],
         'E2': -5966,
         'E3': 44555,
         'E4': 48525330344676774,
         'E5': 175,
         'E6': 57,
         'E7': 177,
         'E8': 33787}]}

Вариант №18

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

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

(b'\x8eABX*c]\xdc\xc3\xdd\xcf*OH\xe8\xa6^\xcb\xf7\xed35\xe5\xda\xe3\xc9\x04\x00'
 b'h\x00\x00\x00@b-I\xa9\x06\x00l\x00\x00\x00\xba\xaak\xf11\x08\x00r\x00'
 b'\x00\x00\xb5\xfbX\xbcR\x05\x00z\x00\x00\x00\xe6\xc7b\xd5\xfd\x05\x00'
 b'\x7f\x00\x00\x00\xbc\xed\xf6\xe1\xa7\xe8\xe91\x91\x87\x980\xf5\xa7\x84\x00'
 b'\x00\x00.\xafgW\x90\xebx?{pulep\xd9L\xca2K7\xd6\x04\xa6v;k-\x0b\x82\xd4'
 b'g\x86i\x87\x1a\xdc\xf6[\xdb\xb9\xa7\xc8\xbbj\xd9\xc5N\x1c\t\xbf\xa1n0\x1f'
 b'P\xc7\x1b\x87\r,')

{'A1': 25386,
 'A2': -9123,
 'A3': {'B1': 12026942309750791619,
        'B2': -2673672306622477474,
        'B3': -13853,
        'B4': 'ulep',
        'B5': [{'C1': 64, 'C2': -1454822046, 'C3': [217, 76, 202, 50, 75, 55]},
               {'C1': 186,
                'C2': 837905322,
                'C3': [214, 4, 166, 118, 59, 107, 45, 11]},
               {'C1': 181, 'C2': 1388075259, 'C3': [130, 212, 103, 134, 105]},
               {'C1': 230, 'C2': -36347193, 'C3': [135, 26, 220, 246, 91]}],
        'B6': {'D1': 3596661585180290492,
               'D2': [145, 135, 152, 48],
               'D3': -22539}},
 'A4': {'E1': -4190200623533671973,
        'E2': -0.5355881452560425,
        'E3': [161, 110, 48, 31, 80, 199, 27, 135],
        'E4': 11277},
 'A5': {'F1': 1466412846, 'F2': 0.9723443984985352, 'F3': 28795}}

(b"\x8eABX\xdc{\x9c,R\x92C\xf6\x9a\x1at\x8cS'\x17\x949]\xb1\xad\xb9\x9b\x02\x00"
 b'h\x00\x00\x00\x0e\x9a\x88\xd9\x19\x06\x00j\x00\x00\x00\xe4\xbe\x8e\x18\xab'
 b'\x08\x00p\x00\x00\x00\xa3\xaa\xf7\x9bJ\x08\x00x\x00\x00\x00\x9e\xad}'
 b'Ji\x04\x00\x80\x00\x00\x00i\x90\xd8\x92H!\xba\xa3?\x11\xe3\xc6\xfay\x84\x00'
 b'\x00\x00\x14\xcb\xc7)#F\xff>t\xcdrw\x960\xbb\xec8\x88\xe5\x93\xadw'
 b'\xed{\xc7\xfcmu\xcb=\xef\xe1\x87\xce=\x9dl\xc7\x05\xd3\xd2<Zm7\x85A\x18~\xbf'
 b'\xb5\xe6u\xf1\xf4\x8a\x151\xc8\x9c')

{'A1': 31708,
 'A2': 11420,
 'A3': {'B1': 10120743515467256402,
        'B2': -5930856732391168173,
        'B3': -25671,
        'B4': 'rw',
        'B5': [{'C1': 14, 'C2': 433686682, 'C3': [150, 48, 187, 236, 56, 136]},
               {'C1': 228,
                'C2': -1424453954,
                'C3': [229, 147, 173, 119, 237, 123, 199, 252]},
               {'C1': 163,
                'C2': 1251735466,
                'C3': [109, 117, 203, 61, 239, 225, 135, 206]},
               {'C1': 158, 'C2': 1766489517, 'C3': [61, 157, 108, 199]}],
        'B6': {'D1': 11797778769435463785,
               'D2': [63, 17, 227, 198],
               'D3': 31226}},
 'A4': {'E1': -8847482708611116283,
        'E2': -0.9925575852394104,
        'E3': [181, 230, 117, 241, 244, 138, 21, 49],
        'E4': -25400},
 'A5': {'F1': 700959508, 'F2': 0.49858197569847107, 'F3': -12940}}

Вариант №19

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

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

(b'COUpsxyvn\xa2p\xdd~\xab\xee\xb5\xdd&\x00\x00\x009\x00\x00\x00L\x00\x00'
 b'\x00\x12\xe8\xf7g\x00\xdb\xbby\x83\x89\x10U\x02\x00\x00\x00"\x00\x00'
 b'\x00\x07\xab\x1e\x91 J\xbc\x95\xfcYm\x02\x00\x00\x005\x00\x00\x00'
 b'\xce\xa9\x10\xa5\x01\xe5n!\xe1\xc6\x95\x02\x00\x00\x00H\x00\x00\x00\xc8'
 b'\x96X+\x0f\xad\nj\xf3\x04\xca=\xab\xb4\xcc\x02\x03\x00\x00\x00['
 b'\x00\x00\x00\xc4\xdf\x02?')

{'A1': 'sxyv',
 'A2': 110,
 'A3': -2470806400207589214,
 'A4': [{'B1': -119,
         'B2': {'C1': 16, 'C2': 85, 'C3': [48091, 33657], 'C4': 2434706183}},
        {'B1': -4,
         'B2': {'C1': 89, 'C2': 109, 'C3': [18976, 38332], 'C4': 2769332686}},
        {'B1': -31,
         'B2': {'C1': -58, 'C2': -107, 'C3': [58625, 8558], 'C4': 727226056}}],
 'A5': {'D1': 18, 'D2': 63464},
 'A6': {'E1': [1779084559, 1036649715, 46970027], 'E2': 0.5112268924713135}}

(b'COUpgrvv\x85j&\t\xdcZ\xb0\xc6\xb9&\x00\x00\x009\x00\x00\x00L\x00\x00'
 b'\x00\xd9\xac\xa3o\x00\xb2&\xc6{\x16o\xd7\x02\x00\x00\x00"\x00\x00'
 b'\x00,\xa9\x8e~h\xe7540H\xf0\x02\x00\x00\x005\x00\x00\x00e$\xba\xb9\x061@\x97'
 b':\x18\x06\x02\x00\x00\x00H\x00\x00\x00\x9d\x96\xa7\x03\xc7\xdb~\x92\x05'
 b"$\x92\x97\x0fl\x14\xb1\x956'\xe9\xe3<\x8ah\x05\x00\x00\x00[\x00\x00\x00\x84"
 b'DU?')

{'A1': 'grvv',
 'A2': -123,
 'A3': -5060163227019041174,
 'A4': [{'B1': 22,
         'B2': {'C1': 111, 'C2': -41, 'C3': [9906, 31686], 'C4': 2123278636}},
        {'B1': 48,
         'B2': {'C1': 72, 'C2': -16, 'C3': [59240, 13365], 'C4': 3115983973}},
        {'B1': 58,
         'B2': {'C1': 24, 'C2': 6, 'C3': [12550, 38720], 'C4': 61314717}}],
 'A5': {'D1': 217, 'D2': 41900},
 'A6': {'E1': [2457787335, 2542937093, 2970905615, 3911661205, 1753890019],
        'E2': 0.8330767154693604}}

Вариант №20

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

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

(b'\x83XFI\x95V\r?0\xdcL\xa9\xafM\xdc\xbfL\x00h\x8a\xf4h%\xd3\xd6\xb6\xdce'
 b'\x94*\xf4\xaf6;K\x1fK\xb2\xd2\xd6\rg\xb9\xa8\x1b\xf9cM\x85\xfdA\x10'
 b'\x18\x8f\xa4\x15\x14\x86\n\x0c\xe9\\\xa9\xdeOG\xa6hL\x85\x02\x00'
 b'.\x00\x00\x006\x04\x00\x00\x00\x12\x00\x9f4\x17?\xcda\xb7\x10V[\x03\x00\x00'
 b'\x00\x1a\x00^\xb0\x8a\x1a\xd0L\x96C\xd9\x7f \x00\x00\x00\x02\x00&'
 b'\x00\x00\x00\x8e\xf6\x82\xaf\xd8\x10a\xdf\xcf\xbb\xa5I\xfa\x0e\xfe\xbb\xae'
 b'\xd6-\xcd\xd6\xfd\xdb\xc6>\x00\x00\x00')

{'A1': 0.5521023869514465,
 'A2': -0.4422415879557233,
 'A3': {'B1': 54,
        'B2': [{'C1': [35432, 26868, 54053, 46806],
                'C2': 1204538959499572383,
                'C3': 23382},
               {'C1': [26076, 10900, 45044],
                'C2': 4870164503729975390,
                'C3': 32729}],
        'B3': {'D1': 15158, 'D2': 2991267659},
        'B4': [1728960210, -115627847],
        'B5': [-2350579007667112306,
               -4900462876392309809,
               -4117418335293024594],
        'B6': {'E1': -8535,
               'E2': 18255,
               'E3': 2236377254,
               'E4': [10311009222477040995, 6694895560401622436]}}}

(b'\x83XFIn\xdaC\xbf\xd8\x01\x81/\xd5B\xce?V\x00[\xceP!\xc8V\x01h\xb4\x1c'
 b"\x93\x1aK'8\x08-\x8a\x88\xea\xc0B\xf3\xc8\x9dk\xa7\x1f\x93\xafM\xdb\x8e5"
 b'}\xae\xda!l\xa5\xb0\xc0\x95\x11\xb2s\xa2\xc1\xc4\xef\x16IGh\xc7\xb6\x8fY'
 b'\xe2\x04`\x0e\x02\x008\x00\x00\x00j\x03\x00\x00\x00\x12\x00\xc2\xa9\xb0'
 b'\xfc\xcb\xc4r\x15\xb3\x03\x03\x00\x00\x00\x18\x00\xf1)\xe0*\x86e\xb6'
 b'\x1f\xf8x\x1e\x00\x00\x00\x05\x00$\x00\x00\x00D\x8f\x14.\xc4\x80\\\x18m\xb9O'
 b'\xc8\x0fB|^$O\xca\x9a\x9e\xc1\x97\xe7H\x00\x00\x00')

{'A1': -0.7650517225265503,
 'A2': 0.23641457385566755,
 'A3': {'B1': 106,
        'B2': [{'C1': [52827, 8528, 22216],
                'C2': 1545514002538342850,
                'C3': 947},
               {'C1': [26625, 7348, 6803],
                'C2': 2285125487856462321,
                'C3': 30968}],
        'B3': {'D1': 10059, 'D2': 2318207032},
        'B4': [1119939208, 1805502707, -1349312601, 898554701, 567979645],
        'B5': [1755419534842695492, 6808389372229957997, -1758724242518946012],
        'B6': {'E1': -18745,
               'E2': 22927,
               'E3': 241173730,
               'E4': [8336745195096810860, 7514054866151719330]}}}

Вариант №21

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

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

(b'IGVD$\x02\x00(\x00@\x02\x00\x00\x00P\x00\x00\x00\x88\xdb\x15\xf9\xc4Z'
 b'\xda??\xfb\xb3\xbe\xea\xba\xc4y\x80xU\x08X\x00\xb8\xb71?j\x81-?qb/v'
 b'\x07\xab\x18\x03\x00\x00\x000\x00\x00\x00\xf2\xf1\xe1\xb9\x19\xac\x82K\x14'
 b'\x04\x00\x00\x00?\x00\x00\x006\x00\x00\x00G\x00\x00\x00\x94\xf5Q\x1c'
 b'`\x8f\xe2\xbf\xe0\xc7\xcaC\x93+\xb7?Jd\xa7>\xf9m\xbee!\x1c\x0eR\xebB\xaa&'
 b'3\x84\xff$\xe1\xc3')

{'A1': [0.6942095756530762, 0.6777559518814087],
 'A2': 64,
 'A3': [{'B1': 24, 'B2': [25201, 30255, 43783]},
        {'B1': 20, 'B2': [61938, 47585, 44057, 19330]}],
 'A4': {'C1': 0.41179012608284227,
        'C2': -0.3515262305736542,
        'C3': 600518618517912298},
 'A5': {'D1': [-0.580001883805084, 0.09050865559655064],
        'D2': 0.3269370198249817,
        'D3': 5912694290550517241,
        'D4': 2665994859653513963,
        'D5': 50145}}

(b'IGVD$\x02\x00(\x00\x9e\x03\x00\x00\x00]\x00\x00\x00\x88\t%8\x9b\x06'
 b'\xcb\xbf\x95\xc0m?R\r\xcc\xfd\x95J\xf7\xbci\x00\xc4\xdc\xe7\xbe\xa8\xfcr\xbe'
 b'\xc1\xc4\x15LH\xbb\xb3\x03\x00\x00\x000\x00\x00\x00G\xb1\x8a\\\xad~)\x03\x00'
 b'\x00\x00?\x00\x00\x00Q\xab\xf4\xee\xc1\xd3\xd7\x03\x00\x00\x00N\x00\x00'
 b'\x006\x00\x00\x00E\x00\x00\x00T\x00\x00\x00\x805\xe2 Jg\xbf?\x80\x91\xcb'
 b'\x8ag\xd8\x98\xbf3\xab\xc9>\xc8M\xe4\xe2[*B\xa8\xa5[gf\x98Q\x95\x97\xffM')

{'A1': [-0.452856183052063, -0.23729193210601807],
 'A2': -98,
 'A3': [{'B1': -77, 'B2': [50369, 19477, 47944]},
        {'B1': 41, 'B2': [45383, 23690, 32429]},
        {'B1': -41, 'B2': [43857, 61172, 54209]}],
 'A4': {'C1': -0.2111391090530328,
        'C2': 0.9287198185920715,
        'C3': 13616434006446574930},
 'A5': {'D1': [0.12266982367346735, -0.02426301750792126],
        'D2': 0.3938842713832855,
        'D3': -6322444352737751608,
        'D4': -7524017887457616987,
        'D5': 19967}}

Вариант №22

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

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

(b'MFJSh<\xdd\x07\xf5\x02\x00\x8e\x00\x00\x00\x1b\x82\x8e,\xf6\n\xe6:='
 b'\x05\x00\x90\x00\x00\x00\x13d\x04V\x93?\x0c\x9dM\x05\x00\x95\x00\x00'
 b'\x00\x8f\xd5\xddX\xfb\x81p\x96\xc9\x03\x00\x9a\x00\x00\x00n\xd7\x84\xfc'
 b'd\x8d\xf3/\xca\x07\x00\x9d\x00\x00\x00\xbaB\x11\xb8\xd7*\xec\x04\xa6'
 b'8<\xd6\xa3=\xf1\x89\xb0S\xa2\xe2\x98w\x91\xfc\x85\x16^z\xeb\xf2+\xe2\xc5gQeX'
 b'\xe9\xae\xa7Gn\xe5\xb3\xe2\xbf\xefbD?\xe9\x04\x00\x00\x00\xa4\x00'
 b'\x00\x00\x9aK%\xca\x90(\xe1\xbflqmsesvlpnncwmjblcmoep\x8a4\x13\xdd')

{'A1': [{'B1': -184033988, 'B2': 'lq', 'B3': 27, 'B4': -164852094},
        {'B1': 1027270154, 'B2': 'msesv', 'B3': 19, 'B4': -1823079324},
        {'B1': 1302137919, 'B2': 'lpnnc', 'B3': -113, 'B4': -78062123},
        {'B1': -912887679, 'B2': 'wmj', 'B3': 110, 'B4': 1694270679},
        {'B1': -902827123, 'B2': 'blcmoep', 'B3': -70, 'B4': -675802814}],
 'A2': -1509626838,
 'A3': 12720963869528702008,
 'A4': {'C1': {'D1': 83,
               'D2': -7518,
               'D3': 30616,
               'D4': [-942525152480592751, -1632443464614026709]},
        'C2': -0.5844599870590537,
        'C3': 0.7671346068382263,
        'C4': -23},
 'A5': [138, 52, 19, 221],
 'A6': -0.5362018535764606}

(b'MFJSh\x83\xc7\x11\xec\x03\x00\x8e\x00\x00\x00XM]?\xd0\x84\xd7\x8e$'
 b'\x04\x00\x91\x00\x00\x00\xce\x81\xc3$\xac{4tq\x03\x00\x95\x00\x00'
 b'\x00\x19\x1b[\xb6\x95\xbf\xb6d\xf5\x02\x00\x98\x00\x00\x00\xe6\xdc\x01\xc8'
 b'\xc4\xd8J\xe28\x06\x00\x9a\x00\x00\x00Y\x19Yq%t\xf4\xc4\x01\x85\xc4\xcb1'
 b'\x04\x9ad\x8a\xae\xb6\x07\xa8\xc4(D\x88\xa3O\x92\x80\x01v\x0e\x08'
 b'\xe8\xfc\x9d\x96w@\r@\xb9\x1c\xba\xba\xbf(\x84U?\xa4\x03\x00\x00\x00\xa0\x00'
 b'\x00\x00x\x13K|f\xd1\xe0\xbfsfnhbpxqndugndxcfn\x0cY\xee')

{'A1': [{'B1': -334379133, 'B2': 'sfn', 'B3': 88, 'B4': -801153715},
        {'B1': 613341060, 'B2': 'hbpx', 'B3': -50, 'B4': -1406876799},
        {'B1': 1903441019, 'B2': 'qnd', 'B3': 25, 'B4': -1783211237},
        {'B1': -177948993, 'B2': 'ug', 'B3': -26, 'B4': -993525284},
        {'B1': 954354392, 'B2': 'ndxcfn', 'B3': 89, 'B4': 628185369}],
 'A2': 29684852,
 'A3': 9972264817711105157,
 'A4': {'C1': {'D1': -82,
               'D2': 1974,
               'D3': 50344,
               'D4': [108247261800580136, 8617248646570184310]},
        'C2': -0.10440234682760252,
        'C3': 0.834047794342041,
        'C4': -92},
 'A5': [12, 89, 238],
 'A6': -0.5255615642168854}

Вариант №23

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

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

(b'YFA\x8a\x83\x1f\x00\x00\x00\x04\x00g\x00\x00\x00\x02\x00\x83\x00\x8a'
 b'\xde\xea\ni.\xed\xbfmsxw\x16l\x15?*Z\x04\x00\x00\x00\x1b\x00@\xbb*u:'
 b'h\x03\xb09zJ\x91\x94\xe7?\xf3o8Kb\xe7\x06N_\xd4P\x93\x84\xe5\xbf\x1b\x95\xb7'
 b'Q\xc5\xd3T\xc0\xcb\xb9\x16\xad\x81\xac\xbf\xa0\x82\xddW.\x1a\x80\x08'
 b'%\xa0\xc7G \xe9\xbf\xe1\x9e\n+\x00\x00\x00\xf0\x04\xbd:\x00\x00\x00\x19H\xa8'
 b'I\x00\x00\x00\xbf\xa9\x8cX\x00\x00\x00I\xe9\xa3\xfd\xb0\xdb\xbbZ\xa6'
 b'\xc8\xd4H\xba\xcfR\xaf')

{'A1': -31862,
 'A2': {'B1': 0.5836805105209351, 'B2': 23082, 'B3': 'msxw'},
 'A3': [{'C1': -31,
         'C2': 2718,
         'C3': {'D1': [64, -69, 42, 117, 58, 104, 3],
                'D2': 0.7368856863629869}},
        {'C1': -16,
         'C2': -17148,
         'C3': {'D1': [-13, 111, 56, 75, 98, -25, 6],
                'D2': -0.6724335268690795}},
        {'C1': 25,
         'C2': -22456,
         'C3': {'D1': [27, -107, -73, 81, -59, -45, 84],
                'D2': -0.055676850341931594}},
        {'C1': -65,
         'C2': -29527,
         'C3': {'D1': [-96, -126, -35, 87, 46, 26, -128],
                'D2': -0.7851904772698228}}],
 'A4': [6538060837274511689, 12633388303720433830],
 'A5': -0.9119153226119618}

(b'YFAU\xa7 \x00\x00\x00\x03\x00Y\x00\x00\x00\x02\x00n\x00\x88!y\x97\xac'
 b'V\xc7\xbfouqtiX\xbd\xf6\xbe\xabU\x05\x00\x00\x00\x1b\x00\x1e \xde\x1e'
 b'A\xf8\xb4\xc8\xbb\xf9Qv\x80\xef?\xa2\xe5k\xb8(\x0e@t\\\xb6\x9c!n\xe5?!H\t!F~'
 b'\xd8 H\xa4\xf1\xa8~\xd0?\xa3\xd5\x1c,\x00\x00\x00\x88\xab\xf0;\x00\x00\x00u'
 b'\xe8\xc2J\x00\x00\x00\x8cX\xcc\xb7}\xfbaI=\xc2\xd0\x1b\xf0\x1a\xd9\x91')

{'A1': -22699,
 'A2': {'B1': -0.48191332817077637, 'B2': 21931, 'B3': 'ouqti'},
 'A3': [{'C1': -93,
         'C2': 7381,
         'C3': {'D1': [30, 32, -34, 30, 65, -8, -76],
                'D2': 0.9844314194759756}},
        {'C1': -120,
         'C2': -3925,
         'C3': {'D1': [-94, -27, 107, -72, 40, 14, 64],
                'D2': 0.669693761900716}},
        {'C1': 117,
         'C2': -15640,
         'C3': {'D1': [33, 72, 9, 33, 70, 126, -40], 'D2': 0.257730709055183}}],
 'A4': [5287783954882779276, 10509460824006902333],
 'A5': -0.1823325862517431}

Вариант №24

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

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

(b'KBP\x1c\x00\x00\x007\x98>\xdf;\xa1D\xe1P\x0e\x9b\x88\x00\x00\x00\xee\xa3'
 b'\xbb\xa3hdK\x99\x8f\x83\xa5\xf1\xc5\xa0\x02\x00\x1a\x00\x00\x00\xe8\xd3'
 b'\x15\xde\xf3\xcf\xe5\xbf\x82\x8e \xd4\xde\xb9ZZ\x05\xbeR\xd9\xb0\x01r+\x1cQ'
 b'\xd4\xed5 \xaeT\xa4$\xbc\x030\xb7\xee\xa7\xd8\x15\xa9\xa1\xd1\xb9'
 b'c\x1e\xfa\xcf.\xd2\xdd\x83\xf0p!\x05\xdc\xd5\x83\xf0\xad?\x96\xf7\x9a%#\xf4'
 b"IJ\xb5s\xf6EhJ\x86A\xb1\xba'\x9f~\xff\x81\xd5\x91\x9f\xc68\xe8\xedY8\x00\x00"
 b'\x00F\x00\x00\x00T\x00\x00\x00b\x00\x00\x00\x03\x00\x00\x00p\x00\xe8'
 b'\xeb\x9cO\xbf\x01\xc1a?\x92\x0f\xaa\xfa')

{'A1': {'B1': -2087741109,
        'B2': -1597640283,
        'B3': 'hd',
        'B4': -0.6816348397829843,
        'B5': 3558903426,
        'B6': -17954},
 'A2': 55,
 'A3': 1004486296,
 'A4': 17569,
 'A5': 2601406689,
 'A6': {'C1': 89,
        'C2': [{'D1': 23130, 'D2': 3130566550047866373, 'D3': 3990114588},
               {'D1': 8245, 'D2': -5246689459283143506, 'D3': 366520302},
               {'D1': 41385, 'D2': -3301472803657369135, 'D3': 1894810589},
               {'D1': 1313, 'D2': -606227083537689124, 'D3': 4095944090}],
        'C3': [5361612281190107721, -36416753987665530, -1303729666391943807],
        'C4': 232,
        'C5': {'E1': -0.8109881281852722, 'E2': 0.8818512558937073},
        'C6': [-110, 15, -86, -6]},
 'A7': -23570,
 'A8': 41915}

(b'KBP \x00\x00\x00P]H\xf5\x8aT}\xf0Q\xd0\x0b\x8c\x00\x00\x00\xa2\xb6j\x85gx'
 b'iegf`\x10PL\xaf\x1c8\x7f\x06\x00\x1a\x00\x00\x00B\x05nKC~\xea?Vp'
 b'k\xaa\xdb\xdc\xf5\xf07$q\xf2\x95\x9d\xed8[e\xb8\xdezC~Ff\xa4\tm\xa0T'
 b'\xe4p.\xe2\xea\x8c\xe8\xc9\xc2i\\\x85R\x07\n`\xde\x9a\xd8\xad}\xd1\x88\xae'
 b'\t\x9f\xa9\xe2\x9f\x97\xd2md\x17h\xceb\x97\xb8t\x8d\x8c\xac+\xde:^\x11'
 b'\xc4\xf16 3O\xff\x08$<\x00\x00\x00J\x00\x00\x00X\x00\x00\x00f\x00\x00'
 b'\x00\x03\x00\x00\x00t\x00\xfd\xf5z\x1b\xbf\xc2\x83&\xbf\x0f\xfc\xfcy')

{'A1': {'B1': 1280315488,
        'B2': 2134383791,
        'B3': 'gxiegf',
        'B4': 0.8279129479634906,
        'B5': 2859167830,
        'B6': -8997},
 'A2': 80,
 'A3': -1963636643,
 'A4': 32084,
 'A5': 198201840,
 'A6': {'C1': 36,
        'C2': [{'D1': 61685, 'D2': 4102108102947578935, 'D3': 3736626523},
               {'D1': 17274, 'D2': 6097993783639950974, 'D3': 3794694372},
               {'D1': 36074, 'D2': 527630738313628136, 'D3': 2598264842},
               {'D1': 44504, 'D2': -2113983686142013059, 'D3': 1842517919}],
        'C3': [8410638754739918692, 1251502472345455757, 648323952367038916],
        'C4': 253,
        'C5': {'E1': -0.607344925403595, 'E2': -0.6504479646682739},
        'C6': [15, -4, -4, 121]},
 'A7': -18782,
 'A8': 34154}

Вариант №25

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

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

(b'\xedHTJ\xe6i\x05\x00\x00\x002\x00<-\xe9\xaa\x973\x8e\r\xaeG7\x00'
 b"D\x00\xc7\xb9.\x19\x16M\xe3\xf8\x82\x8ak\xae\x8b4'\x08\x87\xb1qqQ\x00"
 b'\x00\x00tegmk\xb2MM\xb1\xc7\x99k \x92\xd1\xf5\x159\x984\xad\x1e'
 b'\xa9\xab\x92\x9d\xeb\xce|=\x89Us\x8fS\x8e>~j6\xbf+\xfc\xc4\xbdjK->')

{'A1': 27110,
 'A2': 'tegmk',
 'A3': 11580,
 'A4': 5165080727042632425,
 'A5': [{'B1': 178,
         'B2': 19789,
         'B3': [177, 199, 153, 107, 32, 146],
         'B4': 957740497},
        {'B1': 152,
         'B2': -21196,
         'B3': [30, 169, 171, 146, 157, 235],
         'B4': -1992459058}],
 'A6': {'C1': -512481175282992697, 'C2': 587496050926520962, 'C3': 1903276423},
 'A7': {'D1': 29525,
        'D2': [0.2779812514781952,
               -0.7125624418258667,
               -0.09618409723043442,
               0.16923299431800842]}}

(b'\xedHTJ\xa5\xd0\x03\x00\x00\x002\x00\x90\n\x84\x8d\xd7;\x08\x19v\xb25\x00'
 b'B\x00*?\x10\xa7\xe5\xda\\\xbd\x10}\xe2\x92\x87\x10\xc3X\x1d\x01\xb5\xb9O\x00'
 b'\x00\x00xdiGc0\x92\xe7\x8a\xf2\xca\x06#\x06\x0e?N\xa5\xd7\xb4\xed\xbf'
 b'\x05\x8c<bm\x11\xcc2a\x12\xa04\xbe\xfb\xc2A\xbfe\x88*\xbf\x1d@\xe7\xbd')

{'A1': -12123,
 'A2': 'xdi',
 'A3': 2704,
 'A4': 12859493309157444996,
 'A5': [{'B1': 71,
         'B2': 12387,
         'B3': [146, 231, 138, 242, 202, 6],
         'B4': 1057883683},
        {'B1': 78,
         'B2': -10331,
         'B3': [180, 237, 191, 5, 140, 60],
         'B4': -871273118}],
 'A6': {'C1': -4801722422798565590,
        'C2': 6395974070267182352,
        'C3': 3115647261},
 'A7': {'D1': 24882,
        'D2': [-0.1763918697834015,
               -0.7568814158439636,
               -0.6661437153816223,
               -0.11291525512933731]}}

Вариант №26

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

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

(b'OHH\x03\x00\x00\x00\x96\x00\x00\x00\x02\x9b\xf2@\x11\xe4i\x8b-S]\x16\xcb'
 b'\x9bVWLQ\xc7\x1d\x1du%\x9a\xf2\xc7\xcb\x8d\xe79:\x01b\xb2j\x8d\xe1'
 b'\xbfU\x08\xdf}\x1dA\xc2\x13\x86#\xa9\xbc.:%\xc9;\x973\xaa\xe3A_n\x19\x89\x8c'
 b'c\x13\xb8\xc0\xb9re\x99*[@\xe1\xbf<d\x0f\x97\xcb\xbd\x9a\x0eX\xfeO\xffw\xfdP'
 b"R\x85\xb2\xcc\xbdQ7TK\xe3\xa2j\xa2\xf1\xe3\x10'\x00\x8f\x14\x92M\x9d\xe0"
 b'F\xe2\xdc\x18\xcf\xcc$Y\x18i3K:e~\x9a-\x96\xeebj\xf9f\x00\x00\x00v\x00'
 b'\x00\x00\x86\x00\x00\x00')

{'A1': {'B1': {'C1': [{'D1': 20733,
                       'D2': [82, -123, -78, -52],
                       'D3': 7683953826922451389,
                       'D4': -3678},
                      {'D1': 4323,
                       'D2': [39, 0, -113, 20],
                       'D3': 1791555545830608274,
                       'D4': -13105},
                      {'D1': 22820,
                       'D2': [24, 105, 51, 75],
                       'D3': 7128800382783743290,
                       'D4': -1686}],
               'C2': 1089641218,
               'C3': 17},
        'B2': [764111332, -887726765, 1280792219, 488490833, -224778891],
        'B3': -410137657,
        'B4': {'E1': 57,
               'E2': -0.5485127910651848,
               'E3': [2111768661,
                      331497757,
                      -1129766010,
                      -920307154,
                      -1439459525,
                      1851736547,
                      1670154521],
               'E4': -1178552301,
               'E5': -0.5391059715285975,
               'E6': 25660}},
 'A2': 15,
 'A3': 5764141392829729687,
 'A4': [255, 119]}

(b'OHH\x03\x00\x00\x00\x96\x00\x00\x00qze\xf8\xae\x82 \xbf\xd4RE\x90\xf8\xd8}o1'
 b'\xb7-\x9d\xc1(\x15m\xe9\xe60\x1f\xee\xe0\x00M\n\xbe4i\xbe?uG\\\xf4=\xbd\xec'
 b'\xec\xfd\xec\xcc2\x9eJ\xee\xa0\x0c\xba\xb1S\x0c\x1c\xcd\xf5\t\x94\x9bzcZ\x8a'
 b'$\x12v\x98\xcb\xb2W\xe9\xbf\x07\x7fD\x1c\xea\xda\xa0\xb5\x87\xc2\xc7'
 b'\x18\xa9\x0e_\xaf\x81\xa5\xd9\xb6\xd7\xb8\xf5\xc8\x03\xad\xe1\x1ced\x90'
 b'\xc7\xc4\x83\x1b\xde\xf0\xc1\xceZ\xd7\xb1m\x12\x9c\x12\x9f\xe7\x96\xf1\xf4'
 b'M\xd88\x9e\x95\x88\xa8\x10\xc7\x87f\x00\x00\x00v\x00\x00\x00\x86\x00'
 b'\x00\x00')

{'A1': {'B1': {'C1': [{'D1': 24334,
                       'D2': [-81, -127, -91, -39],
                       'D3': -2185086082553948234,
                       'D4': 25884},
                      {'D1': -28572,
                       'D2': [-57, -60, -125, 27],
                       'D3': 7904335606027776222,
                       'D4': -25582},
                      {'D1': -24814,
                       'D2': [-25, -106, -15, -12],
                       'D3': 1200359476880267341,
                       'D4': -30777}],
               'C2': 4167400049,
               'C3': 174},
        'B2': [-725671806, -124762798, 829390296, -1046663753, -378727128],
        'B3': -299945754,
        'B4': {'E1': -32,
               'E2': 0.11879281654028162,
               'E3': [-195278987,
                      -320029379,
                      852290813,
                      -1594996066,
                      1404156428,
                      -171107316,
                      2057016329],
               'E4': 613046883,
               'E5': -0.7919553734279268,
               'E6': 32519}},
 'A2': 68,
 'A3': -4052527500522493412,
 'A4': [24, 169]}

Вариант №27

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

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

(b'NJOY3x\xe4\x00\x00\x00\x04\x00\x1d\x00\x00\x00^/\xa9\x98?\xd2\xd4\x10VvFF'
 b'R\x00\x00\x00\x11\x00\x00\x00\x14\x00\x00\x00\x17\x00\x00\x00'
 b'\x1a\x00\xbf\x94\xe5c^\xf9#+\x19\xb1\xa3c\xffJC:\xc1\x8a\x06\x98\x8f\xec'
 b'\xe5f\xa5\xf6T\xd4,\xff\xd5l\x92\x12\x00\x00\x00\x04\x004\x00\x00'
 b'\x00\x05\x00<\xb7\xad\xac\xb7\x16@Jq\x00\x00\x00\x04\x00\x00\x00-'
 b'\x00\x00\x00\x03\x00\x00\x001\x0f\x00P')

{'A1': 30948,
 'A2': [{'B1': 12201, 'B2': -104},
        {'B1': 16338, 'B2': -44},
        {'B1': 4182, 'B2': 118},
        {'B1': 17990, 'B2': 82}],
 'A3': {'C1': {'D1': -1397287360,
               'D2': 19057,
               'D3': [0, -65, -108, -27],
               'D4': [99, 94, 249]},
        'C2': 15,
        'C3': {'E1': [9003, 6577, 41827, 65354],
               'E2': [1127924106,
                      110661612,
                      3848709622,
                      1423191295,
                      3580662290],
               'E3': 47021}}}

(b'NJOY3\x00\xcf\x00\x00\x00\x03\x00\x1a\x00\x00\x00O\x055\x90G\x1c\xad\xd7'
 b'Q\x96\x00\x00\x00\x11\x00\x00\x00\x14\x00\x00\x00\x17\xe3d\xfc\xa0\xa0@'
 b'\x91d#|+V\xf5\x0b\xb3t\x98#Sh\xfc\x8035->\x8b\x00\x00\x00\x02\x00-\x00'
 b'\x00\x00\x04\x001\x0e\x0e\t\x1d\xe2\xb2M\x1f\x00\x00\x00\x04\x00\x00\x00'
 b'&\x00\x00\x00\x03\x00\x00\x00*\xc7\x00A')

{'A1': 207,
 'A2': [{'B1': 1333, 'B2': -112},
        {'B1': 18204, 'B2': -83},
        {'B1': -10415, 'B2': -106}],
 'A3': {'C1': {'D1': 152953522,
               'D2': 19743,
               'D3': [-29, 100, -4, -96],
               'D4': [160, 64, 145]},
        'C2': -57,
        'C3': {'E1': [25635, 31787],
               'E2': [1458899891, 1956127571, 1761378355, 892157579],
               'E3': 3598}}}

Вариант №28

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

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

(b'UPZ\x00\x00\x00\x02\x00\x00\x00g{\nqq\x13\n\xdbq\xd6\x0b_\x14\xbf'
 b"\x17\xe7\xbbc\x9b\xd9\x80\xf3\xab_\x8f'8\xf4\xea\xab0\xe1\x06W\xe7s\xdf\x0e"
 b'j\xfd\x06\x86\x15o]z\xe7\x0e\xd2\xcf\xb0<Q\xcf>\xc4Y\t\xe7\xd3\x8f\r'
 b'\x07\x10\xa3\xd3\x7f\x05u\x03\x07\xaa\x16G\xf5\xb2nUk\x19O\xb2\x0f_@\xc4'
 b'\xae\x92e:\x92\xf3\xc8f\xb0@\x80\x83Bg\xcaj\xef\xd8\xa3\xb4%\xc2s\xb3'
 b'\xe4\x9e\xea\x07>\x1f\xd8e\x9c\x17m\x10\xea\xf9\xda\x85\xc3{\xff\x8f'
 b',\xb59\xd7\xfd\x93\xb3\xfb\xb4\x00\xcc\x181\xf60[3O\x84\x92\xda\x07!')

{'A1': [{'B1': 7399485108471883722,
         'B2': 27375,
         'B3': 216,
         'B4': {'C1': 163,
                'C2': -1272593805,
                'C3': 12962660355460177880,
                'C4': 26012},
         'B5': 393023722},
        {'B1': 18003849535012441900,
         'B2': 46393,
         'B3': 215,
         'B4': {'C1': 253,
                'C2': -1816921164,
                'C3': 57447498111802163,
                'C4': 20356},
         'B5': 2463762209}],
 'A2': [{'D1': [2064281969, 319478641, -703897836], 'D2': 48919},
        {'D1': [-407149669, -645860437, 1603217208], 'D2': 62698},
        {'D1': [-1422860026, 1474786271, 241892614], 'D2': 34325}],
 'A3': {'E1': [28509, 31463],
        'E2': 14,
        'E3': 53967,
        'E4': 45116,
        'E5': 5894999450279602131,
        'E6': -113},
 'A4': 218566819,
 'A5': -746650251,
 'A6': [50833942, 1207284334, 1433082191, -1307615424, -995192219, 982709192]}

(b'UPZ\x00\x00\x00\x02\x00\x00\x00g\xa0\xbc\xcd\xa5\x96\x9d~\xcc+Q\xa1L+'
 b"j\x03\x88\xd5r\xae\xcb\x91S\xde\x81\xec\xc2'r\xbc\xe5\xe8\xca\x93\xd6\\6\x03"
 b'\xfeO\x19f\xeb:\xc1\xd6o\x98\xa4\xed1\x05\xfb\xbe\xa7\xc1\x82\xc2'
 b'\xcd\xd9\x0f\xc8\x11M\xe8\xcd\xfb\x9b\x12\xca\x9e\x8f\x94:\xf72\x98\xd5'
 b'\xb0\x0f\xbe\x8e\xe4\x15\xa4\xf6\xe4\xed\x8b\xdb\x16\xec\xaa\x92'
 b'$\xa1\xd6\xad\xf0\xe8\xea\xf3v\xcdlG\x15\x8b\x14\xe4\xbe\x1f+F]\x9c\x89\xc2'
 b'\xebV\xd5\xc0\xcd\xf2\xdae\x87\x86\xb1\x8d\xaf\x1c\x14$\x95\xa9\xd0%wg:\xae'
 b'\x80\\\xce\xdf\xd2\xbd\x99sN\xd6\xd2')

{'A1': [{'B1': 10530719772112382186,
         'B2': 62326,
         'B3': 205,
         'B4': {'C1': 108,
                'C2': 1192594196,
                'C3': 16482645956947188873,
                'C4': -15637},
         'B5': 1456849101},
        {'B1': 17499410934856256943,
         'B2': 7188,
         'B3': 36,
         'B4': {'C1': 149,
                'C2': -1445976713,
                'C3': 7438449600891903954,
                'C4': -16999},
         'B5': 1934546642}],
 'A2': [{'D1': [-1598239323, -1768063284, 726769996], 'D2': 11114},
        {'D1': [59299186, -1362390701, -561910590], 'D2': 10098},
        {'D1': [-1125783350, -1814668234, 66998041], 'D2': 26347}],
 'A3': {'E1': [15041, -10641],
        'E2': 152,
        'E3': 42221,
        'E4': 12549,
        'E5': -306623275050283559,
        'E6': 15},
 'A4': 3356577256,
 'A5': -839148782,
 'A6': [-895578220, 989278872, -709881922, -1897654876, -152769141, -619254614]}

Вариант №29

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

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

(b'\xaaQZSF|\x1fU\xd6s\x1cGz\x92[\x03Y\x1e\xe1\xed?\x02\x00]\x00=\xcf\x08'
 b'\xd47UC\xef\x03\x00\x00\x00\x7f\x00\x00\x00`\x97\x1a\xf1\xc1\x19\xa5'
 b'\xbf\xd0\x91\x81\xdc\xd2\x03\x00\x00\x00\x82\x00\x00\x00\xaf6R\xbfu\x0c'
 b"0?\xc6\x14\x00>Xp\xa3\xbd\xfc0U>\xcc\xe5\x07\xbf=T>Kg\r\xbf'Q\x1d"
 b'\xe6L\xd7\xb76\xe9\x9eh/\x03\xfe:\xda\xc6\x05O\xb66\xe6A\x98\xf9\x0f\xde'
 b'p\xd4\xfe\xd1\xbd1uskwyF\x0f?\x7f:#\xbf\xae5\xde\xbe')

{'A1': {'B1': 8811042479816384380,
        'B2': 0.9337302912270948,
        'B3': [{'C1': 39,
                'C2': [7505, 19686, -18473, -5834, 26782, 815],
                'C3': 3336190718},
               {'C1': 5,
                'C2': [-18865, -6602, -26559, 4089, 28894, -300],
                'C3': 1966194129}],
        'B4': -1206026576936251587},
 'A2': 'skw',
 'A3': -0.04121213977968696,
 'A4': {'D1': -595488304,
        'D2': 210,
        'D3': [0.5596690773963928, -0.6376113295555115, -0.4340032935142517],
        'D4': [-0.8211469054222107,
               0.6876900792121887,
               0.12507924437522888,
               -0.07980412244796753,
               0.20819467306137085,
               -0.5308501720428467]},
 'A5': 61,
 'A6': 15956,
 'A7': -0.5523573756217957}

(b'\xaaQZSFU\x11\xda\x9b\xe7\xfb#Y\x9c\xb9g\x8e?w\xdf?\x02\x00]\x00\xddR\x10'
 b'\xae\xec{\t?\x03\x00\x00\x00\x7f\x00\x00\x00\xb8sl\xfbT\x0f\xc7\xbfo^\xde'
 b';\xa3\x03\x00\x00\x00\x82\x00\x00\x00| C>PTC\xbex\x15\xa7\xbe\xa7\\D\xbfl/'
 b'\x80=\x8e\xd0\x94>\x96\xf0\xd9h[\x1f\xbeH|N\xf9~yJR\xbb\xe1\xa5!\xf49\x1a'
 b'\xf3Y\xc7 \xc9\x05\xcd\xaaH\xe0\xc1?8\xac\xca\xc7\xa0k~lwc\xbd\x0e}?8\xb7'
 b'k?\xe9\xc4\x089')

{'A1': {'B1': 6423254465731236181,
        'B2': 0.4916533365893885,
        'B3': [{'C1': 72,
                'C2': [20092, 32505, 19065, -17582, -23071, -3039],
                'C3': 1509104185},
               {'C1': 199,
                'C2': [-14048, -13051, 18602, -15904, 14399, -13652],
                'C3': 2120982727}],
        'B4': 4542297955642659549},
 'A2': 'lwc',
 'A3': -0.18015539433045347,
 'A4': {'D1': 1004428911,
        'D2': 163,
        'D3': [0.9885061383247375, 0.9207644462585449, 0.00013043325452599674],
        'D4': [0.19055360555648804,
               -0.190751314163208,
               -0.3263356685638428,
               -0.7670387625694275,
               0.06259045004844666,
               0.29065364599227905]},
 'A5': -106,
 'A6': 55792,
 'A7': -0.15562212467193604}

Вариант №30

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

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

(b'uJRFXC\xe3\xe7>\x03\x00\x00\x001\x00\xcc\\\x8c0pidc(\xb04\x99\xd7'
 b'a\x8d\xc3\xbf\xbf.\x98\x02\x00\x00\x00\x9a\x00\x00\x00V\xe8\xfe\x12\xa5'
 b"Y$\xe7N\x8f'\xfd\xd8\xbfSi\xd6&\xe8v\xb7\x17N\xa4k?\x02\x00+\x00\x00\x00\xf0"
 b'o\xab\x0c\x9f\xec\xe6\x91\xc7\xec\xb2\x8b\x9a\xc1\xff\xeb\xbf,\xc8\x8d\x01'
 b'\xf6\xda\xc5\xd9\x80MG?\x02\x00-\x00\x00\x00\xd4<@D\xe3p0`nP6Ijoo\xe3?!'
 b'\x0c^\xdei\xeb\xc4\x00<\x1fx?\x02\x00/\x00\x00\x00d\x86\x01p\\\x08\x92'
 b'S\xdb\xe6\x98')

{'A1': {'B1': 58179,
        'B2': -25,
        'B3': 62,
        'B4': [{'C1': -0.3904513263220102,
                'C2': 1708965323066468691,
                'C3': 0.9204758405685425,
                'C4': [86, 232],
                'C5': -7933393525710032912,
                'C6': -57},
               {'C1': -0.8749702471228296,
                'C2': -2754554846944311252,
                'C3': 0.7785263061523438,
                'C4': [254, 18],
                'C5': 6931163947928141012,
                'C6': 110},
               {'C1': 0.6073529315851349,
                'C2': 55427935370087457,
                'C3': 0.969226598739624,
                'C4': [165, 89],
                'C5': 6021884844856936036,
                'C6': -37}],
        'B5': 814505164},
 'A2': 'pidc',
 'A3': {'D1': 40, 'D2': -0.15275214221256794, 'D3': 11967, 'D4': -104},
 'A4': [230, 152]}

(b'uJRFX\xe5\xc78\xa1\x02\x00\x00\x00/\x00|6\xcb~snib\x8a\xc0U\x96/'
 b'\xf3P\xba\xbf\x98}.\x03\x00\x00\x00u\x00\x00\x00)\xb5G\xab4\xd7VR\x15'
 b'\x08\xe0\xbf\xbf,$)b\x9bJ\xc3\x80\x9bx\xbe\x02\x00+\x00\x00\x00\xb8\t\xa3'
 b'd\xc4;\x189\xd3\xdc\x9c\x95\xb3_\xe4\xd6?\xe7J\xb5\xae\xf9\x1e\x0b\xdcJ\x88'
 b'c?\x02\x00-\x00\x00\x00V\xd1\xeclq\xc2\xd9{E\xef]\xd7')

{'A1': {'B1': 51173,
        'B2': 56,
        'B3': 161,
        'B4': [{'C1': -0.5009867294490733,
                'C2': -4374513242137678657,
                'C3': -0.2427806854248047,
                'C4': [41, 181],
                'C5': 4114103974290983352,
                'C6': -45},
               {'C1': 0.35768883264104345,
                'C2': -2590943102894781721,
                'C3': 0.8887983560562134,
                'C4': [71, 171],
                'C5': 8924377929025900886,
                'C6': 69}],
        'B5': 2127246972},
 'A2': 'snib',
 'A3': {'D1': 138, 'D2': -0.10279769813344952, 'D3': 32152, 'D4': 46},
 'A4': [239, 93, 215]}

Вариант №31

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

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

(b'LSC\xe7\x90$\x0f\xa47\xcc\xc5\xbfj\x8d\xac>\x083}={)}\xda*\x00-\x00'
 b'0\x003\x006\x009\x00<\x00H\x00\x00\x00\x18Fl&\n\x10\x9e\xc2k@=pl>'
 b'\xf2H\xaa\xf3\xc9\xb7\xbb\x97\xf6V\x05\x87\xf7\x8a\xb59;\x03\xcdv~\x99j\x88'
 b'T.$\xe8\x19\x88\xf5U\xbb\xbf\x03\x0e\x12\xfav\xcaK\x06Z\x92]\x0b\t\xff'
 b'\x8eW\x164\\|\xa8\x86\x97\x10\xbda\xdf\xdb\x03\x00?\x00\x00\x00'
 b"\xb7\x80\xd6\xdbh{L\xbf'\x99\x03\x00E\x00\x00\x00\xd0\xea\x8e\xbf#\xbdB\x05"
 b'\x99\xb9\x11')

{'A1': -0.17029471884442104,
 'A2': 0.33701640367507935,
 'A3': 15743785481646453512,
 'A4': [{'B1': 17944, 'B2': 108},
        {'B1': 2598, 'B2': 16},
        {'B1': -15714, 'B2': 107},
        {'B1': 15680, 'B2': 112},
        {'B1': 15980, 'B2': -14},
        {'B1': -21944, 'B2': -13},
        {'B1': -18487, 'B2': -69}],
 'A5': {'C1': 827,
        'C2': {'D1': [3338443215211493069,
                      13815730794927876132,
                      453678799831305731,
                      6309260542303113818,
                      1195572284289201174],
               'D2': -606117443,
               'D3': [-2409, 1366, -2169]},
        'C3': {'E1': -32585,
               'E2': -7410744326605972522,
               'E3': [138, 181, 57],
               'E4': -5424,
               'E5': -0.039977602660655975,
               'E6': 3113813314,
               'E7': 17}}}

(b'LSC\xe7\x10\x04\xb9\x1f\xa2\x99\xec?o\xad)?K6\xa1\xd5\xa4I\xa71*\x00-\x00'
 b'0\x003\x006\x009\x00<\x00E\x00\x00\x00]\x14\x9d\x0bd\xa1\xf57\x08\xe0'
 b'e\xbe\xba\x13\xa5\x1b\x8az(\x007\x08\x06Tw\x064\xfa\xe1\x00\x0e\xe7\xb0\xb9'
 b'\x9cc\xaa\x13u\xee\xe3E\xb3\xcf\x9d\xdd\xae\x7f\xdf\xc3U.\x06\\\xb5S\r\x16'
 b'\nf\x88\xf5\x028\x9f\xdd\xc3\xa9\x01\xa9V\x16\xb7\x02\x00?\x00\x00'
 b'\x00\x01\xfc\xe0o\xbc`\x9b\xec)\xb7\x02\x00C\x00\x00\x00\xea\x86\xf5'
 b'\xba\xc0\xbe\x940A\xc3\xf7')

{'A1': 0.8937540645202962,
 'A2': 0.6628026366233826,
 'A3': 3577909401276724811,
 'A4': [{'B1': 5213, 'B2': -99},
        {'B1': 25611, 'B2': -95},
        {'B1': 14325, 'B2': 8},
        {'B1': 26080, 'B2': -66},
        {'B1': 5050, 'B2': -91},
        {'B1': -30181, 'B2': 122},
        {'B1': 40, 'B2': 55}],
 'A5': {'C1': -7686,
        'C2': {'D1': [12277829330492919296,
                      11371504696891962643,
                      445387712912928477,
                      9828554326611834204,
                      119842221728465653],
               'D2': -1223272791,
               'D3': [1544, 30548]},
        'C3': {'E1': -1023,
               'E2': -5248403738636554272,
               'E3': [6, 52],
               'E4': -30998,
               'E5': -0.3764263689517975,
               'E6': 3275829396,
               'E7': 247}}}

Вариант №32

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

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

(b'\\FHQF\x08\xae\xe9\x1e\x04>\xcc\xbf\x8e\xediI\xc7 \x96j\x02\x002'
 b'\x00\xbb\xef\xc9\xf0zQ\xf6g\x9a%H\x00\x17\xde\xf1\xa6\x98\xee\xd4\x9bnln'
 b'za#\x02\x00.\x00\x00\x00\xe7\x02\x000\x00\x00\x00?q\xc8\xf9h\xb6\xd3>'
 b'b\x8c\xd4\xbe\x8c\xe9\x12XM\xb2\xdf\xbf\x02\x00\x00\x00@\x00\x00\x00,\xa93a'
 b'\x04\x00\x00\x00D\x00\x9aN\xe2\xe7\xea\xb0/\xf1\xf7`')

{'A1': -0.22064258107580792,
 'A2': 7680362254829219214,
 'A3': [{'B1': 35, 'B2': 'ln'}, {'B1': -25, 'B2': 'za'}],
 'A4': 61371,
 'A5': 2709592433443401929,
 'A6': {'C1': -0.415133535861969,
        'C2': -0.4952576980682799,
        'C3': [28991, -1592],
        'C4': 1630775596,
        'C5': {'D1': [104, 182, 211, 62],
               'D2': 20122,
               'D3': -1326782494,
               'D4': [-3793, 24823]}},
 'A7': -7217881963364753897,
 'A8': 110}

(b'\\FHQF\xf8\x97/\xb9X\xaf\xe8?\xee\x14\xf4V\xf3Yd\xf2\x02\x002'
 b'\x00\x1b\x99\x04\xa7\xd6\xe9\x16W\x9f=J\x00,\x8a\x82\xban"\xb6\x0e\x0cxu'
 b'ap\x8c\x02\x00.\x00\x00\x00N\x02\x000\x00\x00\x00^#\x11\xba%\xb1t\xa3'
 b'\xa6\xea\x99\xd5E>@\x13\x930\xf35\xa0?\x02\x00\x00\x00@\x00\x00\x00\x15\x9e'
 b'Qk\x06\x00\x00\x00D\x00q2\xa6\x00\xa3i\x8d\nY\x04')

{'A1': 0.7714046112930637,
 'A2': -980559917189163794,
 'A3': [{'B1': -116, 'B2': 'xu'}, {'B1': 78, 'B2': 'ap'}],
 'A4': 39195,
 'A5': 4440363513534654212,
 'A6': {'C1': 0.19319762289524078,
        'C2': 0.03166160552931396,
        'C3': [9054, -17903],
        'C4': 1800510997,
        'C5': {'D1': [37, 177, 116, 163, 166, 234],
               'D2': 12913,
               'D3': 1772290214,
               'D4': [2701, 1113]}},
 'A7': 1060072621263194668,
 'A8': 12}

Вариант №33

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

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

(b'\xb4EGDE\xf0f)\x0c\xf5 \xcd\xed?a\xf5\x98\x00\x03\x00\x00\x00\x95\x11'
 b'\xf8\r\x81(\xbd\xb0\xcd\xbfB\xdc6\xb6\xee:\xbd6\x1eI\xe2H9[9\x1b'
 b'\xce\xc3\xf0\x07\xdbF+\xd5IB\x92m\xb2|Kr\x1d\xc1|0\x1a>\xb8\xaa\xbf\x1dI\xbf'
 b'\xc4\xce-g\x00\xd0\xc8\x9dF\x10\xd9",Z\x0e\rb\xbb\xb09\x03\xa9\x95\x99'
 b'\xf7X\xe3\xc5\x85\xbf\xd0J\x85\x03w/d\xa2A\xb3d\xf8\xa9J\x04?\xe7\x1d'
 b'.D\xa4\x83\x9e@\xaf}\xc6U\x9e\x13\x88?\xe2\xa9\xbe\xdf\xa6\xa8\x02te\x9e'
 b'\xce\x00e\x00u\x00\x85')

{'A1': -261740276,
 'A2': [62752, 52717],
 'A3': 0.8826537132263184,
 'A4': [{'B1': [88, -29, -59, -123],
         'B2': -0.25454831446108117,
         'B3': -1572752540},
        {'B1': [-8, -87, 74, 4], 'B2': 0.7223121014286453, 'B3': 1085242822},
        {'B1': [85, -98, 19, -120],
         'B2': 0.5832208984550109,
         'B3': 1952816846}],
 'A5': 1294799741254480077,
 'A6': {'C1': 3208830006, 'C2': -18706, 'C3': 985478686},
 'A7': 73,
 'A8': {'D1': -30,
        'D2': [5204291145241117680,
               566123332241015442,
               7904516959467585916,
               3466151826074574153],
        'D3': -0.16254203347637586,
        'D4': 40262,
        'D5': [282665516, 1510870370, 3148888323, 2845153783]}}

(b'\xb4EGDE\x00\x81\x03\x7fL\xd6-\xc1>\xd4\x92\xf0\x00\x03\x00\x00\x00\x95\n'
 b'\xf9\xb6_\x00\xca\x92\x1f\x93\xcd\xd3\xd1\x19Y\t\xe1\x92\xe4\xc8\xc0\xe8'
 b'\xa1k\xce\xf9\xd5v\x82\x87`\xf9j>\x86a{\x92S\x86\x90\xf9\xe1j %\\\x8e\xa14'
 b'\xcfK[\xbf\xe6\rO\xdc\x98V\xfev:Y\xd33\xf6;\x16\x81iV\x0fK\x1eR\xaf\xa8'
 b'\xee{\x97\xfco?\xee\x8a\x99n\x8c\xbf\xdc\xe5\x9b\x12\x96\xa1V\xff\xb3?\xb0-'
 b'\x0e\x18Q\xd3\xa0\xe80\xe1f\xb0.)|\xbf\xd8k\x0f\xa2\x89p\x00}\xbd\xa9'
 b'\xe3\x00e\x00u\x00\x85')

{'A1': 8455039,
 'A2': [19670, 11713],
 'A3': 0.41518354415893555,
 'A4': [{'B1': [123, -105, -4, 111],
         'B2': 0.9544188651252585,
         'B3': -442821994},
        {'B1': [-95, 86, -1, -77], 'B2': 0.06318748563519572, 'B3': -399449754},
        {'B1': [-80, 46, 41, 124],
         'B2': -0.3815344893716883,
         'B3': 2109581795}],
 'A5': 790863728731656735,
 'A6': {'C1': 2479739857, 'C2': 6489, 'C3': 165778148},
 'A7': -56,
 'A8': {'D1': -64,
        'D2': [16762797824748648066,
               9755071027595338107,
               10543919109830175264,
               2692183500287593307],
        'D3': -0.6891249950883489,
        'D4': 30266,
        'D5': [1507013622, 991330665, 1443842846, 1387243758]}}

Вариант №34

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

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

(b'XMDU\xa1\xfaT\xe5\x83b\x1b \x00\x04\x00\x00\x00E\x85\x00]\xbf\xe1\xd6'
 b'F\x9c\xe5\x8f\xfc\t\xe4/\xbb\x00\x00\x00\x82cmETx\xe6\xa6\x12\xdc\xbe\xd7'
 b'1\x82\xcd\x07\xbfxp+\xe7\xeb?(\xc7%\x1d\xae\xbfR\xf9\xbe\x19\x00-\x00'
 b'3\x009\x00?\x11\x80\x1e}\xacB;\xefl\x06\xff\x93U\xe7\xceG\x00\x02\x00'
 b'M\x00Q\x82\xc7\xf8\x8a\t\xa1\xeb\x05\x01\xe9W+\x01\xb0\x17\xa1\xf7+K_~'
 b'\x00\x04\x00\x00\x00Y-\x11`a\xd1:\x8c\nC')

{'A1': -6775009344697001184,
 'A2': [{'B1': 220, 'B2': -0.42029958963394165, 'B3': 205},
        {'B1': 7, 'B2': -0.9704615473747253, 'B3': 231},
        {'B1': 235, 'B2': 0.6592887043952942, 'B3': 29},
        {'B1': 174, 'B2': -0.8241232633590698, 'B3': 25}],
 'A3': 133,
 'A4': {'C1': {'D1': [4480, 7805],
               'D2': {'E1': -84, 'E2': 1111224172, 'E3': 1791, 'E4': 147},
               'D3': -2100823926,
               'D4': 9,
               'D5': [41451, 1281, 59735, 11009, 45079, 41463, 11083, 24446],
               'D6': [85, -25, -50, 71],
               'D7': 756113505},
        'C2': -0.5574067177190041,
        'C3': 165949371},
 'A5': {'F1': 209, 'F2': 982256195},
 'A6': 7164458811324278290}

(b'XMDU^\xf2\x85\xbf\xe9VA\x80\x00\x04\x00\x00\x00E;\x00`\xbf\x98\x006*\x11\xcc'
 b'@\x83\x02\xde\xd8\x00\x00\x00\x85t\xb4|\x10\xe5\x17\x81\xeb$=\xba"\x05\x8f5'
 b'?w\xab\x82\x18v\xbfk\xe2\xbac\x7f\xbf?\xbc\xfcX\x00-\x003\x009\x00'
 b'?\x8a\xa2\xc0-\xa9\x17Jz\x1c\x14\xea\x9e\x1a\xe7\x01Py.\xe5\x00\x02\x00M'
 b'\x00Q\xc6\xad\x1a_\xa9\x15\x82\xaaN#\xf8\xdeQ=\x00\n\xb8\x8e\xdd\xb7\x17\x00'
 b'\x07\x00\x00\x00Y\xeeo\x1a\x9c\xb1\xdb\x85+\xcc')

{'A1': 6841677843229196672,
 'A2': [{'B1': 36, 'B2': 0.09088519960641861, 'B3': 143},
        {'B1': 53, 'B2': 0.9674607515335083, 'B3': 24},
        {'B1': 118, 'B2': -0.9214283227920532, 'B3': 99},
        {'B1': 127, 'B2': -0.7489774227142334, 'B3': 88}],
 'A3': 59,
 'A4': {'C1': {'D1': [35490, 49197],
               'D2': {'E1': -87, 'E2': 390756892, 'E3': 5354, 'E4': 158},
               'D3': -961734049,
               'D4': -87,
               'D5': [5506, 43598, 9208, 56913, 15616, 2744, 36573, 46871],
               'D6': [26, -25, 1, 80, 121, 46, -27],
               'D7': 4000258716},
        'C2': -0.02343830711147299,
        'C3': 2198003416},
 'A5': {'F1': 177, 'F2': 3682937804},
 'A6': 8409482816212402667}

Вариант №35

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

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

(b"JFDE\xa5\xba[\x00\xcf\x8d$\xb1o.-\xeb\xb8r\xb4\xcd'\xa9\xfd\x1b"
 b'\x08\xbf\xc5\x11s\xfd\x15\xb4pb\x96\xd4N&C\xb8\x7fT0\x02"I\x01\x0b'
 b'W\xd3\xbe\xe8\x99\x0b?UX^?by\\S\xc6\xdd\xed#\x11\xf1l\xa6\x9d^\xa0\xa24'
 b'\xba\x19\xcaDW\xc6\xa9\xc8\x00\x07\x83\xfea\xf0\xb8[\x02\x00;\x00=\x00C\x00'
 b'I\x00O\x00U\x00\xc0')

{'A1': 186,
 'A2': {'B1': 91,
        'B2': 'by',
        'B3': [{'C1': [92, 83, 198], 'C2': 60893, 'C3': 35},
               {'C1': [17, 241, 108], 'C2': 40358, 'C3': 94},
               {'C1': [160, 162, 52], 'C2': 6586, 'C3': 202},
               {'C1': [68, 87, 198], 'C2': 51369, 'C3': 0},
               {'C1': [7, 131, 254], 'C2': 61537, 'C3': 184}],
        'B4': -64},
 'A3': {'D1': [-1500492043596296753, 2016954196551824056],
        'D2': [48904, 4549, 64883],
        'D3': 21,
        'D4': 4838641524619243700,
        'D5': 92642660133928888,
        'D6': -0.412773460149765,
        'D7': 0.5453171730041504},
 'A4': 0.8685353398323059}

(b'JFDE\xa5#[\x00\x9b?3\xd8N+\x8b=\xad\xa97\x03\x01UW\xb0\xea\xa0\x84\xbc'
 b'6)\x15\xdb\x99D\xfa\x9d\x1a\xf8,3\x0b\xfc\xc4\x94\xa3\x19]@t\xe1\xbe\xa5'
 b'K\r>\xe9\xbds\xbffe0\x9fi\x90\t\xda.R\x90\xb0\xba\x06\x06\xe9@wq7^'
 b'\x91\xf8\x81\x0c\xdd\xfa\x81\xee\x13(\xbb\xa5\x02\x00;\x00=\x00C\x00'
 b'I\x00O\x00U\x00\x87')

{'A1': 35,
 'A2': {'B1': 165,
        'B2': 'fe',
        'B3': [{'C1': [48, 159, 105], 'C2': 2448, 'C3': 218},
               {'C1': [46, 82, 144], 'C2': 47792, 'C3': 6},
               {'C1': [6, 233, 64], 'C2': 29047, 'C3': 55},
               {'C1': [94, 145, 248], 'C2': 3201, 'C3': 221},
               {'C1': [250, 129, 238], 'C2': 10259, 'C3': 187}],
        'B4': -121},
 'A3': {'D1': [4434685875711066011, -5740025737223099987],
        'D2': [41194, 48260, 10550],
        'D3': 21,
        'D4': 3240369197704059355,
        'D5': 6708572979300404019,
        'D6': -0.4403400421142578,
        'D7': 0.13798387348651886},
 'A4': -0.9521165490150452}

Вариант №36

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

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

(b'FVQO\x02\x00n\x00\x00\x00\xb08,3g\x7f9\x91=\x1f\xec\xaeq\x10\xee\xb7&\xd6'
 b":\xbf\xb2\xdeY\xa1.;\xfd\x05\x18\xbf\xc3\xdd\x83\x8a\x07'.Z\xfa-\x82\xbc"
 b'\t\x1eK9$\xe4\xbdg\xe6v?oc\x8f\x8a\xb7\xfa\x88\x19o\x14\xbd\x9b\xa7'
 b'\xf4!\x81\x1a\x02aV\xcbB\x85\xf5F\xde\xd1]?\x9c\x12T\x0f\x04\x00\x00\x00'
 b'p\x00\x04\x00t\x00\xed\xae\x1a\xbfqjhnhd>\xdf\x19\x0f')

{'A1': 'qj',
 'A2': {'B1': -7982208783320598352, 'B2': 13253548833850007357},
 'A3': [{'C1': -0.7298301458358765,
         'C2': {'D1': -1587945806,
                'D2': -2466918060968297682,
                'D3': 654805635,
                'D4': 46},
         'C3': 5412774507388467802,
         'C4': -0.11139721423387527},
        {'C1': 0.9644531607627869,
         'C2': {'D1': -1970314385,
                'D2': -7224595759830074697,
                'D3': -2128481113,
                'D4': 26},
         'C3': 5113139473874837762,
         'C4': 0.8664835691452026}],
 'A4': 257168028,
 'A5': 'hnhd',
 'A6': [62, -33, 25, 15],
 'A7': -0.6042316555976868}

(b'FVQO\x04\x00n\x00\x00\x00\xd9\xc6Tg\xce$\xcff?\xb9\x92\x8e\xe6HaJ\xe1_'
 b'c>\x8e\xffA\x9d\xc2Y\xfb\xb1:\xc5P\xea\x92&\x995h\xa7\xdb\xd6\x06\xbb{{\xa4m'
 b'\xf8~?\x0cnR?\x99A\xae\xdd\x02\xc0\xcdk\x93\xa2\x015\xf6x\xf3(\xeaQ\xf97\xf5'
 b'm\x8f\xe5\x96f\xa7\x1f\xbf\xf8\\"\x7f\x05\x00\x00\x00r\x00\x05\x00'
 b"w\x00\xc5\xbb\xac\xbenexbsysij?'f\x8d\xa0")

{'A1': 'nexb',
 'A2': {'B1': 7408180380963227353, 'B2': 5359645186619259199},
 'A3': [{'C1': 0.222045436501503,
         'C2': {'D1': -1656619122,
                'D2': -1562532214812747326,
                'D3': 899229330,
                'D4': 104},
         'C3': -6594541186150114393,
         'C4': 0.9959781765937805},
        {'C1': 0.8219916820526123,
         'C2': {'D1': -575782503,
                'D2': 3819512713039429634,
                'D3': 687044854,
                'D4': -22},
         'C3': -7573489495925327535,
         'C4': -0.6236480474472046}],
 'A4': 2132958456,
 'A5': 'sysij',
 'A6': [63, 39, 102, -115, -96],
 'A7': -0.3373700678348541}

Вариант №37

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

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

(b'VNB\x02\x00\x00\x00M\x00\x00\x00\xac\xf5\x1bl{O\xe4\xd8\xde\xf6\xdf\x07\xa5'
 b'\x91Ql\xc9R\xe8\x99\x9cw\xdb\xbc\xa6\x8c!;k\x10\x05\x99;\x01\x8c\x94\x86'
 b'\x98\xbaj"\x04\xfb\xdc\x18\x97\x9a\xea?\xff\x02\x00\x00\x00T\x00\x00'
 b'\x00\x02\x00\x00\x00p\x00\x00\x00ky/\xe0\xb9\xe3(\xbf\xecKX\xb4\x89\t\x7f'
 b'\x02\x00\x00\x00O\x00f\x90\xb4YL\x88C\xaa\x03\x00\x00\x00Q\x00\x81 \x9b\x84'
 b'\xac\xee\xd3\x87\xc8pI\xfd\n\xa7\xa6\xd7')

{'A1': 'ky',
 'A2': 172,
 'A3': -2388908572295816203,
 'A4': -1526210570,
 'A5': 11284305783617769873,
 'A6': {'B1': -1497572489,
        'B2': {'C1': 8588, 'C2': 27451, 'C3': 1296, 'C4': -103},
        'B3': 7690627017473786171,
        'B4': 34,
        'B5': 0.8313708768472172,
        'B6': -1,
        'B7': [{'D1': 9153999125275733183, 'D2': [47, 224]},
               {'D1': 12268799671391260774, 'D2': [185, 227, 40]}]},
 'A7': [9787428839932764289, 15539291229929435336]}

(b'VNB\x03\x00\x00\x00M\x00\x00\x00\xfd\xe5^\xecB\x94y\xda\x02\x12\xed\xaaN'
 b">\x9c\xce\x98\xbevR\xd8#\xb7{\xa2'\x87\xb5\xdb\xfdE\xda_{%\xb7\xf4\xe4#\x06&"
 b't\xc7\x86\xe0\x84\xbb\xe7?Q\x04\x00\x00\x00Z\x00\x00\x00\x02\x00\x00'
 b'\x00\x92\x00\x00\x00tsx\xb0a6\x87\xbeB\xa9\xdb\xdb\x8fL\xa6 s\x83.1:\x02\x00'
 b'\x00\x00P\x00\xe9L\x9b\xc8\x06\x1e\x1d@\x03\x00\x00\x00R\x00\xe6R'
 b'\xdd\xa5\xc7)<7\x03\x00\x00\x00U\x00d\xe7\xf6N\xfcWk\xde\x02\x00\x00\x00'
 b'X\x00\xc2\x85\xbfMr\xf5cw\r1\t\x1c\xb0\x8e\xf75')

{'A1': 'tsx',
 'A2': 253,
 'A3': 205610410683686629,
 'A4': 1319824658,
 'A5': 15587651821262249022,
 'A6': {'B1': -1568950493,
        'B2': {'C1': 34599, 'C2': -9291, 'C3': 17917, 'C4': -38},
        'B3': 442448928108280671,
        'B4': 38,
        'B5': 0.7416405091555434,
        'B6': 81,
        'B7': [{'D1': 4193183870165755468, 'D2': [176, 97]},
               {'D1': 4619881807236254953, 'D2': [54, 135, 190]},
               {'D1': 3980102108146651878, 'D2': [66, 169, 219]},
               {'D1': 16027000440096221028, 'D2': [219, 143]}]},
 'A7': [8602989584487253442, 3888733690293465357]}

Вариант №38

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

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

(b'SFD\xb9\x00:\x89\x8b\xa7\x12>#tH\xb0I\x14\nA\xedf\x963\x13A\xe5+\x8f'
 b'\xceO\xa4\xc2\xd5\x9c\xd3\xc4\xc0n?\xe7B\xbax\x15C7\xb1v\xa4$z\x88t\xa8^V'
 b'\xdc\xe8?\xe8_Yg*\x0e\x1a\x00\x00\x00\x04\x00\x0e7\t>\xf3\xf1\xbd*3\xd1?^q'
 b'\xcf>\xcf/O\xbe\xcf&C\xbfE\x92F?~5\x82\xbdm\xf1Y\xc5\xa3\x88\x82<\xb2a'
 b'\xa8\x16\x19\x15\x91\xc6\x1d\xa3\x9d')

{'A1': {'B1': 0.7616393103530215,
        'B2': {'C1': [{'D1': -20407, 'D2': 20, 'D3': 739132838727848769},
                      {'D1': -6869, 'D2': 143, 'D3': 14866282051687732164},
                      {'D1': -16274, 'D2': 63, 'D3': 16664086596139825073},
                      {'D1': 30372, 'D2': 36, 'D3': 8829435335945936104}],
               'C2': 14089,
               'C3': {'E1': 1056174525,
                      'E2': 42,
                      'E3': 13265,
                      'E4': [0.868924081325531,
                             0.4046578109264374,
                             -0.4045887887477875,
                             -0.7717632055282593,
                             0.9930039644241333,
                             -0.05809149518609047],
                      'E5': [-14941, -30590, 15538, 25000]}},
        'B3': [22, 25, 21, -111, -58, 29, -93, -99]},
 'A2': -8535544971956882360}

(b'SFD\xb9\x00Pg\xbe\xdf#\xd8(\xbc\xe8w\x08\xeb\xd2,T\xe67\xddBa\xac\xd3\xe7'
 b'R\xb2\x90\xa9\x9d>?\xe6{p_CC\x84\x82G\x08\x91m\x8cX\xee^\xdf\xb5j\xbf\xa4'
 b'\xc5\x8fO\xff\xb3RCMH\xce\xb7\x8a\t;\x1c\xc8\xb3K\x12\x9b.\xef\xd8q'
 b'\xbf\xeap(P\x98\x18\xb4\x00\x00\x00\x06\x00\x0eIH\xc6\x13\x87\x07'
 b'\xba\x8a^\xbd\xc6O\x04<\x13w&?2\x80\xda?1s\x11\xbe\xb6\xbb\x87\xbf'
 b'x\xaf\xe3\x88\xba8\x02\xdcj\xfa\x15\xc4/Q \x08\xc6\xbe\x11')

{'A1': {'B1': -0.8261910986045877,
        'B2': {'C1': [{'D1': 30472, 'D2': 235, 'D3': 15144572994696594017},
                      {'D1': -21293, 'D2': 231, 'D3': 5958984315126562790},
                      {'D1': 31600, 'D2': 95, 'D3': 4846863319053144429},
                      {'D1': -29608, 'D2': 238, 'D3': 6836382229458109839},
                      {'D1': 20479, 'D2': 179, 'D3': 5927666509650823689},
                      {'D1': 15132, 'D2': 200, 'D3': 12919440413759101041}],
               'C2': 18760,
               'C3': {'E1': 3323168519,
                      'E2': 186,
                      'E3': 35422,
                      'E4': [-0.09683039784431458,
                             0.009000575169920921,
                             0.697278618812561,
                             0.6931620240211487,
                             -0.3568994700908661,
                             -0.9714338183403015],
                      'E5': [-30534, 14338, -9110, -1515]}},
        'B3': [-60, 47, 81, 32, 8, -58, -66, 17]},
 'A2': 7475657776524999912}

Вариант №39

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

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

(b'\xb2RDLTigzh\x02\x00\x17\x00\xfcf\x07;Af!}\xd7\xe9\x86\xcc\xd9\xc0<;\xe5?^'
 b'\xf7\x96>\x15\xb4\xcc\x16O\xbf,We\x9dC\x16\xd6?\n\xfb\xafHC\x009'
 b'D\xef\x92\xf40\xbb~\xd4\x02\x00\x00\x00\x13\x00\x00\x00i\x8e\x05\x85'
 b'\x03l\x03/\x19d\xd4\xfb\x90\xd4\xf4\xea,\xf7\xe7?\xd0>\xd3\xbe'
 b'\xea\xf6\xf8\xf2\xbe\xbe\xac\x16\xbf\xd3\x07\x19\xba\x94Y\xb5\x1cq\x0eF'
 b'\xe2\xa6\xe6v\xef\x15+}E\x02\x00\x00\x00\x15\x00\x00\x00\x81g\xe95\xa4\xdaC'
 b'9\xbe\xa4u\xcb')

{'A1': 'igzh',
 'A2': [{'B1': {'C1': 0.6634811178795565, 'C2': 0.2948560118675232},
         'B2': -19435,
         'B3': -0.8089416027069092,
         'B4': 44,
         'B5': {'D1': 1134388567,
                'D2': -10730,
                'D3': [2952464959, 956318536, 4103270212],
                'D4': 3565075248,
                'D5': [33, 125]},
         'B6': -2063233431,
         'B7': -300505215801267197},
        {'B1': {'C1': 0.7489227856628009, 'C2': -0.41258859634399414},
         'B2': -2326,
         'B3': -0.37294745445251465,
         'B4': -84,
         'B5': {'D1': 131317526,
                'D2': -17895,
                'D3': [481646996, 3796242033, 4017546918],
                'D4': 1165830933,
                'D5': [-41, -23]},
         'B6': 904488833,
         'B7': -3785938774823544156}],
 'A3': 990340860,
 'A4': 26177}

(b'\xb2RDLTtjyy\x02\x00\x17\x00>z\xa7\x8f\xacuY\x91&\x10\xf4\xf1\x80 `'
 b'_\xe9?\xcf\\m?6\xd5\xfdi\xa5>\xe5\xc3(\xa3\xa6\xa8u\x95D\xca\xbf\x05\xf0GL'
 b'[\xd6;\x1e_1\xac\r\x02\x00\x00\x00\x13\x00\x00\x00\xe5\xe6D @r\x07\x1e'
 b'\xf0\xdd\xa3}\x84\xd4\xbd\x19\xe9\xc8\xd0?>\xf4-?\x1d9\xf3\xcd'
 b'\x0e\xbf\x97\x9a\xf2\x07F\xc5\xf7\xd3\xc6\xf4\x1d\xc0\xdeq{\xeb\xab\xd9'
 b'\xe1\x12\xe3\x15\xa1\x02\x00\x00\x00\x15\x00\x00\x00\xb6\xe0\xe6'
 b'\xdc\xb3\x8e\xc1\x93\xa0\xb1f\xef')

{'A1': 'tjyy',
 'A2': [{'B1': {'C1': 0.7928925165975316, 'C2': 0.9271973967552185},
         'B2': -10954,
         'B3': 0.32307425141334534,
         'B4': -27,
         'B5': {'D1': -1499256637,
                'D2': 30120,
                'D3': [3217704085, 1279782917, 507237979],
                'D4': 229388639,
                'D5': [89, -111]},
         'B6': 541386469,
         'B7': 9053323699310522944},
        {'B1': {'C1': 0.26226260675259305, 'C2': 0.6795080900192261},
         'B2': 14621,
         'B3': -0.5578300356864929,
         'B4': -105,
         'B5': {'D1': 1174925978,
                'D2': -2107,
                'D3': [502580947, 2071060160, 3789138923],
                'D4': 2702566162,
                'D5': [38, 16]},
         'B6': -588848970,
         'B7': -1196073347788468557}],
 'A3': -1884849602,
 'A4': 30124}

Вариант №40

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

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

(b'QKGL/\xa01\xc4\x07\x1f\xd5\xa0\xbepkrjpnfb{\xaf\xc4}\x82\xd0\n\xcf\xd8?\xeb'
 b'i\x95\x0f\x89\x9a O\x17E\x02\x00\x00\x00E\x00\x00\x00a\x00|x\x17\xaf)'
 b'M\xbb\xf1 \xea\xe1\xb29\x15\x83\xb3\xc8\xf73\x00\x00\x00\xfe\x0373\x1aoe'
 b"b<\x00\x00\x006 \xc6x\xf499Z\x15\xd8\xfa9'\xca\x1e\x05%\xddN\xe5\xbf6\xdd"
 b'\xefFW\xd9\xe9\xbf\x8c\x80\xe6\xd2e\x80\xb2\x87?\x18[\xffG\x0b\xbb\xdb\x84s'
 b'\r\x13\x83\xfeo\xbaR\x8a`y\xcc?H\x0b\x8d\\\x84_-\x02\x00]\x00')

{'A1': 12704,
 'A2': 1988,
 'A3': -0.31412598490715027,
 'A4': {'B1': 'pkrjpnfb',
        'B2': 123,
        'B3': 175,
        'B4': 0.387636855719361,
        'B5': 5701727041713695211,
        'B6': 23,
        'B7': 69},
 'A5': [{'C1': {'D1': 124, 'D2': 2373884418687178616},
         'C2': 7090195346683790334},
        {'C1': {'D1': 234, 'D2': -592025975421029663},
         'C2': 6501291259247075382}],
 'A6': {'E1': 39,
        'E2': [-0.6658769343420883, -0.8077808747756652],
        'E3': -116,
        'E4': 0.011570933444420506,
        'E5': [1207917336,
               -2065974517,
               -2095903373,
               1387950078,
               -864460662,
               -1928640449,
               761234524],
        'E6': [55317, 14842]}}

(b'QKGL/\xb7\xd6:Q\x11#,>mdycjgpf\x8a\xdc 5\x92Pj\xbc\xab?\tO\x1c\xf1\x0b'
 b'\xc5xsU?\x02\x00\x00\x00E\x00\x00\x00a\x00\xb0\x14t\xb8\xb6\xdbI\xac\x13'
 b'\x95\x02Q\xa9\x96\xc54N\xf53\x00\x00\x00\x0c&\x89\x01\xb4)b\xe0<\x00\x00'
 b'\x0014\xbf\x8f\x8aj\xb2\xdeW\x01\x1dm\xe2\xb0\xcesq\x87\xcb\xb9?\xdePNW\xe9]'
 b'\xe3\xbf1\xa0\x13AQ]@\xd9?\x11\xaf\x89j#\xdb\x82]\x85\x89N\x1f\xdfw\x89O\xa9'
 b'5\xcbC\xbc\xd7/\x81J\xe0\xd4^\x02\x00]\x00')

{'A1': 54967,
 'A2': 20794,
 'A3': 0.16810251772403717,
 'A4': {'B1': 'mdycjgpf',
        'B2': 138,
        'B3': 220,
        'B4': 0.054171869597761324,
        'B5': 8320616966647467785,
        'B6': 85,
        'B7': 63},
 'A5': [{'C1': {'D1': 176, 'D2': 1417589190727070740},
         'C2': -2278212608399432180},
        {'C1': {'D1': 149, 'D2': -770620462992895742},
         'C2': -2399738508085349327}],
 'A6': {'E1': -30,
        'E2': [0.1007618572219211, -0.6052138047403124],
        'E3': 49,
        'E4': 0.3945534986017325,
        'E5': [1787408145,
               1568856867,
               525240709,
               1334409183,
               1137391017,
               -2127571012,
               1591009354],
        'E6': [343, 27933]}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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