ИКБО-15-22

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

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

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

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

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

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

(b'\xdcWFJ?\xe0d\x0bu\xcaJ\xd8\xd6\xcd\xe8&cgm\xbf\xed\x80\xab\x98\x95\x0b\xd68'
 b'\xaa\xbb\xef?a\x90\\\xf7\xc8\xb2\xf1\xbfS\x05\x05Z\xbc\xee)\xbd\x0e\x8aib'
 b'\xea?\xee\xbcq\x1fD\x85\x1c\x80HH\x90\xbe]^\x1f\xc8\xd2\xb9\x14U\xc1<'
 b'\x00\x0b\r~(\xdaV\tatK?\xd8L\x85\xb5\xbd\xb98%\xc1l\xc6?y\xbc\xb3\xd7'
 b'\xcc\xebf\x9c>%j\x17\x94g\x08A/"\xbf\xb8S\xcf\'\xce\xbe\xf0\xbf.sh>\xfb'
 b'\x19;\xbf#{\x04=LX\xa7??V\xf8')

{'A1': 0.5122124958600933,
 'A2': 3603818534,
 'A3': [{'B1': 'cg',
         'B2': {'C1': 109, 'C2': -0.9219568233605695, 'C3': 950713327},
         'B3': {'D1': 0.8811089992523193,
                'D2': [-9, -56, -78, -15, -65],
                'D3': 83,
                'D4': 84236988,
                'D5': -299254514},
         'B4': 138},
        {'B1': 'ib',
         'B2': {'C1': 234, 'C2': 0.9605031595894249, 'C3': -2142746480},
         'B3': {'D1': -0.21617935597896576,
                'D2': [-56, -46, -71, 20, 85],
                'D3': -63,
                'D4': 1006635789,
                'D5': 2116606550},
         'B4': 9},
        {'B1': 'at',
         'B2': {'C1': 75, 'C2': 0.3796705508056166, 'C3': 633433286},
         'B3': {'D1': 0.9755355715751648,
                'D2': [-41, -52, -21, 102, -100],
                'D3': 62,
                'D4': 627709844,
                'D5': 1728594223},
         'B4': 34}],
 'A4': -0.09502882692208536,
 'A5': [-0.6814484596252441,
        0.4904268682003021,
        -0.6385958194732666,
        0.04988923296332359,
        0.7474207878112793]}

(b'\xdcWFJ?\xe8\x14H\xca\xd2\x16\xe2\xe6\x9b\xff\xdbni5\xbf\xe6\x95\xa2u'
 b'\xf7\xf5:\x12G\xea\x86?1\x0e\xff\x94\xb5\xc7\x824mF\xdbnm\x8c\xe1Z\xae\x0chu'
 b'\x83\xbf\xd6^\x94\xce\xcaa4\xcf\x95\x7f\xc1>\x1a\x95d\xd4Q\xce'
 b'\xab\xd1\xfa\xe4\xdb\\\x88\x00\xaf\xfe4\xaalg\xd7\xbf\xeeT\x8f\x1f'
 b'I\x19\xd0\xceR\xd0\xf8?3\x84\xad\x80\x0c\xf4+e\xb4\x9e\xdd\xb3\xd6\xc7\x9d8'
 b'#\x97\xbf\xd1\x95\n\xe4|\xa4\x8c?]_o\xbe\x9e\x8a\xd4\xbfE\xbe\x8a\xbe\xd9'
 b'*\x88?H\xca\xc6')

{'A1': 0.7524761163083122,
 'A2': 3868983259,
 'A3': [{'B1': 'ni',
         'B2': {'C1': 53, 'C2': -0.7057659439157427, 'C3': 306702982},
         'B3': {'D1': 0.6916350722312927,
                'D2': [-108, -75, -57, -126, 52],
                'D3': 109,
                'D4': 1188785773,
                'D5': -1931388242},
         'B4': 12},
        {'B1': 'hu',
         'B2': {'C1': 131, 'C2': -0.34952278322591046, 'C3': -812286015},
         'B3': {'D1': 0.1509605050086975,
                'D2': [-44, 81, -50, -85, -47],
                'D3': -6,
                'D4': 3839581320,
                'D5': 11533876},
         'B4': 170},
        {'B1': 'lg',
         'B2': {'C1': 215, 'C2': -0.9478221522375012, 'C3': -833433352},
         'B3': {'D1': 0.7012432217597961,
                'D2': [-128, 12, -12, 43, 101],
                'D3': -76,
                'D4': 2665329622,
                'D5': -945997789},
         'B4': 151}],
 'A4': -0.27472183526203575,
 'A5': [0.8647374510765076,
        -0.3096529245376587,
        -0.772438645362854,
        -0.4241526126861572,
        0.7843440771102905]}

Вариант №2

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

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

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

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

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

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

(b'YYYG\xb4*[\xa1\xfcU<\xe8\x00\x00\x001\x00\x00\x00\x03\x00C\x00F>\xa6\x06\xd9'
 b'\xbf-\x1bw\x00\x00\x00\x06\x00\x00\x00b\xae\xacrenwemz\xc4\x14\x00'
 b'\x00\x00\x07\x00\x00\x00*B\x95\xca\x85>\xf1\xfb\xcache\x92k\xd3\xab\xcbh'
 b"\x94^\t\x93\xaad\x7f'\xad\xd7\xff\x00\xa7\x92\xa0$9\nK\xaf\x95\x99\x00\x00"
 b'\x00\x02\x00\x00\x00J?\x912\x9c\xb4f\x85\x80\xf4\x9e\x00\x00\x00\x02'
 b'\x00\x00\x00N\xbf\xc4\x0fLGeI\xa0\x14\x8c\x00\x00\x00\x02\x00\x00\x00R?\xe2'
 b'\x18j\x0f\x08\x88\xda\xe4!\x00\x00\x00\x02\x00\x00\x00V?\xe4\xe0L'
 b'8\xdf\xed\xe2\xce;\x00\x00\x00\x02\x00\x00\x00Z?\xb8M\xefz9np\xa4N'
 b'\x00\x00\x00\x02\x00\x00\x00^?\xe3+\x99[\xce\xf7\xb0$|')

{'A1': -5464454446579368728,
 'A2': {'B1': 50196,
        'B2': 'renwemz',
        'B3': 1117112965,
        'B4': 0.47262412309646606},
 'A3': 'che',
 'A4': {'C1': 37483, 'C2': 54187},
 'A5': 0.32427099347114563,
 'A6': -0.6762003302574158,
 'A7': [{'D1': [52072, 37982], 'D2': 0.01679463244511714, 'D3': -12, 'D4': -98},
        {'D1': [2451, 43620], 'D2': -0.15671685682407333, 'D3': 20, 'D4': -116},
        {'D1': [32551, 44503], 'D2': 0.565480260240544, 'D3': -28, 'D4': 33},
        {'D1': [65280, 42898], 'D2': 0.6523800955614514, 'D3': -50, 'D4': 59},
        {'D1': [40996, 14602], 'D2': 0.0949392007254859, 'D3': -92, 'D4': 78},
        {'D1': [19375, 38297], 'D2': 0.5990721505293006, 'D3': 36, 'D4': 124}],
 'A8': 44716}

(b'YYYG\xd8\x9a\x15[7M\xecR\x00\x00\x00-\x00\x00\x00\x03\x00?\x00B\xbd\xb34\x8e'
 b'?!\x8aQ\x00\x00\x00\x04\x00\x00\x00V\x7f\xa8thn\xaa<\x00\x00\x00\x03\x00'
 b'\x00\x00*]A\x1bh?{M\x08yitb*x\x9aW\xf1\xdam)\xb6\x8d\xf2\xb8\xba'
 b'K\xbd\x89\x9a\xe6\xde\x00\x00\x00\x02\x00\x00\x00F?\xef\xe2\x82\xa9\xd3'
 b':P\x88k\x00\x00\x00\x02\x00\x00\x00J?\xd1\xfb\xd1\xb8\xd2\xc5\xcc'
 b'\x9e\xe2\x00\x00\x00\x02\x00\x00\x00N?\xd0\x9e\xa1\xee\xe5\x96\x88\x91\xe1'
 b'\x00\x00\x00\x02\x00\x00\x00R\xbf\xc7\xa8\xd9\xa9\xee3\x08\xfe;')

{'A1': -2838933133589615534,
 'A2': {'B1': 43580, 'B2': 'thn', 'B3': 1564547944, 'B4': 0.9816441535949707},
 'A3': 'yit',
 'A4': {'C1': 25130, 'C2': 30874},
 'A5': -0.08750258386135101,
 'A6': 0.6310167908668518,
 'A7': [{'D1': [22513, 55917], 'D2': 0.996400195779481, 'D3': -120, 'D4': 107},
        {'D1': [10678, 36338], 'D2': 0.28099482583192237, 'D3': -98, 'D4': -30},
        {'D1': [47290, 19389],
         'D2': 0.25968216256874443,
         'D3': -111,
         'D4': -31},
        {'D1': [35226, 59102], 'D2': -0.18484040067087215, 'D3': -2, 'D4': 59}],
 'A8': 32680}

Вариант №3

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

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

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

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

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

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

(b'XYP\x04\x00\x00\x00 \x00\x00\x00\xe2bxR"\xd1\x93$\x00x\xa5I\xbaF\xad\xc8?'
 b'\x9f\xdcf\xbdonje\x81]\xd1\x05\x9a\xde\x84\xf3\x8em\x04\xce\x93\\!I'
 b'\xc6U(\xfe\xa4\xc5\xacD\xe7\xd5\xfe\xad\x83E\x0ej\xbc\xd5\x17QG\xa17\xf2'
 b'\x80\xd8\xa8\x8d\x8e\x82\xc3\xa8\xc3\x059\xdf\x9f\xfdL\x82e\x8c\xba\xa0'
 b'C\x8anQ\xe0$Q\x1e8\xf3lQ\x02\xa8\xf7s\x00T2\x80\rg\x00d\xee\xdc\xbf\xa5'
 b'\xbe\x9cI\xfc')

{'A1': 'onje',
 'A2': 25314,
 'A3': 3508687480,
 'A4': 147,
 'A5': {'B1': [{'C1': 17547394801246231937, 'C2': [142, 109, 4]},
               {'C1': 2906447151932150734, 'C2': [254, 164, 197]},
               {'C1': 5009038520588125356, 'C2': [14, 106, 188]},
               {'C1': 9291550147044513749, 'C2': [216, 168, 141]},
               {'C1': 16084893882038583950, 'C2': [159, 253, 76]},
               {'C1': 7965253248561735042, 'C2': [81, 224, 36]},
               {'C1': 12106328276704173649, 'C2': [247, 115, 0]}],
        'B2': 12884,
        'B3': {'D1': -0.4520502094203138,
               'D2': [165, 190, 156, 73],
               'D3': 252}},
 'A6': 0.19278797241285495,
 'A7': -0.05636274442076683}

(b'XYP\x03\x00\x00\x00 \x00\x00\x00\x9e\x08\xa5\xf0\xb7#\x04#\x00h0R\x1f'
 b'N\xfe\xde\xbf)0\xa7\xbeazt\x9b8\t\xa2\xdcM\xd7\x06o{J\x9b\xc5\xdb\xc2i!'
 b'\x9c\xff\xce-\x0b\xf9\x80\xac\xb46\xc0/\xf9\xfc\xc5\x1b\xdc\x16]d'
 b'\x1c\x999\x95\xa7B=\xf5\x98\x8c0,Yq\xef7\xa2\x1ag\xe53\x0c\xe5\xefQ\xf9\xc9['
 b'\x01\x8a\xd5aM/!\xb9H\xb8&q\xa1I\x98 \x94\x1dN\x8a\xe3?\xc7\x1d\xe6\x0f\xb0')

{'A1': 'azt',
 'A2': 2206,
 'A3': 599257253,
 'A4': 4,
 'A5': {'B1': [{'C1': 492948294227015835, 'C2': [111, 123, 74]},
               {'C1': 18418633314162951579, 'C2': [206, 45, 11]},
               {'C1': 17955781580541427961, 'C2': [252, 197, 27]},
               {'C1': 10752793932545726172, 'C2': [167, 66, 61]},
               {'C1': 17253669693761034485, 'C2': [55, 162, 26]},
               {'C1': 17965404155588896103, 'C2': [201, 91, 1]},
               {'C1': 5240256128467719562, 'C2': [184, 38, 113]}],
        'B2': 18849,
        'B3': {'D1': 0.6106329515178173, 'D2': [199, 29, 230, 15], 'D3': 176}},
 'A6': -0.4842715555066719,
 'A7': -0.3265393078327179}

Вариант №4

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

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

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

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

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

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

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

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

(b'APQJ\x81\xd6\x9dv\x02\x7f\xbc4\x00\x00\x00\xdbE\xfb\x0b\x17#%M\x1e'
 b'\xd2\x90\x16\xf1\xf0pw?\xfa\x92\xbe\xf4\xb3\x1as\xd2\x02\x00\x00\x00'
 b'9\x00G\x00\x02\x00k\x00\x07r \xf6FCS\xe8\xb2\xc1\x81\x01\xab-\xaeV4\xecm@'
 b'@\x8d\xfc\x03\x00\x00\x00?\x00\x00\x00\xe6\x88nT<{U\xf02\x7f\xca\x06\x1a'
 b'o\x0cv\x11\x00\xed\xbf\x05\x00B\x00\xff @\xbf\xc4A[\xbf')

{'A1': {'B1': 2648080714,
        'B2': -1132526986,
        'B3': {'C1': -165645817, 'C2': 70},
        'B4': 17883},
 'A2': -3306120254545523717,
 'A3': -414481313732422000,
 'A4': [146, 190, 244, 179, 26, 115, 210],
 'A5': [{'D1': 21315, 'D2': -24}, {'D1': -15950, 'D2': -127}],
 'A6': {'E1': 4237115456,
        'E2': {'F1': [1, 171, 45],
               'F2': -26,
               'F3': 28296,
               'F4': 1434139732,
               'F5': 13040,
               'F6': -13697,
               'F7': 6,
               'F8': -0.9062583261142863},
        'E3': [174, 86, 52, 236, 109]},
 'A7': [-0.7505034804344177, -0.8564722537994385]}

(b'APQ\x9f\xc3\xb6\xb1\xd3\xb8\xd9\xcf4\x00\x00\x00\x9f \xd9\xb4\x0c'
 b'\xd0J\xad\xf1\xac\xe5\x8d\x91\xb4\x0f\x85T\xb2\xfc!\xe3\xc7\xa2lN'
 b'\x02\x00\x00\x009\x00G\x00\x02\x00k\x00\xde\xa6\xda\xfc-\xd5\xd3|.\xc0\x88j'
 b'\xda\xf0N\x0e\xfa\xaeU+\xde\xe6\xfe\x02\x00\x00\x00?\x00\x00\x00H'
 b'\xd3\xe0\xf7\\\x87\x00}\x82\xb3\x9e"8\xbb\xc8\x9e\xc7\x97\xe4?\x06\x00A\x00B'
 b'\x16\xa2<\\\xba\x84>')

{'A1': {'B1': 2981544863,
        'B2': -807814957,
        'B3': {'C1': -52779298, 'C2': 45},
        'B4': 8351},
 'A2': -5984811892968999719,
 'A3': -5596702134414242331,
 'A4': [252, 33, 227, 199, 162, 108, 78],
 'A5': [{'D1': -11307, 'D2': 124}, {'D1': -16338, 'D2': -120}],
 'A6': {'E1': 4276543019,
        'E2': {'F1': [106, 218],
               'F2': 72,
               'F3': 57555,
               'F4': 8871159,
               'F5': -32131,
               'F6': -24909,
               'F7': 34,
               'F8': 0.6435278035404286},
        'E3': [240, 78, 14, 250, 174, 85]},
 'A7': [0.019786003977060318, 0.25923430919647217]}

Вариант №5

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

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

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

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

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

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

(b'oTLGq\x00\x00\x00\x02\x00Q\xecO;\xe8\n\xd8J\xef\xf5\x99\x8e\x19n'
 b'\xc4U\xd8\x1aP\xa1\x16\x8am\x83\xb9\xb8\x19\xe8\x14\xa2\xfa\xd0{wf\xf4\xe9l'
 b"\x18\xea\xf29\xf1\xec\xc0y7\x0c\x117\xe5>\x0ct\x0f'\xc0\x82\xf1$\x94h"
 b'\xe2\x18\x12=~\xd7\x9d\xe3\xa5\x00\x02\x00\x00\x009\x1b\x00\x04\x00\x00'
 b'\x00A\x8d')

{'A1': {'B1': {'C1': 113,
               'C2': [{'D1': [202455013, 1041003535], 'D2': 27},
                      {'D1': [666927857, 613705954, 403848574, -677518427],
                       'D2': -115}],
               'C3': -330351640,
               'C4': 781456929826901529},
        'B2': 28356,
        'B3': [85, -40, 26, 80, -95, 22, -118],
        'B4': 109,
        'B5': -125,
        'B6': -71,
        'B7': [-18407, -6124, -23814, -12165, 30566]},
 'A2': -186029032,
 'A3': -1517086413248497353}

(b'oTLG\xab\x00\x00\x00\x02\x00Y\xce\x12\xf5\x1d\xb3\xda\xd7q\xb4.+)p\x9e}\xc3m'
 b'\xf1_\xe5K\xf0\nLo0e\xc2\xafQ\xe5\x8a\x8e~\xb24\xda\x8b\xb2\xe3\xfc'
 b'\x83c\xabe\x0f>\xc1\x95\xec\x1do\xafh\x04\xd0\r\x9a\xdf\x8c\xd1\x8f\x17\x0fV'
 b'fY\xc6j\x03?\xe9@\xd5d3\x1ec\x00\x04\x00\x00\x009\xc8\x00\x04\x00\x00'
 b'\x00I\x85')

