ИНБО-10-22

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

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

Поле	Описание
1	Структура B
2	Структура C
3	Структура E
4	int64
5	uint16
6	uint16
7	int8
8	Структура F

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

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

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

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

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

(b'VIV\xe4\x04\x00\x00\x00s\x00\x00\x00\x88#\xc5\x7f\x02\x00\x00\x00'
 b'w\x00\x00\x00\xfb\xea\x82\xfd\x02a[[\x94\x88\xe4^\x88\x9d\xb3\xd7'
 b'\xbe\x02\x00\x00\x00y\x00\x00\x00\x17?\x1bl\xfdg\x89\xfc_\nx\xaf\xc4\x8dF'
 b'\xf7>\x07\x88m\xb5\x98O&\x0e*i\x921\x95\xaf\xb1]\x8a\x15zwV\xf5'
 b'\x06\x00\x00\x00{\x00\xcf\x06hE\x9c\xb8@4\xf4y\xd0U\x16\x1f\xd6\xc8>\xb2'
 b'\x0c\x006cljh\xd6h\xac:\x19:\xdc\xf5Y\xd9')

{'A1': {'B1': -28, 'B2': 'cljh', 'B3': 2143626120},
 'A2': {'C1': [{'D1': [214, 104],
                'D2': 4253215483,
                'D3': 6837740305024508162,
                'D4': -120,
                'D5': -0.4212922155857086},
               {'D1': [172, 58],
                'D2': 1813724951,
                'D3': 12643867361217701885,
                'D4': -60,
                'D5': 0.48296013474464417}],
        'C2': 1019589882943473671,
        'C3': [26922, 12690, 44949, 23985]},
 'A3': {'E1': 5514, 'E2': 4116084602, 'E3': [25, 58, 220, 245, 89, 217]},
 'A4': 3765212269800589007,
 'A5': 31220,
 'A6': 21968,
 'A7': 22,
 'A8': {'F1': 0.3922586143016815, 'F2': 905972914}}

(b'VIV\xe0\x02\x00\x00\x00s\x00\x00\x00\xc16T\xce\x02\x00\x00\x00u\x00\x00\x00'
 b'\x19d@\x9a\xa3\x9d\xb82Lp\xcb1\x8frc\xf3>\x03\x00\x00\x00w\x00\x00'
 b"\x00\x08B\xd6#\x95\x07|Q\x96\xbc\xdaK\xcb'la?\xecz|\x9f\n\x13 \xc2\xe0\xfe"
 b'\x90\t5B\xe4z\xf5\xf7\x1f\xfb\xc5\x94\x02\x00\x00\x00z\x00\xa0}\xd6r\xf2\xfc'
 b'\xcb\x92\xe3-\xc59\x81x\xe1E?\x9bA\xf0hek[\x0b~gP\x90Z')

{'A1': {'B1': -32, 'B2': 'ek', 'B3': -833341759},
 'A2': {'C1': [{'D1': [91, 11],
                'D2': 2587911193,
                'D3': 3588085000701517219,
                'D4': -113,
                'D5': 0.47536808252334595},
               {'D1': [126, 103, 80],
                'D2': 601244168,
                'D3': 5465888451565717397,
                'D4': -53,
                'D5': 0.8805565237998962}],
        'C2': -4458542694750455060,
        'C3': [65248, 2448, 16949, 31460]},
 'A3': {'E1': 63477, 'E2': 2496002847, 'E3': [144, 90]},
 'A4': -7868917805660865120,
 'A5': 11747,
 'A6': 14789,
 'A7': -127,
 'A8': {'F1': 0.7729716300964355, 'F2': 1760575899}}

Вариант №2

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

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

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

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

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

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

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

(b'\xbaKPI\x00\x1ab!\x0fb\x00\x00\x00J\x1b\xd1\x01L\x04@x\xb7\xd3\xe0\xf8\xb4bh'
 b'a>j\xea&H)\xbf\xbc<Fgb\xd3@>\x95\xf7\xc3.#9m\xba\xf86\x05\xdcpi\x8e\xbf'
 b'\xb2\xf4\x00\x00\x008\x00\x00\x00:\x00\x00\x00<\xf4\xf6\t\xf0\x04\xf3'
 b' \xc1\x00\x00\x00\x03\x00\x00\x00>kp\xc9\xd1\xb9R\xbf\xebxp\xde\xb4\x19\x16'
 b'?\xef\x8dh_\xdf]\xb2?K?\x03\x04\xc1Zv\xcb\xf24\xc6W\xd0')

{'A1': {'B1': 'bha',
        'B2': 15978,
        'B3': -366589911,
        'B4': -0.11029472374032157,
        'B5': 0.29290589690208435,
        'B6': 3324564093380605445,
        'B7': -36},
 'A2': 1646333794,
 'A3': {'C1': 4109765104,
        'C2': 83042497,
        'C3': [{'D1': 112, 'D2': 105},
               {'D1': -114, 'D2': 191},
               {'D1': -78, 'D2': 244}],
        'C4': 1802553809,
        'C5': {'E1': -71,
               'E2': 82,
               'E3': [-0.8584522580793272, 0.9860116837034438],
               'E4': 1061895939},
        'C6': [4, 193],
        'C7': 6518621751793309648},
 'A4': 466682188,
 'A5': 306377505590278324}

(b'\xbaKPI\x00\x1a\x9d\xd6\x0e\xa9\x00\x00\x00J\xec\x9eo\xa4\x910[\xda\xbbo'
 b'2\xdbthk\xed\xda9s\xe7\x11?\x9f\x9c\xe7\xe7\xac\xc7\x00\xbe\xe1bh\xe6'
 b'L\x9f\xf7D\xb3R>M\x04A\x83*\xa3\x9a\x00\x00\x008\x00\x00\x00:\x00\x00\x00<G2'
 b'f\xed\xd7\xefd\x08\x00\x00\x00\x03\x00\x00\x00>\xfbf\t\xda\xe3\xa9'
 b'\xbf\x90B\xf7\xc7\x90\xe9\x00?\xcd\xe0\xed~VW q\x05X\xcb\xcfS\x08('
 b'\x94\xf2\t^pZ')

{'A1': {'B1': 'thk',
        'B2': -4646,
        'B3': 963897105,
        'B4': 0.03087198592692797,
        'B5': -0.4402039051055908,
        'B6': -1851929462397775298,
        'B7': 77},
 'A2': 2648051369,
 'A3': {'C1': 1194485485,
        'C2': 3622790152,
        'C3': [{'D1': 4, 'D2': 65},
               {'D1': -125, 'D2': 42},
               {'D1': -93, 'D2': 154}],
        'C4': 4217768410,
        'C5': {'E1': -29,
               'E2': 169,
               'E3': [-0.015880462222619407, 0.23342674893199788],
               'E4': 1896175819},
        'C6': [207, 83],
        'C7': 587883518632030298},
 'A4': -325161052,
 'A5': -7984781144322264357}

Вариант №3

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

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

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

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

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

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

(b'HJFAX\xad\x18\xe6>~\x95n?"\xb3\x95>X\x0c\x07?\xe8\x84\x1a?\xf6\xac\xb9'
 b'\xbe\xf0\x82S\xbfgygdZsXR\xd7(6(\x80\xacG\xe9\x0b\xb0\x9d\xbfY\x00\x05'
 b'\x9b\xbd$"xS\x18\xe1\xf6\x9eW\xed;w\xd7\x85\xfb\x1f\x0f\x18Q\xc1\x02\x8d'
 b"\x08i\x00v\x00\x82\x00\x8c\x00\xfe'\xec\xddL3@zOf\xbd\xca\x96\xbf\xe9"
 b'#\x02\x00\x00\x00g\x00z\xcb\xf7\xc2^qe\x05\x00\x00\x00q\x00\xc2P\xbf\xa6'
 b'\xb3t\x04\x00\x00\x00~\x00+>}@\x02\x00\x00\x00\x8a\x00y\xea')

{'A1': [0.44940701127052307,
        0.9319685697555542,
        0.29238229990005493,
        0.5275321006774902,
        0.6035904884338379,
        -0.3626477122306824,
        -0.8262166976928711],
 'A2': 'gygd',
 'A3': 2897548315524100954,
 'A4': -0.028991876710204867,
 'A5': {'B1': {'C1': 3723241470, 'C2': 13132, 'C3': -0.0222577661223744},
        'B2': 1752876768017881861,
        'B3': -2335,
        'B4': -322614891180632162,
        'B5': 1360531231,
        'B6': 143459009},
 'A6': [{'D1': [233, 35], 'D2': 52090},
        {'D1': [247, 194, 94, 113, 101], 'D2': 20674},
        {'D1': [191, 166, 179, 116], 'D2': 15915},
        {'D1': [125, 64], 'D2': 60025}]}

(b'HJFAXN\xdeg<\xe9\x86\x01?\x01I\x1f<\x03\xbb\xa2>\xd2\x05.\xbe\x0e\xccs'
 b"\xbfI\x8d\xad\xbewxmg\x19\xbaH\xdd\x89\x9a\xcd\xbfR\xb3'\xc4\xf0\xb6\xe2"
 b'?Y\x00Z\xb2\xf5\x8b\xac\xa1\x85p\xc8Bh\xd3\xdc:\xd8\xa9\xafw\xf5\x90\x9b'
 b'\xa3\xa9%Rlk\x00w\x00\x83\x00\x90\x00G\xb0P\x8bgF\xb0\xf4Dc\xf27\xe9\xbf='
 b'\xb7s\x0b\x04\x00\x00\x00g\x00\x85RX(0\x87\x04\x00\x00\x00s\x00\x9b4\x19'
 b'/\x07\xa8\x04\x00\x00\x00\x7f\x00\xc2\x16@\xe1\xdb\xbd\t\x05\x00\x00\x00'
 b'\x8b\x00\xa8\x85')

{'A1': [0.014152122661471367,
        0.5059648156166077,
        0.009721995331346989,
        0.3178330361843109,
        -0.16994407773017883,
        -0.9523323774337769,
        -0.33896854519844055],
 'A2': 'wxmg',
 'A3': 13820872748383648281,
 'A4': 0.5848316031602769,
 'A5': {'B1': {'C1': 2337321031, 'C2': 18023, 'C3': -0.7880794466833745},
        'B2': 8108064466605027930,
        'B3': 17096,
        'B4': 8624298557603369832,
        'B5': 2744881397,
        'B6': 1817322921},
 'A6': [{'D1': [61, 183, 115, 11], 'D2': 21125},
        {'D1': [88, 40, 48, 135], 'D2': 13467},
        {'D1': [25, 47, 7, 168], 'D2': 5826},
        {'D1': [64, 225, 219, 189, 9], 'D2': 34216}]}

Вариант №4

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

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

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

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

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

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

(b'XHGI=\x00\xe0g_\xa0J\x9c\xee\x03U\xd2\xbf\x05\x00V\x00\x00\x00\x03'
 b'\x00\x00\x00[\x00\xc5\xa8h\xf4\x907F3\x9d^\xdb?\xaa\xba\xb0\xe7Lu&'
 b'\x9d\xec0\xad\xf2\xe1?\xb5K\xce!C\xea\x02\x00!\x00\x00\x00<\xbbc\x9d@iVuf'
 b'\x9f\xb2S\xe0\xdd\xc6\xea:L/fqphn\x04\x93\xc0')

{'A1': {'B1': {'C1': [{'D1': 0.42764978415731836,
                       'D2': 47786,
                       'D3': [59312, 30028]},
                      {'D1': 0.5608735995819287,
                       'D2': 19381,
                       'D3': [8654, 59971]}],
               'C2': -17604,
               'C3': 40291,
               'C4': 64,
               'C5': 22121,
               'C6': 26229,
               'C7': 45727,
               'C8': 3408163798045810771},
        'B2': -32,
        'B3': 24423,
        'B4': -0.28643892576034524},
 'A2': 'fqphn',
 'A3': [4, 147, 192],
 'A4': -194467643}

(b'XHGI=\x00N\x9e\xbf\x00\xe8\xa1\x8bVI\x90?\x04\x00V\x00\x00\x00\x04'
 b"\x00\x00\x00Z\x00\xbc'\xbe\xfc0%\t\x86\x84c\xb4?\xe0\xa2\xfc2\xf2j\\"
 b'\xb0\xcb\xd5\xa6\xe8\xd1?\xb4\xe9\xd31\xbb\x8b\x02\x00!\x00\x00\x00]'
 b'\x11\x0b\x02\x1c\x90PJ\xaa/T\xe2\xab\x92\x13\xbc\x13\xf1\xa1pboh\xb4\xe7'
 b'\x1c?')

{'A1': {'B1': {'C1': [{'D1': 0.07964351913792167,
                       'D2': 41696,
                       'D3': [13052, 27378]},
                      {'D1': 0.27982493284685517,
                       'D2': 59828,
                       'D3': [12755, 35771]}],
               'C2': 4445,
               'C3': 523,
               'C4': 28,
               'C5': 20624,
               'C6': 43594,
               'C7': 21551,
               'C8': 11669129807996824546},
        'B2': 78,
        'B3': 49054,
        'B4': 0.015904762527931382},
 'A2': 'pboh',
 'A3': [180, 231, 28, 63],
 'A4': -54646852}

Вариант №5

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

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

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

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

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

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

(b'DBR\xca!:\x00\x00\x00\x8e\x00\x00\x00 4X\xa4\xbb\xe9/\x1fF\xf4\xaa<\x80\x8fN'
 b'sK\x99\xd3\x1f\xca\xc7\x02\x00\x00\x00\r\x00\x9ey\xe0\x08\xa8xa\x15\xc1\x83['
 b'\x16\x9b\xf2\\\x95xo\x1d\x00m\xf2\t\xee\xa0\x83\xab{\x91\x00\xd2'
 b'\xbf\xb0Z\xa60\xd4\x11\x0f:\xb0"\xbb2Ud?\xe1,.Q\xd9\x18\x1c\xbf'
 b"\x13\x90\x1b\xd6\xe4\x13\xcb\xfeDF\xbb\xd1\x9f\xe8\xadv'g\xd6@,7\xd6\x04"
 b'\x00\x00\x00Q\x00\xde\xfaEA\xae\x7f\\\x01\xa1\xb7\xd7\xb1Z\x1b\xa0\xaed=q'
 b'\x00\x02p\x122.\xe8\x12Iv\x84\xe7?5sQx\x9er\xe0\xf3')

{'A1': 33,
 'A2': [{'B1': 111,
         'B2': {'C1': {'D1': 533961035,
                       'D2': 51146,
                       'D3': [2247271731206566944, 8308736143481566278]},
                'C2': 148928926,
                'C3': 1611026157025720488,
                'C4': [-101, -14, 92, -107, 120]},
         'B3': -301338003,
         'B4': -0.2812846858706113,
         'B5': 23216,
         'B6': [12454, 4564, 14863]},
        {'B1': 61,
         'B2': {'C1': {'D1': 742446695,
                       'D2': 54839,
                       'D3': [-2215942174556872016,
                              1422886900323135020,
                              4971634324967660432,
                              2843651429356387142]},
                'C2': 1095105246,
                'C3': 12814913166846492590,
                'C4': [90, 27, -96, -82, 100]},
         'B3': 840069122,
         'B4': 0.73491968414533,
         'B5': 29493,
         'B6': [30801, 29342, -3104]}]}

(b'DBR\xca\xe7J\x00\x00\x00\x96\x00\x00\x00\xbb!C\x97\x81#\x93\x9ar\xd6\xc7'
 b'\xa0Fw?\xd36\x8bH\xc2P\xf2\x8eB.\xe1\x94\xae\x16m\x7f\xd3\x96\x951'
 b'\x8dS\xf6\x04\x00\x00\x00\r\x00\xa4n\x93K\xb8J\t\n\xf0v{%\xda\xfc\x15Uas-'
 b'\x00\x12\x1co\x9dd\xaaO\xf8\x19\x9c\xe5\xbfp\x91@\xdf\xca\x91}'
 b'\x1d\xf6\xdb\x931t<\x13\x91`R\xde\x95U\xf8&\xef\xdf\xcas\xab\x99\xa8/'
 b'\x9f\x19[\x99\x84\xb1C\x03\x00\x00\x00a\x00\x82\xf9\x81\x19C\x80\xca+\xb1Le'
 b'\x01Z\xfc>mGVy\x00\xb4\xfds\x0f\xf8c~\x0b\xe6~\xcb?m\x05K~\xbe(\xd1\x9f')

{'A1': 231,
 'A2': [{'B1': 115,
         'B2': {'C1': {'D1': -1926130282,
                       'D2': 63059,
                       'D3': [-7308458730796670533,
                              -3224727662945118606,
                              4796037081866996534,
                              -3206724465478803154]},
                'C2': 1267953316,
                'C3': 2700883174871354040,
                'C4': [-38, -4, 21, 85, 97]},
         'B3': -1653662702,
         'B4': -0.6753053521945955,
         'B5': -28304,
         'B6': [-8384, -28214, 7549]},
        {'B1': 86,
         'B2': {'C1': {'D1': -2070324455,
                       'D2': 17329,
                       'D3': [-7992978443906851850,
                              -1214010003059486112,
                              -6976171919813653793]},
                'C2': 427948418,
                'C3': 100570890513317955,
                'C4': [90, -4, 62, 109, 71]},
         'B3': 259259828,
         'B4': 0.21481013833252383,
         'B5': 1389,
         'B6': [32331, 10430, -24623]}]}

Вариант №6

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

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

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

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

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

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

(b'\xe3UPBE\xb9\xc3\xba\x14\xd2?\xe0\x90\xdfQ\xffZ\x94\x00\x00\x00\x04\x00:'
 b'\x00\x02\x00H\x00\x00\x00\x02\x00\x00\x00P\xed@X\xb98="\x9b\x8d\x01\xf2o'
 b'^@(\x94\x82\x1a\x00\x02\x00RjegoW\xe3\xf60\n\xa2\xf1\xf4O\xd8\x00\x00\x00>'
 b'\x00\x00\x00CvaK\xa2')

{'A1': {'B1': 1169802170,
        'B2': 5330,
        'B3': 0.51768461241848,
        'B4': 'jego',
        'B5': [{'C1': 1474557488, 'C2': 10}, {'C1': 2733765711, 'C2': -40}]},
 'A2': 'va',
 'A3': {'D1': -1350982335675424101,
        'D2': -29439,
        'D3': -977458964464369126,
        'D4': [75, 162]}}

(b'\xe3UPB>\xc2~v?\xb9\xbf\xc4E\xa04w\xc4\x88\x00\x00\x00\x05\x00:\x00\x03\x00N'
 b'\x00\x00\x00\x03\x00\x00\x00ZK\xc2\xd6R]\xbfe\xb3c\xb8\xdd\x11\xe7\x93:\x0b'
 b'T\xd0\x00\x03\x00]akfhb\xd7\x9e\x0767\xe2\xd0\xf1H\xcd\x89#O\x1c\xfd\x00\x00'
 b'\x00?\x00\x00\x00D\x00\x00\x00Ixvg(\xf0\x15')

{'A1': {'B1': 1052933750,
        'B2': 16313,
        'B3': -0.15837481080919624,
        'B4': 'akfhb',
        'B5': [{'C1': 3617457974, 'C2': 55},
               {'C1': 3805344072, 'C2': -51},
               {'C1': 2300792604, 'C2': -3}]},
 'A2': 'xvg',
 'A3': {'D1': 5459161347574949299,
        'D2': 25528,
        'D3': -2516976097203366704,
        'D4': [40, 240, 21]}}

Вариант №7

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

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

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

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

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

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

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

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

(b'TJE\xa6\x0b\xd8\xc2E\xac\x00\x00\x00\x05\x00r\x0b6~\xe2\xc3cdf\x00'
 b'\x825\xab\x0e\x1e\xbd46|\xe4+\x1f\xf0l\xec?\x8c`\x86\x91#27\xf5x\xa3J\xc3'
 b'\xccA\xc2\xc5j`_9Sx\xe9\x94\xf8\xe4\x89|\xee?M\xa3\x8b\xb3\x00E4\t\xbfh'
 b'\xd8j\xd5\x00Nu\x9e\xbfX(\x1cc\x00WO\xde>\xc9\xcd\xee\xda\x00`\x99'
 b'M\xbe\xf1\xed\x18D\x00i<L\x00J\x00S\x00\\\x00e\x00n\xc2\x1e\x10='
 b'\xa4\x90h\x116\xf9v\x93\xcb\x16\xe7\xc4E\xaa\x00\x03\x00|')

{'A1': 198754885,
 'A2': {'B1': -84,
        'B2': [{'C1': {'D1': 0.8032767176628113, 'D2': 179},
                'C2': {'E1': 52, 'E2': 9}},
               {'C1': {'D1': -0.9095522165298462, 'D2': 213},
                'C2': {'E1': 117, 'E2': 158}},
               {'C1': {'D1': -0.8443620204925537, 'D2': 99},
                'C2': {'E1': 79, 'E2': 222}},
               {'C1': {'D1': 0.3941492438316345, 'D2': 218},
                'C2': {'E1': 153, 'E2': 77}},
               {'C1': {'D1': -0.47251200675964355, 'D2': 68},
                'C2': {'E1': 60, 'E2': 76}}],
        'B3': 188120802,
        'B4': 195,
        'B5': 'cdf',
        'B6': {'F1': 1745958649,
               'F2': 8544396217290081706,
               'F3': [49694, 4157, 42128]},
        'B7': 900402718,
        'B8': -0.04399727284908295},
 'A3': [-466935824,
        1827422092,
        1619431715,
        842528120,
        -1555381300,
        1103283562,
        1616853331],
 'A4': 2028573944,
 'A5': 58505,
 'A6': 31982}

(b'TJE\xa6\x9e%&rZ\x00\x00\x00\x05\x00r\xaa\x8b{\x8b\x1dfol\x00\x80\xf9\xbb]'
 b'\xb7?\x14\x8f\x1c\xb5S\xc5@\xd0Y\xd6qU\xc71\xb2\t\x96N\x16\xad=\xa9(F-\xee'
 b'\xbe\xff\xe5\x9b\xd3\xf5\xe9=V\xa7%\x1e_?m\xc4\xb6\x14\x00EJw\xbfy'
 b'\x03\x1a\xe1\x00N\xa88?I\t!\x13\x00WP\xa4?c9^\x1c\x00`\x9e?>\x98\x8b'
 b'\x06\xcf\x00i\xef\xf3\x00J\x00S\x00\\\x00e\x00nZx\xe0<T\xa8\xec\xde'
 b'7\xa0\x10O\xbc\xf2U`\x00\x02\x00|')

{'A1': 2653234802,
 'A2': {'B1': 90,
        'B2': [{'C1': {'D1': 0.9287828207015991, 'D2': 20},
                'C2': {'E1': 74, 'E2': 119}},
               {'C1': {'D1': -0.9727035760879517, 'D2': 225},
                'C2': {'E1': 168, 'E2': 56}},
               {'C1': {'D1': 0.7852955460548401, 'D2': 19},
                'C2': {'E1': 80, 'E2': 164}},
               {'C1': {'D1': 0.8875941038131714, 'D2': 28},
                'C2': {'E1': 158, 'E2': 63}},
               {'C1': {'D1': 0.2979356646537781, 'D2': 207},
                'C2': {'E1': 239, 'E2': 243}}],
        'B3': 2861267851,
        'B4': 29,
        'B5': 'fol',
        'B6': {'F1': 1420356830,
               'F2': 4008221603018200416,
               'F3': [23160, 57404]},
        'B7': -105161289,
        'B8': 0.5803086757659912},
 'A3': [-1252801216,
        -799418767,
        1439117746,
        160845334,
        -1388467928,
        1177415358,
        -1729581],
 'A4': 4125703510,
 'A5': 42789,
 'A6': 7775}

Вариант №8

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

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

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

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

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

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

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

(b"\xe2KUQ'\x048\xc2\xbf\xee\xa6\x13\xba\x16\x8b\x90\x85\x11\xb2\xe2"
 b"\x08\x06)\xe2\x98\xb4\xe3\x11\xd7'(\xf2\x00\x02\x00S\x00\x00\x00\x82"
 b"\xcb?\xec1\xf1\xf5:\x06$\xcd\xe6\x88\x9d\xed\x9a'x{\xc3f^\xbb\xca\x1d"
 b'}q\xae\xc4\\\xca\xc7\xbcbJ(\x0cjx\xe8;\xff\x9d\x9f\x00A\x00J\xea'
 b"\xc4\x8dj\xe0\xaa:6#W\xfbW\xc1S\x01E\xe82'\x17\xd5:u\xaf\xf5\xe8\xca>Y"
 b'\xb9f\x17=\xd0\xa4\xa62Ka\xec\x1a\x05Q\x00\x05\x00W\x1c\x1d\x00\x03\x00\x00'
 b'\x00\x7f~\x10\x80\x9a\xc7\xcd\x15\x133c')

{'A1': 654588098,
 'A2': -0.9577730783970413,
 'A3': 9588641765515471330,
 'A4': {'B1': -7443074618372970254,
        'B2': [{'C1': 113, 'C2': [174, 196, 92, 202, 199, 188, 98, 74]},
               {'C1': 40, 'C2': [12, 106, 120, 232, 59, 255, 157, 159]}],
        'B3': {'D1': [16916801590485727798,
                      2546780468625473861,
                      16731478548949923247,
                      17719635103031322135,
                      4454241065184748012],
               'D2': 28,
               'D3': 29,
               'D4': [26, 5, 81],
               'D5': 9083901850671715603,
               'D6': 13155},
        'B4': 203,
        'B5': 0.8810968198378686,
        'B6': -840529763,
        'B7': {'E1': 17121040331828323934, 'E2': -0.006168066058307886}}}

(b'\xe2KUQ\x00a\x86\x9e\xbf\xe8\xb5\x9f\xc9\xb1\xcf4R\x0f\x80\xca^\xb9\xccc'
 b'}7\xf2\xe7\\\x10\x1d\x13\x00\x04\x00e\x00\x00\x00\x88\x8e\xbf\xc40d9Z,'
 b'0\x15\xad\x06\x8c=J\xe7ftV\r;?\t9\x91X\xee\xe1u-\xfd\x99\x83\x19\x89vY`1\x98'
 b'`\x91\xcf\xa6B\x0e8\xd3\t\xa2i\xd3\x1fH\xc0\xea\xaaWy\xc1\x83\x00A\x00'
 b'J\x00S\x00\\\xbb\xf2\x05\xc7j\xe8\xf4YD\x9f\xe3\xd1\xd0V\x83m\xc0ts'
 b'\xc6\xa7F\xee\x90\xc3>\xdc\x00\x03\x00mF\xb4\x00\x03\x00\x00\x00\x85'
 b'\xd0\x8a\xb5R\x16\x93\xa5\x1efR')

{'A1': 6391454,
 'A2': -0.7721709193560629,
 'A3': 5913086442421734499,
 'A4': {'B1': 9022947453956005139,
        'B2': [{'C1': 88, 'C2': [238, 225, 117, 45, 253, 153, 131, 25]},
               {'C1': 137, 'C2': [118, 89, 96, 49, 152, 96, 145, 207]},
               {'C1': 166, 'C2': [66, 14, 56, 211, 9, 162, 105, 211]},
               {'C1': 31, 'C2': [72, 192, 234, 170, 87, 121, 193, 131]}],
        'B3': {'D1': [13542893383506785369,
                      4944921406159094637,
                      13867836449627762320],
               'D2': 70,
               'D3': -76,
               'D4': [-61, 62, -36],
               'D5': -3419721602863749858,
               'D6': 26194},
        'B4': 142,
        'B5': -0.15772679138567147,
        'B6': 363660940,
        'B7': {'E1': 4416596811814669627, 'E2': 0.5360346436500549}}}

Вариант №9

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

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

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

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

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

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

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

(b'RCC&\x00q1\x13\x80\t\xb8P\xe6#\xbf\xd5P\x11a\xcb0\x98?\xd8Z"\xde\xa8'
 b'r\x1c_\xa3\xae,\xd8>\xccc\x1f\xba\xa4\x03\x80\x04\xc3\x1c:\xf9\xa6\xaa=\x90'
 b'\xf2\xc5\r\x15\x9bL\x97\xf9\xf4K\xd3Y\x8b\x01\x80\x04\x0b\x8f\x01\xce'
 b'\xbe\xf5\x15\x97\xca\xf1\x96x\xbd^\x00\x04\x00L\x9f\xc3\xcam\xaa\x00'
 b'\x03\x00V\r\xf3\n\xd9\x11s\xa4r\x00\x06\x00_\x00P\x00Y\x00evsfizm\xeb'
 b'\n\x87\x0eC[\x8b8\x00\x03\x00\x00\x00k\x1bl\x8d\xfb\xe8\xe7=*\xde\x0e~'
 b'x$`\xf5m\xb9\xb2')

{'A1': {'B1': 'vsfizm',
        'B2': 16936497844009536312,
        'B3': [{'C1': -17058, 'C2': [202, 241, 150, 120]},
               {'C1': 28074, 'C2': [159, 195, 202]},
               {'C1': -23438, 'C2': [13, 243, 10, 217, 17, 115]}],
        'B4': {'D1': 460099067, 'D2': -24, 'D3': 59197},
        'B5': 10974,
        'B6': [14, 126, 120, 36, 96, -11, 109],
        'B7': -71,
        'B8': 178},
 'A2': 3536310911651341859,
 'A3': {'E1': -0.3330119566933347,
        'E2': 0.38050147766060305,
        'E3': [6891543362436779107,
               2286320095783600924,
               4249610973508334277,
               942830450273547339,
               15229356453489019791],
        'E4': 1},
 'A4': -50,
 'A5': -0.4786803424358368}

(b'RCC&\x00e7\x17\x92\xc6:6H\xa4\xbf\xec\x1d\x0c7h\xb5\x9c?\x80\xb3\x92\x18\x1c'
 b'\x96\x00\xf2\xac\x0f\xb8G!\xbet\xfes\xf8\xd8\xab\x95\xb0i\xc0\xad\xa0i>\xbe'
 b'X6;rS\xc6\xcc\xc2\xc6,\xe7Sf\xe9,>\x9c\x99\xfb\x9f>>3\x7f\x98\x95\xaf\x07'
 b'\x84E\x00\x04\x00L\x15!\xdaIF\xf1\x0e\x00\x05\x00V\x00P\x00[uadgey@'
 b'd\x1e\xee,\x00\xae\xc1\x00\x02\x00\x00\x00a\x8d\x85HY)\x0e\x9f'
 b'\xd7\xbc\xf6\xad\x90D\xe2\\\xcfzG')

{'A1': {'B1': 'uadgey',
        'B2': 4639867524387745473,
        'B3': [{'C1': -31675, 'C2': [152, 149, 175, 7]},
               {'C1': -3826, 'C2': [21, 33, 218, 73, 70]}],
        'B4': {'D1': -1920645031, 'D2': 41, 'D3': 3743},
        'B5': 55228,
        'B6': [-10, -83, -112, 68, -30, 92, -49],
        'B7': 122,
        'B8': 71},
 'A2': 3969802976628197540,
 'A3': {'E1': -0.8785458643157429,
        'E2': 0.008155003891782364,
        'E3': [17486368737314586228,
               18335272117430759529,
               13883929600137779254,
               4283578308886709804,
               16668779797484051609],
        'E4': -5},
 'A4': -97,
 'A5': 0.1857433170080185}

Вариант №10

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

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

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

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

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

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

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

(b'AOHPu\xbe\xca"t>i\xa8\xa5\x00\x00\x00Y\rz57\x81\x05V\xc3\x1a]\xb62\x19\t\t'
 b'\xceEV\x18\x18\xd0$\x8a\x8b\xae\xae\x19\xff\xcd\xb5(b3\x15\x85/\x89\xb4\xbe'
 b"\x00'4\x10FE0H\x06\x04\xbb\xbc\x93fP\xf2\xbc\x88\xa8\x81\xfaa\xde\x9a"
 b'2\xbf\x0f.\x07>\xc7\x9e\xc1\x00\x1a\xc2\x00\x00\x00\x06\x00\x00\x00\x1c'
 b'\x00"\x06\x00\x00\x00\x02\x00\x00\x00$\x00&\x07\x00\x00\x00\x07\x00\x00'
 b'\x00(\x00/R\x00\x00\x00\x03\x00\x00\x001\x004m\x00\x00\x00\x06\x00\x00\x006'
 b'\x00<,\x00\x00\x00\x07\x00\x00\x00>\x00\x03\x00\x00\x00E\xc1-\xaa\xaa*\xebQ'
 b'\xd8\xec]\x12\xbc\xc0\x922\x0b\x00\x02\x00\x00\x00Q\x8a\x9d\x18Y\xa8'
 b'\xee\x83~.\xfc\xa7\xc5\x02\xc6\x96\x93')

{'A1': -0.3947941064834595,
 'A2': 0.22818239033222198,
 'A3': {'B1': [{'C1': {'D1': 93, 'D2': 182},
                'C2': 194,
                'C3': [50, 25, 9, 9, -50, 69]},
               {'C1': {'D1': 86, 'D2': 24}, 'C2': 6, 'C3': [24, -48]},
               {'C1': {'D1': 36, 'D2': 138},
                'C2': 7,
                'C3': [-117, -82, -82, 25, -1, -51, -75]},
               {'C1': {'D1': 40, 'D2': 98}, 'C2': 82, 'C3': [51, 21, -123]},
               {'C1': {'D1': 47, 'D2': 137},
                'C2': 109,
                'C3': [-76, -66, 0, 39, 52, 16]},
               {'C1': {'D1': 70, 'D2': 69},
                'C2': 44,
                'C3': [48, 72, 6, 4, -69, -68, -109]}],
        'B2': [1716581052, -2002222598, 1641978418],
        'B3': 13919969671113298392,
        'B4': {'E1': -5027,
               'E2': 4796,
               'E3': -1064160757,
               'E4': [-0.5592960715293884, 0.3898830711841583]},
        'B5': -8458577751766563970,
        'B6': 3385765484472735379},
 'A4': 3450,
 'A5': 892829957,
 'A6': 86,
 'A7': -15590}

(b'AOHPu\xbf\x12kw\xbe\xcf\x88?\x00\x00\x00[\xf7M\xc8\xbc\x97kEDd\xa9\xd4'
 b'\t\xcb\x0c \xd5\x0f\x7f\xb52\x80E\xf2\x9e\xce\xb65_q\x8b\xb3\xe6m\xdc\xfa'
 b'MR\x97\xfb\xf5{\xca-Z\xc4U\xe7\x9aaN\x1b\x0c\x16JD\xa3\xddi\x93\xdd7\x98?'
 b'~]-\xbf?\xe6\x8d?\x03\xc1P\x00\x1a\x06\x00\x00\x00\x06\x00\x00\x00\x1c\x00"'
 b'(\x00\x00\x00\x06\x00\x00\x00$\x00*\x03\x00\x00\x00\x05\x00\x00\x00,'
 b'\x001\x1c\x00\x00\x00\x04\x00\x00\x003\x007~\x00\x00\x00\x06\x00\x00'
 b'\x009\x00?\x9e\x00\x00\x00\x06\x00\x00\x00A\x00\x02\x00\x00\x00G\xf2\xc8K**'
 b'\x8d\x1e\x9e\xafD\x0f9\x0e{:\xf3\x00\x03\x00\x00\x00O"L\xdeH;\x8e\xd7'
 b'\xe9\x00\xdbA\xde\x13C\xcc\x1f')

{'A1': -0.5719522833824158,
 'A2': -0.4053363502025604,
 'A3': {'B1': [{'C1': {'D1': -87, 'D2': 212},
                'C2': 6,
                'C3': [9, -53, 12, 32, -43, 15]},
               {'C1': {'D1': 127, 'D2': 181},
                'C2': 40,
                'C3': [50, -128, 69, -14, -98, -50]},
               {'C1': {'D1': -74, 'D2': 53},
                'C2': 3,
                'C3': [95, 113, -117, -77, -26]},
               {'C1': {'D1': 109, 'D2': 220},
                'C2': 28,
                'C3': [-6, 77, 82, -105]},
               {'C1': {'D1': -5, 'D2': 245},
                'C2': 126,
                'C3': [123, -54, 45, 90, -60, 85]},
               {'C1': {'D1': -25, 'D2': 154},
                'C2': 158,
                'C3': [97, 78, 27, 12, 22, 74]}],
        'B2': [1151589737, -1814218856],
        'B3': 17494315396995292830,
        'B4': {'E1': -20668,
               'E2': 3897,
               'E3': 242957043,
               'E4': [0.9936092495918274,
                      -0.7496116757392883,
                      0.5146684646606445]},
        'B5': 2471594697337788393,
        'B6': 61715441961389087},
 'A4': -2227,
 'A5': 3367802731,
 'A6': 69,
 'A7': 17508}

Вариант №11

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

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

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

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

(b'?MVTF+\x00\x00\x004\x00\x00\x00=\x00\x00\x00F\x00\x00\x00O\x00\x00'
 b"\x00X\x00\x00\x00i\x00\xc0V\xfbH\x02\x00{\x00i'gx\xcd\x02\x00)\x00\x00\x00vx"
 b'\xc2\x02\x002\x00\x00\x00gh\x04\x02\x00;\x00\x00\x00mc\xef\x02\x00D\x00\x00'
 b'\x00wr\xba\x02\x00M\x00\x00\x00jy\x1b\x02\x00V\x00\x00\x00\xdb'
 b'\x9e\xae\x03\xe9^\x9d\xf1\x0fI\x02\xc8\x04\x00_\x00\x00\x00\x0b\x92\x02'
 b'\x00g\x00\xbf\xe2\xe1=u(P\xa9\x1a\xde3\xcd\xa5:\xc1S\xb8\x7fQ\x02')