{'A1': {'B1': {'C1': 171,
               'C2': [{'D1': [1052874220, 493858664, 80743834, -544419441],
                       'D2': -56},
                      {'D1': [386881126, 1506175491, 1072251093, 1681071715],
                       'D2': -123}],
               'C3': -837618403,
               'C4': -5486836312643327191},
        'B2': 28830,
        'B3': [125, -61, 109, -15, 95, -27, 75],
        'B4': 240,
        'B5': 10,
        'B6': 76,
        'B7': [28464, 26050, -20655, -6774, -29058]},
 'A2': -1305159029,
 'A3': -5556319874001967857}

Вариант №6

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

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

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

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

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

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

(b'BVDQ?\xed\x81\x15\x1f\x97\x99\xfc?\xc0\xe8!:\xb0\x83\xa8\x00\x00\x00\x04'
 b'\x00\x00\x00L\x00\x04\x00P\x83!\xc6<\xbcf\x96\x0c!n\x91~?\xd4\xf1\xc1'
 b'K\xd86\xf4\x00\x00\x00\x03\x00\x00\x00\xb4%\xa5\x9e\xb7+w\xaf\xb0'
 b'\xbf\xa1\xd3\xc9B\x1a\xac`apppycxt\xbf\xe3`\xf7\xa3\x9ca(j\xf2C\xd5'
 b'\xb1\xfcT\xf4\x9fAP\x81"2\x89P\xa6\x85\x97\xaf\x81\xb1\x93\x9f\xbf\xe35\x85'
 b'\xac\xafK\xcc[\x99\x80\xbbM\xc4,\r\xb925\xd6,E\xd5\xa0\xda\xfa\xd6\x8f'
 b'\xc1\xdf+Z?\xe9\xbbg\r\xe1 \xa4\xc6\xb2d\x99\x15t\xcb\xceT\xcd\xec\x14'
 b'\xfb\xcd\x85\xaa@\xb3{(\x1b\xe62\xd6\x00T\x00t\x00\x94')

{'A1': {'B1': 0.922007142737868, 'B2': 0.13208403936098745, 'B3': 'appp'},
 'A2': 'ycxt',
 'A3': -2094938564,
 'A4': -4871040968109944450,
 'A5': 0.32725555807779405,
 'A6': [{'C1': -0.6055868335270462,
         'C2': 1794261973,
         'C3': -1308863244,
         'C4': [-1623109503, 573737296, -1501194321, -2119068769]},
        {'C1': -0.6002834675549535,
         'C2': 1536786619,
         'C3': 1304701965,
         'C4': [-1187891754, 742774176, -621095281, -1042338982]},
        {'C1': 0.8041262885172,
         'C2': 3333579929,
         'C3': 359975886,
         'C4': [1422781460, -70416982, 1085504296, 468071126]}],
 'A7': 631611063,
 'A8': {'D1': 729264048, 'D2': -0.03481892520843455}}

(b'BVDQ?\xd38Bo\xb3U\xcc?\xdd\xd9O\xfb\\\t\x1c\x00\x00\x00\x04\x00\x00\x00L'
 b"\x00\x04\x00P\x97\x03\x92\t\\z\xba\xe8OB#\x06?\xe8\xfe\xeaV'\xcc\xbe"
 b'\x00\x00\x00\x03\x00\x00\x00\xb4\xa8\x7f\xeds\xf2J}\x1d?\xe28R'
 b'\xb6\xb6\xe3\xf8kiigtcee\xbf\xdc$Qm\x8c\xdc \xf0\x1a\x1f\x0f\xd3\xac>\xd4'
 b'\'"hM\x87\x8b,\xc1,\xab\xd0\xbb\x91\x15+T?\xec\xfa-\xd8\x87\xd16'
 b'\x9e\xd4\xa1s\xdf42\xb4\x8c"\xc7\xdd:\x08Nv\xafEY\xfe\xe1\xabs!\xbf\xef\xa0C'
 b"\xa6\xa1\xf8\xec\x9d\x99\xabi\xa3'\x89\xd6\x00bm\n\x89\xbaS\xd0\xbd\xf4\x98r"
 b'gi\xe3v\x00T\x00t\x00\x94')

{'A1': {'B1': 0.30030880840544394, 'B2': 0.46638869807078875, 'B3': 'kiig'},
 'A2': 'tcee',
 'A3': -1761373687,
 'A4': 6663844105572983558,
 'A5': 0.7811175997470838,
 'A6': [{'C1': -0.43971667955651306,
         'C2': 4028243727,
         'C3': -743686444,
         'C4': [656566349, -2020922175, 749457595, -1860883628]},
        {'C1': 0.9055394391166718,
         'C2': 2664735091,
         'C3': -550227276,
         'C4': [-1943877667, 973622902, -1354409474, -508857567]},
        {'C1': -0.9883135084671983,
         'C2': 2644093801,
         'C3': -1557689898,
         'C4': [6450442, -1984277552, -1108043662, 1734992758]}],
 'A7': -1468011149,
 'A8': {'D1': -229999331, 'D2': 0.5693753784790934}}

Вариант №7

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

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

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

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

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

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

(b'LACG)\x03\x00\x00\x00;\x00\x00\x00Nqd\xb1\x89\xad\xe8\xbf\xb0\xcc\xd9'
 b'W\x881\xd3\xc7)\xa9\xcc?\xb3OY\x0f!"F\xbf\x89\t\x1d>\x02\x00\x00'
 b'\x00J\x00\x00\x00D\rN\x00\x00\x00\x84\xbe\xcc\x94\xca\xbf\xf8\x9a\xaf'
 b'\x7frk\x01\xc1\xfd+\xc0\xff\x9b\xfe)-\xfdf\x00\xc5\x81/U\x141=\xc1\xbej\xd0')

{'A1': [{'B1': -124, 'B2': 3398749374},
        {'B1': -65, 'B2': 2142214904},
        {'B1': 114, 'B2': 4257284459}],
 'A2': -0.7711838211721813,
 'A3': {'C1': [176, 204, 217, 87],
        'C2': 0.22391245133475146,
        'C3': [20403, 3929],
        'C4': -0.7739582657814026,
        'C5': 0.15335668623447418,
        'C6': [-16341, -25601],
        'C7': 3396},
 'A4': {'D1': 10750,
        'D2': 45,
        'D3': 1465129488181389053,
        'D4': -0.37741997838020325,
        'D5': -12182}}

(b"LACG)\x02\x00\x00\x00;\x00\x00\x00\x88\xb0\xe3jr'\xcb\xbf\x84\xbe\xfb"
 b'^6\xdc\xf0\\\xce(\xeb\xbfP\xa9\x8a\xb89\x92\x1c?\xeb\xf9\xe1\xbe\x07\x00\x00'
 b'\x00E\x00\x00\x00%bS\x00\x00\x00B\xa0\xb8\xf5on9\x94\xb8!v\xe1\x97\xdau.l'
 b"\x91'x'\x88\x82Xj\xad\xf2\xb7v\x02\xcd\x15^\xf7\xe6W\xdf\x86>\x80D")

{'A1': [{'B1': 66, 'B2': 1878374560}, {'B1': 110, 'B2': 565744697}],
 'A2': -0.21214132518014517,
 'A3': {'C1': [132, 190, 251, 94],
        'C2': -0.8487312140704322,
        'C3': [-22192, -18294],
        'C4': 0.6116061806678772,
        'C5': -0.44135984778404236,
        'C6': [-7818, -9577, 11893, -28308, 30759, -30681, 22658],
        'C7': 25125},
 'A4': {'D1': -21142,
        'D2': -14,
        'D3': 16642874395697772215,
        'D4': 0.2634226977825165,
        'D5': 17536}}

Вариант №8

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

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

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

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

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

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

(b'YQC-[\xd7`vjdnzes\x00\x00\x00E\x00\xd2\x1c\xc7\x14\xa12\x01=\xfe'
 b"\xa2\xaco\xc6\xb5%\x87z\xa7\xb0h%\xec\xd3$\xf8g\x9b\x8f0'\xd7_V\xf7&\x0c\x00"
 b'\x00\x00\x13\x00\x00\x00\x1f\x00\x00\x00+SL\x00\x00\x00\x03\x007\x88'
 b'o\x0b\xff\xed\xe1\x00\x00\x00\x02\x00\x00\x00C\x07\x84\xccr\xbf}\x81{J\xa1)'
 b'\xfd')

{'A1': 760993632,
 'A2': 'vjdnzes',
 'A3': {'B1': [{'C1': 15140194938730447165, 'C2': [-350, -21393]},
               {'C1': 14318391854102982760, 'C2': [9708, -11484]},
               {'C1': 17899446283297871711, 'C2': [22263, 9740]}],
        'B2': 2288978943,
        'B3': -19,
        'B4': -31,
        'B5': {'D1': [83, 76],
               'D2': 1924,
               'D3': 52338,
               'D4': -0.9902569651603699,
               'D5': 1252076029}},
 'A4': 0}

(b'YQC\xdd\xb2\xbc\xf8jdfayoz\x00\x00\x00E0\xd6\xacS\xe9\xc4$\x01%[t`FyKm|\x80'
 b'\rn`\x99j\xf2\xc6\xc5\x82\xcd1\xec\x1e\xa7^CJ_\x80\x00\x00\x00\x13\x00'
 b'\x00\x00\x1f\x00\x00\x00+\x7f\x8d\x00\x00\x00\x03\x007\x03XN\xd1\x07'
 b'\xce\x00\x00\x00\x02\x00\x00\x00C\xf5H\xdaE>\xded\xa7\xf1\x8bVm')

{'A1': -575488776,
 'A2': 'jdfayoz',
 'A3': {'B1': [{'C1': 15468831083593990437, 'C2': [23412, 24646]},
               {'C1': 8740199883334315616, 'C2': [-26262, -3386]},
               {'C1': 14232163386742712158, 'C2': [17226, 24448]}],
        'B2': 56118993,
        'B3': 7,
        'B4': -50,
        'B5': {'D1': [127, 141],
               'D2': 62792,
               'D3': 55877,
               'D4': 0.43436166644096375,
               'D5': 4052440685}},
 'A4': 48}

Вариант №9

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

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

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

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

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

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

(b'\xcaMTBQ\x00\x00\x00)?\x1d\x1b!\xbf]C\x11\xbf\xe8\xe6\xb47\xb2\xeb\x8e?}\xe8'
 b'\x17bY\x8b\xc2,\x9f\x07\xbf\xa07M\xf0\xa5$\xbd\xd5\xa5n+\\\xb9\xac?'
 b'\xd2\xe6\xec[\x18/\xc4\x1e0J8rcqmcky-\x15\xbf\x84S\xd8\x16\xe4\xa4\x00'
 b'\xe3\xac\xe6b\xf2&\xab\xc3Z\x06=\xc5D\xc8\xe4\x99\x91Ri\x91\x0b\x97\x87P'
 b'\xbfC)\x86\xfc\xe3\xec\xda\xb2\x1d\xb7\xe5n4\x15>U4\x02\xd4\x9d\n\xed\x1e'
 b'"v\xbcE?-\x98\xc6\xa6\xd4?\xd3\xc8A\x94\xd6\xdb(')

{'A1': {'B1': 165,
        'B2': {'C1': 616420773,
               'C2': 1848335545,
               'C3': 172,
               'C4': 0.29534443756051254,
               'C5': 506481208,
               'C6': 'rcqmcky',
               'C7': 11541},
        'B3': -0.009925544928210073,
        'B4': [{'D1': 16405740855247678403,
                'D2': [23046, 15813, 17608, 58521, 37202, 27025, 2967, 34640],
                'D3': -0.7623523473739624},
               {'D1': 18222668941306476517,
                'D2': [28212, 5438, 21812, 724, 40202, 60702, 8822, 48197],
                'D3': 0.6781123876571655}],
        'B5': -22828,
        'B6': 0.3090976670750245},
 'A2': [0.6136952042579651, -0.8643046021461487],
 'A3': -0.7781621063107751,
 'A4': 0.9918226599693298,
 'A5': 7086849154732722111,
 'A6': -1606988304}

(b'\xcaMTBQ\x00\x00\x00)\xbeeM\xb3?T^A?\xc9\xb2\x8f\xfd.\xe6\x80\xbfp!'
 b'\n\x1a\xd8W\xff4\n\xf6`\x17\x91\x90L\xd5\xfa\x88\xf5c!Ii\xde\xb8\xbf'
 b'\xe2\xf1\x8b\xb6&\x19\x1c\xa1\\\xa7\x85smivdjh\x96\xd1\xbf\xdb\x0fY'
 b'\x0b\x15)\x0cS\xb8zpC91\xd6\x96\xd3\xca\xb5\x96\xa6\x08\xd3\x11\x17\xfd\x00'
 b'lt\xf1\x8b>\x80=I59\xe0\x96\xbd\x89E\x14\xadX\x17\xfe\x84\xbcvtF\xc1F\xd4'
 b'\x89\xf1\x14R>\xa0Nu\x81\x98\xbf\xee\x1a\xbb4\xfa?\x88')

{'A1': {'B1': 213,
        'B2': {'C1': -91687581,
               'C2': 558459358,
               'C3': 184,
               'C4': -0.5919855649561074,
               'C5': 2707203973,
               'C6': 'smivdjh',
               'C7': 38609},
        'B3': -0.4228117569188192,
        'B4': [{'D1': 6032706323445526998,
                'D2': [38611, 51893, 38566, 2259, 4375, 64768, 27764, 61835],
                'D3': 0.25046756863594055},
               {'D1': 3835343495712294164,
                'D2': [44376, 6142, 33980, 30324, 18113, 18132, 35313, 5202],
                'D3': 0.31309857964515686}],
        'B5': -32360,
        'B6': -0.9407630953519268},
 'A2': [-0.22392921149730682, 0.8295632004737854],
 'A3': 0.20076179373227276,
 'A4': -0.9380041360855103,
 'A5': 1934392793557038688,
 'A6': 395415628}

Вариант №10

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

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

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

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

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

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

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

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

(b'QFRDp\xf1\x1b0\xfeU\xb3?\r\xa3\x84\x9e\xbe0\xa8\x1d\xe2?8\xed'
 b'\x00\xbc\xde\xba\x12\xdb\xef\xbf\x13odrfj\x00k\xf6UY6\xf1I\r<'
 b'\xeb\xff\xae\xfd3\n\xf1\xfc~\xfd9\x027\x7fl\x01r0\xe8\x8b\xedL\x90)'
 b'\x95\x04\x00\x00\x00t\x00\x1cJ\x16;\xad\n\xd2?\xdbG\x04\x00\x84'
 b'\x00\xf8\x84\xef\xd2\xbeV\xdfK\xd1\xfc}\x9d\x8d\xf6\xf1?%\xa1QI>\x02\x12'
 b'\x9c\xd7\xfe\xbe\x00}g\xbd\xca\xfda\xbfY\xcb&?C4\x12?\xe0\xc7Q?\xb5\xb1a\xbf'
 b'\xe61\xa4>')

{'A1': 0.07553089785137046,
 'A2': [{'B1': 41741, 'B2': 0.5661202384989825},
        {'B1': 60728, 'B2': -0.9954923295789513}],
 'A3': {'C1': 19,
        'C2': 'odrf',
        'C3': {'D1': 624947702, 'D2': 0.19660045206546783, 'D3': 4610},
        'C4': 1498805867,
        'C5': {'E1': [54, -15, 73, 13, 60, -21], 'E2': 872263423}},
 'A4': 2130505994,
 'A5': {'F1': 8214966488940034557,
        'F2': 3985369136,
        'F3': 2502529100,
        'F4': [-0.49773871898651123,
               -0.05651569366455078,
               -0.8827787637710571,
               0.6515403389930725],
        'F5': 0.28190165300580516,
        'F6': 18395,
        'F7': [0.57110995054245,
               0.8194561004638672,
               -0.8816178441047668,
               0.3206931948661804]},
 'A6': -8,
 'A7': -0.4119836091995239,
 'A8': 10204450855488053078}

(b'QFRD\xa8\x99\x9c\x03\x93\xc9\xe5\xbf\xf9\xf0f\xbdY\xfcC\xf7\xed?=Z'
 b'\x12\x93\xe7\x06\xbd\x94\xe6?\xc6apkwj\x00v$\xa6wb\xabE,\x9a\xb1G\nrz?\xca\\'
 b'\xc2\x99\xb2n\x81\x17z)\xcf\xe35\xd3K\xf3\x8cr\x07\x04\x00\x00\x00t\x00\x00'
 b"\xadl\x1b\xef\xb9x?\xa9\xff\x03\x00\x84\x00\x81\xfd'R\xbf!i1W\x95;"
 b'l\x9f\xc2\xa4v\xb3X\xea+?\xba_"\x02q\xbf<;\xab\xbe\x14\x8f\xc7>\x109:?'
 b"y'\x03?%\xe7\x94>|TI\xbf")

{'A1': -0.6808562346021079,
 'A2': [{'B1': 61689, 'B2': 0.9364337853166205},
        {'B1': 23101, 'B2': 0.7056565413336975}],
 'A3': {'C1': -58,
        'C2': 'apkw',
        'C3': {'D1': -1284070206, 'D2': 0.6715445518493652, 'D3': 24506},
        'C4': 2007377014,
        'C5': {'E1': [98, -85, 69, 44, -102, -79], 'E2': 2054294087}},
 'A4': 3260860991,
 'A5': {'F1': 14927596681270571673,
        'F2': 1272133091,
        'F3': 124947699,
        'F4': [-0.9414387941360474,
               -0.334436297416687,
               0.3897634744644165,
               0.7274332046508789],
        'F5': 0.006036695491995703,
        'F6': -87,
        'F7': [0.5123210549354553, 0.2908259928226471, -0.7864453792572021]},
 'A6': -127,
 'A7': -0.8209226727485657,
 'A8': 11487622262114314529}

Вариант №11

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

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

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

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

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

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