{'A1': [{'B1': 205, 'B2': 'gx'},
        {'B1': 194, 'B2': 'vx'},
        {'B1': 4, 'B2': 'gh'},
        {'B1': 239, 'B2': 'mc'},
        {'B1': 186, 'B2': 'wr'},
        {'B1': 27, 'B2': 'jy'}],
 'A2': {'C1': {'D1': 51202,
               'D2': [-24869, 942, 24297, -3683],
               'D3': 37387,
               'D4': [15, 73],
               'D5': 0.11029576510190964},
        'C2': 1224431296,
        'C3': [-3660337866030962571, 167055090845301413],
        'C4': 10089}}

(b'?MVTF+\x00\x00\x004\x00\x00\x00=\x00\x00\x00F\x00\x00\x00O\x00\x00'
 b'\x00X\x00\x00\x00i\x00N\xf1\x93\xe8\x05\x00{\x00%\xebfy6\x02\x00)\x00'
 b'\x00\x00jy\x02\x02\x002\x00\x00\x00atQ\x02\x00;\x00\x00\x00hmo\x02'
 b'\x00D\x00\x00\x00lsw\x02\x00M\x00\x00\x00var\x02\x00V\x00\x00\x00)\x08o`\xad'
 b'\x02\xe4\x13+\xd4\xe4\xec\x04\x00_\x00\x00\x00\xe6\x95\x02\x00g\x00\x18'
 b"\x825\xbc\xd8d\xe9\xcf\x85\xcb\xd3\xc3\xb5\xd6?#q\xd0$\n\x18\x1b\x10'6"
 b'Q\x13\xe4\xe7\x1b\xd6:\xe1\x17\xf8\xaf\xbe\x82\xd8\x7f\x00U\xeds')

{'A1': [{'B1': 54, 'B2': 'fy'},
        {'B1': 2, 'B2': 'jy'},
        {'B1': 81, 'B2': 'at'},
        {'B1': 111, 'B2': 'hm'},
        {'B1': 119, 'B2': 'ls'},
        {'B1': 114, 'B2': 'va'}],
 'A2': {'C1': {'D1': 60644,
               'D2': [2089, 24687, 685, 5092],
               'D3': 38374,
               'D4': [43, 212],
               'D5': -0.011078380048274994},
        'C2': -392957618,
        'C3': [-4335898240648387368,
               730938223882131125,
               -2012175315479028968,
               -5766833066725729305,
               8353426344475394750],
        'C4': 60197}}

Вариант №12

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

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

(b'FHB\xce\xbfY\x14g=\xb4?\\\x08\x9eH\x93\xf4p\xa2(\xcd\xeb\x99\x00\x02\x007>'
 b'\xa3\x89\xd2\xe97cMj\x9b\x85K\xdc\xeb\x00\x00\x00N?\x0c\xd1\x96\x11\xbfu'
 b'\x9dlG\x00-\x002\x04\t\x9e\xd9e\xd6\xb2\xc2j<\x0b\xffbVc\x12R;%NBY(\x8c\xde'
 b'RA\xbfS\xa8\xaa\xbe[=\xe4\xab\x18\xb2b>c\xbdi\x18\x8a?x\x98\x9d'
 b'\xef\x05\x00\x02\x00\x00\x00;\x8e/\x95\x8a\xbf\xd5p\xbbr\n61\x8fu\xe0\xe2'
 b'\x1d\xec\xabM\xe2\xca\x80\x81\xdc\x1f\x9f\x00\x03\x00\x00\x00KGZ\xdf\xcd')

{'A1': -0.8479675650596619,
 'A2': {'B1': 15796, 'B2': 0.8595064878463745, 'B3': 5229792356901375467},
 'A3': {'C1': 153,
        'C2': [{'D1': 0.5500730276107788, 'D2': 17},
               {'D1': -0.9594333171844482, 'D2': 71}],
        'C3': 0.31941086053848267,
        'C4': 16805009718708503883,
        'C5': 56555},
 'A4': {'E1': 5639167714118226497,
        'E2': [{'F1': -0.8267923593521118, 'F2': 48731},
               {'F1': 0.11165446043014526, 'F2': 45666},
               {'F1': 0.22240222990512848, 'F2': 6282},
               {'F1': 0.9710786938667297, 'F2': 61189}],
        'E3': [290938307495768770, 7655006658117395218],
        'E4': 36399,
        'E5': 149,
        'E6': [-8448799695765894602, 3571202638254828715, 5612270738940370847],
        'E7': [82, 59, 37],
        'E8': 1197137869}}

(b'FHB\xce?a\xb1\xee\x94G>\xce6\xb4"\xb7\xb4\x1c\xe7{o\xcc\xa0\x00\x04\x00A\xbe'
 b'\xc2\xfdL\xfd\xc9\x15\xfb\x1d\xeb\x1f\xd3\x80\x19\x00\x00\x00[>\xd4;'
 b'f\xd8>\xb8\xc4\xf2F?K\xdbz\xef\xbe\xcc:\xd6\xa1\x00-\x002\x007\x00'
 b'<\xa0\xa3\xa2\x1c\x15\x1a\xff\xd8x:\x0b@\xad\xe5\xce\xd1\x88\xec\x1d'
 b'\xc1q\x15\x81A\x1e\xb5\xbe\xa5,~\xd27\xbf\x19\xfe\xd1\x95\x02>\x91T\xa2r'
 b'M>\xa3\xd1\xe5{2\x00\x02\x00\x00\x00I\xfb\xca\r\xcd\xc9\\5+\xdc\xde\x18'
 b'U\xd9\xf5\xbb\xbd\xed\xcb\x05\x18\xaa\xe0(\xea$2\x0e\x00\x02\x00\x00\x00Y~W'
 b'7\x8b')

{'A1': 0.881621241569519,
 'A2': {'B1': 37959, 'B2': 0.4027611017227173, 'B3': 2501666154263310284},
 'A3': {'C1': 160,
        'C2': [{'D1': 0.4145156741142273, 'D2': -40},
               {'D1': 0.3608775734901428, 'D2': 70},
               {'D1': 0.7963176965713501, 'D2': -17},
               {'D1': -0.39888638257980347, 'D2': -95}],
        'C3': -0.3808387517929077,
        'C4': 18287171930197532627,
        'C5': 32793},
 'A4': {'E1': 2144119234781847221,
        'E2': [{'F1': -0.32260507345199585, 'F2': 53815},
               {'F1': -0.6015444397926331, 'F2': 38146},
               {'F1': 0.2838488221168518, 'F2': 29261},
               {'F1': 0.31996074318885803, 'F2': 31538}],
        'E3': [-6871470364940369960, 8663249205623901905],
        'E4': 64458,
        'E5': 13,
        'E6': [-3618259442176565736, 6186245749864254213, 1777479469282636302],
        'E7': [-120, -20],
        'E8': 2119645067}}

Вариант №13

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

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

(b'\xa2BBDS.\xcf\xc3\x00\x00\x00n\x00\x00\x00\x06\x00\x00\x00\x87'
 b'\x00\x03\x00\x8d\xbf\x19\xae\xcd1\x1d\xf4\xa2mlvzsx\xda\xaf\xbc\xf5l]'
 b'\x84\xb9\x90:\x82\x1a\x9c\xeftx;\x84\xb6\x8dAE?m5\x91\x01\xf0\x05\xae'
 b'S\\u\xda\xbd\x1f\xde\x88\x8c\x11;3K\x05|s\xbfX\x82\xff \xcc\xbd#M\xaa}\xec'
 b'>H`\x8b\x91\xc5\x006\x00B\x00N\x00Z\x00\x02\x004.\x81\xfcLcl\xf2\xc3\x00\x00'
 b'\x00\x04\x00\x00\x00f\x11\x9c\xc7"\x99qjnudv\xa8\xf1\xb5\x01\xbb\x7f\xbc'
 b"N\xfa\xdbl\x90\x0f'\xca\x81\x03\x8cR\x837{\xf6Q")

{'A1': 11983,
 'A2': -61,
 'A3': {'B1': 'tx',
        'B2': 3351237002756158147,
        'B3': [{'C1': 59,
                'C2': 2226556225,
                'C3': 69,
                'C4': 0.9265986084938049,
                'C5': 496},
               {'C1': 5,
                'C2': 2924698741,
                'C3': 218,
                'C4': -0.03903058171272278,
                'C5': 35857},
               {'C1': 59,
                'C2': 860554620,
                'C3': 115,
                'C4': -0.8457488417625427,
                'C5': 8396},
               {'C1': -67,
                'C2': 592292477,
                'C3': 236,
                'C4': 0.19568078219890594,
                'C5': 37317}],
        'B4': 17,
        'B5': 40135,
        'B6': 8857},
 'A4': 'qjnudv',
 'A5': [-6273033786905084850, -370583178342577535, 255670002378339921],
 'A6': {'D1': -0.600323498249054,
        'D2': [12573, -2910, 28012, 30330, 29560, -9553, -17163, 27741]},
 'A7': -8882910209046307601}

(b'\xa2BBDS\x94\xa2\x19\x00\x00\x00`\x00\x00\x00\x04\x00\x00\x00y\x00\x03\x00}'
 b"\xbf\x10\xeb\xd6\x1b\x1f'[\xa7h\xe4uw\xd6Y\xbd\xdb\xb7\x8f\x8b\x19U\x90\x15"
 b'\xa40\x95\x83js\xa5H\x82.7,\xbe\x06\x1d\xb4\xfc\xc7Q\x0cb\t<\xf1?\x0f\xd8o'
 b's\x88\xcb\x833\x9c\xed^=\x83\x15\xe7\x17\xb0\x006\x00B\x00N\x00\x02\x004'
 b'\x81\xf9b\x1e\xf7\xac\x00h\x00\x00\x00\x03\x00\x00\x00Z*I\x82\x0b\xa6ryx'
 b'm\x186@\xc5\xe9\x1aD(\x83\x93\x87\xf3irS\x15\xb8\x9b<\x08\xca\xcf\x9b\xda')

{'A1': 38050,
 'A2': 25,
 'A3': {'B1': 'js',
        'B2': 9365624785237442664,
        'B3': [{'C1': -91,
                'C2': 1216491063,
                'C3': 44,
                'C4': -0.13097268342971802,
                'C5': 64711},
               {'C1': 81,
                'C2': 207751484,
                'C3': 241,
                'C4': 0.5618962645530701,
                'C5': 29576},
               {'C1': -53,
                'C2': 2201197805,
                'C3': 94,
                'C4': 0.06400661915540695,
                'C5': 6064}],
        'B4': 42,
        'B5': 18818,
        'B6': 2982},
 'A4': 'ryxm',
 'A5': [1744653124416193576, -8965672953648622827, -5144452140880651302],
 'A6': {'D1': -0.5660985708236694,
        'D2': [6943, 10075, -22680, -7051, 30678, 22973, -9289, -28789]},
 'A7': 1825523646591964547}

Вариант №14

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

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

(b'ETRF\x00$\x00G\x1eT\xf1\x00\x03\x00\x00\x00b\r\xff\x8be\xe5\xf8\xa0'
 b'I[\x83\x12\xbbP\x80\x1d\xa3r\xaa/\xffp\xbf4d\x82\xbf\x00q\xf0\x00\x03'
 b'\x00\x00\x00\x19\xbbW\x8aiN\x9f\xd1\x00\x05\x00\x1f\xbe\xbfz\x95\xfa'
 b'\x01\xady\xe9Q\xbe\xb7\x8c\xe9?\x0bR\xba\x00\x03\x00\x00\x00?\xb5<\x0by\x92'
 b'\xcd\x1e\x00\x02\x00E\xe3n.O\x9e\xb8(\x9el\xa4<\x1d\xfb\xa1\xfc\x95\xabv'
 b'\\\xc5\xcbL\xbbB')

{'A1': {'B1': [{'C1': 65392,
                'C2': -0.7046586275100708,
                'C3': -0.5017385482788086,
                'C4': [23427, 4795, 20608],
                'C5': -69,
                'C6': 22410,
                'C7': {'D1': 1766760401, 'D2': [29, 163, 114, 170, 47]}},
               {'C1': 59729,
                'C2': -0.35849693417549133,
                'C3': 0.5442310571670532,
                'C4': [48831, 31381, 64001],
                'C5': -75,
                'C6': 15371,
                'C7': {'D1': 2039663902, 'D2': [173, 121]}}],
        'B2': 30,
        'B3': 21745,
        'B4': [-2058657060161574754,
               7828448151750179989,
               -6091579441382900926]},
 'A2': 1008678111320514633}

(b'ETRF\x00%\x00L\xdc\xda\xf4\x00\x03\x00\x00\x00g[\xaamM^\xc1H\xb8\x93\xc5$'
 b'\xf7~\x01j\x95\xd2\x057\xffn\xfd?\x0c9\x1a\xbdW\x06\x1a\x00\x03\x00\x00\x00'
 b'\x19\x80\x01\xac@\xc6P\x08\x00\x06\x00\x1fw\xab\x98\x82b\xd5\xdd\x92'
 b'\xa5\xea\xd4M\xb8\xe9<\x84\xd3\xbb?r\xebr\x00\x05\x00\x00\x00@8\x83\xb3\xb7'
 b"\xc8H!\x00\x02\x00J\x9c\xe9\xf1[\x87\x07i\x7fQ\xeb'\x1b\xfd\x8d\xecl\xeb"
 b'\x8bL\x87\x0b\x9c\xdeW')

{'A1': {'B1': [{'C1': 28413,
                'C2': 0.5477463006973267,
                'C3': -0.0524960532784462,
                'C4': [37829, 9463, 32257],
                'C5': -128,
                'C6': 428,
                'C7': {'D1': 1086738440, 'D2': [106, 149, 210, 5, 55, 255]}},
               {'C1': 47337,
                'C2': 0.016214242205023766,
                'C3': 0.9489051103591919,
                'C4': [30635, 39042, 25301, 56722, 42474],
                'C5': 56,
                'C6': 33715,
                'C7': {'D1': 3083356193, 'D2': [212, 77]}}],
        'B2': 220,
        'B3': 56052,
        'B4': [-7139910358809482881,
               5902854737770703980,
               -1474000310134579625]},
 'A2': 6605211982561888440}

Вариант №15

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

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

(b'BJCE\x15\xaa\xff\xe1\xb9\xbfH\xf2\x18\xbf\xc18q\xa4N|8\x00\x00\x00'
 b'\x02\x00[\x00\x00\x00_Z%\xbd\xf1\xb8\x86C\x1c\xb6\xb4f\xbe\xc8\xb5\xfel\xc3'
 b"y\xf5YN\xf3,=H'b\xf1\xa5\x06\x99\xf6\xbc\x00)\xd5?X\xaceR\xee[\xd0\xbe"
 b"\x90\\5A\xdc\xa85\x05$2r\xdf\xfb\x00B\x008\x00Q*\xfd\xdb\xdeu\x10\r\x13'"
 b'f\xc8c\xeb\xfcU\\')

{'A1': -1426071111,
 'A2': -0.7849440574645996,
 'A3': -0.13453503153593416,
 'A4': [{'B1': [10082, -3675, 1689, -2372],
         'B2': {'C1': 102,
                'C2': -0.3920134902000427,
                'C3': [108, -61, 121, -11, 89, 78],
                'C4': 4079762760}},
        {'B1': [-22475, 1316, 12914, -8197],
         'B2': {'C1': 213,
                'C2': 0.8463805317878723,
                'C3': [82, -18, 91, -48, -66, -112],
                'C4': 1546994140}}],
 'A5': {'D1': [721279966, 1963986195, 661047395], 'D2': 3959182684},
 'A6': 1512422897,
 'A7': [47238, 17180, 46772]}

(b'BJCE\x15\xba"\x90\x98?\x11\x1f]\xbf\xe8.\x9c\xd7\xde\xb2p\x00\x00\x00'
 b'\x02\x00[\x00\x00\x00_\xff\x1c\x17eY\xa8y\xc82\t[\xbeB\xa2\xf0\xa6\x8d'
 b'l\xf8\xde\xee\xa5.d\xda\xe3WWj\xc7H\xb4y\x00)4>\x98\x15X46T\xf8\xa7'
 b'\x87\x96\xe4;\xc6\xc1m\x12\xc9p\xe5\x8cr\x00B\x008\x00Q\xb0D[\xdcGqr\xa2\xbf'
 b'\x04\x98\xfbm\x19\x01\xe2')

{'A1': -1172139880,
 'A2': 0.5668848156929016,
 'A3': -0.7556900230607209,
 'A4': [{'B1': [-7337, 22378, -14520, -19335],
         'B2': {'C1': 91,
                'C2': -0.19007468223571777,
                'C3': [-90, -115, 108, -8, -34, -18],
                'C4': 2771281114}},
        {'B1': [-16019, 4809, 28901, -29582],
         'B2': {'C1': 52,
                'C2': 0.29703783988952637,
                'C3': [52, 54, 84, -8, -89, -121],
                'C4': 2531539910}}],
 'A5': {'D1': [2957269980, 1198617250, 3204749563], 'D2': 1830355426},
 'A6': 4280031077,
 'A7': [22952, 31176, 12809]}

Вариант №16

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

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

(b'\x04AHDM=\x02\x00\x86\x00\x00\x00\xb22\x9b\xf1\x98Qwnhjsp\xfb!\xb3{p\xff+}'
 b'\xddlP\xeaE\x1f\x1b\x99\xbe\xed\xfed=mm\xe3*I\x94JA\xf2n\x914\xd8$\xe2'
 b'\x02\x00\x92\x00\x00\x00@\x03Q\xefO\x81\x82Q\\\xc8\x7fn\xda\xf0\x9c 6\xb0'
 b'Y\x18\xf7\xec\xbc\x88$\xbf\xcf\x14\n\x9f{l\x9ebv\xcd\xf9D&R\xd3\x9e'
 b"\xda\x15\xbdv\\\xf7t\xd6_\x1c\xfd\xeb&\xa1%\x93GM\xbc\x9f\x03'\x10\xb3"
 b'\xe8\xbf\xab~^\x82!!\x12\xd7\xb7Un\xbd\xa9=\xba\x00')

{'A1': 61,
 'A2': {'B1': {'C1': [{'D1': 32427, 'D2': 555844190},
                      {'D1': -10478, 'D2': -1116842569}],
               'C2': -241487182,
               'C3': 20888},
        'B2': 'wnhjs',
        'B3': [3170376339280755568,
               1954357635976060285,
               7885026026578624153,
               7994524077107260131],
        'B4': 13457},
 'A3': 9432,
 'A4': 226,
 'A5': {'E1': [15785, 186],
        'E2': -279903424,
        'E3': [7962302965044379983,
               1754627276359397594,
               1499627364571475191,
               -3641614816118071542,
               1574745650172937465,
               2044588553704076989,
               5568581254093663229]},
 'A6': -0.7718582880015599}

(b'\x04AHDM\xa9\x02\x00\x86\x00\x00\x00iIs\xd8} gmelp\x13d\x0c\x06\x01'
 b'\x9a\xd0\xe9Z\x98\xf6r\xaa=\r-\x97\xadH\x88\xb7:\x08\xee\xcd\x0f\xa8\xc1^'
 b'\x92\x13$(8\x93\xb4\xd0\x08\x00\x92\x00\x00\x00\xc1\xf6\xa5\xef\xf5)'
 b'\x9d\xfak]\xb9\x1b\x96\xc8b\xa3U\x91\x96@\x83\xa7\xb6\xf2P\xa4C\xf5\x18\x1d'
 b'Y\xe0\x1b\n\xe0Ii8|b0An\xbe\xacy\xcc\xb1\x13a\x8b\x98V(\x1a\xa5f\xce\\O\xc4&'
 b'\xe1\x05%\x00\xdf\xbf*\x0f]3\xd5\r\x8e\x0cA4\xa5\x87\xe7\x1b\xe3\xd4\x9a6'
 b'\xe0\xea\xf4\x8b*6\xc7\x92\x84z')

{'A1': -87,
 'A2': {'B1': {'C1': [{'D1': 3882, 'D2': 232076125},
                      {'D1': 3214, 'D2': -2019216319}],
               'C2': -663533207,
               'C3': 8317},
        'B2': 'gmelp',
        'B3': [16848135535180145683,
               3246318708686493786,
               17152023740780424599,
               2599582345596506061],
        'B4': 14376},
 'A3': 46227,
 'A4': 208,
 'A5': {'E1': [7143, -11037, 13978, -5408, -29708, 13866, -27961, 31364],
        'E2': -274336063,
        'E3': [1997730628063013365,
               4654067061933394070,
               -773594043401197693,
               5323265874396257560,
               -4724767282998527895,
               -7454758020966483540,
               5718672567105628246]},
 'A6': -0.48438382696313576}

Вариант №17

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

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

(b'WKRr\x90\x00\x00\x00\xb7\xaf\x1d\xa8y\xd1\x1f\x80\x00\x00\x95YV\xc8>H'
 b'\xe8\xca\xed?p\x8f\xe9\x0bUT\xbb\xbf\x80I}\x97\x1c\x18\xba\xbfr\x87\x95>'
 b'\x8e\t\x03\x00\x14\x00\x00\x00&\xfd\xb8\xbe3\x10\xe7e\x8a\xd3M\xa8\xc4x\xae='
 b'\x02\x80\xe3\x1a\xe6\xbfT\xb9\xe5\xa9Sj\xe4?P{\xc3\xc3\xa3+\xdd?\xd7:c?-\xbb'
 b'\x03\x00F\x00\x00\x00?\r4\xbf\xbf)\xefb\xeb\xad\xbe\xfb\xb8O,\x00\x00\x00'
 b'^\x00\x00\x00\xcdF[>\xad\xa0.\xbf\xb4\xdb\x00?\x84\xfdB7ntkuqek\xed'
 b'\x8a\xd2\xd1\xac\x02\x00x\x00\x86W\x94\xd3>-\xc8\x9c\x03\x00\x80\x00'
 b'\x00\x00\x02\x00\x00\x00\x8c\x00\xee\xe32\x90\x00\x1e\x15\xe3')

{'A1': {'B1': 'ntkuqek',
        'B2': -19,
        'B3': 2899432074,
        'B4': [{'C1': 0.29204899072647095,
                'C2': 2446,
                'C3': [0.9310189639129571,
                       -0.10675555744961485,
                       -0.10193041513892886],
                'C4': -0.361306369304657,
                'C5': -6319162110762348493,
                'C6': -60,
                'C7': 120},
               {'C1': 0.8876165747642517,
                'C2': -17619,
                'C3': [-0.6907823085947962,
                       0.6379793470676227,
                       0.45578855626620385],
                'C4': -0.7033271193504333,
                'C5': -306616498125854273,
                'C6': -72,
                'C7': 79}],
        'B5': 134,
        'B6': {'D1': 0.41324111819267273,
               'D2': -14291,
               'D3': 156,
               'D4': [0.2141372710466385,
                      -0.6821392178535461,
                      0.5033524036407471],
               'D5': [64900, 14146],
               'D6': 58350,
               'D7': 503353394},
        'B7': 58133},
 'A2': -1474449481,
 'A3': 6455065643055042937}

(b"WKRr\x8e\x00\x00\x00\xa8q\x97D+ye\x8f\xc63\xcbq.\xf2\x1a)\xc9'\xea?\x1cw)e"
 b'\x8e\t\xdc\xbfHZ\x1b\x89\xbe)\xe5\xbf\xd2\x05\x1a\xbf\x9e\xad\x03\x00'
 b'\x14\x00\x00\x00\xa6\xc3\xfa=\xf8\xdf\xf56\xf7\xbb\xeden{\xe8<'
 b'\xda\xf9\x9a\xfa\xcb?\xa0s\xacu\t\x9b\xb8?\n\x1f\x82\xe8@m\xed?HvR>\x86<'
 b'\x03\x00F\x00\x00\x00\r!\xff\xbe\x82\xe2\xb1\xdft6Ai\xd5j,\x00\x00\x00'
 b'^\x00\x00\x00\x85\xa7\x04?\x81\xea\xab\xbes\xa1\xb0\xb9\x14\xd1judycupz\xb6o'
 b'^\xbf\x02\x00x\x006\x04\xd5\x11>\xeb^@\x02\x00\x80\x00\x00\x00'
 b'\x03\x00\x00\x00\x88\x00h+\x98\xf62\xa7\xecM')

{'A1': {'B1': 'judycup',
        'B2': 122,
        'B3': 3210637238,
        'B4': [{'C1': -0.6016513109207153,
                'C2': -21090,
                'C3': [0.817356663020808,
                       -0.43808326605891224,
                       -0.6613457372539608],
                'C4': 0.12244348227977753,
                'C5': 7344733237764546552,
                'C6': 110,
                'C7': 123},
               {'C1': 0.2055293321609497,
                'C2': 15494,
                'C3': [0.21858536910847381,
                       0.09611567614451966,
                       0.9195866147210563],
                'C4': -0.4982990324497223,
                'C5': 7584403123065709186,
                'C6': -43,
                'C7': 106}],
        'B5': 54,
        'B6': {'D1': 0.1424141526222229,
               'D2': 24299,
               'D3': 64,
               'D4': [0.5181811451911926, -0.3357734978199005],
               'D5': [41331, 47536, 53524],
               'D6': 11112,
               'D7': 2805135000},
        'B7': 19948},
 'A2': 1150775720,
 'A3': 8199704474460453163}

Вариант №18

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

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

(b'JCAU2\x00x\x95\xddDV\xbf\xe9\xa1\x1f\x92\xa6\xab\x9eQ2v\x05\xca\xbavR\xf7'
 b'E\xbf\xe5\xf2\x7f\x05\xa0\xe1\x94N"\x86\x96eP\x99\tL\xbc\xbf\xd6\xfb\x04?'
 b'\xd4F\xa0\xe6\xdd\xb7Rw\xf0\x9b\xe1\x0cO\xbf\xbenu_\xc6\\\x00\xe5\xba\xef'
 b'<E\xd4\x03\xb0G*?\xdeb\xdc\xffa\xec`\x13,\x9c\xa3\xbe~\xdd\xe5\x00'
 b'\t\x00\x1b\x00-\x00?\x00Q\xd9F\x90\xbd.\xaa\xfa\x890\\G\x00\x00\x00\x05'
 b'\x00c\xbe(\xb6)\x0c\xd7\x16F\x8a\xe6\x08H\x00\x00\x00\x07\x00m\x9e\xd1_\x89'
 b'u\x00\x00\x00\x04\x00t')

{'A1': {'B1': [{'C1': 17494,
                'C2': -0.8009183754232827,
                'C3': [20786, 30213, -13638, 30290]},
               {'C1': -2235,
                'C2': -0.6858515844278821,
                'C3': [20002, -31082, 25936, -26359]},
               {'C1': 19644,
                'C2': -0.35907083733864376,
                'C3': [-6435, -18606, 30704, -25631]},
               {'C1': 3151,
                'C2': -0.11887296283963167,
                'C3': [-6726, -4292, 17876, 944]},
               {'C1': 18218,
                'C2': 0.4747841352434019,
                'C3': [4908, -25437, -16770, -8731]}],
        'B2': -0.1647573858499527,
        'B3': {'D1': 215422534,
               'D2': 35558,
               'D3': 2120,
               'D4': [-39, 70, -112, -67, 46, -86, -6],
               'D5': -24879,
               'D6': 24457},
        'B4': 117,
        'B5': [137, 48, 92, 71]},
 'A2': -27171}

(b'JCAU2\x00K\x1eY\x8cP\xbf\xdaxY=\x86\\\xfc\xb5\xc9\xd2\xacZN\x01^)'
 b'\xc4\xbf\xca\xc1\xb6y\x10\x90\x88\xcd\x85Gh\x89kjU\x86:?\xef\xf4\x17\xcf'
 b'\xc4s\xf6\xdda\xd9<\t\x83Pg\x00\t\x00\x1b\x00-\x07\x8d<4\x80\n\x00'
 b'\x00\x00\x03\x00??[:>n\x82i\xdcb\xb9z\x9a\x00\x00\x00\x04\x00E\xea\x0b\x0epY'
 b'\x00\x00\x00\x02\x00I')

{'A1': {'B1': [{'C1': -29616,
                'C2': -0.41359549530302764,
                'C3': [-18999, -11604, 23118, 350]},
               {'C1': 10692,
                'C2': -0.2090366450439698,
                'C3': [-12923, 18280, -30357, 27221]},
               {'C1': -31174,
                'C2': 0.9985465105015681,
                'C3': [-8863, -9924, 2435, 20583]}],
        'B2': 0.8563574552536011,
        'B3': {'D1': 1854040540,
               'D2': 25273,
               'D3': 31386,
               'D4': [7, -115, 60, 52],
               'D5': -5621,
               'D6': 3696},
        'B4': 89,
        'B5': [128, 10]},
 'A2': 7769}

Вариант №19

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

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

(b'VFXY\x81\xadMX?\r\xf3j\xc1\x9a\x1e&s\xbf`\x92o\xe4\x9b\x06\xda\xd2iK'
 b'\xa9kR\x00\x00\x00r\x00\x00\x00\xb6\x16\x00,,G?S\x9e\x8c\xf3\x00\x9fc'
 b'e\xb9\x85\x9c\x93?{&v\xe9p\xd7\xa6A\xcc\x95\x7f\x00\x00\x00x\xcb\xdf/'
 b'\xd9H\xc1\x99nP\x02\x00H\x00\xfa\x04\x00\x00\x00J\x00\xc6\xf2B4\xf2?\x02'
 b'\x15\xd0nP\xb3\xf7#\xee\xaf"\xca\x9fS\x95\x05\x00_\x00f\x07\x00\x00\x00d'
 b'\x00\xd7@\xa2{5\xb0^\xe640\x95')

{'A1': -21119,
 'A2': 11151311744477911117,
 'A3': -0.9498003721237183,
 'A4': {'B1': -3253280514199547296,
        'B2': 1806257001,
        'B3': {'C1': [{'D1': [120, -53],
                       'D2': 250,
                       'D3': [12255, 18649, -26175, 20590],
                       'D4': 62150},
                      {'D1': [66, 52, -14, 63, 2],
                       'D2': 102,
                       'D3': [-12267,
                              20590,
                              -2125,
                              -4573,
                              8879,
                              -24630,
                              -27309],
                       'D4': 16599}],
               'C2': 738203318},
        'B4': 18220,
        'B5': [2359186239,
               1671364851,
               2626009445,
               645611411,
               3614501238,
               2513191334]},
 'A5': {'E1': [-94, 123, 53, -80, 94, -26, 52, 48], 'E2': -107}}

(b'VFXY\x97\x1b)w\x87\xa6\xc7m/\x81Na\x81>\xc2\xce\x06\xe5\t\xb8\xa20\xad@'
 b'\xc9+U\x00\x00\x00s\x00\x00\x00ZE\xb2\xe3\xf6#\xbc:\x82"U]}\xcaQ!K\xbd'
 b'\x84\xb0[\x03u}cBU!\xc1\xa4\x80\x00\x00\x00\xba\xcf\xcb\xaa\x12\xf9\xeb<'
 b'L6\xafMQ\x05\x00H\x00\x03\x04\x00\x00\x00M\x00_Q\xa8_\xf2\x00t\x86'
 b'\xd3\xa2\x1c\x00n\xf0\xd9D\x0f\x05\xbc\x05\x00b\x00i\x06\x00\x00\x00'
 b'g\x00\xaf\xe3\xb3\xda\x00\xadE\xe8Gu3')

{'A1': 7063,
 'A2': 9308779659057919785,
 'A3': 0.2526955008506775,
 'A4': {'B1': 3504565812684312258,
        'B2': 734609581,
        'B3': {'C1': [{'D1': [-70, -49, -53, -86, 18],
                       'D2': 3,
                       'D3': [-5127, 19516, -20682, 20813],
                       'D4': 20831},
                      {'D1': [-88, 95, -14, 0, 116],
                       'D2': 105,
                       'D3': [-11386, 7330, 28160, -9744, 3908, -17403],
                       'D4': 58287}],
               'C2': 3820111194},
        'B4': 9206,
        'B5': [578960060,
               3397213525,
               3175817553,
               56340612,
               1113816437,
               2764120405]},
 'A5': {'E1': [-77, -38, 0, -83, 69, -24, 71, 117], 'E2': 51}}

Вариант №20

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

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

(b'CHVWJA)\x00\x00\x002\x00\x00\x00;\x00\x00\x00D\x00m\x00\x00\x00L\x8d\x91\xe2'
 b'\x13E\xd3?~c\xde\x11\x10\x7fz\x98\x1bifykq\xe9\xb9\x9d\x0bkuswd\x1d'
 b'\xb5\xcc\xb8jfrpcBsbXl\xb4_\xb0]P\xf3\x15G\xd2o\n]\x91u\xceu\tv\xcd'
 b'\x03\x08n\xd7\x10\xaa\x1c\xc0\xbfU\x9a\x9b\x05\x7f\x10>\xe6o\xe6\xd1'
 b"\xe2\x1c\xc0Ol\xa4(h\xbat\xddi\x8c\xd6LK\x1e\xbfjs4\xa1\xcd1|'19"
 b'>\xe4\xd5\xbf\x03\x00\x00\x00a\x00')

{'A1': 65,
 'A2': [{'B1': 'ifykq', 'B2': -23, 'B3': -71, 'B4': 2973},
        {'B1': 'kuswd', 'B2': 29, 'B3': -75, 'B4': 47308},
        {'B1': 'jfrpc', 'B2': 66, 'B3': 115, 'B4': 22626}],
 'A3': {'C1': -1335905172,
        'C2': 368267357,
        'C3': 53831,
        'C4': 111,
        'C5': 23818,
        'C6': 274004935342716305,
        'C7': -0.12587476560916877},
 'A4': {'D1': [1817165852, 3127388324, 2355748212],
        'D2': -42,
        'D3': -0.6183364391326904,
        'D4': [106, 115, 52, -95, -51, 49],
        'D5': -0.3420558508411131,
        'D6': [94083669, 3862827135, 3805406831]},
 'A5': 0.30109116674266967,
 'A6': 126,
 'A7': 1988473921633115747}

(b'CHVWJ\xaa)\x00\x00\x002\x00\x00\x00;\x00\x00\x00D\x00q\x00\x00\x00 \xc5\x9aq'
 b'B$\xe8?2\xde\xa6\x00\x83+O\x08\xa6epqis\xc0\x8d\xccUtaryu \xc8y\xbbijbdh'
 b'\xb4$\x03o4%\x89{\x1c\x9e\xec\x8c\x07\xa3\x82@@\xd5\xbf"\xd4\xed\xf0\xcd'
 b'XT\xdfT\x8bD|\xd7?y\xd6}\x1fa\xfd\xcb\xa3\xbc\xfa\x0ba5Z\xda?\nj\x95'
 b"\xa5\x0bl\x03\x05R\xf3\xb9\x8bi\xcf'*\xbf3Zfu\xabH\xf8 VA~L\xe5?"
 b'\x04\x00\x00\x00a\x00')

{'A1': 170,
 'A2': [{'B1': 'epqis', 'B2': -64, 'B3': -115, 'B4': 21964},
        {'B1': 'taryu', 'B2': 32, 'B3': -56, 'B4': 47993},
        {'B1': 'ijbdh', 'B2': -76, 'B3': 36, 'B4': 28419}],
 'A3': {'C1': 2072585524,
        'C2': -1930650084,
        'C3': 41735,
        'C4': -126,
        'C5': 16448,
        'C6': 6399035549820305365,
        'C7': 0.3669597016009807},
 'A4': {'D1': [2778032650, 84110347, 2344219474],
        'D2': 105,
        'D3': -0.664669930934906,
        'D4': [51, 90, 102, 117, -85, 72],
        'D5': 0.6655875469305377,
        'D6': [528340601, 2748054881, 1628175036, 1071274549]},
 'A5': 0.7544262141074434,
 'A6': 50,
 'A7': -6482844615299782946}

Вариант №21

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

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

(b'\xddFVEO{o6%?f\xa1\xb1Aosxej\x00\x07\x00L3\xe0\xeb\xa3\x8a\xff\xa71\x99'
 b'\xba\x97\xe8\xc9\xc4Uv\xd4\xbc\x8d?\x8bdO;\xd8\xaay\xff\xe0r\xa7\xa4M'
 b",\xf4\x83\x0f\x1d\xfe(\xa1\xa1Nzj:\xbcP\xc6('\xaaDhgswyku")

{'A1': {'B1': 2070885925, 'B2': 0.9009047150611877, 'B3': 65, 'B4': 'osxej'},
 'A2': 'hgswyku',
 'A3': 3738246778361718577,
 'A4': [{'C1': 39354, 'C2': 38888, 'C3': 201},
        {'C1': 50261, 'C2': 30420, 'C3': 188},
        {'C1': 36159, 'C2': 35684, 'C3': 79},
        {'C1': 15320, 'C2': 43641, 'C3': 255}],
 'A5': {'D1': -32,
        'D2': 8261752692808123151,
        'D3': 7678,
        'D4': [40, 161, 161, 78],
        'D5': 31338,
        'D6': 4232346561828858436}}

(b'\xddFVEO\xecg\xb5\xeb>\xf5\xe2\xcd\xe4sjkyi\x00\x03\x00L\x84\x1a\xbao\xb4'
 b'J\x00\xc4\xfc\x92\x18Q4;n\xaa\xc5\x89\xaa\xf0y7a\x8e\xea\x17vz\xc0\xb5X-\xaa'
 b'\xc2\x15\xbd\xdco\xb2\xef\xdbw\xa9\xd3f\x96\xe3\x83\x91\xf50\xa9\xb9fck')