(b'DLWvy\x02\x00\x00\x00$\x00\x00\x008\x00U\xfa \xbd\x1d\x03\xd4\xe7?'
 b'S\x00\x05\x00\x00\x00t\x00\xd2ls\xc5\xaa\x0b\x02\x00 \x00m/\x02\x00"\x00'
 b"\xca\xe4n=\x0e\xae\xc7>\x02\x000\x00\x00\x00JdU\x07 '\x0f\xfcj\xef"
 b'\xd9\xc8\x85\xa5\xed\xa18\xed?\xea\x17\x7f<^\xe0\xa2K\x9a\xedt\x8cz\xcd\xd1'
 b'e\xd6C=\xa9\x82\xb5b\x15\t\xaf\n,\x19\xfe)\xb1\\\x05\xdb\xce\x8f\xe3\xdc{')

{'A1': 'vy',
 'A2': [{'B1': 2986, 'B2': [-46, 108]}, {'B1': 12141, 'B2': [115, -59]}],
 'A3': {'C1': [0.058323659002780914, 0.3899998068809509],
        'C2': 123036746,
        'C3': 4228851488,
        'C4': 106,
        'C5': 55791,
        'C6': 0.9131631509337064,
        'C7': 6122},
 'A4': 85,
 'A5': 0.7446303921542772,
 'A6': {'D1': 17121080096323419263,
        'D2': 4888206397327182964,
        'D3': 12612635745124002109,
        'D4': 386378461961858058,
        'D5': -37},
 'A7': [206, 143, 227, 220, 123]}

(b'DLWth\x04\x00\x00\x00(\x00\x00\x00H\x00\x9c\xe8c(v\xef\xe3\xcf\xbf'
 b'c\x00\x05\x00\x00\x00\x84\x00\xf3o\xb2\xf3Q?\xba\xc1\x08\x0c\x02\x00 \x00Wr'
 b'\x02\x00"\x00\xd1\xf8\x02\x00$\x00$\xf9\x02\x00&\x00\xb1mW?}\x804?'
 b'\x02\x00@\x00\x00\x00\xc7\xca5\xe4\x87\x01\xe2\x89\xc3\xbe\xc3tK\xab'
 b'\x97\x06z\xef?/SqD\xd1^NU\xe2\x7f\xcf\xe7\x17|p\xa5V\xa1\xa3\xf4&\xc1\x10'
 b'\x1c\x1c\xa4F\xdf\xba\xa1\xa9\x8b\x07\x9f2k\x01m\x03\xff')

{'A1': 'th',
 'A2': [{'B1': 3080, 'B2': [-13, 111]},
        {'B1': 29271, 'B2': [-78, -13]},
        {'B1': -1839, 'B2': [81, 63]},
        {'B1': -1756, 'B2': [-70, -63]}],
 'A3': {'C1': [0.8415175080299377, 0.7050855755805969],
        'C2': 3828730567,
        'C3': 2313290119,
        'C4': 195,
        'C5': 50110,
        'C6': 0.9836457216537,
        'C7': 21295},
 'A4': 156,
 'A5': -0.249143536276079,
 'A6': {'D1': 9215021582640039025,
        'D2': 11625661390640375759,
        'D3': 11825357579853690019,
        'D4': 11459281337546628934,
        'D5': 50},
 'A7': [107, 1, 109, 3, 255]}

Вариант №12

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

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

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

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

(b'YWEV\x88\xb4\xd8\xab\xfe$\x87U\x9f7\x00\xb0\x07\x05\x00\x00\x00[\x00\x00'
 b'\x00=\xb0p?\x0c[xbv>\xfao\x1b\xc2\r\xb6\xd3\x9bl\x00\x00\x00\x8d'
 b'\x00\x00\x00\xae\x00\x00\x00e\xa4r+@\x95\xffC\xa9\x94\xa6\x04\x8e'
 b'\xde\xe5\xef\xbf\x98\t9\xbf\x17\xa3#yttmnndd=\xb9\x81\xb8hlbou:\xaav"'
 b'\x0b\xba|v\xf5Dg\x00\xea\xfc+-\xbaH\xa9\x12\x8d[.N\xd2\x97h\xb8T\x03\x00\x00'
 b"\x00`\x00\x00\x00B\x8b\x13W\xdb\x07q\xdf\xceL\x0e\xf4'\xf4\xb1 \xb1;\x9b"
 b'\x94\x9a\x0e\x8c\xd1\xef\x02\x00\x00\x00\x85\x00\x00\x00\xdek\xecE37'
 b'\xa6:\xca\xac\x1c*\x12\xf9\xca\xbe\xb2K\xa9\xc1\xa17\x1aS,\x02'
 b'\x00\x00\x00\xa6\x00\x00\x00')

{'A1': {'B1': 11481231418012194996,
        'B2': {'C1': 101,
               'C2': -6249870841368317276,
               'C3': -0.9968102239410706,
               'C4': -0.7228026390075684,
               'C5': 2032378647,
               'C6': 'ttmnndd',
               'C7': -1199457987},
        'B3': 1968,
        'B4': 'hlbou',
        'B5': 0.9401891827583313,
        'B6': 23308,
        'B7': 0.2406100034713745,
        'B8': -7218225607537364998},
 'A2': [{'D1': 234,
         'D2': [3123522556, 2366810440],
         'D3': 3528339035,
         'D4': 1421371543,
         'D5': [578202170, 1987885579, 6767861]},
        {'D1': 206,
         'D2': [670305868, 2971709940],
         'D3': 2593430331,
         'D4': -271479794,
         'D5': [1460898626, -546240549]},
        {'D1': 202,
         'D2': [304749740, 2998848249],
         'D3': 2713823563,
         'D4': 743643703,
         'D5': [1173122014, 983971635]}]}

(b'YWEV\x88\xc5\x13\x94t\xfc\xd6\xa867\x00\r`\x02\x00\x00\x00[\x00\x00'
 b'\x00\xf1-\x1e\xbf;x\x0e\x016>\x92\xb5M\\\x05/]Zi\x00\x00\x00\x8e'
 b'\x00\x00\x00\xaf\x00\x00\x00+[\xe5\x85\x05Y)\x87\xb9L$\xfd\x0c_9\xd6?mHW?'
 b'#\x9bV\x8cdijmbdhqzx\x9cxp\x9a\xa2\x87\x16\n\xb8\xc7\xc7)D\x1a`\xc2PN'
 b'\xc8~\xc4"Y\xd3\x82\x9f\xc8\xe1\xfd\x8c\xf7\x07\x03\x00\x00\x00]\x00'
 b'\x00\x00\xf1\xe3s\xaa4\x1d\xba+\xf0(\x94B1\xdb\xf4m\xc7\xda\x18+\x0el'
 b'\x94\xfc\x9aXm\xa5\xbd\x03\x00\x00\x00\x82\x00\x00\x00\xff\xc3\x9c\x8aq'
 b'\xa5\xed\x8c\xe7i\x02]\xf4\x82kv\xff\x01\xe1\x99/d\x968\x9d\x02\x00\x00\x00'
 b'\xa7\x00\x00\x00')

{'A1': {'B1': 3938634253911462853,
        'B2': {'C1': 43,
               'C2': -5078044592515455653,
               'C3': 0.34725166576806,
               'C4': 0.8409488797187805,
               'C5': -1940481245,
               'C6': 'dijmbdh',
               'C7': -1669825935},
        'B3': 24589,
        'B4': 'xp',
        'B5': -0.6178885102272034,
        'B6': 30779,
        'B7': 0.17773839831352234,
        'B8': 6511412336317543826},
 'A2': [{'D1': 194,
         'D2': [2127056464, 3545834180],
         'D3': 3788021634,
         'D4': 133663997,
         'D5': [377987738, -943212534, 1612334121]},
        {'D1': 49,
         'D2': [3345872091, 237705434],
         'D3': 2600244332,
         'D4': -1113232040,
         'D5': [-1435245583, 733617460, 1117006064]},
        {'D1': 231,
         'D2': [4099736169, 4285950850],
         'D3': 798613761,
         'D4': -1657235868,
         'D5': [-1969437697, -1930582671]}]}

Вариант №13

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

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

(b'FEMO/\xa2\x97\xb3\x9a\xbc\xbb\xda\xd5\xd6Y\xeb\xb8\xb7-&\x02\xec\x02\x00'
 b'\x00\x00=\x00\xeb|\x96\x95K\xce\xdb\xca\x9dh\xb5\xef\xfa\x86v\xb5\x82\x96$^'
 b'\x00\xe6\x10%\x01\x92}\xac\xd4\xdav\xae\x9ac\x02\x00\x00\x001\x00'
 b'\x00\x00\t\x056\xbf\xce\x04\x00\x00\x005\x00\x00\x00\x81\x1f\x1e?2'
 b'\xac\x8f\x19{\xc4r/\xe5=\xa2\xbe\x99~["\xb5\x1b\x99j>\'\x8b\x81\x07'
 b'\x00W\x00\x910;\xa8\x898j+')

{'A1': -1699506270,
 'A2': -68,
 'A3': 13238589875744529083,
 'A4': {'B1': -335403475,
        'B2': [{'C1': 99, 'C2': [4326, 293], 'C3': -0.7110143303871155},
               {'C1': -50,
                'C2': [32146, 54444, 30426, 39598],
                'C3': 0.6176682114601135}],
        'B3': 2509667563},
 'A5': 3403402827,
 'A6': {'D1': -99,
        'D2': -19096,
        'D3': [64239, 30342, 33461, 9366],
        'D4': {'E1': [47, 229, 61, 162, 190, 153, 126],
               'E2': 2827814821862646363,
               'E3': -117,
               'E4': -127,
               'E5': [50, -84, -113, 25, 123, -60, 114],
               'E6': 2822451345,
               'E7': 728381577}}}

(b'FEMO/\x10%\x10{\xb1\rN+4#U\x96\xa8A|\x90\xc8\x03\x00\x00\x00=\x00\xdd\xa1%s'
 b'"\x9frDp\xf8\x85\x83|\xcd\x10e|\xb2\xe5k\x00\x82\x1cL]\xd5g\xbbkZ\x9c\xeb'
 b'\x0ea\x02\x00\x00\x001\x00\x00\x00+\xd18\xbf3\x02\x00\x00\x005\x00\x00\x00C'
 b'\x0e\x8b:}\x02\x00\x00\x009\x00\x00\x00v\xb3n?\xf2\xca~\xad\x18\xac`\x9c'
 b'?\xaf.\x87\xfb\xf1\x02d\x0e\x15\x8e\x07\xd9\xe0\xaf4\x07\x00d\x00'
 b'\xb9U\xc7\x93\xb1\xbf\xc1\x02')

{'A1': 2064655632,
 'A2': -79,
 'A3': 12147990654565961229,
 'A4': {'B1': -930055103,
        'B2': [{'C1': 97, 'C2': [7298, 23884], 'C3': -0.7219416499137878},
               {'C1': 51, 'C2': [26581, 27579], 'C3': 0.0010609108721837401},
               {'C1': 125, 'C2': [40026, 3819], 'C3': 0.932425856590271}],
        'B3': 1931846109},
 'A5': 1148362530,
 'A6': {'D1': 112,
        'D2': -31240,
        'D3': [31875, 4301, 31845, 58802],
        'D4': {'E1': [156, 63, 175, 46, 135, 251, 241],
               'E2': 16201989441262085122,
               'E3': -81,
               'E4': 52,
               'E5': [-14, -54, 126, -83, 24, -84, 96],
               'E6': 2479314361,
               'E7': 46251953}}}

Вариант №14

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

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

(b'HEPO\xe3\x02\x00\x00\x00a\x00\xab\x8b\x08\xc2\xb6C\x9b\x05m\xf1\xd3\x0e.'
 b'\xb0\xda\x06\xda\xcbekewT\xed\xc2\xe2\xae\xbe\xc2\xb65\x9a<\xe3\xf6\x05\x00'
 b'i\x00\x00\x00\xda\x9aY\xe2,jEL)l\xec\xaf\xf6\x10\xd9\x05\xde\xf4G\xe1'
 b'?\x1c\xdb\xd0\xbeQ,O\xdfV\xa7\xc0r6\x9a7\xbf\xc0\xcd\xc1\xa6\x08\x15X'
 b'\\I\x00\x00\x00U\x00\x00\x00I\x97#\x91\xee\r\x7f\x96\x08\x9d')

{'A1': [{'B1': -0.4079216718673706, 'B2': 8268792907407764561},
        {'B1': -0.7171968221664429, 'B2': 6654091576341548480}],
 'A2': 35755,
 'A3': -1050176973693337080,
 'A4': 14689060670950739667,
 'A5': 'ekew',
 'A6': -4780,
 'A7': {'C1': -7486, 'C2': 174, 'C3': 17790129586067391166},
 'A8': {'D1': [-26807, -28381, 3566, -27009, -25336],
        'D2': [218, 154, 89],
        'D3': 1164586210,
        'D4': 76,
        'D5': 41,
        'D6': 4138724460,
        'D7': 0.5400337540038738}}

(b'HEPO\xe3\x02\x00\x00\x00a\x00\xab\x15\xe7\xa0\x12h\xd1\xd8+\x9ay\x94\xd1'
 b'\xe5M\xff\x8dSkufcW$\x01\xe2h\xb5\x9a_\xb6\x1btk\xd2\x02\x00i\x00\x00\x00'
 b'wi\xda\xa8\xcfI\xa2\xd0\xc9.\xe2)\xd7X\xe1U\xb6\x0b\x83\xd2?h\xd4{\xbe\xa7|D'
 b'\x85R\x9d\x02\xb8\x8b\xd8\xc1\xbejr4\x9f\xeeh=rI\x00\x00\x00U\x00\x00'
 b'\x00\x94r\xc4\xd9')

{'A1': [{'B1': -0.24592745304107666, 'B2': -5187410843028652889},
        {'B1': -0.3786052167415619, 'B2': 8231851067985654378}],
 'A2': 5547,
 'A3': -7337532773964275481,
 'A4': 6020748986897503353,
 'A5': 'kufc',
 'A6': 9303,
 'A7': {'C1': -7679, 'C2': 104, 'C3': 15162340232845564597},
 'A8': {'D1': [29332, -9788],
        'D2': [119, 105, 218],
        'D3': -1572221016,
        'D4': 208,
        'D5': -55,
        'D6': 3609846318,
        'D7': 0.2892483978862592}}

Вариант №15

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

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

(b'WYCMX5\x00\x00\x00\x02\x00\x00\x00R\x96\xda?\xe5*\xc4\x9et\x882\x00\x00\x00V'
 b'nc#\xb5\xa7\x14uU\xeb/\x00\x02\x00\x00\x00\x1c\xd4*\x07\xc1\x95M\xfe\xc3&l1n'
 b'r\x1c\x11\xaev<{1D\x00\x02\x00\x00\x007\xadl%_\xe5\x95\xd7\x19;'
 b'\xae\xb8\x00\x1e\x009"\xff\xbfT8s\xe7w_;\xb2\xb8\xafAK$\x7f\xad\xbf(\r\xd4'
 b'\xbfb\x9a\xfa\xbe\xf5\xacC\xbf0^\xa3\xbdy\xfb\xe4\xbfY\xab\xda>\xa8W_'
 b'\xa8\x03,\xe3\xa3g\xad%\xeaX\xff\xc2\xca')

{'A1': 53,
 'A2': [{'B1': 9141,
         'B2': 42772,
         'B3': 1968565039,
         'B4': 'nc',
         'B5': -3158703660631982397,
         'B6': 9836,
         'B7': 49},
        {'B1': 7185,
         'B2': 44662,
         'B3': 1014706500,
         'B4': 'nr',
         'B5': -5950339913859344615,
         'B6': 15278,
         'B7': -72}],
 'A3': -26918,
 'A4': 0.6614707083538234,
 'A5': {'C1': 34,
        'C2': 18428540801662809951,
        'C3': {'D1': 0.005454144906252623,
               'D2': [65, 75, 36],
               'D3': 32685,
               'D4': [-0.6564610004425049,
                      -0.8851772546768188,
                      -0.479829877614975,
                      -0.6889440417289734,
                      -0.06103123724460602,
                      -0.8502784967422485,
                      0.3287915885448456],
               'D5': -6340174494196847323},
        'C4': -22,
        'C5': 1493156554}}

(b'WYCMXU\x00\x00\x00\x02\x00\x00\x00R\xc43\xbf\xeaA8\x10\x93v\x84\x00\x00\x00V'
 b'ko#\x1a\x178V/\xb9I\x00\x02\x00\x00\x00\x1c\xc0\x0e \x99\xd7\xe434\xf6S?o'
 b'szsQ\\\x1d\xd4\x8f\x1e\x00\x02\x00\x00\x007\xceI\xfe;\x8d\xa21m\xc9'
 b'\x8fj\x00\x1e\x009\x16\xbd\x12\x05\xd7+m\x1b\xf0?JH\x05\xcbX(t\xf3?)\xe1\x87'
 b'>\xb5\xef\xf7\xbe\xf4\x17v?|\x00$>\x84\x8e\xa3?j\xa4a\xbe\xc3B\x81'
 b'\xa8\x06\xb5\x90eLY\xe5\xc7}{\xd5\xa5')

{'A1': 85,
 'A2': [{'B1': 8986,
         'B2': 5944,
         'B3': 1445968201,
         'B4': 'ko',
         'B5': -4607709523629296844,
         'B6': 63059,
         'B7': 63},
        {'B1': 31347,
         'B2': 20828,
         'B3': 500469534,
         'B4': 'os',
         'B5': -3582052496863776403,
         'B6': 51599,
         'B7': 106}],
 'A3': -15309,
 'A4': -0.820461304068616,
 'A5': {'C1': 22,
        'C2': 13623958244453850096,
        'C3': {'D1': 0.7901614308357239,
               'D2': [203, 88, 40],
               'D3': 29939,
               'D4': [0.6635975241661072,
                      0.3553464114665985,
                      -0.4767414927482605,
                      0.9843771457672119,
                      0.2589007318019867,
                      0.9165707230567932,
                      -0.3813667595386505],
               'D5': -6339179793697973787},
        'C4': -57,
        'C5': 2105267621}}

Вариант №16

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

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

(b'YKSV}\x00\x00\x00\xcd\x9f\x00\x00\x00\xa7\xec\xa9\xdb8^\xed\xf4E\x17j'
 b'\x1a$\xbc\xb9R%$x\xfc\xa0\xbc\xed\xf8\xcaox$\x88\xfd\x84/\xc0\x93\x99'
 b'\xb4\xefN0cyP3YL\xf5.E\x07\x006\x00\x00\x00\xa4\xfa\xc0_\xb5\xf9\x96\xe5\xe4'
 b'1\x06@\x05\xe7\xab\xef\x02\x00Q\x00\x00\x00\xa0\x04\xfa\x8c\xe2\xa7\xba'
 b'9w\xee:A3z/4\x02\x00g\x00\x00\x00\x1a\xb1\xb2\xbb\xb8\x97N\xb9\xb0\x8d0\xf1|'
 b'\xf6\x02\x004\x00\x8a S\xbe\x118@\r=\x00\x00\x00S\x00\x00\x00i\x00\x00'
 b"\x00\xaf\xf9}Pc'\xcd\xa8!\xc6\xackF(\xf7\xf7\xdd?\xd1\xe1\\\xf8\x18"
 b'\x90\xf6\x9c')

{'A1': {'B1': 'cy',
        'B2': 954824769861263498,
        'B3': [{'C1': [80, 51, 89, 76, 245, 46, 69],
                'C2': -1903059235126576476,
                'C3': 12772,
                'C4': [6, 64, 5, -25]},
               {'C1': [171, 239],
                'C2': 4159821797299717280,
                'C3': -4489,
                'C4': [58, 65, 51, 122]},
               {'C1': [47, 52],
                'C2': -5093967308830625510,
                'C3': -29264,
                'C4': [48, -15, 124, -10]}],
        'B4': 1350433199,
        'B5': 10083,
        'B6': -970872627},
 'A2': 205,
 'A3': {'D1': 0.4682596104918797, 'D2': 11310385951108030929},
 'A4': {'E1': 60583,
        'E2': 1677015736590588841,
        'E3': 2604578917182610026,
        'E4': -0.019651636481285095,
        'E5': -177852085590886163,
        'E6': 5687963426094067588,
        'E7': 48}}

(b'YKSV{\x00\x00\x00*\x9d\x00\x00\x00\\\xbaY8m\xbf\xd5=/\xd3\xd7\x88D\xfb\x00'
 b"\xabk\xbd\xfe\\>?\x01'\x84\xc68\xa8Dn9\xd1$A\xc3\x90<w2jdLC\x02\x006\x00"
 b'\x00\x00%m\xe6bA\xa6*\xce\xb6\xda\xc6W\xadS\xae\x83\x02\x00L\x00\x00\x00'
 b'\xae\x9c[H\xa9\xc8b\xa0\x93y_\xd6\xa0\xe54\xe7\xf6;)\x05\x00b\x00\x00'
 b'\x00o/\xeea h\x07A\x12\x9aPP\x9f\xc7\x02\x004\x00\x1co<lw\xedb[8'
 b'\x00\x00\x00N\x00\x00\x00g\x00\x00\x00\x18\xa0\xe0\xed\xf0\xab;\xe3\r'
 b'\xc3\x10\x9e#\xe46\xb3\xc1\xbf\xa7\xf7\xfa\x853?j\xcd')

{'A1': {'B1': 'jd',
        'B2': 6585086702341877532,
        'B3': [{'C1': [76, 67],
                'C2': -3590874953112195803,
                'C3': -9546,
                'C4': [-58, 87, -83, 83]},
               {'C1': [174, 131],
                'C2': -6889723850534445906,
                'C3': 31123,
                'C4': [95, -42, -96, -27]},
               {'C1': [52, 231, 246, 59, 41],
                'C2': 4685828425593532271,
                'C3': -26094,
                'C4': [80, 80, -97, -57]}],
        'B4': 3990921240,
        'B5': 44016,
        'B6': -1022500037},
 'A2': 42,
 'A3': {'D1': -0.13828169002157198, 'D2': 14801712615830255527},
 'A4': {'E1': 47708,
        'E2': 15217449654157129817,
        'E3': 13649191116380342487,
        'E4': 0.743606448173523,
        'E5': 7945660604390582017,
        'E6': 8591901357402018105,
        'E7': 50}}

Вариант №17

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

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

(b'MLVU\xf6hrnor\xc1Lk)\xe5\x0fuI\xdf\xa8\x08\xff+\xdc\xdb\xdd\xbfg'
 b'\xa3\x91\xf8\x920\xf2\x13\xbe\x03\x00\x00\x00\\\x00\x00\x00\xf3\xa3\x04\x00'
 b'\x00\x00_\x00\x83\x04\x00\x00\x00c\x00e\x04\x00\x00\x00g\x00\t\x06'
 b'\x00\x00\x00k\x00\x1b\x04\x00\x00\x00q\x00\xcb\x06\x00\x00\x00u\x00\x95'
 b'\x10v\x91\xbcwal\xef(yx\xa8\xa9\x19>S\x1b\xc9}\xe5\xdc\xc7\xb5\x82u\xbcgm'
 b'9\x16\xa8A\x8d\xb0p')

{'A1': 'hrnor',
 'A2': {'B1': {'C1': -63, 'C2': -450270388, 'C3': -548834033},
        'B2': -0.46654419228083066,
        'B3': -124673177,
        'B4': 146,
        'B5': -0.14447855949401855},
 'A3': 'wal',
 'A4': -23565,
 'A5': [{'D1': [-17, 40, 121, 120], 'D2': -125},
        {'D1': [-88, -87, 25, 62], 'D2': 101},
        {'D1': [83, 27, -55, 125], 'D2': 9},
        {'D1': [-27, -36, -57, -75, -126, 117], 'D2': 27},
        {'D1': [-68, 103, 109, 57], 'D2': -53},
        {'D1': [22, -88, 65, -115, -80, 112], 'D2': -107}],
 'A6': -0.017756491899490356}

(b'MLVU\xf6uvnxk\xf8M\xba\x11N\xc5\xc7\xa7\xf5\x9e\xd1\xd7\x9d\xbc\x19\xee?\xdd'
 b'\x00\x07:\x15\x8c\x9c.=\x03\x00\x00\x00\\\x00\x00\x00\x94g\x03\x00'
 b'\x00\x00_\x00\x10\x04\x00\x00\x00b\x00\xd3\x05\x00\x00\x00f\x00\x91\x05'
 b'\x00\x00\x00k\x00\xd6\x06\x00\x00\x00p\x00\xa6\x04\x00\x00\x00v\x00\xca'
 b'!\xd1\xf5\xbeeqr\xe7W}f\xbe\x8f\xfa[\x17%\x0cp\x066b\xb8\x08\x82WM\x08'
 b'U\xe2I\x1e]W')

{'A1': 'uvnxk',
 'A2': {'B1': {'C1': -8, 'C2': 1309784653, 'C3': -173553723},
        'B2': 0.9406416972038192,
        'B3': 973537501,
        'B4': 21,
        'B5': 0.04262976348400116},
 'A3': 'eqr',
 'A4': 26516,
 'A5': [{'D1': [-25, 87, 125], 'D2': 16},
        {'D1': [102, -66, -113, -6], 'D2': -45},
        {'D1': [91, 23, 37, 12, 112], 'D2': -111},
        {'D1': [6, 54, 98, -72, 8], 'D2': -42},
        {'D1': [-126, 87, 77, 8, 85, -30], 'D2': -90},
        {'D1': [73, 30, 93, 87], 'D2': -54}],
 'A6': -0.48011115193367004}

Вариант №18

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

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

(b'\xddCLVY3\xd6\xa8\xf1\x1a&\r2\x04\x00\x00\x003\x007\x00\x00\x00Z\x00e\x00F'
 b'c\xf0Q^\x10\xb8\xe1g_\x83\xb3\xd9\xc3\xbb\x02\xde\x98\x15\xaa?4\x16\xe9iqom)'
 b'\xdc\xb1$\x95\xbdg\xbf\xa9\x1b\x152\xbfB\x8e\xe4\xa1\x14H\x89[\x98\x8aD\xbf'
 b'\xa1\xe3wjysijpo\xd4m3p\xcc\xfd?\x8b\x05\x9fD\xc6Hn\xc5\x07?S0\xa5w7')

{'A1': 3606580773759014451,
 'A2': 'iqom',
 'A3': {'B1': 615636009,
        'B2': {'C1': -0.905236542224884,
               'C2': -87,
               'C3': -0.6956345438957214,
               'C4': 6595882382713458242},
        'B3': -0.7677397727966309,
        'B4': -7263,
        'B5': 'wjysijpo'},
 'A4': [{'D1': [212, 109, 51, 112, 204, 253, 63], 'D2': 1151272331},
        {'D1': [198, 72, 110, 197, 7, 63, 83], 'D2': 930587952}],
 'A5': 1374708550,
 'A6': [3786936414, 3011731303, 45859801, 2853542110],
 'A7': 13375,
 'A8': -5866}

(b'\xddCLVYJ\xef4\x1b\xab\xb8\xb1\x86\x02\x00\x00\x003\x005\x00\x00\x00X'
 b'\x00c\x00\xc4\xdcv\xd4\x8b\x17\xfc\x11\xa4\x80l\x8c\xbe\x1d\xb3j\xf5'
 b'\xb3s\xf6\xfe\xaf\xad\xbfxu\x9f\xe8\xcb\xf4W\x9f\xc4>\x10\x0f\x06\xa0>\x0cb'
 b'\x8f\xf5\xdd"\xf1\xc4\x93*|?{\xedxnieboavO\x03u\xdb\x92di\xeah\xbf\x1b\xf3'
 b'\x18\xe7\x87\x80^M*!\xbd\xf8')

{'A1': 9705741716995501898,
 'A2': 'xu',
 'A3': {'B1': -187963233,
        'B2': {'C1': 0.3840281665325165,
               'C2': 16,
               'C3': 0.3125462234020233,
               'C4': 14191162237524075020},
        'B3': 0.985024631023407,
        'B4': -4741,
        'B5': 'xnieboav'},
 'A4': [{'D1': [79, 3, 117, 219, 146, 100, 105], 'D2': 465529066},
        {'D1': [243, 24, 231, 135, 128, 94, 77], 'D2': 4173144362}],
 'A5': -730407740,
 'A6': [301733771, 2355921060, 1790123454, 4134777845],
 'A7': 45054,
 'A8': -16467}

Вариант №19

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

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

(b'FLVU^\xd0b\xcd\x8b\x05\x00\x00\x00r\x00\x00\x000\x14_\x9b\x8c\xe9\x06Z\x8cc9'
 b'\x97\\w\x8fcu?\xd3o\xe8\xbe\x0b}\x00\xf5\xf6\xfb\xfbTrX?^\xe6\xfb\r\xa3$'
 b'\xf7\xe9\xddu\xc3s\x85\xf8\xba\x0e-\xdf\xba\xf5_\xbf\x90y\x00\xbf'
 b':\x95\x00\xa0\x12\x8b~\xad\x10t?\x9a\x0eQ\xc9\x04\x9c-e\x9a\x880\x0b\xac'
 b'>BG\xd0\xbfT\x9a?\x9a\xa5\x00\x00\x00\xc9qmnjiC\x01\x85\xd3\\\x02\xd8\xb1 '
 b'\xc3\xed\n\xdf"\x15l\x03\x00w\x00v\x97\x1ea\xb2\xf8\xac!K\xc6\x03,\xcb'
 b'\xc7\xf4\x03>^%\x06\x04\x00\x8d\x00\xcc\xbe\xc9*r\xb9-\xb9\xdc\x11\x0e\x8d')

{'A1': -1949474096,
 'A2': 'qmnji',
 'A3': [{'B1': 6487129103385170992,
         'B2': {'C1': 25484,
                'C2': -26823,
                'C3': 30556,
                'C4': 0.9585503935813904,
                'C5': -0.45397815108299255,
                'C6': 11},
         'B3': {'D1': 2512739133393252824,
                'D2': 21,
                'D3': 108,
                'D4': [323, 54149, 604],
                'D5': -26762},
         'B4': -67373323,
         'B5': 0.8454945087432861,
         'B6': 234612318},
        {'B1': 8341640530793800867,
         'B2': {'C1': 63621,
                'C2': 3770,
                'C3': 57133,
                'C4': -0.8748432397842407,
                'C5': -0.5018548965454102,
                'C6': 58},
         'B3': {'D1': 6790869637980171267,
                'D2': 37,
                'D3': 6,
                'D4': [24862, 63666, 8620, 50763],
                'D5': -16692},
         'B4': 2123043488,
         'B5': 0.9533794522285461,
         'B6': -917434726}],
 'A4': [-25596, 25901, -30566],
 'A5': -0.25434929008786167,
 'A6': 2587859540,
 'A7': {'E1': 10953, 'E2': 10164081048719047026},
 'A8': 201}

(b'FLVU^\x16\x9dQt\x03\x00\x00\x00r\x00\x00\x00O\xa9\x82:o/\xbc\xef(\xc4\xfa'
 b'\xf6\xd3t\xefLP\xbfj\xc7!\xbc\x03\x81\x00\r\x7f\xc5\x9d\x9d>6?"\xea'
 b'\xd0b\x80\xa6\xae-4\xeci\xd5L\x11_\x91\x84\xe0OA\x08\xbe\xe6\xb9\xa6\xbd'
 b'\xb4\x9b\x00F\xff\x94\xb8\xd2\xe6\x81>\x18\xff\t\xa10\x02\x8c\xcdH\xfch|['
 b'\x08\x95\xd6\xde\xbf\n\xe6\x98\xa5\xab\x00\x00\x00\xb8gel\xbfQy\xcd&\x9b@'
 b';\xa4+\x96\x16\x1a\xbf\xcb\x89\xae\xd1\x91\xb4yz\x06\x00u\x00\xe0'
 b'g\x91\xaf\xf8H!\xfe\xc9\x0c>\x0b\xab\xb5\x9b\x1a\xea\x17\xe4\xac\xa2'
 b'B\x05\x00\x91\x00\x8b\xf7\xaeD\xcc\xbc\x9db\xbc\x7f\xdd\xcd')

{'A1': 1951505686,
 'A2': 'gel',
 'A3': [{'B1': -1172009648253654705,
         'B2': {'C1': 50216,
                'C2': -2310,
                'C3': 29907,
                'C4': -0.8136739134788513,
                'C5': -0.00987420417368412,
                'C6': 3},
         'B3': {'D1': -5435332727693132006,
                'D2': 121,
                'D3': 122,
                'D4': [20927, 52601, 39718, 15168, 11172, 5782],
                'D5': 26592},
         'B4': -1648001267,
         'B5': 0.7118929028511047,
         'B6': 1657858594},
        {'B1': -3068661962227407232,
         'B2': {'C1': 4428,
                'C2': -28321,
                'C3': 57476,
                'C4': -0.13306163251399994,
                'C5': -0.0814092606306076,
                'C6': 180},
         'B3': {'D1': -5988635310259718741,
                'D2': 162,
                'D3': 66,
                'D4': [44945, 18680, 65057, 3273, 2878],
                'D5': -2165},
         'B4': -1198194874,
         'B5': 0.2537141442298889,
         'B6': -1593180392}],
 'A4': [560, -12916, -952],
 'A5': -0.4818470555891907,
 'A6': 2778261002,
 'A7': {'E1': 17582, 'E2': 14834153194713365708},
 'A8': 184}

Вариант №20

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

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

(b'\xebGXIW\xdb\x89\x8b\xe2\xd4[ac\x004\xe2`\x8e\xafpdkj\x00\x04\x00\x96\xbe'
 b'k\xf6\xb8\x8e\x16ZZ:\xb9\xd5!U\xf3\xb9\xb8\xf9\x16\x1c\xff\xcc'
 b"\xb4\x84\xe5\xbc\x02\x8c\x801rk\x96\x99\xe0c\xf7\xd5d'/\xcc\x00\x02\x00 "
 b'\xc1g\x92\xad\xdf\xdb\xb1\x0f\xed\xd83\xde\xfa\x96[\xb9\xa9\x00\r\xb7'
 b'\xbb\x03\x83\xef\x0c\xb9\x8d\xfdZ,\x05\xe6\xd6\xe5k{5\x03bU\xb1\x81\x08\x81'
 b'\x0f5i\x00\xaf\xa9\x83Ix\xfd\xd3\x8f\x9c# ,\xb1\n\x07i\xa1;|\x9f\xd9yG\x13'
 b'\x8b\xee\xeb\xcc##X<\xcd V|\xf0\x81\xcci{\xc8A`\xb0\xce')

{'A1': 15819328972457206115,
 'A2': {'B1': 183662634676754073,
        'B2': {'C1': 16169039583070597068,
               'C2': [{'D1': 375020090, 'D2': 47573, 'D3': 559281081},
                      {'D1': 3103331868, 'D2': 65484, 'D3': 3028608444}],
               'C3': [-4510475226305548017,
                      -1308238658971214919,
                      -6268995598531984401,
                      916920118425683430,
                      -2961843003011669419,
                      -5656230306601670400,
                      -5788951494422310001,
                      -7195872403287046295],
               'C4': 2705030303,
               'C5': 15670634527689993164},
        'B3': 8995},
 'A3': 3797978799,
 'A4': 'pdkj',
 'A5': [1480379680, 1451028609, -865502264, 1096855758],
 'A6': -0.23043334484100342,
 'A7': -114}

(b"\xebGXIWp\x13\xe8\xbd'\x07<\x95\x004\xac\xbf\x9f ofdo\x00\x04\x00\x96\xbe"
 b'\xd4\x93\x95_\x1e\xfbkG\xb7\x86\x06\x85j\xd7\x1b\x06m\xe9\x9d\x13\xd4JK\xae'
 b'V\xb8\x99\xbd\xb0\x91\xdc\xd5N/\xfdv\x87\xe3\x18\x1b\x00\x02\x00 _Q\xaa\xf3'
 b'\tN \xb7\xae\t\xa8\xa3>7\xc7k0V%\xd1\xce\xe3_e=\x8b\xf4\x1b|\xea\xa1\xd0'
 b'\xf8\xfdX\xe8~x\x03V\x06vk&\xed\xdcfvF\x1f\xdb\x1ed\xa1\x0fEm\xe0\xd3\x85'
 b'\x8e)\xb2J9>*\x10X\xbaj\x040C/k\xba\x94T\x1e!\xb1\x19\xde8\x1eGy\x1cg\xebe'
 b'\x8c\x10')