{'A1': {'B1': 3966219755, 'B2': 0.480245977640152, 'B3': 228, 'B4': 'sjkyi'},
 'A2': 'fck',
 'A3': -8927618322379702076,
 'A4': [{'C1': 64658, 'C2': 6225, 'C3': 52},
        {'C1': 15214, 'C2': 43717, 'C3': 137},
        {'C1': 43760, 'C2': 31031, 'C3': 97},
        {'C1': 36586, 'C2': 6006, 'C3': 122}],
 'A5': {'D1': -64,
        'D2': -5379499543470162468,
        'D3': 28594,
        'D4': [239, 219, 119, 169],
        'D5': -11418,
        'D6': 10872678588309612985}}

Вариант №22

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

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

(b'DVWQ$?\xe4y\x97\x81\x07\x08\xc0\x00\x00\x00k.d\x00\x00\x00\x02\x00'
 b'{\x00\x00\x00\x02\x00\x7f\xe35\x9f\xa5\x8dK\xea\xb4\xa3A\x1f#\xa7>~\x90\x88'
 b'.#\xa4\xdd;\xd9\xfb\x8c\xf8YC6\x84DZ\xbe\x9e\xb5>Fp\x18\x0b`\x14\r\x13('
 b'\xc6J\x97\x03 \x8c\x9e_J\xa5zk\x00*\xffC\x9d\xbc\xac\xf9\x8c\xbb\x02\x98'
 b'\xf0\xa0\x06\xba\xe9\x86j\x8c\xeb0T\x00\x00\x00,\x00\x00\x00A\x00\x00\x00Vw'
 b'\x92\xfa\xf9\xac\xbc\x1d&')

{'A1': 0.6398427505557933,
 'A2': {'B1': {'C1': 2364223572,
               'C2': [{'D1': 1048481928,
                       'D2': 46,
                       'D3': [9124,
                              -8901,
                              -9733,
                              -29448,
                              22851,
                              13956,
                              17498,
                              -16738]},
                      {'D1': -1254209936,
                       'D2': 24,
                       'D3': [2912,
                              5133,
                              4904,
                              -14774,
                              -26877,
                              8332,
                              -24993,
                              19109]},
                      {'D1': 2053832746,
                       'D2': -1,
                       'D3': [17309,
                              -17236,
                              -1652,
                              -17662,
                              -26384,
                              -24570,
                              -17687,
                              -31126]}]},
        'B2': 11876,
        'B3': [30610, -1287],
        'B4': [-21316, 7462],
        'B5': 3811942309,
        'B6': 2370562740},
 'A3': -23743,
 'A4': 7971,
 'A5': 167}

(b'DVWQ$?\xe8j\x02\x16\r,\xd8\x00\x00\x00k\x95~\x00\x00\x00\x02\x00'
 b'{\x00\x00\x00\x03\x00\x7f)0\xf5\xe1\x88`\x93\x8f1\xde\x11\xa9\r\xf8\xf0h\x8c'
 b'\xf7J[\xffm\xa6Okj\x9c\r\x89\xc1\xed\xc7z\x05\xf0\xf4\x038\xe0"\xf8'
 b'\xad\xc92R\xa1\x05\xf8\xc7\xed\xd4\xbdb\xfe\x0fS\xde\xf8\xf1\x9f#'
 b't\x07\xf7\xe4\xa0q\x97\x92\x1f\x10\x05|\x8a\x90B(\xb8\xfb\xca\x00'
 b'\x00\x00,\x00\x00\x00A\x00\x00\x00V\xc5\xfc\xc96Gv0"\x91\x86')

{'A1': 0.7629404478733717,
 'A2': {'B1': {'C1': 683211722,
               'C2': [{'D1': -118462324,
                       'D2': -9,
                       'D3': [19035,
                              -147,
                              -22961,
                              27498,
                              -25587,
                              -30271,
                              -4665,
                              31237]},
                      {'D1': -252443848,
                       'D2': -32,
                       'D3': [8952,
                              -21047,
                              12882,
                              -24315,
                              -1849,
                              -4652,
                              -17054,
                              -497]},
                      {'D1': 1407121649,
                       'D2': -97,
                       'D3': [9076,
                              2039,
                              -7008,
                              29079,
                              -28129,
                              4101,
                              31882,
                              -28606]}]},
        'B2': -27266,
        'B3': [-14852, -14026],
        'B4': [18294, 12322, -28282],
        'B5': 691074529,
        'B6': 2288030607},
 'A3': 12766,
 'A4': 4521,
 'A5': 13}

Вариант №23

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

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

(b'BVKK?\xd7\xeb\xb5B\xc5\xc30\xec\x1cdklm?K\x8f\xa9\x00\x00\x00@\x00\x00'
 b'\x00^\x00\x00\x00tM\xa4\x00\x00\x00\x08\x00\x00\x00\x83K\xbf%\x9b'
 b"\x03\xa7\x17 \xa6?\x80\x9d'\xff\xdc\xbc>\xfd\xaa5\xbf\xe0\x8b\xc1"
 b'\x80\x01\xea\xa4\x00\x00\x00\x04\x008?\xd4m\x06\xd8\xd0\x7f\x8c\xb0\xd3'
 b'G+\x9b\xb1\xfb\xa9\xbf\xe4\xb3&\xc0\xc2\xd7N\x00\x00\x00\x04\x00V?\xd9E\x0c'
 b',\xcby\x18\x98\x8a"$\xfa\xa4\x1b\x91\x9c\xaaC5\x07~\xba\xbe\x07@!ZE\xff\xb2L'
 b'\xde\xea!\xb7T\xb9-C\x03\x90\xe2l\xab\xa0\xfa=\x03\xdd\xcaD\xbdk\xbf\x10'
 b'\x8c\x0f\x02\x87\xea\xce=?\xda\xd3ki\xb9\xfe\xec\xc1\x92K\xfa\xddb D\x03'
 b'\xa2\xc0e\x17-\x18\xa4')

{'A1': 0.3737614776683129,
 'A2': -5092,
 'A3': 'dklm',
 'A4': 0.7951608300209045,
 'A5': {'B1': [{'C1': -0.5170600414415571,
                'C2': [10239, -9028, 16125, -21963],
                'C3': 0.31915446446691287},
               {'C1': -0.6468690647950355,
                'C2': [-20269, 18219, -25679, -1111],
                'C3': 0.39483932852262305}],
        'B2': {'D1': [152, 138, 34, 36, 250],
               'D2': -92,
               'D3': 1986541165733021566,
               'D4': 186},
        'B3': 19876,
        'B4': [-4753760369673633870,
               5539122022242892077,
               4828862527631499514,
               4396601522050132927,
               1192344504891002429,
               4601222427601141484,
               -4498449536961601468,
               261983268753971364],
        'B5': 75,
        'B6': -0.6468965411186218,
        'B7': 167},
 'A6': 388015679,
 'A7': -32611}

(b'BVKK\xbf\x93sFG\xc8V\x80\xf1Xnnac\xbf\x05(\x17\x00\x00\x00<\x00\x00'
 b'\x00Z\x00\x00\x00p\xe1\xa5\x00\x00\x00\x08\x00\x00\x00\x7f\x19>\xd6o'
 b'\x84\xba{\xfd&t\xb7Wf\xdcF#?\xa4\xf6\xc9\x92+\x8a\xe0\x00\x00\x00\x02'
 b'\x008?\xea\xad*\xa5\x8c|\xcaN!1c\x14\x99\xc5\xc2\xbf\xc9\xc4\xa5^\x92'
 b')X\x00\x00\x00\x04\x00R\xbf\xe4?n\xa1\xad!<\x01\xaeY17\xbe\xcd\x8f'
 b"\xd8\x106\xcdh\xa55\x00\xad\xce\x83\xa4\x82\xae\x05;\xfc\xdb\x05\rQ'z\xb0"
 b'\xa2\x8a\xcc~\x0f\x93\x023\x838L\r\\]\x87\x18\x7f.\x110\xfe\x15\xb3\x12'
 b'\xb4\xaf\x86c#{\xd5\xe5<\xfcC\xc4\xeb\xf7\xf0\x953d\x83\x9f+\xf9\x95')

{'A1': -0.01899442494512593,
 'A2': -3752,
 'A3': 'nnac',
 'A4': -0.5201429724693298,
 'A5': {'B1': [{'C1': 0.04094533833792524,
                'C2': [26332, 17955],
                'C3': 0.8336384995817749},
               {'C1': -0.2013136588833031,
                'C2': [20001, 12643, 5273, -14910],
                'C3': -0.6327431829204566}],
        'B2': {'D1': [1, 174, 89, 49, 55],
               'D2': -66,
               'D3': 14812295263595358373,
               'D4': 53},
        'B3': -7771,
        'B4': [48922235767008773,
               4322570557113575290,
               -5718855965914197246,
               3711872417176247687,
               1765180230323803571,
               1347895180214369237,
               -1928389172424607760,
               -7695696821772093035],
        'B5': 25,
        'B6': 0.4188195466995239,
        'B7': 186},
 'A6': 2080188020,
 'A7': -18601}

Вариант №24

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

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

(b'PQMOe\x00\x00\x00i\xe7\x9c\x00\x02\x00\x8cS\xb5\xde\x0f^\xd2\xe4\x9f\xd5'
 b'\xb7E\xa0\xf9\xa6\xc4\xc1\xa9l\x00\x0f\x00\x15\x00\x1b?\xef\x01\xde\x06'
 b"\x9f'\x12\x97,\x9d\xd0\x8b\xe8\xc8\xe6\x8b]\xbd\x86\xad\x08\xb7\xb4\xbe"
 b"\xbb\x94>\xf6/?\xde\xa0M\xee\xfee$\x00' \x15\xc8a9\x91c\xee\x13\xf1*\x08\xac"
 b'\x11\xce7Pp\xc8\x97\xbear\xf3!\xdf?\xcc\xf1@\xa9\xd8\x11\xf0>\xd4n~\x18\x00r'
 b'\xce\xca\xaf\xfaj\x00\x03\x00\x00\x00!M\xf9\xf0\xa6\x00\x00\x00E\xb8'
 b'\xc58\xfc\xd0\xb1\xdf\xbfY')

{'A1': {'B1': 0.22611244481244297,
        'B2': 0.41490548849105835,
        'B3': 1729508489399630442,
        'B4': [{'C1': 1404427791, 'C2': 24274},
               {'C1': -459287113, 'C2': 17824},
               {'C1': -106511167, 'C2': -22164}],
        'B5': 1308225702,
        'B6': {'D1': 0.4785342058108475,
               'D2': {'E1': 0.9689779404954797,
                      'E2': 10893255117728434406,
                      'E3': 139,
                      'E4': [93, 189, 134, 173, 8],
                      'E5': -18508,
                      'E6': -0.36636537313461304,
                      'E7': 63023},
               'D3': 538298465,
               'D4': 14737,
               'D5': [25582, 5105, 10760, 44049, 52791, 20592, 51351],
               'D6': -0.22016505897045135,
               'D7': 8671},
        'B7': -72},
 'A2': [231, 156],
 'A3': [-986121008, -1310736551]}

(b'PQMOe\x00\x00\x00y\x97:\x00\x02\x00\x9cr\xa4\xcdu\xb2\xb4\xc8=J\x1e)h\x15'
 b'\xe5O\xe6\x7ff_\x95\xd4\x7f\xe7\xc5\x17\x93\x0c@z \x00\x0f\x00'
 b"\x15\x00\x1b\x00!\x00'\xbf\xd9\x82\xa1\x94?\x83\x04\n\x0b\x82Kz\xdd\xb1\xfaG"
 b'\xce\xb2\x95\xac\xc7\xf6\x14\xbe\xe5\xcfv\xcd\x86?\xd2gE\x1c\x84\xc6'
 b'\xb0\x007\x99\xda\xc57I\xd0\x07\xf3\xbc\xc0\xd8w\xcan\\\xdf\x1f'
 b'\xf8\xe2\x0f\xbd\xa7z\xdbs\x99\xbf\xe5\x9a\x16-]\xc1\xc0\xbe\x08T\x92Kb*'
 b'\x079\x81\x13b\x00\x05\x00\x00\x00-_\x83M;\x00\x00\x00US\xad~\xcc\xd5'
 b'\xa1\x92vq')

{'A1': {'B1': -0.675059403043683,
        'B2': -0.1331351101398468,
        'B3': 5431950311080137570,
        'B4': [{'C1': 1923403125, 'C2': -19788},
               {'C1': -935507426, 'C2': 10600},
               {'C1': 367349734, 'C2': 32614},
               {'C1': 1603654783, 'C2': -6203},
               {'C1': 395512896, 'C2': 31264}],
        'B5': 1602440507,
        'B6': {'D1': 0.2875530985357768,
               'D2': {'E1': -0.3985980937705309,
                      'E2': 723815425818604026,
                      'E3': 71,
                      'E4': [206, 178, 149, 172, 199],
                      'E5': -2540,
                      'E6': -0.4488484263420105,
                      'E7': 52614},
               'D3': 2581251383,
               'D4': 18896,
               'D5': [2035, 48320, 55415, 51822, 23775, 8184, 57871],
               'D6': -0.08177729696035385,
               'D7': 29593},
        'B7': 83},
 'A2': [151, 58],
 'A3': [-1384198955, -1584236943]}

Вариант №25

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

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

(b'MIEVW\r\x00\x00\x00Q\x00\x00\x00\x8frR\x98aek%\xed\xa3\xb7\x16\x0b\xd2]'
 b'\xf6\x9aom\xf6\x94\xad\x85\x8e\x02h\x08\x00\x00\x00\x17\x00\x00\x00\xf4'
 b'\x95IY\xb4D\xc3\xb0\xd0f\x02\x00\x00\x00/\x00\x00\x00\xea\x8fr2>\xbb\xe1'
 b'\x8a\xd6T\xa5\x86\xe9/1\xd6\xdb\x1f\x00\x00\x001\x00\x00\x00\x02\x00'
 b'\x00\x00A\x00\x03\x00\x00\x00E\x00\x00\x00\xea\xc1\x9e8\xbe\x9f\xea\xbf'
 b'\xbc\x96\x0b\xba\x13w\xec?')

{'A1': {'B1': -1739427185, 'B2': 'aek', 'B3': 37, 'B4': 41965},
 'A2': {'C1': 219,
        'C2': [{'D1': -1382746515,
                'D2': 1744998021,
                'D3': [183, 22, 11, 210, 93, 246, 154, 111]},
               {'D1': 1152670025, 'D2': 1724952771, 'D3': [244, 149]}],
        'C3': [-28694, 12914],
        'C4': [-1964917954, -2035985194, -701419543],
        'C5': -0.8319998842107996,
        'C6': 0.8895357736298233}}

(b'MIEVW\r\x00\x00\x00O\x00\x00\x00\x95\xf4\xae\x90vph\xa4\xbf@\xec'
 b'\xd3\x0f\xce6.\x7fE\x8b\xf5\xd6\x03\x00\x00\x00\x17\x00\x00\x00B\xcd'
 b'\xe9\xa7\xc7\xd4\xb3T\x90\xb9:\x03\x00\x00\x00*\x00\x00\x00\xcd6\xc5'
 b'P~\xe4\xf1\x80z\xb1\xc3\x16\xc8!\xcc\xc3q\xc6t\x1a\x00\x00\x00-\x00\x00\x00'
 b'\x03\x00\x00\x00=\x00\x03\x00\x00\x00C\x00\x00\x00p\x19\xb4\xa2<\x7f'
 b'\xbd?\x9c\x08\x00\xfe\x8fT\xdd\xbf')

{'A1': {'B1': -1867582315, 'B2': 'vph', 'B3': 164, 'B4': 16575},
 'A2': {'C1': 116,
        'C2': [{'D1': 2133735118, 'D2': -688551099, 'D3': [236, 211, 15]},
               {'D1': -1277900889, 'D2': 985239636, 'D3': [66, 205, 233]}],
        'C3': [14029, 20677, -7042],
        'C4': [-1317371663, 566761155, -965622836],
        'C5': 0.11522273037198771,
        'C6': -0.4582862835378678}}

Вариант №26

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

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

(b'dYVV\xc8\xea\x9c\x1d\xa9\x9eL6\xc3\xd2I\xd1s\x90\x97\x0c\xf7=T\x00'
 b'\x00\x00\xf0!\xe9\xdd9\x1d\x1e\xda\x9d\xed\x00\xcb\xbeF\x83\xb1B]'
 b'b\x00\x00\x00l\x00\x00\x00\x8d\xf1\x9f\x87\x80<\x98}q(\x02\x00\x00\x00v\x00'
 b'\x84\x00\x00\x00t\x80=\xa9P/o\xcc:\xceb\xc8\x8aG\xb2\xf2\x98\x85\x12\xc1'
 b'\xdf\x9c\x9eB6\xdc\xba\xf1\xe9\x9d\x85\xac5\xbf\x80\x04\\\xac\xbb`Q\xbe\xed1'
 b'\x8d\xebv"F)\xce\xbe\xa6\xa5x\xbf!\xdfK?r\x19\x93\x06\x89y\x1f\xa5'
 b'\xdc\x03\x00x\x00\x00\x00\x8co')

{'A1': 496822984,
 'A2': 910991017,
 'A3': 907352677045359299,
 'A4': {'B1': 15863,
        'B2': {'C1': -4534414982855374966, 'C2': -25377, 'C3': -600423778},
        'B3': 8688,
        'B4': {'D1': 17122081181206699497,
               'D2': 6720128771375942400,
               'D3': [{'E1': 2649354682, 'E2': 44165, 'E3': 75546421},
                      {'E1': 1622912092, 'E2': 48721, 'E3': 3951899117}],
               'D4': -3699,
               'D5': {'F1': 159,
                      'F2': 135,
                      'F3': 15488,
                      'F4': 678526360,
                      'F5': [118, 34]}}},
 'A5': {'G1': {'H1': 114,
               'H2': 15899148666351817497,
               'H3': [-0.4026586413383484,
                      -0.9712775945663452,
                      0.7963734269142151],
               'H4': 140,
               'H5': 111},
        'G2': -3715699144074100620,
        'G3': [-12742, -14238]}}

(b'dYVV\x14\x1e\x82\xac\x05\xd7,R\xba\xc7re\xa4\x08I\x0b\xd8\xaaT\x00'
 b'\x00\x00\xf5\xf5R\xdc5\x02j\xab?\x96\x9a\xd4\xab8|t\x05\xc9b\x00\x00\x00'
 b'l\x00\x00\x00\x12\x07\xc0\xe1u\xb5}\x02\xd5\x91\x02\x00\x00\x00v\x00'
 b'\x8c\x00\x00\x00W2\xad\xc6\x0c7*k`\x91~\xb3\xeaf\xb1\xcdy@~\xc5*9u\xfd'
 b'\x81\x0c\xaa\x85\x9c\xac\xd7R\xabi\xa9t\xbfyzn?\x8c\xfay7\xc1\xa6('
 b'\x00`\xac\xbej\x99\x92\xbe\xe5#\xf4<\x8e\xc1\xb5>-G5>\x1c\x0b\xbe\x91'
 b'\x1f\xa2\x84\x10\xab\x05\x00x\x00\x00\x00\xb4<')