{'A1': 8076054455906679957,
 'A2': {'B1': 6248913522966781141,
        'B2': {'C1': 5634000344391555099,
               'C2': [{'D1': 519793479, 'D2': 46982, 'D3': 109406935},
                      {'D1': 453406185, 'D2': 40211, 'D3': 3561638830}],
               'C3': [6868458867526607031,
                      -5906004017242716309,
                      3483012944867057509,
                      4434906656973431248,
                      -505149827618176170,
                      465677426422998646,
                      5052998230516764485,
                      7917560715486540362],
               'C4': 960375312,
               'C5': 6393539187227963243},
        'B3': -17772},
 'A3': 2898239264,
 'A4': 'ofdo',
 'A5': [1411260849, 433993758, 1199119463, -345666544],
 'A6': -0.4151884615421295,
 'A7': 95}

Вариант №21

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

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

(b'IAV\xdeS\xea,`\xbbL\x89\xb7\xa6\xdeT\t\xa9\x9fk\xef\xbf<\xfe\xf9[u\xdeG'
 b':\xdd_\x00\x1e\x1b\xc4\x87\xed\x9a\xfav\xda\xe1>\x10\xa1;\x98\x97'
 b'\x9d\xaa|\xa5\xce\xe4\x1e\xb7\xfdX\xbc\xa0\x14\xb5\xbf\xac\x80\x85\xd8\xb1'
 b'\x08)`\xcf\xbf9\x08\x03P\xe1\xfap\xe6v(M\x1bO\xd7\xcaYS\x1d\xd6Qw\x0b\x98'
 b"\x8b\xd4\xd4\xbbK\xd6\xbf\xd2ojbpg'\x007\x00\xfcvv\x1d\x03\x00G\x00")

{'A1': {'B1': {'C1': -34, 'C2': -5221557925303227821, 'C3': -90},
        'B2': -0.9818876554005802,
        'B3': 60,
        'B4': 1968962046,
        'B5': 18398,
        'B6': 58},
 'A2': 221,
 'A3': {'D1': -0.34837241920666306,
        'D2': -46,
        'D3': 'ojbpg',
        'D4': [{'E1': 0.44111984968185425,
                'E2': [-1740922608, 2091556247, 518311589]},
               {'E1': -0.01324408408254385,
                'E2': [-1078651744, -662339412, 1613301937]}],
        'D5': 494302972,
        'D6': [18077818353195007951, 15514649259519960688, 826219036702628298]},
 'A4': 30,
 'A5': -309869541,
 'A6': 64154}

(b'IAV34\x80(1x\x9b \xb0\xf9\x90\x1fs\xdc\xe9\r\xee?\xafxL\xda\xac\x00Y'
 b'g\xdcW\x00\xd2\xa6\x8a\x82\x03\xc2\x00(^\xb8\xbet\x92\x9b\xadR*`kP'
 b'\xdd\xc1]\x10\x93\xd0>\x05\x88|\xbf\xe1\xa8;\x0f\x8a\xe9\x84\x1e\xdf'
 b'\x14V\xd5\xc5\x97Vuw\x06V\x9d{\xf5X\xce\x10@z\xcb\xf4\xa5\xc9\xbfukesh'
 b"g'\x007\x00\xd4\xdd\xac|\x02\x00G\x00")

{'A1': {'B1': {'C1': 51, 'C2': -5755429383256375244, 'C3': -7},
        'B2': 0.9391984277399263,
        'B3': -81,
        'B4': -1394979720,
        'B5': 22784,
        'B6': 103},
 'A2': 220,
 'A3': {'D1': -0.2003770822088886,
        'D2': 117,
        'D3': 'keshg',
        'D4': [{'E1': -0.360093355178833,
                'E2': [-1382313356, 1801464402, 1572986192]},
               {'E1': 0.40737199783325195,
                'E2': [-1082357755, 255568097, 512027018]}],
        'D5': 2091703764,
        'D6': [8455112226378224863, 14868904081033135735]},
 'A4': -46,
 'A5': 58886822,
 'A6': 194}

Вариант №22

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

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

(b'UPMZ\x03\xc6F\x1b2\x00\x00\x00\x02\x00\x00\x00R\x00I\x9c\xb1\x93V\x00'
 b'\x00\x00\xcfM\x1f\x940i\x83\xfa\xe5;\x85\rQ>\xe7\x8c}\xce\x93\xf0\xf4\xaf'
 b'I\x029\x7f\xe2S\xd5\xcb\x90\xa1`\r\xa7\x03\x00\x00\x00\x1a\x00\xba'
 b';\x99\xe6\x03\x00\x00\x00&\x00}\xbd\xb9\x9c\xdbw("\x97\xe4\xbet\x91\x9e\xf4'
 b'\xe7\xbf\xf1\xb6\x84>\xa0')

{'A1': 457623043,
 'A2': {'B1': 57,
        'B2': -7553,
        'B3': -1865689773,
        'B4': [{'C1': -1492295519, 'C2': [-1809887793, -92051152, 226835429]},
               {'C1': -426165318, 'C2': [-1931002287, -258748803, 38383604]}],
        'B5': [125, 189, 185, 156, 219]},
 'A3': [10359, -26846],
 'A4': 2477890633,
 'A5': {'D1': -0.7486107674539793, 'D2': 0.25920823216438293, 'D3': 160}}

(b'UPMZ\xaf\xf2\xe1r*\x00\x00\x00\x04\x00\x00\x00J\x00\xc0\xf0\xe7\xf2R\x00'
 b'\x00\x00\xc1\xd3K\x19\xd7\xe5Yt"\xfb|\x10\x13\xba\xd0\xb0Mc\xf2\xb6!\xb7'
 b'\xb8\x07$w\xbb\x02\x00\x00\x00\x1a\x00Qx\xef\xf7\x02\x00\x00\x00"'
 b'\x00*\x0b\xb2\xc2\xbd:&{\xa3\xb2\x17@W>\xd11i\x97\x7f\xe7\xbf\xd7(\xd3>\xf2')

{'A1': 1927410351,
 'A2': {'B1': 77,
        'B2': -3485,
        'B3': -1195957834,
        'B4': [{'C1': -1149819897, 'C2': [424399809, 1952048599]},
               {'C1': -135301039, 'C2': [276626210, -1328498157]}],
        'B5': [42, 11, 178, 194, 189]},
 'A3': [9786, -23685, 6066, 22336],
 'A4': 4075286720,
 'A5': {'D1': -0.7343251280385983, 'D2': 0.41242095828056335, 'D3': 242}}

Вариант №23

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

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

(b'VJRH0wxkg\xd5\xb5\xd2A:\x83SP\xe9?rr\xd7\xa6\x05\xbd\xe0.\x99\xeb\xf7m\xa3'
 b'\xbf{\xbc\xe1tA\x11A\xb94\x95D\x00\x00\x00|E\xfch\xca_^\xd5.2\x96\x1e\x14'
 b'wb\xef5]\x03\xf0\xfe\x047\x00\x00\x00 @\x88\xf6i8\xac\x8d\xcfm\x81'
 b'\x1d\xc9$\xfe\xaeJ.\xbf\x99.\x16\xba\x14\xae(\x18\x05\x00\x00\x00'
 b':\x00\x00\x00\x84g\xe0>d\xea\xd53\xd2\xed\xe9\x7f\xc1\x05')

{'A1': [{'B1': 'wx', 'B2': -1244305557, 'B3': 0.7910554469145217},
        {'B1': 'rr', 'B2': -1123703081, 'B3': -0.03794836760479625}],
 'A2': 1960950907,
 'A3': -1186918079,
 'A4': -27340,
 'A5': {'C1': 4,
        'C2': {'D1': 46, 'D2': -27086},
        'C3': {'E1': 4136124448,
               'E2': -1918093207,
               'E3': 495021519,
               'E4': 9417,
               'E5': -2,
               'E6': -0.6808270215988159,
               'E7': 1740832660023291545},
        'C4': {'F1': [5150, 25207, 13807, 861, 65264],
               'F2': 0.4382897615432739,
               'F3': [100, 234, 213, 51],
               'F4': 60882,
               'F5': 32745,
               'F6': [-63, 5]}},
 'A6': 15374831500838847868}

(b'VJRH0nl9\x9b\xb1\xfc\xb0\x7f\x11\xbf\x1e7\xe9\xbfph j\xc1(`\xd3\xfb'
 b'3\xcfL\xe2\xbf\xaf7\xc83\\\x16u\x01lID\x00\x00\x00,%`T\xef\xbb\xf1#\x94'
 b'=\x9e\xd2\xe2\x97\x9a \x03\x88\xdd\x91\xf7\xa57\x00\x00\x00kV\xb2'
 b'\xfd\x0eP\x04;\x1a\x16M\xdeR\xbd\xd52\x95M?RK\xf5\xbc\xff\x14\xdbI'
 b'\x05\x00\x00\x00:\x00\x00\x009#F\xbf\xf7\x89\\\\[\xcd\x8d\xc0_0')

{'A1': [{'B1': 'nl', 'B2': -55469255, 'B3': -0.78797852819479},
        {'B1': 'ph', 'B2': 683764256, 'B3': -0.5718761458689237}],
 'A2': 868759471,
 'A3': 24450652,
 'A4': 18796,
 'A5': {'C1': 165,
        'C2': {'D1': 148, 'D2': -25027},
        'C3': {'E1': 4256323179,
               'E2': 990138382,
               'E3': -565373414,
               'E4': -17070,
               'E5': -43,
               'E6': 0.8030577898025513,
               'E7': 5321870473287781202},
        'C4': {'F1': [58066, 39575, 800, 56712, 63377],
               'F2': -0.7739749550819397,
               'F3': [247, 137, 92, 92],
               'F4': 52571,
               'F5': 49293,
               'F6': [95, 48]}},
 'A6': 2590057897301910828}

Вариант №24

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

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

(b'IJIT\x8fK\x00%\xdf\x85\x19\xee\xbe\x02\x00\x00\x00\x85\x00\x00'
 b'\x00\x98\xe6\xae\xcb&\\c\x87\x1as\xbb(\x14\x81\x02\x00\x1f\x001'
 b'\xde\xe9\x0c\x9d\xd3\x1e\x03\x00(\x00o\xc5?\x7fo\x10\xf1\x03\x003\x00pF\x02'
 b'\xe0\xd0\x8c\xc5\x0c#\x04\x00>\x00i#\x00\x00\x00.\x00\x00\x009\x00\x00\x00F'
 b'\x00\x00\x00\xca\xe0y/H\x15\xf3\x99"\xf8\xe1\xa3\xc2\xa03G\x14\xab\x96L@'
 b"\x00\xfe\xb4'\x8f\xac\x9a\xbc\x12o\xebc\xaaps\xa2\x88 \xe5^\xd5`\x9b%"
 b'Z\x17\x1a\xdb?\x80\xd8JK\xda\x1e\x8d?')

{'A1': {'B1': [{'C1': [10427, -32492], 'C2': 49},
               {'C1': [-5666, -25332, 7891], 'C2': 111},
               {'C1': [16325, 28543, -3824], 'C2': 112},
               {'C1': [582, -12064, -14964, 8972], 'C2': 105}],
        'B2': [-7353510366787542838,
               5130621158338721826,
               -5404882226635166956,
               -1481945151123452121,
               -1936397608466470301],
        'B3': 94,
        'B4': 213},
 'A2': {'D1': -8411,
        'D2': -0.4650384485721588,
        'D3': [0.4234674816456643, 0.01421900312685076],
        'D4': -8691001534199175528},
 'A3': 29466}

(b'IJIT\x8fI\x00\xd1#\x12\x9c\x9e>\x02\x00\x00\x00\x83\x00\x00\x00wch'
 b'\xd5\xda\xb8\x9fr\xa99\xcf\x92*\x8e\x05KJ\xfc\xb0\x08\x05\x00\x1f'
 b'\x00\xb4\xc4\xb0\xe5\x8d\x02\x00.\x00\xc6.y"\xe0\x02\x007\x00\x9fY\x84!\xc0'
 b'\x02\x00@\x00\x80)\x00\x00\x002\x00\x00\x00;\x00\x00\x00D\x00\x00'
 b"\x00\x1aR\x01\xa6\xdd0P'ag\x9d\xbe\xe2\x11H\xb2\xadC\\\x87\x8cxc\xa5\x8aiw"
 b"\xdfn\xfd\x12\xabk\xe7F\x8e\x97\x919'I\x1ePH\xf4\x82#\xf8\xd9?\xb2s\xf1d$"
 b'!\xec?')

{'A1': {'B1': [{'C1': [-27953, -29142, 19205, -950, 2224], 'C2': -76},
               {'C1': [-20284, -29211], 'C2': -58},
               {'C1': [31022, -8158], 'C2': -97},
               {'C1': [-31655, -16351], 'C2': -128}],
        'B2': [2832817894147052058,
               -5600206471076944031,
               -6529242489795361875,
               -6119550291005707894,
               2826450321264797547],
        'B3': 73,
        'B4': 30},
 'A2': {'D1': 9169,
        'D2': 0.309784471988678,
        'D3': [0.4057701853608977, 0.8790456744715043],
        'D4': 8259523491643548535},
 'A3': 14761}

Вариант №25

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

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

(b'CGY\x00\x00\x00\x02\x00\x00\x000-\x9f\xb4t\x02\x03\xf2g\x00\x00\x00\x02\x00'
 b'j/\xd3\x86\x11\xd75\x10\xd1K\xc3?W\xaf\xdd>\xcdK\x91\x83%\xe0\x00nwa\xf7?'
 b'\xa0\x88m\xf0\xba\xd0\x80?<B\r\xb2\xae^\xb6\xe2\xdc\x88h,o!\x17\xbc'
 b'\x18[\xa7?\xe8\xcf;\xdet;\x86\xbe\xdd\x99\x92\xbe\x8a>\xc3/!\xce\xed:'
 b'\xad\x7fy\xfc\x0c\xc8\x002\x00N\xb6r\xc9\xef\x02\x83\xbc^\xc6J')

{'A1': 'wa',
 'A2': 765441140,
 'A3': 33813095,
 'A4': [{'B1': -9,
         'B2': 0.032290874134020875,
         'B3': 0.7353828549385071,
         'B4': 178,
         'B5': 2925442786,
         'B6': [-9080, 26668, 28449, 6076, 6235]},
        {'B1': -89,
         'B2': 0.77529710243276,
         'B3': -0.43281227350234985,
         'B4': 190,
         'B5': 2319369007,
         'B6': [8654, -4806, -21121, 31228, 3272]}],
 'A5': 12243,
 'A6': {'C1': [-2045651147, 282151875, 1062711261],
        'C2': 0.40096715092658997,
        'C3': -125},
 'A7': 9696,
 'A8': {'D1': 13146792290624453726, 'D2': -14774}}

(b'CGY\x00\x00\x00\x05\x00\x00\x000\x84\xb4\x1c! \xb5\xb1\xdd\x00'
 b'\x00\x00\x04\x00\xa5\x02\xdeY\x1fM\xf6\x07\xa714\xae\x1f\xcat>}_ \x88'
 b'\xc6\xf3\x00\xadlbjel\xb3\xbf\xa4\xd6\x10\x1a\xe8\n\xe0?\x1dG\x892\xff'
 b'@\x0f\x17\x04\xa4a\x97\x9f\r\x8cy\xc3\x134?\xa0\xa4\xc6\x8cS\x12\xa0?c'
 b'M>\x1d\x7f\xce\xb4\x04\xc5\xa2\xa25\xafF-[H\x15\xf2?\xa7\x92\xa344p\x80\xbfk'
 b']\x96\xd5MZ\r\x93\x92\xcdf\xaf\x1a\xd2\x82XQ\xd8\xa0\xbf\xc7Z8n\xa3'
 b'\x9eP>\xce6\xd6\x93\xc3c}\xbe\x900\xfc\xeb1\x7f\xd7R\x93z\x005\x00Q\x00m\x00'
 b'\x89\xaf\x18\xdb*\x87\x8ae\xb5Dd')

{'A1': 'lbjel',
 'A2': 2226396193,
 'A3': 548778461,
 'A4': [{'B1': -77,
         'B2': -0.040695670399164774,
         'B3': 0.6143727898597717,
         'B4': 50,
         'B5': 4282388247,
         'B6': [1188, 24983, -24819, -29575, -15597]},
        {'B1': 52,
         'B2': 0.032507137898879934,
         'B3': 0.8878973722457886,
         'B4': 29,
         'B5': 2144252932,
         'B6': [-14942, -24011, -20666, 11611, 18453]},
        {'B1': -14,
         'B2': 0.04604063045755513,
         'B3': -0.9193967580795288,
         'B4': 213,
         'B5': 1297747347,
         'B6': [-27955, 26287, 6866, -32168, 20952]},
        {'B1': -96,
         'B2': -0.1824408092718266,
         'B3': 0.40276211500167847,
         'B4': 147,
         'B5': 3278077374,
         'B6': [-28624, -789, 12671, -10414, -27782]}],
 'A5': 734,
 'A6': {'C1': [1495223798, 128397620, -1373648268],
        'C2': 0.24743318557739258,
        'C3': -120},
 'A7': 50931,
 'A8': {'D1': 12617075331787548085, 'D2': 17508}}

Вариант №26

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

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