{'A1': -1400758764,
 'A2': 1378670341,
 'A3': 813190709886764986,
 'A4': {'B1': 43736,
        'B2': {'C1': -4215861309286029590, 'C2': 14634, 'C3': 209845621},
        'B3': -2571,
        'B4': {'D1': 10826560501013929042,
               'D2': -3961632220326931302,
               'D3': [{'E1': 2895938986, 'E2': 21207, 'E3': 1957259691},
                      {'E1': 1853520319, 'E2': 35903, 'E3': 3241638394}],
               'D4': 1810,
               'D5': {'F1': 192,
                      'F2': 225,
                      'F3': 46453,
                      'F4': 2446656125,
                      'F5': [-90, 40]}}},
 'A5': {'G1': {'H1': 28,
               'H2': 12326498011962261003,
               'H3': [-0.336669921875,
                      -0.28632670640945435,
                      0.029802272096276283,
                      0.3549923300743103,
                      0.1770293265581131],
               'H4': 180,
               'H5': 60},
        'G2': 7722045039092511319,
        'G3': [-28320, -19586]}}

Вариант №27

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

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

(b'ZLY\x00\x00\x00\x1bua\xb1\xb9\x008\x00F\x00T\x00b\x00\x00\x00lsu\xda\xb4\x8f'
 b'5\xadD4\xbf\xef\x11\x80\n\x85v\xac^\xd7\xa8_\x15XN\x88\xc8\xd1\xd4\x82'
 b'\x92\x88\xd7>\x00\x00\x00\x02\x004%Z<\x06f\x17\xdfn\x00\x00\x00\x02\x00B'
 b'\xde\xd2\xf7\x03\xc5\xa8=\xc0\x00\x00\x00\x02\x00P?c\x02\x85\xab\xef'
 b'\x8aI\x00\x00\x00\x02\x00^i\xd5\xda\x7f\x7f\x7f\xa2\xee\x8d\xe4\xc3!'
 b"\xfe\xfd?X\x93\xbf\xbdF\xea'?nn\xfc?3\x93\xe8\xbfH\xfc\xd3\xbe\xb4"
 b'\x05\x0b\xbf\x0f\x00\xaaY@\x02_\xf5\xe8(\x90{\x8aEq\xe9L\x1e')

{'A1': {'B1': -1892307644,
        'B2': 52,
        'B3': -0.9708862500662767,
        'B4': 94,
        'B5': -41,
        'B6': -6314304683531253551,
        'B7': -11134},
 'A2': 1969336761,
 'A3': {'C1': [{'D1': [37512, 55102], 'D2': 626670598},
               {'D1': [26135, 57198], 'D2': 3738367747},
               {'D1': [50600, 15808], 'D2': 1063453317},
               {'D1': [44015, 35401], 'D2': 1775622783}],
        'C2': {'E1': 32639,
               'E2': -6706266781442244867,
               'E3': [0.8460044264793396,
                      -0.0485631488263607,
                      0.9313809871673584,
                      0.7014756202697754,
                      -0.7851077914237976,
                      -0.3516009747982025,
                      -0.5586038827896118],
               'E4': [22848, 607, -2584, 10384, 31626, 17777, -5812],
               'E5': 30},
        'C3': 1937103540}}

(b'ZLY\x00\x00\x00\x1b\xe1\xfbLk\x008\x00F\x00T\x00b\x00\x00\x00li\xd3\xb2.\r'
 b'@M\x87\xf4\xbf\xed\xfe\xae\xc8lzr\xb8\xae\xfd\x92\x9a%Q\xea6\xf7l\x1d'
 b'[\xaa\xd7\x9d\x00\x00\x00\x02\x004\xa0\xc7\x9a%?\xf81\x97\x00\x00'
 b'\x00\x02\x00BV&\xd2E\xa5\xe0\x9e\xec\x00\x00\x00\x02\x00P\x9d\x97'
 b'o\x1c\x98\xb5p\xdb\x00\x00\x00\x02\x00^ck<\xd7\t\xd6\xd7\xc9x\xa7\xedV'
 b',\x08>\x83.\xea?}\xef\xc8\xbe\xdf;+\xbe+\xca\x8b>d\xeb\xbe\xbe\x93<\x14?q'
 b'-fF\xb8\x87\x97\x98\xf7\x02\xef\x83\x08o\xceh\xe4\xd4')

{'A1': {'B1': 222317959,
        'B2': -12,
        'B3': -0.9373392023588407,
        'B4': -72,
        'B5': -82,
        'B6': -174907950435256585,
        'B7': 27677},
 'A2': -503624597,
 'A3': {'C1': [{'D1': [23466, 55197], 'D2': 2697435685},
               {'D1': [16376, 12695], 'D2': 1445384773},
               {'D1': [42464, 40684], 'D2': 2643947292},
               {'D1': [39093, 28891], 'D2': 1667972311}],
        'C2': {'E1': 2518,
               'E2': -2897652222599484408,
               'E3': [0.2562173008918762,
                      0.9919400215148926,
                      -0.4359982907772064,
                      -0.1677648276090622,
                      0.2235555350780487,
                      -0.28756773471832275,
                      0.9420989751815796],
               'E4': [18104, -30825, -26377, 751, -31992, 28622, 26852],
               'E5': -44},
        'C3': 1775481390}}

Вариант №28

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

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

(b'WMTX\xce\xb6T?}\x9d\x05\xfaF\x81\xc9Sx5e\xb9xJ\x00\x00\x00G\xea|'
 b'\xa3\xde\xe5\x01;\xfc:X@\xeb[%g^\xc7ls\x18\x93.\xf8R\xf2\xc4\xef+\xa08'
 b';\x02\x94\x02e#\xc5\xa4\xe2?\x90v\xedz7k\xe2\xbfmt\x06\xb6\xea\xe6F\xcc\xb5/'
 b'A\xc4\xfeP\xec\x15\xb9\x0e\x8c\xcc\xdc\xfcF\xc8\xc1\xdd\xc7f\xc6\x0b8[\x98A'
 b'\xc90z\x8cVfQ3\xb5\xd7P\xfb\xd1\x1d\xb5G\xdeQ\xe7J\xa9\xdam\xfa'
 b'\xc6\x99\x10\x1aV\x02\t0R\x86V"\x00F\xe3\x0c\xcf\xa7)e\xc62\x00\x00\x00')

{'A1': 0.8309143781661987,
 'A2': 4194671997,
 'A3': 70,
 'A4': 8699095435569252737,
 'A5': {'B1': 'mt',
        'B2': 3437878495461160454,
        'B3': 1358873665,
        'B4': 236,
        'B5': [{'C1': [47381, 35854, 56524, 18172], 'C2': 200},
               {'C1': [56769, 26311, 3014, 23352], 'C2': 152},
               {'C1': [51521, 31280, 22156, 20838], 'C2': 51},
               {'C1': [55221, 64336, 7633, 18357], 'C2': 222},
               {'C1': [59217, 43338, 28122, 50938], 'C2': 153},
               {'C1': [6672, 598, 12297, 34386], 'C2': 86}],
        'B6': {'D1': 22586,
               'D2': [64, 235, 91, 37],
               'D3': 24167,
               'D4': 5978579714639621319},
        'B7': -4150865680842038458,
        'B8': {'E1': 737133810,
               'E2': 37435552,
               'E3': [0.5826135340976912, -0.5755879784516811]}},
 'A6': 71,
 'A7': -271621265731388182}

(b'WMTX\x08v\xab\xbc>\xf8)\x16\xcf,\x04\xe8\x04y>$\xf6J\x00\x00\x00x\xba\xbf'
 b'\xf07w\xcb\x96o\x81N\x98G\xd2!\x1f\xd9d\xf8e\xb2\x94\xcac\xbd\xfa\xd6'
 b'@]\xcc\xc7\x93\x85PS\x94\xa7\xc6\x90\xed\xbf\x00\xf2\xa1\x13\xbe\xa1'
 b'\x9d\xbfuo_E\xd15]\xe8\xf4\xe3\xec\xb3\x9a\x8az>ve\xfd\xe0\xc9\xd6'
 b'\t\xc0\x0f\xe4`\x08\xaf\x0b\xe2\x96\x1f\xe0\xa0\x85R\xb3\x93)v\xa1\xc0\xefiS'
 b'\x89\xd9\x13M\x8f\x02Bl\xae\xf5\xb6\x04\xcf\xba]\xdbX\x81\xaf\xb2'
 b'\x82\xa2\xb3"\x00\x8b^\xd0\x1e\xa9\xaa\x9cl2\x00\x00\x00')

{'A1': -0.020930305123329163,
 'A2': 371849278,
 'A3': 207,
 'A4': -710374151723416532,
 'A5': {'B1': 'uo',
        'B2': 16426009227959551327,
        'B3': 2325394412,
        'B4': 122,
        'B5': [{'C1': [30270, 64869, 51680, 2518], 'C2': 192},
               {'C1': [58383, 2144, 2991, 38626], 'C2': 31},
               {'C1': [41184, 21125, 37811, 30249], 'C2': 161},
               {'C1': [61376, 21353, 55689, 19731], 'C2': 143},
               {'C1': [16898, 44652, 46837, 52996], 'C2': 186},
               {'C1': [56157, 33112, 45743, 41602], 'C2': 179}],
        'B6': {'D1': 20097,
               'D2': [152, 71, 210, 33],
               'D3': -9953,
               'D4': -4799770037849819036},
        'B7': 7826317895806246539,
        'B8': {'E1': 1564530426,
               'E2': -2053912628,
               'E3': [-0.9239228508982738, -0.028937311123160114]}},
 'A6': 120,
 'A7': 8040837897616670650}

Вариант №29

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

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

(b'3DHGl\x00\\\xa0\xdc\xa5\xb5\x15\xde?\xe7l\xba\xad n\xc7\xe2\r\xbc'
 b"\xfe\xf3\x94\x07\x8f\xe8'\x02\x00\x00\x00\xb2\x00\x00\x00a0%(."
 b'\xb1\xa1\xb7\xbf\x07\xd25>!\x98\x1c\xbf\xe9\xe2=\xbf\xef]\x0f?\xfe\x172\x04'
 b'\x19m\xe0\xc8O\xf88\x9c\x82\xdd\x89O\xb7\xe9;?~\x84\xd8\xbeR%@?\xdb\xd41D'
 b'Z\x8b*)\xf8\x0b\xdb\x91t\\\x8f%"R\xfe\xd9\xbdw\xa3\xc5^nb\n\x8f\x04\x000'
 b'\x00\x00\x00\x02\x00@\x00\xc3\x17\xb2\xbd\xfb(\x00\xf4\x82\x90.)\x03'
 b'\x00P\x00\x00\x00\x02\x00\\\x00\x89"\xb0\x85l0-\xae\xfds\xe2\x9b\xa2\x0c\x02'
 b't\x1e\xef\xa0\xa7\xc09J\x1d\xbf:6\xcb\xbe\x15\x1fj\xbf')

{'A1': {'B1': 34,
        'B2': {'C1': [{'D1': -0.10644210875034332,
                       'D2': -8139585150342814857,
                       'D3': [0.1775590032339096,
                              -0.6116963028907776,
                              -0.7417436242103577,
                              0.5600270628929138],
                       'D4': [14474689156580775934, 5731355553842133071]},
                      {'D1': -0.08695938438177109,
                       'D2': 2967468096597534971,
                       'D3': [0.7340349555015564,
                              -0.42288583517074585,
                              0.7505694627761841],
                       'D4': [2966336524384326875, 2706483556805970936]}],
               'C2': -119,
               'C3': -20446},
        'B3': 758148229,
        'B4': -495714898,
        'B5': -23909,
        'B6': 13882241325261390348,
        'B7': -0.6144137978553772},
 'A2': 0.4700750465149264,
 'A3': -25,
 'A4': [1000581343038257772, 2875705624802623164],
 'A5': [-0.396898090839386, -0.9145367741584778],
 'A6': 97,
 'A7': -0.09231097580790926}

(b'3DHGd\x00\x96\xf4\xfb\xe4\x84=\xe4?R\xc7\x99\x1fT\xc4\xa4\x0e\xf3\xb4'
 b'\x8a]\xf3|\xc1\x81\xc9\x03\x00\x00\x00\xaa\x00\x00\x00\xca\xe0\xe0>\xd8'
 b'\x9e\xcc\xaf?/\xc1v?9B\x81\xbe\n\xae\x9c\xfcf\x10\x18\x976\x8a\xf0\x04'
 b'gd\xef\x8a\x9c\x1aj\xbf\x90\x98/\xbfW\xaa\xfa>\xf0BD\xa0\xff{\xe4\xc2'
 b'\xf8\x84"\x88W-1\xf7\xca\xa9f)?]\xd5\xd2\x8b\x96\xb3AX\x02\x000'
 b'\x00\x00\x00\x02\x008\x00\x8cA\x1a\xbf\x8a\x0f\x84\x87e\xffk\x00\x03'
 b'\x00H\x00\x00\x00\x02\x00T\x00\xca\xec\xec\xa0zV\x10\xd0\x11n\x86'
 b'\xf2\xf7_\xa1QzGE\xd0\x9a2"\xdd>\x0e\x84\x12\xbf\x00\xdeN\xbemP\xc1\xbe')

{'A1': {'B1': 202,
        'B2': {'C1': [{'D1': 0.661722719669342,
                       'D2': 6359561607996167517,
                       'D3': [0.9638852477073669, -0.2524583637714386],
                       'D4': [10887470133679009290, 10011330890295183926]},
                      {'D1': -0.602562665939331,
                       'D2': 30398634038398858,
                       'D3': [-0.91446852684021,
                              -0.6859216690063477,
                              0.48958083987236023],
                       'D4': [14043485875883754224, 17812067855196390648]}],
               'C2': -54,
               'C3': -4884},
        'B3': 274102944,
        'B4': -2039606832,
        'B5': -2062,
        'B6': 11155492450293883231,
        'B7': 0.4319015145301819},
 'A2': 0.6325096580836937,
 'A3': 82,
 'A4': [17514117164022340039, 14520099416022289076],
 'A5': [-0.5723274946212769, -0.20201873779296875, -0.37756672501564026],
 'A6': 202,
 'A7': 0.062108005425615564}

Вариант №30

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

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

(b'>JURwnmntjC|g(_\xdd>\xaf*\x80>\xb8\xe2\xdd\xbe\xd0\x17\x96\xbfE?\xc5'
 b'>\x94\xb8s?\xcfO\xf4\xcac\x9bP]g\xc8\xff\x00\x00\x00`\x9c\xdb\x82y>\xb1c\x14'
 b'>U\xe0\xe2=\xa2\xa9\xd5\xbe\x84\xd43\xbf=\xdc\xf7\xbf\xe9\xad\x99'
 b"\x03{\xab\x864\x97\x10$\x00\x00\x00lh'o\x98\x8e\xd0\x92\xe5\x86P\x17\xeb"
 b'\xa5};|\xd0\xb31\xfbdF\x10\x90!V(\xb1')

{'A1': 'wnmntj',
 'A2': 17276,
 'A3': 1730699229,
 'A4': [{'B1': {'C1': [0.3421211242675781,
                       0.3611058294773102,
                       -0.4064299464225769,
                       -0.7705042958259583,
                       0.2904697358608246],
                'C2': 0.24462756998328894},
         'B2': 1567082751,
         'B3': {'D1': 36560,
                'D2': 37605,
                'D3': [134, 80, 23, 235, 165, 125, 59, 124]},
         'B4': 2631631481},
        {'B1': {'C1': [0.3464590311050415,
                       0.2088656723499298,
                       0.07942549139261246,
                       -0.2594314515590668,
                       -0.7416529059410095],
                'C2': -0.8024411266354583},
         'B2': 882315300,
         'B3': {'D1': 53427,
                'D2': 12795,
                'D3': [100, 70, 16, 144, 33, 86, 40, 177]},
         'B4': 1747414936}]}

(b'>JURjkpwaq\xedo\xfd\xfa\xc3p?\x02F\x9f?\x11$R\xbe\xb9\xa0\x02?(\xe0\x84'
 b'\xbf{M\x85?\xb5\t\x7f\x87\xd6c N\xd7;*\x00\x00\x00`\x0c}U\xf9=\x01\xd8/'
 b'\xbe\xe6\xbaJ\xbe\x1f\xca\x89\xbe\xcf\xa6e\xbf\x11\xe8T?\xd4\x19\x81'
 b'\x8d\xd1\x12\x14v>\xfd\x99\x00\x00\x00l\x91\x83\xf2W\x15\x93ej'
 b'\xd3\xcf\xff\xbc\xaa\xde-y\xc5s\xf2\xe0\xff\x89tm\xe8\xd5-\x1f')

{'A1': 'jkpwaq',
 'A2': 60783,
 'A3': 4261069680,
 'A4': [{'B1': {'C1': [0.5088900923728943,
                       0.5669604539871216,
                       -0.3625488877296448,
                       0.6596758365631104,
                       -0.9816516041755676],
                'C2': 0.0821761805185699},
         'B2': 1322728234,
         'B3': {'D1': 5523,
                'D2': 25962,
                'D3': [211, 207, 255, 188, 170, 222, 45, 121]},
         'B4': 209540601},
        {'B1': {'C1': [0.03170030936598778,
                       -0.4506400227546692,
                       -0.1560460478067398,
                       -0.40556636452674866,
                       -0.5699512958526611],
                'C2': 0.3140567669800316},
         'B2': 1983839641,
         'B3': {'D1': 50547,
                'D2': 62176,
                'D3': [255, 137, 116, 109, 232, 213, 45, 31]},
         'B4': 2441343575}]}

Вариант №31

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

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

(b'SDAAEn;b\xbf\x9a\x00\xaf\xbd\x07\xac\xe2\xf2W\x96\xe3\xb2\xcbc\xcd'
 b'\x97\xd6\x05\x1e\xda\t\xfc\x86\xc4[\xce\x1f>H\x84\'"[\x81\r(\x90L\xfb'
 b'x\xb4\xe8\n\x815\xbap00\xca\x00-\x0eg\xd2\xef\xbf\x8b\xf4\xcf\x80-,'
 b'\xf5\xd0?Z\xfe\xda\x92\xb3)\x10\xee\xbf\x9b\xfc\x06@\xb4\xf9v\xe1'
 b'\xbf\xe3\x00\xa0\xe8\xb7\x13\xe3h?Z2\xb0sZ:\xfb\xef\xbfx\xf0\xa6\x13\xd1'
 b'L\xa1\xd2\xbf\xa4\xba9\xc4E \xd7\xe7?\xa1\xea9\x00B\x00K\x00T\x00]\x00f\x00o'
 b'\x00x\x00P%\xf3\n\x83|\x1d\x81\x00\xcf\xddC(pM\x89\xfb\x84\xf4\xdb\x98'
 b'\xc0\xf8\x00\xafn\xd2x\xb5\x02\x00\x00\x00\x98\x00')

{'A1': -0.8837193250656128,
 'A2': {'B1': {'C1': -5471,
               'C2': [{'D1': 48, 'D2': -0.9944339062567675},
                      {'D1': -117, 'D2': 0.2649641460768628},
                      {'D1': 90, 'D2': -0.939473009805482},
                      {'D1': -101, 'D2': -0.5457733650693792},
                      {'D1': -29, 'D2': 0.0030379662632817883},
                      {'D1': 90, 'D2': -0.9994174734724821},
                      {'D1': 120, 'D2': -0.29109497468617374},
                      {'D1': -92, 'D2': 0.7450105059268062}],
               'C3': [80, 37, 243, 10],
               'C4': -125},
        'B2': 56783,
        'B3': {'E1': -827259864401041341, 'E2': 39131},
        'B4': 13076432890894547136,
        'B5': [124, 29]},
 'A3': [-81, -67, 7, -84, -30, -14, 87],
 'A4': {'F1': 3417498518,
        'F2': -12957,
        'F3': 151,
        'F4': -4285460876152142378,
        'F5': 0.1560606211423874,
        'F6': [33864, 8743, 33115, 10253, 19600, 30971, 59572, 33034],
        'F7': 47669},
 'A5': 12400}

(b'SDAAE.\xf0\x00\xbf\x9a\x00Lq\xdcI\x9c\xde>\xeck\x17\xbd\xfb4\xfc\xf7\xe9&'
 b'\x87\x9dk\x8a\xa3u\x08s?2\x17\xa3\xcd\xfb\n\xe7\x826s\x07\xfb\xc8\xfc\xb2'
 b'\x15\x1a\xca6\xefxXO\x83\xeefV\xd1?~tU\xfb\x06\x1b\xee\xd8?\xd9'
 b'\xd0\x8d\xbe\xa9\xb78\xc9\xbf\xe1\x88\xee\xf5\xfe\x9e\xa6\xdd'
 b'\xbf\xcd\xc0\xde.>]\xb3\xd1\xbf\xf9\xe0w7\xe8\xac\x03\xe7\xbf2\x90O\x04S'
 b';%\xb0?\xef\x9e\x02y\xabK\xd3\xec\xbf\x87\xbd9\x00B\x00K\x00T\x00]\x00f\x00o'
 b"\x00x\x00\xa65\xfc\x81\x89L\xde\x81\x00*\xc1\xd4\x04(\x19'\x90\xe9\xb2bE"
 b'P_\xd7E\x8bLZ\x0e\x02\x00\x00\x00\x98\x00')

{'A1': -0.5036648511886597,
 'A2': {'B1': {'C1': -17017,
               'C2': [{'D1': 120, 'D2': 0.2708985642650439},
                      {'D1': 126, 'D2': 0.38953281099141823},
                      {'D1': -39, 'D2': -0.19704337871836097},
                      {'D1': -31, 'D2': -0.46329474352362654},
                      {'D1': -51, 'D2': -0.27657252380911856},
                      {'D1': -7, 'D2': -0.7191986594659703},
                      {'D1': 50, 'D2': 0.06306811119821831},
                      {'D1': -17, 'D2': -0.900792918117151}],
               'C3': [166, 53, 252, 129],
               'C4': -119},
        'B2': 49450,
        'B3': {'E1': -5554750167784618796, 'E2': 17762},
        'B4': 1034223225490857808,
        'B5': [76, -34]},
 'A3': [76, 113, -36, 73, -100, -34, 62],
 'A4': {'F1': 3172428780,
        'F2': 13563,
        'F3': 252,
        'F4': -6662394374419715593,
        'F5': 0.9493477940559387,
        'F6': [5938, 52643, 2811, 33511, 29494, 64263, 64712, 5554],
        'F7': 51738},
 'A5': 61238}

Вариант №32

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

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

(b'LWUO\xe4\xbf\xe3\x92\xcc\x8bs\xcb\n\xc2\x83\xacB\x00\x00\x00\x03\x00\x00\x00'
 b'-\x003\x00\x00\x00d\x00\x00\x00j\x9a\x8aB\xb4\xfa2\xe1\xf2A\xaeahhgcj\xbe'
 b'"\xe8\xa3q\x00\x03\x000c\x91\xb2\xe5\xb5\x81\xaaD\\}\x8c\xb8<\xbe\x05\xbd'
 b'\xe7\xd3\xe60\x1c\\\x99R\xba\xbf\xe5\x9dedA\xd1\x16\x13\x05T\xf7k\x92/'
 b'>}\x95\xdc\xd4.>\xe2\xd2n\x1eu')

{'A1': -0.611669800155455,
 'A2': 3263409218,
 'A3': 'ahh',
 'A4': {'B1': -0.1590905636548996,
        'B2': 113,
        'B3': 'gcj',
        'B4': 1670492901,
        'B5': 181,
        'B6': {'C1': 9343355540967569468,
               'C2': -0.1306072324514389,
               'C3': -3177799588692536646,
               'C4': -0.6754633863588733,
               'C5': 19,
               'C6': 1364,
               'C7': -2197,
               'C8': 37423}},
 'A5': [{'D1': 0.24764198064804077, 'D2': 54318},
        {'D1': 0.44301170110702515, 'D2': 7797}],
 'A6': [39562, 17076, 64050, 57842],
 'A7': 16814}

(b'LWUO\xe4?\xea\xe5\xf8y\x06\xce\xa0I\xec\x9b\xa1\x00\x00\x00\x03\x00\x00\x00'
 b'-\x003\x00\x00\x00d\x00\x00\x00jb\xb0\x80^\x91\xdfiE`Rlvstlo\xbf[k,i'
 b'\x00\x03\x000M1\xbcI\xabBL\xb9\xb3\xe8I\x9en\xbf\x19\x04\xfa;UP(\xff\xba\xc1'
 b'I?\xea\xc5i&Y\x99\xea\xcc\xc8\x13"%\x89\x9c?Tal=\x06>\xd5\xc2s:\x8b')

{'A1': 0.8405725826073258,
 'A2': 1240243105,
 'A3': 'lvs',
 'A4': {'B1': -0.8571040630340576,
        'B2': 105,
        'B3': 'tlo',
        'B4': 1295105097,
        'B5': 171,
        'B6': {'C1': 4777397487080676974,
               'C2': -0.5977321863174438,
               'C3': 4275411558277497161,
               'C4': 0.8365979908965617,
               'C5': -52,
               'C6': 51219,
               'C7': 8741,
               'C8': 35228}},
 'A5': [{'D1': 0.8296115398406982, 'D2': 15622},
        {'D1': 0.4174991548061371, 'D2': 14987}],
 'A6': [25264, 32862, 37343, 26949],
 'A7': 24658}

Вариант №33

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

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

(b'AKQO\x00\x00\x00O\x00\x00\x00[\x00\x00\x00g\x00\x00\x00s\xbf\xe1\xba_'
 b'\xac\xb6\xdcD\xee\xefajv\xd7\xf1\x04=\xf5+?C\x94\xd2\xaf@\xc1\x9b\x92'
 b'5\x927\xa7\xef\x95\x18\xc9\x1a?c\xf2\xcb\xd6\xfd|\xe70\xe8\xd5!V\xc2\x8d'
 b'\xf5\xe9\xe0\x8f\xac\x00\x7f`\xcf@\xd4\n\xc6E[\xf0Rqew\xea\xd2\xe8\x88'
 b'y\t\xaff8\x89o\xa4\x12Z\x7f#\xc7\x7f\xed \xf0\xc0S\xc2\x9c\x97Y\xea'
 b'\xfc%\x13\x14\xd3\x0b\xedC9\xcd\xa3"}\x16\xc3ad,-\x19\xf3\x82\xfa')

{'A1': [{'B1': 1624195284, 'B2': 776384246944264549},
        {'B1': 2011878120, 'B2': 9833901910279096687},
        {'B1': -1542301057, 'B2': 2578169968129523795},
        {'B1': -1029925031, 'B2': 16932449462890204141}],
 'A2': {'C1': -0.5540006993604796,
        'C2': 61167,
        'C3': 'ajv',
        'C4': 15560222851694542659,
        'C5': [38098, 44864, 49563, 37429, 37431, 42991, 38168, 51482],
        'C6': 0.8904234766960144,
        'C7': -688030489,
        'C8': 3524301047583641077},
 'A3': 3923808172,
 'A4': {'D1': [17209, 52643, 8829, 5827], 'D2': 7017782691570615034}}

(b'AKQO\x00\x00\x00O\x00\x00\x00[\x00\x00\x00g\x00\x00\x00s?\xee\\\xc5'
 b'\x03\xf4UN\xf0\xa4alx\xd3\x8e\xaaE^\xe0\xd9\xb2\x89\xf4\xd7\xc8I\xbd\xba'
 b'&\xdd^\xa7=\xe4%\xe5\x80\xbe\xbe\xd6\xc9A\x1cWP \xc5E\x15<l\xea'
 b'\xdd\x15\xfe\x9f\xaa\x00\x7f\x7fR\xcc\xd2oC\xbd.\xe0\xc9\xa3\xf8\x11'
 b'\x899\xa02\x19\x95\xe2\xa3\xaf\xbfA\x81\x9b\xfey\x0f\x88\xdd\xdc\xa8'
 b'\xc389\x95M\xbd\xc9&b\xa1rTy\t\xedd\xef\x15\x87\xc6:T\x7fW\x93\xb2\x17\x87'
 b'\xa3\xe2\x96')

{'A1': [{'B1': 2136132818, 'B2': 8017459770687071224},
        {'B1': 294205856, 'B2': 3610081376955514689},
        {'B1': -2120483207, 'B2': 1119388447195478073},
        {'B1': -1790067255, 'B2': 2765950633574468077}],
 'A2': {'C1': 0.9488244130358596,
        'C2': 61604,
        'C3': 'alx',
        'C4': 15244309003616967090,
        'C5': [35316, 55240, 18877, 47654, 56670, 42813, 58405, 58752],
        'C6': -0.3727324306964874,
        'C7': 1092376400,
        'C8': 2361369537136093917},
 'A3': 369008554,
 'A4': {'D1': [25839, 5511, 50746, 21631], 'D2': 6310583317005853334}}

Вариант №34

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

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

(b'WPA\xc49\x10UE\t\xa8Y\xf3\xbe\x15\x08\xf3sYZ\xd1\xe8\xaay\x93\xb5s?\x18'
 b'\x87\x9c\xd4\xdc~\x80(\xec\xb78\x07\x98?+Ri\xd1\xda\xf6\x8c\xefC?\xdf'
 b'\x9e\xd9T6\xaf\x10\x00\x00\x00\x02\x00\x00\x00f\xbb\x1c_=\xb8\xcd'
 b'\x00\x00\x00\x04\x00\x00\x00h\x1f\xeb\xa7O\x89T\x07c\x128\x94\x88'
 b'\xcd\xd9\xa8p\x00\x02\x00\x00\x00ltm\xfe+Ab\x89\xb1\x19N?o\xcd\xfe')

{'A1': [{'B1': 4111880214792395251, 'B2': -0.1455419510602951, 'B3': 29529},
        {'B1': 6544267552427849075, 'B2': 0.5958192348480225, 'B3': -11044},
        {'B1': 9115330642949179288, 'B2': 0.6692262291908264, 'B3': -11814}],
 'A2': {'C1': -158535869,
        'C2': 0.49407036994919995,
        'C3': 'tm',
        'C4': -1155768515,
        'C5': {'D1': 184,
               'D2': 205,
               'D3': [-2, 43, 65, 98],
               'D4': 535537487,
               'D5': -8551201670380874616,
               'D6': -841373584},
        'C6': [-1984882354, 1064291838]}}

(b'WPA\xc4\x19/\n\xfd\x16\x1b)e\xbd]\x1a\xd1\x94\xbeA\xb1Q\x17\xabg\xad2\xbfs'
 b'\xd3\x13\xc7\xe2HL\xbeO\xad\xcd\xd3\x83\xbfOn\x18\x0619^,\x88\xbf\xed%C\x15R'
 b'Y<\x00\x00\x00\x05\x00\x00\x00f\xdf\x1a\xa1\x99\x8cm\x00\x00\x00\x02'
 b'\x00\x00\x00k\x14\xed{\x13\xb6\x81\x7f\xb2)<\x1d\x14\x11`\xef\x94'
 b"\x00\x03\x00\x00\x00mwsvdx}\x80\x11\x06>\x91\xb3'\x85\xc53\xb5_e")

{'A1': [{'B1': 1814681256967481701, 'B2': -0.05398065224289894, 'B3': -27458},
        {'B1': 4733653845444898098, 'B2': -0.9524394869804382, 'B3': -14366},
        {'B1': 5209748118388462467, 'B2': -0.8102736473083496, 'B3': 1585}],
 'A2': {'C1': 962473096,
        'C2': -0.9107985893668125,
        'C3': 'wsvdx',
        'C4': -551902823,
        'C5': {'D1': 140,
               'D2': 109,
               'D3': [125, -128],
               'D4': 351107859,
               'D5': -5295811283638280940,
               'D6': 291565460},
        'C6': [285621905, -1289255483, 867524453]}}

Вариант №35

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

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

(b'HZL\x01\x82\xdf\xabm\x99\x08\x8bY\x03\x00|\x00z\xd0kI\x02\x00\x7f\x00'
 b'\xa5r\xd7%\x03\x00\x81\x00q\x1c\xfcB\x04\x00\x84\x00]\xa4g\xde'
 b'\x04\x00\x88\x00\x80{\xbcj\x04\x00\x8c\x00\xaa\x88\xdf0\x03\x00\x90\x00'
 b'x\x98$\xbf?\x19\xd5n\xe3\xe3~\xe3\xeb1\x03\x00\x00\x00\x93\x00'
 b'\x00\x00\x04\x00\x00\x00\x96\x00\x00\x00N\xbc\x872}\xbb\x89o\x174'
 b'\xb3\xe3\x83\x8e\xa6\xb5\x8d7\x8d\x84\xae\\\xfa\xbaW\xff\xf1\xa6@e'
 b'\xdd\xbaa\xcd\x91b\x9b\xcf\xc5\xe8\xec\xaeX\xe3\xa16\x07\x1f\xcd\x90'
 b'L\xf1\xc1\xa5\xd4\x04\x9b\xe0\x1eC')

{'A1': 1,
 'A2': {'B1': -8318,
        'B2': {'C1': 28075,
               'C2': [{'D1': 1502283929, 'D2': [221, 186, 97]},
                      {'D1': 1231802490, 'D2': [205, 145]},
                      {'D1': 634876581, 'D2': [98, 155, 207]},
                      {'D1': 1123818609, 'D2': [197, 232, 236, 174]},
                      {'D1': 3731334237, 'D2': [88, 227, 161, 54]},
                      {'D1': 1790737280, 'D2': [7, 31, 205, 144]},
                      {'D1': 819955882, 'D2': [76, 241, 193]}],
               'C3': -0.642951488494873,
               'C4': 6463}},
 'A3': {'E1': 3597218861514190549,
        'E2': [-91, -44, 4],
        'E3': [155, 224, 30, 67],
        'E4': 847756366},
 'A4': 125,
 'A5': [35259, 5999, 45876, 33763],
 'A6': -114,
 'A7': 6678421039494313382,
 'A8': 7296014954641472250}

(b'HZL\x15\xa9\xc8&\x91\x82\xc0L\xd3\x03\x00|\x00O\xe8\x8e\xc1\x03\x00\x7f\x00'
 b'\x19\xf2qo\x04\x00\x82\x00\xb4\xd1\xb1\xb1\x04\x00\x86\x00N\xa8\x95?'
 b'\x03\x00\x8a\x00\x96\r,/\x04\x00\x8d\x00%\xbe\x19\r\x04\x00\x91\x00'
 b'\x95U1\xbf\x07\x8a\xfbPr\xa79\x9c\x91\x89\x02\x00\x00\x00\x95\x00'
 b'\x00\x00\x02\x00\x00\x00\x97\x00\x00\x00\xa5\xaf\xfa\xb0\x06\xc4'
 b'\xadb\x16\xdd\x1a\x83PnW\x04\xae\x99\'|\xbe\x8d\xf6\xa4O\x8d\xd8\xe0?"'
 b'\xa0\xdb(\x87\xfc\xff3\xe2 z\xfaB\xe5.\x15\x90\xc1\xe8\xd2\xeb\n\xbe,\xd5'
 b'\x8f\xfc\xc9[\xae')

{'A1': 21,
 'A2': {'B1': -14167,
        'B2': {'C1': -28378,
               'C2': [{'D1': 3545022594, 'D2': [160, 219, 40]},
                      {'D1': 3247368271, 'D2': [135, 252, 255]},
                      {'D1': 1869738521, 'D2': [51, 226, 32, 122]},
                      {'D1': 2981220788, 'D2': [250, 66, 229, 46]},
                      {'D1': 1066772558, 'D2': [21, 144, 193]},
                      {'D1': 791416214, 'D2': [232, 210, 235, 10]},
                      {'D1': 219790885, 'D2': [190, 44, 213, 143]}],
               'C3': -0.692712128162384,
               'C4': 35335}},
 'A3': {'E1': -8533868047454023429,
        'E2': [-4, -55],
        'E3': [91, 174],
        'E4': 2969218981},
 'A4': 6,
 'A5': [44484, 5730, 6877, 20611],
 'A6': 110,
 'A7': 10213737514446750807,
 'A8': 2467938341510685942}

Вариант №36

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

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

(b'qYQM\xef\xa5[\xe3\xd96*\x05\xbf\xecay\xec\x92+\x04?\xd5<b7\xbeYp\x91d8\xe4'
 b'\xce\x90\x1am\xf0r\x7f\x19\xa74\xd1\xfa*A\xa0"Y\xa7\x00T\x00\x00\x00\x03'
 b'\x00\x00\x00\x9c\xc2\xdf\x0bcm"\xa0\xb2\x85\xa8&\x03\xf4H\xb8\xd9'
 b'v\x1d\xb6\xc4svdhjktdepel\xbf\xca\x8f\xc0U\x00\x86\xf0\xbe\xcc\xaa\x14'
 b'?^\xe0\xc9\x00\x00\x00\x04\x00P=\xd6\xaaL\xdf\xf1lY\xc5\xde\xbb\xb6\x01T'
 b'?\x01\x1d\xac\\\xcf\x00Nz\xe38f`\x1f?/\xfaO^\x1f]\xa2?wA\xfc\x95+'
 b'\x00\x00\x00r\x00\x00\x00\x80\x00\x00\x00\x8e')

{'A1': -1178434693327607291,
 'A2': -0.8868989582564102,
 'A3': {'B1': 0.3318105263109805,
        'B2': 37220,
        'B3': {'C1': 14564,
               'C2': -3562318245762269415,
               'C3': 42804,
               'C4': 15130452359452449191}},
 'A4': {'D1': 'jktdepel',
        'D2': -0.20751194143763696,
        'D3': -0.39973509311676025,
        'D4': 0.8706174492835999,
        'D5': 'svdh'},
 'A5': [{'E1': 0.10481700301170349,
         'E2': -33,
         'E3': -1050365906703895039,
         'E4': 84},
        {'E1': 0.5043590068817139,
         'E2': 92,
         'E3': -3530735818153367968,
         'E4': 31},
        {'E1': 0.6874131560325623,
         'E2': 94,
         'E3': 2260140981477309589,
         'E4': 43}],
 'A6': [3269397347, 1830985906, 2242389507, 4098406617, 1981658820]}