(b'ARC\x00\x89\xb6\xecC\x94`\xa7\xfe/\xcc\xd4\xe0\xcb\x00\x00\x00'
 b'\x02\x00\xb1\x00\x04\x00\xb56i\xfe\x87\xd8\xd1?\xe6E\xe0\xb9I\xfe'
 b'\xd4\x96\xeb$h\xb6\xd8\x8e\x89\xce{\xfe{\x98mD\xce\x05\xab\xd625\xdf\xc6'
 b'\xc8\xf3\xe9\x8d\xa3a\xd0\x9f\x0cj%\xdc\x0f\x84\xa8\x94\x02R\xa8\x15'
 b'\xd0I\xdaP\xa8\x004\xd2\xd3\x8f\x84e\xf2\x96q\n\xcf\x17\x00\x00\x00*\x00\x00'
 b'\x004\x00\x00\x00>\x00\x00\x00H\x00\x00\x00R\x00\x00\x00\\ilulx\x86'
 b'.\x83\xe0\xe0\xac\xbf\x96h\xd2x,y\xc0\xbf\x17\x94k*C\x00\x06\x00\x00\x00'
 b'f\xaf\xb7\x9f\xbc\x00\x00\x00\x05\x00\x00\x00~\x00\x00\x00\x03\x00\x00\x00'
 b'\x83\xed\x93x[k\xed\x13\xa4\x18\xf9\x18%\xdcd$\xf1\xf8b\rJ')

{'A1': {'B1': -0.021884239754507595,
        'B2': -0.592108428478241,
        'B3': 10819,
        'B4': [{'C1': 16943782832601205198, 'C2': 31742},
               {'C1': 8905988405406837718, 'C2': 12853},
               {'C1': 16124796465767621473, 'C2': -12129},
               {'C1': 894569103069849748, 'C2': 594},
               {'C1': 12111815788496726016, 'C2': 13522},
               {'C1': 15244548837068927242, 'C2': -12521}],
        'B5': -1346920516,
        'B6': 'ilulx',
        'B7': [-31186, -31776, -8020]},
 'A2': 13180984513962442287,
 'A3': 3436503243,
 'A4': {'D1': [60819, 30811],
        'D2': [1810699172, 418977829, 3697550577, 4167175498]},
 'A5': 13929,
 'A6': -377,
 'A7': {'E1': -10031, 'E2': 0.6960300082136777},
 'A8': -106}

(b'ARC\x00vi\x10:\xfd1s\xd8\xfe4\x8fJ\xfb\x00\x00\x00\x02\x00\x9e\x00'
 b'\x03\x00\xa2\xb0\xa9j\xa9\x87[\xbf\xea~X\xb4_\x88H\xb6\xce+H\x87\x00\x9a'
 b'C\x9b\xfc7%]\x14bz6Y^\x84WY\xc7\xebo6\x9bK|\xc0KgG]\xb7i\xd9\xef\xa5'
 b'B\x1f\x82\x97\xa2s\xe5\xd0\x87Vg\xa3\x00\x00\x00*\x00\x00\x004\x00\x00\x00>'
 b'\x00\x00\x00H\x00\x00\x00RwlR\xae\xf8\x9b?\xda\xee\x82\x00\x05\xd4\x90\xbf8'
 b'\xd0\xe6\xe9a\x00\x05\x00\x00\x00\\,a\xc0\xe4\x00\x00\x00\x02\x00\x00'
 b'\x00p\x00\x00\x00\x02\x00\x00\x00r\x17\xab\xd4\xdc \x9c\xd8a\xb54'
 b'\x19\xdex\x83\xd3\x19')

{'A1': {'B1': 0.4208073616239938,
        'B2': -0.7219375371932983,
        'B3': 59745,
        'B4': [{'C1': 14856047540479607707, 'C2': -969},
               {'C1': 2692330565427157342, 'C2': -31657},
               {'C1': 6469398252631051132, 'C2': -16309},
               {'C1': 7442019951589322661, 'C2': 16927},
               {'C1': 9410168565074528086, 'C2': 26531}],
        'B5': 744603876,
        'B6': 'wl',
        'B7': [21166, -1893]},
 'A2': 7570615832740616446,
 'A3': 881806075,
 'A4': {'D1': [6059, 54492], 'D2': [547149921, 3040090590, 2021905177]},
 'A5': 45225,
 'A6': 27305,
 'A7': {'E1': -30885, 'E2': -0.8279231570161381},
 'A8': -74}

Вариант №27

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

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

(b'GKMh\xe2\x85alfshhqixj\x99\xb4\x00\\\x00 \x00\x02\x00\x00\x000\x00\x00\x00B'
 b'\x06\x90\xf9\x9cgxjxT\xc2jK\xf0\x92J\x1eUz?>b\x0f\xea]<\xbcY-W/k\xfa'
 b"\xa2\x88\x00\x02\x00\x00\x00>\xf17\xd3\xe7\xd2o\xa3'90\xf8 \xfa\xb5\xc1")

{'A1': 57989,
 'A2': 'alfshh',
 'A3': 'qixj',
 'A4': -1716256676,
 'A5': {'B1': 473152411020061304, 'B2': 6107560919059024414},
 'A6': [{'C1': 21882, 'C2': 0.7436837553977966, 'C3': -22},
        {'C1': 23868, 'C2': -0.013255438767373562, 'C3': 47}],
 'A7': {'D1': [27642, -23928],
        'D2': -15,
        'D3': 4022813783174096697,
        'D4': 48,
        'D5': [-8, 32, -6, -75],
        'D6': -63}}

(b'GKMh\xce\xfbinxcctudwp\xb3\xd1\x1f>\x00 \x00\x03\x00\x00\x000\x00\x00\x00I'
 b'\xed\xe4\r\xa0\x1fO\xb0#WsY@S\xed\xc3d\x95R\xbe\xbc\xf3\x16\t#B\xbf\x11\xf7'
 b't\xe5\xee\x0b>\xc0\xc9\x94\xc92\xc2@\x18\x00\x02\x00\x00\x00E\x08'
 b'\xe6j\xd1\xe4x\x14Q\xe1\x8dK\xf0X+\xf5')

{'A1': 52987,
 'A2': 'inxcct',
 'A3': 'udwp',
 'A4': -1278140610,
 'A5': {'B1': 17141841063050194979, 'B2': 6301478436442325860},
 'A6': [{'C1': -27310, 'C2': -0.3690420985221863, 'C3': 9},
        {'C1': 9026, 'C2': -0.5701820850372314, 'C3': -27},
        {'C1': -4597, 'C2': 0.37653791904449463, 'C3': -55}],
 'A7': {'D1': [12994, 16408],
        'D2': 8,
        'D3': 16603313755452101089,
        'D4': 141,
        'D5': [75, -16, 88, 43],
        'D6': -11}}

Вариант №28

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

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

(b'\xf6GQN\xb5\x9d\\\xcdf\xfax\xe6[\n\xce\xb9\xc4\x91\x00\x00\x00U$\xf3'
 b"\xc2Z\xf0\xc3\xbcn3\xec\xbf\x93\r\x902\x07'C\xdfD\x02\x00\xaf\x00@\xed"
 b'\xf6\xadY\x92\x89\xf0\x0b-\xf2^\\\x99Y\xedi$P9\xd0\xb9\x87H\xe9\xc8@yX`'
 b'\x07h\x90\xf14\xc5\n.i\x1d>\r\x04\x0e\xd7M\xc1\xbd\xe0\xbf\xa0{H.'
 b"\x98\xa6\xaa? d'\xa8\xb0{\xe4\xbf\xa0LG\x86\xd1\xec\xb0\xbf\x88\xa0\x84:"
 b"\xba\xf2\xc4\xbfp\x9a@\xc8\xa6'\xdf\xbfO0\tb\xbf2\xbcu?RWV\xc4\x06\x004"
 b'\x00\x00\x00\x06\x00\x00\x00X\x00\x00\x00\x88\x00\x00\x00\tr\x12\x10\\'
 b'\xd0\xf7\xb0Zt\xf1\x03')

{'A1': {'B1': 181,
        'B2': 23709,
        'B3': -51,
        'B4': 102,
        'B5': 14175587846012172538,
        'B6': {'C1': -1000974510,
               'C2': [{'D1': -119, 'D2': [240, 11, 45, 242, 94]},
                      {'D1': 92, 'D2': [153, 89, 237, 105, 36]},
                      {'D1': 80, 'D2': [57, 208, 185, 135, 72]},
                      {'D1': -23, 'D2': [200, 64, 121, 88, 96]},
                      {'D1': 7, 'D2': [104, 144, 241, 52, 197]},
                      {'D1': 10, 'D2': [46, 105, 29, 62, 13]}],
               'C3': [-0.5231634636224389,
                      0.052052264833256645,
                      -0.6400988849883369,
                      -0.06611356285366066,
                      -0.16365745408370835,
                      -0.4867951350774211],
               'C4': {'E1': 79,
                      'E2': -0.8829526901245117,
                      'E3': 0.9599028825759888},
               'C5': -5694854109961489911},
        'B7': 85},
 'A2': 36,
 'A3': -15629,
 'A4': {'F1': -0.8812783896278333,
        'F2': 147,
        'F3': 4962759149289115661,
        'F4': [29786, 1009],
        'F5': 2918640960,
        'F6': 89,
        'F7': -110}}

(b'\xf6GQN\x08\x97<\x8d\xda!N=\x08R\xa2\x0bcw\x00\x00\x00\x82\xf3\x94'
 b'\xbf\x98\xee\xc1Z\xa4\x10\xdd\xbfSM\xeb-\\\xee\xfbE\\\x03\x00\x95\x00l\xdc'
 b'\x0f\xb4\xba\x8d\xdd\xca\xc1\xcdX\xe5\x9f\xcc\xcf\x9c\xfd\x1c\xbe\xcc\x96&'
 b"\xb78\xb8\x19\x87\x8e[p\xe4?n8'\x9a\xfc\x02\xe3?\x00-\xe9u\xd6\x98\xcf?hf"
 b'x\xc5\x19\xd7\xc8\xbf\x88\xa7r?\xc1K\xe8\xbf\xd3u\x7f\xb5\xbcw\x84$?\xdd'
 b'\xc3\xf7@\x03\x004\x00\x00\x00\x05\x00\x00\x00F\x00\x00\x00n\x00\x00'
 b'\x00\xeeI\r\xd7\x17;\x08\x97%\xd8V\xfc\\\xb5')

{'A1': {'B1': 8,
        'B2': 15511,
        'B3': -115,
        'B4': -38,
        'B5': 7136976507707936289,
        'B6': {'C1': 1089979357,
               'C2': [{'D1': -35, 'D2': [202, 193, 205, 88, 229]},
                      {'D1': -97, 'D2': [204, 207, 156, 253, 28]},
                      {'D1': -66, 'D2': [204, 150, 38, 183, 56]}],
               'C3': [0.6387155326599929,
                      0.5941145907215863,
                      0.24685173756947876,
                      -0.19406435148339374,
                      -0.7592474211898983],
               'C4': {'E1': -45,
                      'E2': -0.022155502811074257,
                      'E3': 0.6426462531089783},
               'C5': -7563730600590489106},
        'B7': -126},
 'A2': 243,
 'A3': -16492,
 'A4': {'F1': -0.4541407476715249,
        'F2': 83,
        'F3': 6648997426049706829,
        'F4': [55333, 64598, 46428],
        'F5': 3020938348,
        'F6': -70,
        'F7': -115}}

Вариант №29

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

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

(b'SJCV\x00\\?\xb3?\xea\xb6M\xf6\x83\x11F\xec\xf1\xb4x\xf8\xd8i\xddc\xed\xe0t'
 b'\x10\x1b^d6\x88\x88\xc2\x9d*\xbfB\xda\xd2Xu\xc3\xa4\x95\xa3\xd5\xed\xf9['
 b'\xf5\x96\xe8\xe6\x9a\xc3_\r\xb4a;\x14\xa6\x94\xf8\x96X\xd0\x98,\x19E\x9bf'
 b'\x08g\xe6\x0c\x94\x03\xb0\x03\x13>\x00\x02\x00\x00\x004<!\xb1\xd0My\xc8\xba'
 b'\x90\x97\xf1\x9b\x16&4\xf9(\x01\xa6rh\xb4.\x0bN\x81s#\x1b\xed\xba"'
 b'\x99K\xcc\xd1\xce\x05E{qj\xcb\xe8\x8d\xc2|S\x00<')

{'A1': {'B1': {'C1': [{'D1': 4332939824718268602,
                       'D2': 10419061911338759417,
                       'D3': 10241,
                       'D4': 166,
                       'D5': 114},
                      {'D1': 7544705901849047843,
                       'D2': 2012469266268015825,
                       'D3': -12795,
                       'D4': 69,
                       'D5': 123}],
               'C2': 8172568673488370771,
               'C3': {'E1': 3026270996,
                      'E2': -1500186474,
                      'E3': 22736,
                      'E4': [-26580,
                             6469,
                             -25754,
                             2151,
                             -6644,
                             -27645,
                             -20477,
                             4926],
                      'E5': [-174659354, -1698472179]}},
        'B2': 16307,
        'B3': 0.8347539725005297,
        'B4': 3975263352,
        'B5': 17931198315960852596,
        'B6': 4123},
 'A2': 6801621297274199338,
 'A3': -0.7611514329910278,
 'A4': 22645,
 'A5': [-61, -92, -107, -93, -43, -19, -7, 91]}

(b'SJCV\x00\\\x0e\xf7\xbf\xe2\xdf\xe4.[\xa4\xa2\xc4K\n\xef\x9aC\xce1'
 b'\x8b\xf4\xce^;"-l\xb7m\xb3W\xd0\xc5\xbf\'\xb9\x91\xa4:\x8f\x90\xa1\x10'
 b'|\x1d\xedv\x14\x7f)R1\xac[o\xfe\xf8\x0b\x81m\xdaE\x9cU)T\x83i&8B]Z\x99~'
 b'B\xe6\xd5\xa8\xb3\x03\x00\x02\x00\x00\x004JMS\\\xdb\x17\x9eq\xcf.\x0b\xd5'
 b'\xeec\xde\x02\x94\xff\x8e:\xbd\x01\xef\xbdh~+6.|{"\xc8\x00Anf\xaf\x0e\x85'
 b'\x1ci\xdf\x96\x84%\xea+\x00<')

{'A1': {'B1': {'C1': [{'D1': 5354027190291242609,
                       'D2': 14928882828235234818,
                       'D3': -27393,
                       'D4': 142,
                       'D5': 58},
                      {'D1': -4827313728783504586,
                       'D2': 3349687612171370862,
                       'D3': 26287,
                       'D4': 14,
                       'D5': 133}],
               'C2': 2047413343171766827,
               'C3': {'E1': 4277668737,
                      'E2': 1843021212,
                      'E3': 21801,
                      'E4': [21635,
                             26918,
                             14402,
                             23898,
                             -26242,
                             17126,
                             -10840,
                             -19709],
                      'E5': [343877970, 833379183]}},
        'B2': 3831,
        'B3': -0.5898304849080385,
        'B4': 3293252335,
        'B5': 11115955017477312094,
        'B6': 15138},
 'A2': 3273192710979702981,
 'A3': -0.6551752686500549,
 'A4': 42042,
 'A5': [-113, -112, -95, 16, 124, 29, -19, 118]}

Вариант №30

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

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

(b'QZGT\x91ipojlwvf\xe9\x0c\x80\x80\x92\x00\x02\x00\x00\x00o\xe7\x98|\xfb'
 b"p'\xdb\xdf\xec\xdf\xf8?\xef\x8a\r#^\x91\xd0>\x00v\xdc\xe0\x04\xcdhh"
 b'7@\x16\x93\x0f&\xbf\xe34\xd5I0%\x0e\x91\xc4Y\xb2\xc2{\xfeU\xf5\xa1\xfb\xc3M}'
 b'd~\xa5\xfd\x8f\x19\xae\xbf\x9c\xfa\x87m\xb9\x8c\x80h\x00\x91>uB5\xab\x82'
 b';e\xfd";I\xbd\x005\x00R\xfe\x0b\xf4^\x95\xd4\xbf\x00\x03\x00s')

{'A1': 'ipojlwvf',
 'A2': {'B1': 59660, 'B2': -128},
 'A3': {'C1': 32914,
        'C2': [{'D1': 64,
                'D2': 378736422,
                'D3': -0.6001993588880923,
                'D4': 10503618855236795989,
                'D5': [62881, 64451, 19837, 25726]},
               {'D1': 165,
                'D2': -40953426,
                'D3': -0.028299442359991378,
                'D4': 7494149477385778603,
                'D5': [33339, 26109, 8763, 18877]}],
        'C3': 59288,
        'C4': 9005915196352359647,
        'C5': -8,
        'C6': 0.9856019678887211,
        'C7': 62,
        'C8': {'E1': 1586877631, 'E2': [254, 11, 244]}},
 'A4': -36,
 'A5': [-32, 4],
 'A6': -848795593}

(b"QZGT\x91gcabcdyk\xfa'\x8e1I\x00\x02\x00\x00\x00o,<`{\xf1\xbeF\rA5%\xbf"
 b'\xd3}\x8b\xbc\xce\xeb\xb0\x04\x00y\xd58!\x99\r\x85&\x8d\xad\xda{\xac?\xc3'
 b"\x06z\xc446\xf0\x8b\xa9, \xd7'\xbc\x94\xead3\xefWK=\xcb\x981\xd7\x99I?"
 b'\xd5\xcd\x06/\xd8\xe2lo\x8f\x07?d\x1fU\xec\x08\xa9\xc3\x86\xe6>\xc1 \x00'
 b'5\x00RR\x04\x1d,N\xbe\xf7d\xad\x94\x00\x06\x00s')

{'A1': 'gcabcdyk',
 'A2': {'B1': 64039, 'B2': -114},
 'A3': {'C1': 12617,
        'C2': [{'D1': 141,
                'D2': -1378190420,
                'D3': 0.1486352403666653,
                'D4': 10063623361896365204,
                'D5': [60004, 13295, 22347, 15819]},
               {'D1': 152,
                'D2': 836213065,
                'D3': 0.3406386821039067,
                'D4': 8038651828723733996,
                'D5': [2217, 50054, 58942, 49440]}],
        'C3': 11324,
        'C4': 6952416249297846581,
        'C5': 37,
        'C6': -0.3045377105551621,
        'C7': 4,
        'C8': {'E1': 4150570388, 'E2': [82, 4, 29, 44, 78, 190]}},
 'A4': -43,
 'A5': [56, 33],
 'A6': -1727167194}