(b'qYQMl\xe4\x8a\xed\x87\xbc4\xdc\xbf\xc3\xe4\x17X\xc1X\xb8\xbf\xe0\xf8C'
 b'X\x8dR\xe4\x86\x13\x1a\xac\xc3i+\xd5\xb9O4\xb4\x02\xe1\n\xed\xb1\xdb\x84\x05'
 b'+\xb8\x00T\x00\x00\x00\x03\x00\x00\x00\x9c\xce\x18;\xd8\x01o\xfe?'
 b'\xfd\x00\xc3\xd9`Xx\x0b\x02L\xda\xb2xqevgkgbpxnz?\xed\xc7\xdb\xed}\x906'
 b'\xbfd:\xa2\xbfb\x98\xe4\x00\x00\x00\x04\x00P>\xef\xb6;:\xe4\x08\xc6\xc0&'
 b'\x9ehc\x0c>\x0bU\xd9\x89\xd3\xd4\xfc\x9b\xe9j\xe3\\{\xbfM\xe9\x1d\x98\xa6'
 b'C\xc4\r\xc72\xabQ\x9e\x00\x00\x00r\x00\x00\x00\x80\x00\x00\x00\x8e')

{'A1': 7846549203575387356,
 'A2': -0.1553982909560483,
 'A3': {'B1': -0.5303055505306387,
        'B2': 34323,
        'B3': {'C1': 6828,
               'C2': -4365910166821981004,
               'C3': 737,
               'C4': 787481066230590392}},
 'A4': {'D1': 'gkgbpxnz',
        'D2': 0.9306468618856403,
        'D3': -0.8915196657180786,
        'D4': -0.8851454257965088,
        'D5': 'xqev'},
 'A5': [{'E1': 0.4681871831417084,
         'E2': 58,
         'E3': -2015142304664360861,
         'E4': 12},
        {'E1': 0.1360696703195572,
         'E2': -119,
         'E3': -3182641290077871268,
         'E4': 123},
        {'E1': -0.804338276386261,
         'E2': -104,
         'E3': -6466109076518294703,
         'E4': -98}],
 'A6': [3457694680, 24116799, 4244685785, 1616410635, 38591154]}

Вариант №37

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

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

(b"GNJR\xdc\x97\x82_\xd9\xf2\x9a\xcc\xfa\x00\x04\x00'\x00\x00\x00[|\xb5("
 b'\x13\x00\x02\x00`\x00\x00\x00\x02\x00\x00\x00\x88\xb8dckxh\xbft\x0c\x01?'
 b'*\x82\xdc?k\xd1A?\x1eh\x92>BQ;?\x17\x80\x19\xbfD\x82k\x00\x00\x00\x07\x00'
 b'\x00\x00+)\x1d\x01\xb3=\x9e\x9b*>\x8d\xcb5\x00\x00\x00G\xf6\xe9\xf9\xc1\x15'
 b'\x0c\xf3\x10\xbf$\xf2Q\x18\x8aP\xd2?\x10\x84\x91\x9dI*\xcc\xc5W\x9e\xfe\xbf'
 b'\x0c\x0f\xfbn\xaf\xdc\xd3>\xd1n\x15\xad}\x80c\x9e\x93\xc5Z\x97'
 b'\xcc\x8c\x87\xa1\xaa;\xd0\xaf')

{'A1': -36,
 'A2': -7529350237327274758,
 'A3': 'ckxh',
 'A4': {'B1': {'C1': [-0.9533081650733948,
                      0.6660592555999756,
                      0.9211617112159729,
                      0.6187831163406372,
                      0.18976299464702606,
                      0.5917983651161194,
                      -0.767615020275116],
               'C2': 2962525999224232746,
               'C3': 0.2769409716129303},
        'B2': 246},
 'A5': 2092247059,
 'A6': [{'D1': -23,
         'D2': -1599,
         'D3': 353170192,
         'D4': -0.6443224549293518,
         'D5': 411717842,
         'D6': 0.5645228028297424,
         'D7': 157},
        {'D1': 73,
         'D2': 10956,
         'D3': -984113410,
         'D4': -0.5471188426017761,
         'D5': 1857019091,
         'D6': 0.40904298424720764,
         'D7': 173}],
 'A7': [9043337584495123095, -3707439264817229649],
 'A8': 47204}

(b"GNJRU\x1ag\x99\xb6\xe2\x89V@\x00\x02\x00'\x00\x00\x00I\x16\xbf\xea"
 b'~\x00\x02\x00N\x00\x00\x00\x02\x00\x00\x00vs\x89lh\xbfL\xe0\x8a>\xfc\xa0'
 b'W>\x1d\xe9\x9c\x00\x00\x00\x03\x00\x00\x00)\x94\xf0f\xa1\x0e)9\x1d>oW'
 b"\x8b\x00\x00\x005\xd3\xf8TI\xf1\xd4I\xbd?'\xd2\x80\xc2\xe7J\xa0\xbe\xd9]"
 b'\xaf\x91\xcdWV60?H\xbfY\n\x97R\xc6\xb0t>\xaa\xc4\xc9R#\x8f\xbb.\xc8\xac'
 b'\xc0\xa8\xcd^>.\xd0f\xe4\x97')

{'A1': 85,
 'A2': 1902658378351072832,
 'A3': 'lh',
 'A4': {'B1': {'C1': [-0.800301194190979,
                      0.49341079592704773,
                      0.15421146154403687],
               'C2': 10732190753937242397,
               'C3': 0.23373238742351532},
        'B2': 211},
 'A5': 381676158,
 'A6': [{'D1': -8,
         'D2': 21577,
         'D3': -237745731,
         'D4': 0.6555557250976562,
         'D5': -1025029472,
         'D6': -0.4245428740978241,
         'D7': 145},
        {'D1': -51,
         'D2': 22358,
         'D3': 909131592,
         'D4': -0.8478178381919861,
         'D5': 1388753012,
         'D6': 0.3335326015949249,
         'D7': 82}],
 'A7': [2562472522606756008, -3648410277337701225],
 'A8': 29577}

Вариант №38

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

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

(b'FPKHr\x00\x00\x00brjgR\x9609pi\x99-8\x08Iz\xfc\x99\x03v\x00\x00\x00n'
 b'ix\x8c\x93\xb9\xcdy\x90\x8e\xfb\x1e\xf4E\xd8\x96\x12\xe8\xc0z\x00\x00\x00wx'
 b'ym\xadS\x11\x855\x9fyJ\xa1=8\xfb\x1a\x0b\x7fL\xfaABv.\x84\xaf\x04\x00~'
 b'\x00\x00\x009\xaa=@\xd7\xde\x8e\xbd\x08\xf6\xe03\x0e\xc7\x1f\xe4\xa0'
 b'\x8ec\xbf\x0e\xb88?_\xd7mX\xf1\xe8\x1aG"\xbc\xee\xcbp\xb8\x16)rO\x0b\xbb\xe7'
 b'/\xcc\xa7;\xa72\xb7\x90\xd9K')

{'A1': [{'B1': {'C1': -3752, 'C2': 6888},
         'B2': 'brj',
         'B3': 21095,
         'B4': 4048060318209355926,
         'B5': 4235872520,
         'B6': [153, 3]},
        {'B1': {'C1': 8775, 'C2': 61116},
         'B2': 'nix',
         'B3': -27764,
         'B4': -855970289425986119,
         'B5': 311875653,
         'B6': [232, 192]},
        {'B1': {'C1': 28875, 'C2': 5816},
         'B2': 'wxy',
         'B3': -21139,
         'B4': -6824508560621891245,
         'B5': 452671549,
         'B6': [11, 127]}],
 'A2': {'D1': -5799459334693717428,
        'D2': [189755945, -869275717, 849820583, 1272549559],
        'D3': 1077783097,
        'D4': 3180256983,
        'D5': 870381064,
        'D6': -4655720768097761522,
        'D7': 0.7215584516525269,
        'D8': 95},
 'A3': 28119}

(b"FPKHr\x00\x00\x00cud\xd5s4\xc0\xe8\xbd\x03wr\xd2?',\xbd\x9bJv\x00\x00\x00n"
 b'swm\x8ee\xd4\x85\xdd\xe9a_q\xd4\xe6e\xc5\xb7\x07z\x00\x00\x00kck{\xb7\xf1'
 b'\xa0z\xd86\x1d\xf0\xd7\xfd\x0fW`\x0f\xe22\xdc\xc3\x90\xe7&\xe7@\x03\x00~'
 b'\x00\x00\x00Ui\xee5\xd1\xe89\x9a\x8d\r\xeaBd\x14\xa7\x8f\x83j\x8cS4'
 b'\xda\xe1\xbe\x8b\x825\xbe\xb2\xc4\xf1\x16\x82\x99\xb1 \xb0\xfd\xda\xe2\x85'
 b'\x19s\xb5bk\xbdD\x899r')

{'A1': [{'B1': {'C1': -19778, 'C2': 61892},
         'B2': 'cud',
         'B3': 29653,
         'B4': -3282430320444915660,
         'B5': 3173787455,
         'B6': [155, 74]},
        {'B1': {'C1': -32234, 'C2': 45465},
         'B2': 'nsw',
         'B3': -29075,
         'B4': 8169355906145178725,
         'B5': 3311789780,
         'B6': [183, 7]},
        {'B1': {'C1': -20448, 'C2': 56061},
         'B2': 'kck',
         'B3': -18565,
         'B4': -2886775239747133199,
         'B5': 1616318461,
         'B6': [15, 226]}],
 'A2': {'D1': 4676749514055605298,
        'D2': [1931052514, -1117035851, 1916373316],
        'D3': 904816981,
        'D4': 2587486417,
        'D5': 1122635149,
        'D6': 6020303915170862180,
        'D7': -0.44111788272857666,
        'D8': -117},
 'A3': 13698}

Вариант №39

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

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

(b'UYL\x93\t\x00\xd7\x98\x00{_\xbb\xbe\xff\x07!D\xbc\x15\xfb\\\xa8\x1d\xeb'
 b'\xbf\xdet\x83\x93\x14\xf1\x0ey\x9b\x0f\xdb\xbf\x9eW\x0b~0MD\x1eO\x9b\xb3'
 b'?\n\xc36\xf0\x9co*t\xb2\xb7\xea\xbf\x16\xd4}\xc4\xbc\x06\xb6\xe3\xfeN\xd1'
 b'\xbf4\xbd\x9f&\xdc\xeb\xcfC\xad\xfa\xe1\xbf)\x91ijiljvt)\xf7\x91\x17A\x02'
 b'>\xc1%3HQS\x90\x8c\xaf\xe6\x93\xc5\x06V*\xc4\xfc\xd8#`\x85\xe8\x0fr`i\xc0'
 b'@\x1e\x80\xbf\x89\xb1\x0b\xd9\x02l\x07\x00d\x00s\xb4\x03b \xfb\x82\x11O\xa3'
 b'\x84\x89\xcd\xa6\xa6\x07\x00e\x00\xb9o\x13E\x7f\xd3\xbf\x80\x00\xb8\xa9'
 b'\xbd\xfc')

{'A1': {'B1': -0.36596283316612244,
        'B2': [{'C1': 1143015423, 'C2': -0.8473703208953149},
               {'C1': -1820101410, 'C2': -0.4228275949678999},
               {'C1': 2114672542, 'C2': 0.07658857811866393},
               {'C1': -264846582, 'C2': -0.8349239605772598},
               {'C1': -998386666, 'C2': -0.2704465125790241},
               {'C1': 648002868, 'C2': -0.5618501972634209}],
        'B3': 41,
        'B4': 27025,
        'B5': 'jiljvt',
        'B6': 395441961,
        'B7': 577},
 'A2': -41,
 'A3': {'D1': 7277825410175175044,
        'D2': -0.3046429338272816,
        'D3': {'E1': 7744,
               'E2': 7783021750296100736,
               'E3': [858112318,
                      2421379400,
                      2481368972,
                      710280901,
                      601423044,
                      266896736,
                      3228131442],
               'E4': 46195,
               'E5': [3, 98, 32, 251, 130, 17, 79, 163]},
        'D4': 4240288184}}

(b'UYL\x93\t\x00\xc7\x8c\x00\xdf\xe75?F\xe9\xd7:x`\xe8\xea\xf5\xe4\xe7'
 b'\xbf\xf5\xfd\xfdE\xa0\xc46N\x0b \xcf\xbf\xddQ\xd9\x81\x08\x89\xfc'
 b'\xb1\xe7?\xd6?]\x8a\xf6\x0f\x1e\xc9^\xbcI%\xe2?\n\xaa\x14\xed\x9e\x8b\n'
 b'\xea^\xff\xee\xbf\x0c\x17\xb0\r\x88H\xa4D\xe4\xfd\xc7\xbf\xa7\x83\x83ibsy'
 b'zn\n\xdb\x9e\x82:\xff\xa0bJ\xc2*eR\xc5u\x94c]\t\x0b\x9c/\x98\x13\x88\x08'
 b'V\x07\xa3\xda\xc8\x82\x04\x00d\x00jV|\xbf\xa5\xda.|\x98\x86\xbe\x9f\x06\xad'
 b'A\x86&J\xf00\xccr\x1a\xa1\xc8\xbft\x00\x14\xce\x80\x94')

{'A1': {'B1': 0.7105693221092224,
        'B2': [{'C1': 987228486, 'C2': -0.7466992939034887},
               {'C1': 1174273525, 'C2': -0.243165410223388},
               {'C1': -2116464163, 'C2': 0.34765045529833616},
               {'C1': 267815517, 'C2': 0.567051761541993},
               {'C1': -317412854, 'C2': -0.9686731883160637},
               {'C1': 229644044, 'C2': -0.18743565894743974}],
        'B3': -89,
        'B4': 33667,
        'B5': 'ibsyzn',
        'B6': -2103518454,
        'B7': -198},
 'A2': -57,
 'A3': {'D1': 5343105624555560894,
        'D2': -0.19241648297646163,
        'D3': {'E1': 5016,
               'E2': 9424022614010366088,
               'E3': [3259654816, 3310511402, 1566807157, 798755593],
               'E4': 22122,
               'E5': [124, 191, 165, 218, 46, 124, 152, 134]},
        'D4': 2491469332}}

Вариант №40

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

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

(b'\x97GPR_\x00f\x00\xe1\x13\x1a\xd0\xc5:\xdb\x16~\xc8\x88(\xfe"\xcb\xb4'
 b'\x8e\xae]TAC\xd6\x06\x142\x92\xc7\xa2k\xa5\xad \xf466\x016j\xc0\xbe\x887\x98'
 b'\xff\xf8A\xd8@\x8eh\xce\xe2\xe5a\xb6\x8aH\x10\xa2#\x03\xce\x7fF\xbe\xc8\xd0'
 b'\x85\xc7L\xf6\x19\xc0\xacu%K\x96?9\x96\x19\xe9%\xc2\x14\x02\x00 \x00<'
 b'R\x00\xa5\xadp\xa6\xe7\x11q5l\xe3{\xa0\x806\xfd\xb0P\xbf\xac\xf2\xac@'
 b'\xc20\xc5\x92\x89:\x9e\xab\xe1N\xfdD\xaa\xa5\xefy\n\x03z\xb1\x9d\xe6S\xf6'
 b'J:;x\xa2\x7fE\xe5\x8c\xd3m\xae\xdb\xdd\xb9u:\xe1?|=|')

{'A1': {'B1': [{'C1': 20,
                'C2': 2354720061895709234,
                'C3': 14068,
                'C4': 310,
                'C5': -0.37581032514572144,
                'C6': 4672557151092750216},
               {'C1': -114,
                'C2': 5227190849101811304,
                'C3': 41488,
                'C4': 803,
                'C5': -0.1938469111919403,
                'C6': 13842365739325313224}],
        'B2': 60,
        'B3': {'D1': -7621990979609463380, 'D2': 25, 'D3': 348268009}},
 'A2': {'E1': -1502564955,
        'E2': 4583,
        'E3': 3927315329024013681,
        'E4': -0.8152006268501282,
        'E5': {'F1': [172, 242, 172, 64],
               'F2': 12366385989353287874,
               'F3': -31,
               'F4': [754897907366559054, 5401597053030726147],
               'F5': 15162,
               'F6': 7913823886561485432,
               'F7': 0.5383862142760927},
        'E6': {'G1': 124, 'G2': 31805}},
 'A3': -803597343,
 'A4': [383466181, 680052862, -1261755650, 1415425678, 114705217]}

(b'\x97GPR_\x00f\x00NR-\xab+X\x9b\x82\xd3\xdd\xb7\rz\xe2\x06\x9e^\xc2\xfa\xb9'
 b'\xe3?\xee\x13\x80I\xdeC{e\x90\x80\xe93\xf0\xb3\x19N=\xed\xbd5\xbf\x01'
 b'\xca\x84H\x057\x03\xb1\xed{\xab\xcd\xf7nV\xb9q\xad0;\x06>\xbf\x0f\n'
 b'\xc2\xf2\xdd\xe8\x92\xc8<\xed\xd3\x83\xdd\xe6\x8b\x81W\xb2h\x92\xca\x02'
 b'\x00 \x00cR\x00\x90\xc2M\x88\xb7\xd7\xe1\xfeg\xef\xa8\x8c\xc1&\x18L2?'
 b'\xdff\\\xaa\xf0S\x83T\x9b\x1d\xca\x1eW{\xa4\x89F\r\xa4\x96\x9bi\x837'
 b'\xaf\xa9\x9cl\xeb\xc5\x98\xd3\x96\xbe$\x02#\x98S\x1c#\xcb4\xe2'
 b'\x9a\xe3\xbf\xb7\xb47')

{'A1': {'B1': [{'C1': -128,
                'C2': 16825606973390315081,
                'C3': 61491,
                'C4': 6579,
                'C5': -0.11583958566188812,
                'C6': 3964654782131584821},
               {'C1': 3,
                'C2': 6228187797417356721,
                'C3': 29113,
                'C4': 12461,
                'C5': -0.7422825694084167,
                'C6': 14452870194143562255}],
        'B2': 99,
        'B3': {'D1': -9111935581980201668, 'D2': 87, 'D3': 3398592690}},
 'A2': {'E1': -2008169840,
        'E2': 55223,
        'E3': 2792667901145382625,
        'E4': 0.6964735984802246,
        'E5': {'F1': [223, 102, 92, 170],
               'F2': 2218618319408419824,
               'F3': 87,
               'F4': [11211328699310384251, 16964106149000872809],
               'F5': 39109,
               'F6': 6023602993721415379,
               'F7': -0.6126566916583189},
        'E6': {'G1': -73, 'G2': 14260}},
 'A3': -1423093170,
 'A4': [-2103748565, 230153683, -1643715974, -1174748578, 334381027]}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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