Вариант №31

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

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

(b"YSBP\x9d^\\\xbe\x19\x00\x00\x00'\x00\x00\x005\x00\x00\x00\nQ\x00\x04"
 b'\xfc\x98\xdd\xdb\x9c3\xca\xcc\xbfvprcwx| H0\xf2\x8a\xd7?rbqzts\xe0\t\xaa'
 b'b\xee\xce\xcf?wjzpql\x8f\xc7\xb2E\x07\xbfSx\xcev\x02\x00C\x00\xca\xe9E\x00')

{'A1': 94,
 'A2': 48732,
 'A3': [{'B1': -0.2249207034981111, 'B2': 'vprcwx'},
        {'B1': 0.36785559382452226, 'B2': 'rbqzts'},
        {'B1': 0.2485025388487676, 'B2': 'wjzpql'}],
 'A4': 10,
 'A5': {'C1': 202,
        'C2': -23,
        'C3': {'D1': -0.5284072160720825,
               'D2': [30803, 30414],
               'D3': [-113, -57]}},
 'A6': 4,
 'A7': -4}

(b"YSBP\x9dx\x1dw\x19\x00\x00\x00'\x00\x00\x005\x00\x00\x00\x98Q\x00\xf6"
 b'\n\xdc\xd4\x8f\xa2F\\\xd6?fymlqn\x98\x95\x05\xb6\xf14\xdf\xbfvgqjvy0\xb8\x18'
 b'\xc3\x84\xbf\xde\xbfujdeou\xc0WAc3>\xf9\xd4z\xa5\x02\x00C\x00CQE\x00')

{'A1': 120,
 'A2': 30493,
 'A3': [{'B1': 0.3493820750730501, 'B2': 'fymlqn'},
        {'B1': -0.4876064565235878, 'B2': 'vgqjvy'},
        {'B1': -0.4804393677940224, 'B2': 'ujdeou'}],
 'A4': -104,
 'A5': {'C1': 67,
        'C2': 81,
        'C3': {'D1': 0.17518331110477448,
               'D2': [-11015, -23174],
               'D3': [-64, 87]}},
 'A6': 246,
 'A7': 10}

Вариант №32

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

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

(b'oWUVR\xe6\n2\xdb\xbc\xe9\xbf\x05\x00\x98\x00\xac~\x14^nI\x1eG\xa4V!n'
 b'\'\xd0\xe1?\xe5\x0b\xe9\xedf\t\r_\x80\xbe\xa1HZ@\xeb\xc5"PH\xbb\x01\xc9\xefe'
 b'\xb1^\xe4\xabi\xa6\xca\x8cDt\x96\xdf"\x85\x19:E\x8f|GC\xe7\x1a\x9bjU=\r'
 b'o\x92|%Xe\xdcP\xbeo\x05\xdd)\xc6\xa9F\r\xc0\xac\xfbD\xde\r9\xd5\\\xe8&'
 b'\x91\x8d\xf1R\x84cx*\xc0\xfa9\x1a\xd69L\x8d\xdf\x15\xb6\x18\xe2O\xdd8'
 b'\xc1\x07?\xef\xa6\xd0b\xa2\x9b\x88\xf6\xd6\x03\x9d\x00\xfdqdwnvq!\xb9'
 b'I\xeaL\xfa\xa9\xab\xd4')

{'A1': -0.8043037392992096,
 'A2': 'qdwnv',
 'A3': {'B1': 5124614164367834796,
        'B2': 0.5566594267827054,
        'B3': [{'C1': [3045, 60905, 2406],
                'C2': -0.2507251799106598,
                'C3': [1079658657,
                       1344456171,
                       -922633400,
                       1588684271,
                       -1503024156,
                       1950649546],
                'C4': [2233655190, 2403678745, 3879946108, 1433049882],
                'C5': 61},
               {'C1': [28429, 31890, 22565],
                'C2': -0.20396573841571808,
                'C3': [702350703,
                       222734790,
                       1157344448,
                       -717681186,
                       -1859721124,
                       -2074938995],
                'C4': [3224008803, 3592043002, 3750579257, 3793270293],
                'C5': 79}],
        'B4': -35},
 'A4': {'D1': 0.5302920341491699,
        'D2': 42735,
        'D3': 25296,
        'D4': -94,
        'D5': 155,
        'D6': 64419464},
 'A5': {'E1': 8561, 'E2': 15324529049555585465},
 'A6': -3}

(b'oWUV\x00(\x1f\xdd\x0f\xa6\x8c?\x07\x00\x98\x00H\x0b\xfdM2\xed.\xa9'
 b'"\x05\x1f\xb5\x85$\xe9\xbfs\xf5%2T\xd4\xec\xb4\xa5>\xcb\xd2\xcdc>~'
 b'\xd5"\xfb\xdd\xf9p\xc2\x13\xcc\xb0F<s6oj\x9b\x10\xe3\xe5R\xa1\x8b\x01'
 b'/\xe2\xc6,\x97\x88\xf1\x1f\xea\x00L;\x93\x87\xe5f\xbb\xebVd\xbf>C\xc2'
 b'\xea\xab\x11\x1e\x11\xdb\x7f:\x8f\x18\x8a\xae\xf0\\F\xe5\xc1\xaf\x03\x02'
 b'\xfe\xf1=\xb0+\xdd\xf7\xb8\xa3#\xd1\x86\x9cS\xbf\x00\xefM\xa3\xa08\x94>\x99'
 b'\x1e\xde\xedi\x85\xe1\x82\x89_\x9f\x00dezufwxtK\x12\x04\xc8\x8c:\x81\x1f?'
 b'\xf1')

{'A1': 0.013988613067244415,
 'A2': 'ezufwxt',
 'A3': {'B1': 12190942041651088200,
        'B2': -0.7857082879565136,
        'B3': [{'C1': [62835, 12837, 54356],
                'C2': 0.3236459493637085,
                'C3': [1674433227,
                       584416830,
                       1895423483,
                       -1328802878,
                       913521734,
                       278620783],
                'C4': [2706564579, 3794731403, 2291608774, 15343601],
                'C5': 76},
               {'C1': [37691, 58759, 47974],
                'C2': -0.8919512629508972,
                'C3': [-356367554,
                       287183275,
                       -1891991589,
                       -256996840,
                       -1041938852,
                       -33422417],
                'C4': [732970481, 2746808285, 2626081059, 4009803603],
                'C5': 77}],
        'B4': -93},
 'A4': {'D1': 0.28949451446533203,
        'D2': 7833,
        'D3': -4642,
        'D4': 105,
        'D5': 133,
        'D6': 1602847457},
 'A5': {'E1': 4683, 'E2': 17383647726566950916},
 'A6': 100}

Вариант №33

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

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

(b'\xb0QQSBX\x9e\x95\xd1\xf1\x01\x0c\x92\x04\xcb,\x80\x95\xe9\xe4\xb9-T['
 b'\x11\xa6\x89+\xfb9\xc5\x9a6\xc0\xb8\x00\x00\x00Fo\x07+\x04\x88,\x03\x83$'
 b'\xb1\xbe\xfe\xbf\x17\x00\x00\x00Qvfjssd\x9a\xddn\xe2s\xc3<\x00\x05'
 b'\x009\x00\x00\x00\x04\x00>\x80\x02>\\\xfa\xc4?\x95\xcd\x07:Yp\xa6\xa0\xd7'
 b"\x11\xd2\r'\xf6\xbe\x90K'\xc6\xe1\x0fx\x83\xc9\x91@\xcf")

{'A1': [{'B1': 22686, 'B2': 38353},
        {'B1': -3839, 'B2': 3218},
        {'B1': 1227, 'B2': 11392},
        {'B1': -27159, 'B2': 58553},
        {'B1': 11604, 'B2': 23313},
        {'B1': -22903, 'B2': 11259},
        {'B1': 14789, 'B2': 39478}],
 'A2': 49336,
 'A3': {'C1': 'vfjss', 'C2': [25754, -8850, -7565, -15556], 'C3': 128},
 'A4': 28423,
 'A5': [43, 4, 136, 44, 3, 131, 36, 177],
 'A6': -0.49755164980888367,
 'A7': {'D1': 161668868735997389,
        'D2': 121264496,
        'D3': 12006833078108235766,
        'D4': -0.28182336688041687,
        'D5': 198,
        'D6': -2229430783107317553}}

(b'\xb0QQSB\xdd\xde\xa6\xd4\x02\xa3S\xf1X>e\x9eE#\x936\x8b\x82\x8e}\x834|'
 b'~<\xe5\x9eXi$\x00\x00\x00K\xc6\xee\x8c\xbc\x8a\xae5\x89\xe5\xe5\xbfer'
 b'\xad\x00\x00\x00Vbkmq\x8e\xaa\xac\x1d\xb1f\xbb0\xda\xe1\xbbY\xbe:\x00'
 b'\x04\x009\x00\x00\x00\x07\x00=\xff\xd4\xa9b~z A\xda\xb9NA\xe3\xc0\xea'
 b'\xe0\xaf\x9b\x1b\xbcw\xbe]\xc1\x0b+g\xabXJ\x88\x87H\xca')

{'A1': [{'B1': -8738, 'B2': 42708},
        {'B1': 675, 'B2': 21489},
        {'B1': 22590, 'B2': 26014},
        {'B1': 17699, 'B2': 37686},
        {'B1': -29822, 'B2': 36477},
        {'B1': -31948, 'B2': 31870},
        {'B1': 15589, 'B2': 40536}],
 'A2': 26916,
 'A3': {'C1': 'bkmq',
        'C2': [-29014, -21475, -20122, -17616, -9503, -17575, -16838],
        'C3': 255},
 'A4': 50926,
 'A5': [140, 188, 138, 174, 53, 137, 229, 229],
 'A6': -0.8962810635566711,
 'A7': {'D1': 15323887502459159002,
        'D2': 3108913635,
        'D3': 13901170244658642039,
        'D4': -0.21655671298503876,
        'D5': 43,
        'D6': 7470161484065491146}}

Вариант №34

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

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

(b'`KQJB\x85\x00>\x99\x00\x07\xffn\xe7?\x9a\xca\xf6\x90C\xa5\x00\xbd\xd3'
 b'\xc8?\xd6\x80\xbe\x92\x19p\xeb?\xfb\xb3~6\x93R\xd4\x8a\x8fJ\x88PT\x8b'
 b'g\xd0\xcf\xbf\xe0\x80\x94h\xdb\xe9\xceB\x02\x00\xaf\x00\x00\x00\xa6d_lxp'
 b'b\xed\xfd\xb4\x86\x8d\xd5=\x81\xce\x93\xc3.\xbe\x8fE\x86\x03"\xe1'
 b'\xbf\x10\xa0\x1d\xef\xce\x10\xbf\xbf\xbb!\xa0\x14G.\x84\xd36T@\xef\xf0\xb5\\'
 b'\x1e4\xbc\xcf\xbf\x008\x19D\xc5)\xed?I\x00e\x00\x04\x00\x00\x00E\x00\x00'
 b'\x00}\xa1G\xebt\x03\xfdc\xa2\xdcu\xa5\x04\xbf\x02\x00\x81\x00\x00'
 b'\xa8\x1c\xa6\xb6b\x81\xbf6\x0c\xd8\xf0\x98c\xea?\xb5P')

{'A1': {'B1': 'lxpb',
        'B2': -24195,
        'B3': -2548364500802409657,
        'B4': -0.5181496739387512,
        'B5': [{'C1': -531,
                'C2': -31052,
                'C3': 3369699461344122253,
                'C4': [-0.5354020712370511, -0.12135022485529157]},
               {'C1': 8635,
                'C2': 5280,
                'C3': 17239871968027881031,
                'C4': [-0.24793101770903503, 0.9113489465760267]}],
        'B6': -0.00848906225617796,
        'B7': 0.8246578887923366},
 'A2': {'D1': 0.7322993408932132,
        'D2': -102,
        'D3': -2358,
        'D4': [0.1939617398407134, 0.8574340692612406],
        'D5': 10003711464524657659},
 'A3': 19087,
 'A4': -0.24854749968710999,
 'A5': 4814042180267311328,
 'A6': [-75, 80],
 'A7': 25766,
 'A8': 95}

(b'`KQJB\x84\x00&"\xbeO:\xca\xe4?u#\x8d\xdc\x97z>8\xcd\xd1?x\x03\x8d\xda1)'
 b'\xee?\xe5\x9fR\tE`ft\xa1\xb3\x80\xbe\x14\x9f\x111\xea\xbfk\x11\xad\xf3'
 b'F\xfb\xb1 \x03\x00\xae\x00\x00\x00X\xeb\xeanocdO\xfd\xc1v@\xed\xde'
 b"\xb7}\xed\xed\xbcI.\t\xb4\xc5\xe1?$H\x8a'h\xd3\xe0\xbf\xae\xab$\x17"
 b'\xb7\x91o\x89\xcf\xbcI\x12\xcc\xf6\x074\xe9o\xe8?\xe0\x1f\xd7D\xc80\xc5?'
 b'H\x00d\x00\x03\x00\x00\x00E\x00\x00\x00\xfc\xa14\t\xd3\x9e\x8c\xb6T%h\xa0'
 b'\xea<\x02\x00\x80\x00\x80x\x1b\x94\xab\xf9\x81?\xaa\x1a\xb7Bu\xe8'
 b'\xee?\xc6\x99f')

{'A1': {'B1': 'noc',
        'B2': -24068,
        'B3': 2689975592523335988,
        'B4': 0.02864094078540802,
        'B5': [{'C1': 20324,
                'C2': -15875,
                'C3': 17144497585141923958,
                'C4': [0.5553836993515726, -0.5258065006512465]},
               {'C1': -21586,
                'C2': 5924,
                'C3': 1317791965532623287,
                'C4': [0.7636610046608552, 0.1655512176641869]}],
        'B6': 0.008776989419342351,
        'B7': 0.9658762267143477},
 'A2': {'D1': 0.6496860082125451,
        'D2': 117,
        'D3': -29405,
        'D4': [0.2781506166596708, 0.9425286549159031],
        'D5': 8387497205649547237},
 'A3': 45985,
 'A4': -0.8184898478557017,
 'A5': 2355940362245968235,
 'A6': [-58, -103, 102],
 'A7': 60248,
 'A8': -22}

Вариант №35

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

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

(b'POB\x03\x00\x00\x00^\x00\x00\x00ra\x00o\x00}\x00\x8b\x00\x99\x00\xa7\x00'
 b'\x90\xf9\x02\xbf\xef8\xde\xbf\xbdq\x14\xbf\xf9\xc8K\x01\xff\xbf\xee\x0c'
 b"]2Y\x03\xd8T\xd7\xb0\xd9{z\x1f\xaf_|\xc9\xdbc\x8e\x139$'\x93\xaa\x99J\xf6"
 b'\x8e\xaad\xabU\x92\x94\x83\xf5\x0e\xec\xdf\xc0\x15<\xd2\x05\x8d\xa4"'
 b'\x89\xbacub{j1a\x9f\xaa[\x17\x07\x159\x19|\x88K\x19\xcd\xdc\\\xf50kP'
 b'\xd5r\xcf\x9c\xe2\x92C\xee\x8exM\x85\xe1\xdf\xbb\x19\xdd\xb8\xb9V\x9e@#l'
 b'\xf0c\xd0\x0cr\xdc/N\x95\xd9bP\xd9\x9a\xecL6\xb39@7\x9b\x97\xf8h\xbf;{'
 b'\xa5\xdc\xb4g\x7fF\x9eV,')

{'A1': 'cub',
 'A2': {'B1': 114,
        'B2': [{'C1': 1683126487260162683,
                'C2': [5383, 6457],
                'C3': 124,
                'C4': 136},
               {'C1': 7723943140130625867,
                'C2': [-10928, -12430],
                'C3': -100,
                'C4': 226},
               {'C1': -2196264063083854958,
                'C2': [-17441, -8935],
                'C3': -72,
                'C4': 185},
               {'C1': -3430634143887614378,
                'C2': [29196, 12252],
                'C3': 78,
                'C4': 149},
               {'C1': 3912762326093161177,
                'C2': [14771, 14144],
                'C3': -101,
                'C4': 151},
               {'C1': -5414270703304218376,
                'C2': [32615, -25018],
                'C3': 86,
                'C4': 44}],
        'B3': -0.4722251286838395,
        'B4': -0.579860508441925,
        'B5': 931893274871580921,
        'B6': [56177245,
               2966901976,
               528120793,
               3380371375,
               328098779,
               2468815929,
               4132084138],
        'B7': {'D1': -21874,
               'D2': [-21660, -28075, -31852, 3829],
               'D3': -8284984783973326868,
               'D4': -1165417820}}}

(b'POB\x02\x00\x00\x00^\x00\x00\x00\xca`\x00n\x00|\x00\x8a\x00\x98\x00\xa6\x00'
 b'xtOXv\xc8\xe4\xbf5\xa2_\xbf\xb0U|\xa9~\xc0\x8cwb\x8f\xb8}\xd9\x0e\xdd\xc8'
 b'@\xbf\x91\x11\x03\xdb\xaaX\xbaM,Q\x17\x03\xff\xdf\xc6\x08\x88\x02\xbaO6\xdf'
 b'\xd9\xc7]\x1c\xd1Y\xb3Z_\xcf\xaf]>Z\xe5/\x0b\\fu\x11\x98U\x1f\x1an\xc3\xee'
 b'\x08\xdc\x86\x0f8\xc4\xc8A\xa3;\xc6\x9eR\x81\xe3@\xc4P^c\xc7\x94\x9e\xb8'
 b's\x18\xf3\x9f\xaf\xe0\xa9u%\xf4\xe8\xb6\xc7`\xc1\xbc\xcaY\x1ei\xf8<\xab\xc2'
 b'\xa9\xb5\x91)J\xadKJWM\r\xd9\x8d\xaf|\xc8\xb7\x892]\x95\xae\xfc&\xf79r\x04')

{'A1': 'fu',
 'A2': {'B1': -54,
        'B2': [{'C1': -1242028013750216687,
                'C2': [-9208, 3974],
                'C3': 56,
                'C4': 196},
               {'C1': -9128058920485305912,
                'C2': [16611, 20676],
                'C3': 94,
                'C4': 99},
               {'C1': -6921161317040614201,
                'C2': [-8017, 30121],
                'C3': 37,
                'C4': 244},
               {'C1': 6470191353409550056,
                'C2': [26910, 15608],
                'C3': -85,
                'C4': 194},
               {'C1': 5353563116096566697,
                'C2': [19799, -9971],
                'C3': -115,
                'C4': 175},
               {'C1': -5866680467939932036,
                'C2': [9980, 14839],
                'C3': 114,
                'C4': 4}],
        'B3': -0.649470493775552,
        'B4': -0.8735688328742981,
        'B5': 8614471837494826416,
        'B6': [2109247330,
               3369930457,
               294764352,
               1487592195,
               1361857978,
               3758031639,
               42469574],
        'B7': {'D1': 20410,
               'D2': [-8394, -14375, 7261, 22993],
               'D3': 6502737921649367731,
               'D4': 1544237029}}}

Вариант №36

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

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

(b'UTWlZ\xa5\x85\xec\xcd\xf0|\x1a\x008\x00V\x00\xc0\x03\x00\x00\x00t\x00'
 b'\x83\x00\xdeWH\xae\xca\xef\xbf\x96\x12UC\xb7(\xe3\xd9\xe5\xb4ma\x08J\x17'
 b'\x1dR\xaf\xae\xf8\xad^\xd1\x92\r8\xf5\xa7$\xbb\x16\n!\x03\x9f'
 b'\xab\xee\x06\xbb2U\xb4\x9b\xc9\xa0\xa3Pq\x11\xea[.\xadG\xfd\xee}\xbfk'
 b'V\x16\xf7{\\A\x98+\x8b&\x1e\xc3\xc1\xcc\xfd\x8b\x18A\xfcL\x8d\x98\xf4`odjt'
 b'\x01\xa5\x11\x97$_\x95T\xdf\xc6\xe4?\x1f$8\x9b\xa7o\xabM\x8fw\x00/'
 b'9\x9c\xc1\xfa\xc3\xb5<6\xd6\xe0\x85\x7fr\xf5\xe1\x01\x19\x06e\xb1U\x10\x9e')

{'A1': 9002922070851803756,
 'A2': [{'B1': 222,
         'B2': 3400419415,
         'B3': 2933887714918318063,
         'B4': -1260004893,
         'B5': -5813552183118372499,
         'B6': 1588459694,
         'B7': -47},
        {'B1': 146,
         'B2': 2817865741,
         'B3': -6080137531488814300,
         'B4': 851117806,
         'B5': 8165206035395228757,
         'B6': 777775633,
         'B7': -83},
        {'B1': 71,
         'B2': 3212701437,
         'B3': -7475592218962143637,
         'B4': 505842475,
         'B5': -269907513127943741,
         'B6': 4103638348,
         'B7': 96}],
 'A3': -64,
 'A4': 'odj',
 'A5': {'C1': [7999, 14372, -22629],
        'C2': -1890735249,
        'C3': {'D1': 296026484, 'D2': -1961635033296984937},
        'C4': 3248240943,
        'C5': 9646945930262725626,
        'C6': [3790959231, 1694898433, 2651870641]}}

(b'UTW<\xecL<!x\xe6M\x1a\x008\x00V\x00y\x02\x00\x00\x00t\x00\x82\x00\x9f\x7f'
 b'<[\x8f\xf2\xbc3\x1d$y\xfd\xff\xcf\xcdFk\xce\xde\xf0M\x0c\r\xeb2!\xe8\x12VA'
 b'\x10\x17\xd9\x85\xd5\x9dI\xb72\x1eC\xb4\xab\xca\x83\x1e\xb0_\x7f/*\x81a\xae'
 b'\x86\xde\x95\xf6`\x01.C\x91\xd0*\xbfUm\xd5\xce6\xcd\xff\x95+\x1bS\xf8'
 b'\xf4\xce\xf0\xc0\x90"\xc5\xd9\x10r\x8a\xa7iq\xf9\x15P\xdfG\xb8VcE\xf2'
 b'\xb8\x14e\xed/\xdf\xd5\x12\xd2\x91\x10\x98v\x00\x8aE&\xce\x1fV\xe8\xbd\xa4e'
 b'Z\xb1\x1239[\x13V\xdc\x8c^\xb8\xaav')

{'A1': 5613306069704830012,
 'A2': [{'B1': 159,
         'B2': 2405121151,
         'B3': -711228914418446,
         'B4': 1799802319,
         'B5': 3669040667921800910,
         'B6': 1444079649,
         'B7': 65},
        {'B1': 16,
         'B2': 3582318871,
         'B3': -6074156200437003875,
         'B4': -1340177462,
         'B5': -8741942619293122721,
         'B6': 1626772958,
         'B7': 1},
        {'B1': 46,
         'B2': 718311747,
         'B3': -14294961840368193,
         'B4': 1394289557,
         'B5': -4241668740681370376,
         'B6': 2322731225,
         'B7': -89}],
 'A3': 121,
 'A4': 'iq',
 'A5': {'C1': [-4763, -8401, 4821],
        'C2': -1743744558,
        'C3': {'D1': 3746567673, 'D2': 1493209656306612295},
        'C4': 3458614666,
        'C5': 12779638650852365855,
        'C6': [1530475282, 2363250195, 1990899806]}}

Вариант №37

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

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

(b'CZXW\x00M\x00a\x11\xe6NW\xbee\x07\xf8\x86{\xe75\x92\x97,@s\xbf}['
 b'\xe9\x00\x02\x00\x00\x00sP\xbfG\xf0\x1c\xdb\xa9\xf0\xbf\t$b\x00\x00\x00x\xbf'
 b'\xe3\x1c|\'\x95S\xe4\xbf\xe9\x99!\xc8\xb3"~\xbf\xdd\xbe^\x10N\xfe\x94s'
 b'y\x80\x18\xa9p\x00\x02\x00\x00\x00K\x1b\nrA\x87Es\x06tt\x990\x89'
 b'\xf8\x00\x02\x00\x00\x00_\xef\xda0\n(+\xb9[\x82\x00q$B\xbf\xb4\xd9\x1e'
 b"\x05\x9e)\xe0\x00\x03\x00\x00\x00u\xc1\x02'\x10")

{'A1': [{'B1': -32744,
         'B2': 169,
         'B3': 112,
         'B4': 'sy',
         'B5': 453669441,
         'B6': 34629,
         'B7': 29446},
        {'B1': -26320,
         'B2': 137,
         'B3': 248,
         'B4': 'tt',
         'B5': -270913526,
         'B6': 10283,
         'B7': -18085}],
 'A2': 300306007,
 'A3': -0.22366321086883545,
 'A4': -122,
 'A5': 2078750098,
 'A6': 2536259699,
 'A7': -0.9896836876869202,
 'A8': {'C1': [130, 0],
        'C2': 5818448340187851248,
        'C3': -0.535711407661438,
        'C4': {'D1': -0.08143794667390791,
               'D2': [113, 36, 66],
               'D3': -1056823536},
        'C5': [-0.59722717028728, -0.7999428672711273, -0.46474410622247686]}}

(b'CZXW\x00M\x00a\x11\xdb{\xce\xbe\xcb9L\x95FVLk\xc3\xd0\xc2}?[f)\x00\x04\x00'
 b'\x00\x00s\xa0~G\x1e\xbfn\x8cm\xbf`\xb8x\x00\x00\x00{\xbf\xe0\x04d%F;\x88?'
 b'\xd6=\xea\xcd\xbd0D\xbf\xe9\xd2\xbf \x9e\xf8\x9ccj$q\xca\xab\x00\x02\x00'
 b'\x00\x00Kj\xf6\xe0\x8a&\xce\x90^jze6\rT\x00\x02\x00\x00\x00_?F\x9a7:'
 b'\x16\x18\x19\xb7\xc9>V*H\xe5\x06\xbf\xe4}\x0c\xfb\xff;\xf6\x00'
 b'\x04\x00\x00\x00w+kX\xf1')

{'A1': [{'B1': 9329,
         'B2': 202,
         'B3': 171,
         'B4': 'cj',
         'B5': 1794564234,
         'B6': 9934,
         'B7': -28578},
        {'B1': 25910,
         'B2': 13,
         'B3': 84,
         'B4': 'jz',
         'B5': 1061591607,
         'B6': 14870,
         'B7': 6169}],
 'A2': 299596750,
 'A3': -0.3969215154647827,
 'A4': -107,
 'A5': 1180060779,
 'A6': 3285238397,
 'A7': 0.8570275902748108,
 'A8': {'C1': [183, 201, 62, 86],
        'C2': -6881984983189255059,
        'C3': -0.877814769744873,
        'C4': {'D1': -0.6402649804894043,
               'D2': [42, 72, -27, 6],
               'D3': 728455409},
        'C5': [-0.5005360343946998, 0.34752912608815145, -0.8069759022835288]}}

Вариант №38

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

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

(b'MES\xc3\xf3Z=&\xbf\xd1\x00\x02\x00!\xb2|rc\x0b\xber\xbf\x00\x00'
 b'\x00\x02\x00\x00\x00/\x00I\x10:%\xe07\xa7\x91\x0cr<]z\xf6B\xbbei?\xe2\x1f'
 b'\xce\xc8\xc6\xb9\xd6?\xccX\xc2\xfd\xe8"\xa8?\xc5\\|\xa4\xe2\x03\x006\xbdB'
 b'JIU\xd7\x01F\xa2\xbf\xea\x15\\\x10:\x9c\xc6\xaboJ\xfb\xaa\x03"\x0e)'
 b'\x9e(t\xa3\x01\xea\xb2f\xff[V\xe3qr,\x9c\xa1\xcdLm\x9f\x97\xd4\x90'
 b'\x00\x00\x00\x03\x001')

{'A1': 62298,
 'A2': 0.04071027413010597,
 'A3': [{'B1': 975560759, 'B2': 167, 'B3': 37132},
        {'B1': 1916558714, 'B2': 246, 'B3': 17083}],
 'A4': 12861280405587653311,
 'A5': 'ei',
 'A6': {'C1': 918372938,
        'C2': 1230362369,
        'C3': 18082,
        'C4': {'D1': -0.8151073758098384,
               'D2': -85,
               'D3': [8019498794102165033,
                      -7050256973187861914,
                      -46347836296385380,
                      -6787685029664795504],
               'D4': [0.5663827821170411,
                      0.22145879171173033,
                      0.16688497591896834]}},
 'A7': 16}

(b"MES\xc3>8\xbf\x08'\\\x00\x02\x00!U\x1a?\x0c_\x18\xdbw\x00\x00"
 b'\x00\x02\x00\x00\x00/\x00A\xd4\xca\xd5Bp\xca\x95\x1c\xbf\x9f)\x9c\xdb\x07nr'
 b'm\xbf\xeaz\x8e\xd3\x81\xe44?\xe4\x8f\x19w\xf9\xee\xd4@\xc8+\x9dJ|\xb7'
 b'\x82\xe8\xbd\xbf\xec2\xcd\x7f\xc3\x00\x16K\x92\x95\xd5k\xe5RJ\xef'
 b'\x14\xbb`\xb2\x013\x0e\xc5\x8bB\x97q\xad\x87{\xe5\xdbU\xac\x9e\xd3\xb5\xa1Q'
 b'\x00\x00\x00\x02\x001')

{'A1': 15928,
 'A2': -0.5318505764007568,
 'A3': [{'B1': -891993488, 'B2': 202, 'B3': 38172},
        {'B1': -1080088164, 'B2': 219, 'B3': 1902}],
 'A4': 6132283164985973623,
 'A5': 'rm',
 'A6': {'C1': 1086860189,
        'C2': 1249687426,
        'C3': -5955,
        'C4': {'D1': -0.8812015052171798,
               'D2': 75,
               'D3': [-7884160913256592657,
                      1493894019044019909,
                      -8411994639476229147,
                      -2642015808226221743],
               'D4': [-0.8274606829646758, 0.6424681990897292]}},
 'A7': -44}

Вариант №39

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

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

(b'VFMP\xbd\xd1\xeakay\xf9\x07\x04\xea`z\xb4\x10\xe0\x1fk6|=}2\x1fF'
 b'\xcej\x19\xea\x9c\xf1\x0e\x8bD\xccp\xa9oC\x00c\x81\xfc\xdc\xdd\xf9\xa4>]'
 b'lE4\x07\x00\x00\x00O\x00\xe9\xbf\xfa\x12\x07lLm\x1161\x02\xc8\xb3\xc6'
 b'2\xdb,\x18\xe3^\x9b\xaa\x87\x889\x8d\x96\xb9YL\x8bj\x0c\x05\xbb\xe8#v'
 b'\xd7\xff+,X\xd4\x10')

{'A1': -67,
 'A2': 209,
 'A3': {'B1': 27626,
        'B2': [{'C1': 133790049, 'C2': -5628, 'C3': 96},
               {'C1': -535776134, 'C2': 27423, 'C3': 54},
               {'C1': 847068540, 'C2': 17951, 'C3': 206},
               {'C1': -1662379670, 'C2': 3825, 'C3': 139}],
        'B3': 68,
        'B4': 204,
        'B5': {'D1': -22160,
               'D2': 111,
               'D3': {'E1': -5492137335194555060, 'E2': [12998, 11483]},
               'D4': [-32413, -8964],
               'D5': 0.32221880555152893,
               'D6': 876964957},
        'B6': [2606687000,
               965248938,
               1505334925,
               208309068,
               602454789,
               738187126,
               282351660]},
 'A4': 318423017,
 'A5': 27655}

(b'VFMP\xc7\x85\xef{\x994\x99\xff\xe4\nj\xb9\x0f\xfb\xdf\x94\x8b\x89W\xb1'
 b'\x9d\x06\xb6\x0b\x04\x0fC\xed\xa3\xd2\r\x90\xd3B\xfb\x8ewC\x00E\xf9X\xef\x9e'
 b'1*\xbf\xafc\xd3\xa0\x07\x00\x00\x00O\x00hF\xc36\xa8\xaf%\x02-Jm\xb1\x01\x94~'
 b'\xb2\xae~\xbf9\xa5\xa4B\xf9\xa4J\x0c\x1d\x97"\xcf\xcb<\x8a\x83'
 b'\x96\xfa\x03\xa2\x83\xe8=\x0c\xf4\x90\x0e')

{'A1': -57,
 'A2': 133,
 'A3': {'B1': 31727,
        'B2': [{'C1': -6736743, 'C2': 2788, 'C3': 106},
               {'C1': -537194567, 'C2': -29804, 'C3': 137},
               {'C1': 110997847, 'C2': 2998, 'C3': 4},
               {'C1': -1544731889, 'C2': 3538, 'C3': 144}],
        'B3': 211,
        'B4': 66,
        'B5': {'D1': -28933,
               'D2': 119,
               'D3': {'E1': -7781743598165491163, 'E2': [-19842, 32430]},
               'D4': [-1723, -4264],
               'D5': -0.664819598197937,
               'D6': 2698208175},
        'B6': [2762291647,
               1252325698,
               580328716,
               2319240143,
               66754179,
               1038648226,
               244380684]},
 'A4': 918767208,
 'A5': 44968}

Вариант №40

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

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

(b'HLR\x8eyt\x00\x00\x00B\xed\x96\xd9\xee\x01\xc6\xe9\xca\xa0\xf2\xe2\xf3\xf0R'
 b'\n\xec\xac\x1b\xa4va\x01R^\xe6qs\xb2\xd7\xc2\x84\xbf[\xf4\x83!\xb9.'
 b'\xf8#~\xdby\xa1U\xea\xfcY\xf0\x94\x05\xd8r\x80,\xbf\x00\x00\x00\x02\x00\n'
 b'\xbff\x04\xbd\x8e\xfd\x00\x00\x00\x10\xba\x9b\\\xd3\xdaD\x8f\xd3')

{'A1': -114,
 'A2': 'yt',
 'A3': {'B1': [{'C1': 60822, 'C2': -39}, {'C1': 60929, 'C2': -58}],
        'B2': -0.8985098004341125,
        'B3': 36605,
        'B4': {'D1': 16846454321182928978,
               'D2': 10,
               'D3': [60588, 7076, 30305, 338],
               'D4': 6838277825944339076,
               'D5': -0.8591997027397156,
               'D6': [8633, 12024, 9086, 56185, 41301],
               'D7': [-5380, 23024, -27643, -10126, -32724],
               'D8': -65},
        'B5': 13446443177414528979}}

(b"HLR\xd7qd\x00\x00\x00K\xbaNo\xce\xd0'e\xc8\xe8\x1d\r?\x9d\xc9\xffd\xe0G"
 b']\xcb\xc0Sz\x1e\x94m\xf7\xb2\x15\xa0G\xd2bS.c}5\x889?\x15\xbcn\xed\xfc'
 b'<\xcb\xb3)\x07\xd6 \xc9\x8az\xd4a\xd0oK_\xfe)\xe6\x00\x00\x00\x05\x00'
 b'\n?-\xe4B\xd9\x83\x00\x00\x00\x19\xd2j\x1f\x99M\x8d\x9b{')

{'A1': -41,
 'A2': 'qd',
 'A3': {'B1': [{'C1': 47694, 'C2': 111},
               {'C1': 52944, 'C2': 39},
               {'C1': 26056, 'C2': -24},
               {'C1': 7437, 'C2': 63},
               {'C1': 40393, 'C2': -1}],
        'B2': 0.6792641878128052,
        'B3': 55683,
        'B4': {'D1': 7268888266751890298,
               'D2': 30,
               'D3': [37997, 63410, 5536, 18386],
               'D4': 7085057643621222457,
               'D5': 0.5849064588546753,
               'D6': [60924, 15563, 45865, 2006, 8393],
               'D7': [-30086, -11167, -12177, 19295, -471],
               'D8': -26},
        'B5': 15161965838787779451}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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