ИКБО-03-22

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

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

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

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

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

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

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

(b"AAQH\xb7\xa0\xb6\xa99X\xed\xee\x1f\xd6L\xb1x\xaa\xa2\xc6\xf5'Q\x8dL_e\xeb"
 b'%frt\xd2L\xc7\x01\x0eh\x04\x00\x00\x00D\x00\x00\x00\x96\x02\x00\x00\x00H'
 b'\x00\x00\x00&\xf6\xc9\xe2\x93\x93:c\xd8\xfd5!\xeeectn\xf0!\x99\x0e'
 b'\xc2\xc2\xc4\xa9\x0c\xda\xb6\x9a\xa6D\xcc\xcb^R\xba9')

{'A1': {'B1': 2301037422813230752,
        'B2': {'C1': 19670,
               'C2': 30897,
               'C3': 4123435690,
               'C4': 2732389058910966055,
               'C5': 'frt'},
        'B3': 29838546},
 'A2': 26638,
 'A3': 'ectn',
 'A4': -106,
 'A5': [{'D1': [240, 33, 153, 14, 194, 194, 196, 169], 'D2': 55820},
        {'D1': [182, 154, 166, 68, 204, 203, 94, 82], 'D2': 14778}],
 'A6': 7150189621778445862,
 'A7': {'E1': 216, 'E2': 3995153917}}

(b'AAQH\xb7y\xdaM\x9b\xcc\xf0y0\xfe"\x8ch\x8c\x82g`<\x07\x9bp\xa4yiXphr'
 b'\x0f\xce\xb3\x03\xb2\xef\x06\x00\x00\x00D\x00\x00\x00\xc5\x03\x00\x00\x00J'
 b"\x00\x00\x00d\x978\x92\xeb\xc4\x96M\xb7H0Z\xafclgdad\x1f\x14'\n\x13QDG\xe5T"
 b'\xfdF\x9c\xaa\x16\xbd\x95\x0es\x15!\xe2\xda\xb7\x05\xbc\x1e\xae\xb0\xe8')

{'A1': {'B1': 3493087747572095609,
        'B2': {'C1': 8958,
               'C2': 26764,
               'C3': 1617396364,
               'C4': 6370756895063082812,
               'C5': 'phr'},
        'B3': 62115343},
 'A2': 61362,
 'A3': 'clgdad',
 'A4': -59,
 'A5': [{'D1': [31, 20, 39, 10, 19, 81, 68, 71], 'D2': 21733},
        {'D1': [253, 70, 156, 170, 22, 189, 149, 14], 'D2': 5491},
        {'D1': [33, 226, 218, 183, 5, 188, 30, 174], 'D2': 59568}],
 'A6': 5590872503476590436,
 'A7': {'E1': 183, 'E2': 2941923400}}

Вариант №2

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

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

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

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

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

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

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

(b'AYW\x91)\xc3\x00\x00\x00^x\xa7\x10L\xd2\xc4>\xab\xc2\xa3)\xbcVj\x91O?4'
 b"e\xfa\t`\x8c\x87\xce\xe9>\xcd&f\x15\x1c\x1fA!\xb1='\xc8XD\x08\xb7\x9b\xa2y"
 b'?T\x8f\xae\x1bO\xe7eU2<\xe7\xd6J]\x16\xe5\x94\xef\xc2\xb6\x1b?\xb5+V\x97H'
 b'\x94\xf0@T&\xc8+\x16\xc0\x02\x00\x00\x00\n\x0c\xa5?\xee\xce5w\x98<\x04'
 b'\xc2\xaa\xdc:\x15\xee\xb0R2\xcd\xa3\xa0\xca-"\x81\xd2=\x08\xc1mf%\xd2'
 b'\xe2\r\x04\xd3#\xcf\x00\x02\x00Vl<]k\xef')

{'A1': 10691,
 'A2': {'B1': {'C1': [{'D1': 120,
                       'D2': -89,
                       'D3': 273470148,
                       'D4': 0.3354693353176117},
                      {'D1': 41,
                       'D2': -68,
                       'D3': 1449824591,
                       'D4': 0.7046810388565063},
                      {'D1': 9,
                       'D2': 96,
                       'D3': 2357710569,
                       'D4': 0.40068358182907104},
                      {'D1': 21,
                       'D2': 28,
                       'D3': 524362161,
                       'D4': 0.040962547063827515},
                      {'D1': 68,
                       'D2': 8,
                       'D3': 3080430201,
                       'D4': 0.8303173780441284},
                      {'D1': 27,
                       'D2': 79,
                       'D3': 3882177842,
                       'D4': 0.028300423175096512}],
               'C2': 6707801122855368219,
               'C3': 0.08269253915257813},
        'B2': 3237,
        'B3': 0.9626719795068088,
        'B4': [194, 170, 220, 58, 21, 238],
        'B5': {'E1': -1336790323,
               'E2': [2745223725, 578933309, 146894182, 634577421, 80946127],
               'E3': [1079256776, 722911234]},
        'B6': [108, 60, 93, 107, 239]}}

(b'AYW\x91\xfa\x86\x00\x00\x00j\x95\xba\xd9{\xff\x85?\x06\x860\xccP\xfd\x01'
 b'\x15\x18\xbe^\x9b{,\xe3\xa1"\xcaK\xbfM\xc7k\xa77\x18\xa4\xfe\xa8\xbf\x06'
 b'\x90\xb5\x1e\xba\x00\x18b"\xbd\x06\xa7\xf1\x17\x93\xaeQ\x819>\xe7'
 b'I\xdf\xb0\xd9t2\x1c\x9e}f\xbf\xecLo\xb2@X2\xe0\x04\x7f\x94d\xde^\x85\xeb%'
 b'\xf0C\xb11\xd9\xce\x1a\x99\xaam\x00\x00\x00\n^|?\xe7\xe5\x1f\xd7\xbe\xf8,'
 b'\x08\x15C\x8f3\x8e\xda\x8bNj\xa4\xefQ{\xb7\x9f%nu\x13\xf5x8N\xd3Lh1'
 b'UI\x00\x05\x00V\\\xb9\xd0\xd0\xe9')

{'A1': -1402,
 'A2': {'B1': {'C1': [{'D1': -107,
                       'D2': -70,
                       'D3': 3648782213,
                       'D4': 0.5254850387573242},
                      {'D1': -52,
                       'D2': 80,
                       'D3': 4244706584,
                       'D4': -0.21738998591899872},
                      {'D1': 44,
                       'D2': -29,
                       'D3': 2703411787,
                       'D4': -0.8038241267204285},
                      {'D1': -89,
                       'D2': 55,
                       'D3': 413466280,
                       'D4': -0.5256455540657043},
                      {'D1': 30,
                       'D2': -70,
                       'D3': 1597986,
                       'D4': -0.03287500515580177},
                      {'D1': 23,
                       'D2': -109,
                       'D3': 2924577081,
                       'D4': 0.4517354667186737}],
               'C2': -5703399694510686874,
               'C3': -0.8843306046935651},
        'B2': 24188,
        'B3': 0.7467192853725968,
        'B4': [8, 21, 67, 143, 51, 142],
        'B5': {'E1': -628404630,
               'E2': [2767147387,
                      3080660334,
                      1964242296,
                      944689996,
                      1748063561],
               'E3': [-536576108,
                      1692294789,
                      -349835197,
                      -1322133042,
                      446278253]},
        'B6': [92, 185, 208, 208, 233]}}

Вариант №3

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

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

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

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

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

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

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

(b'2NBP*\x00G\x00\\\x00q\x00\x86\x00\x86\x8a\tY\xd6\x14\xad\xaf\xde\xf4'
 b'\xbc\x8f>ls\x92\xee\x82=\x1d&yvqcywt\xd7p\xb5\xfe\xc0.\xb5\x1b<c'
 b'\xce\x9f\x12\xcc\xeeW\xf6d\xcc\xda\xed\x13\x00\xdcwD\xb4\x99>\xd0'
 b'h\xcc\xb8\x9f\xbbB\xbb#f\xa2E\xaaTu\x15\xf3*\xd5\x9a\xc1\x19\x9c%D'
 b'\\\x94\xdbls\xe3o\x97o\x82\xae)eU\x9f\xee\xa8\r`@!\x01\x90\x9f:al~\xfdf\xb4S'
 b'\x9d\x19Z/Fp\xb5\x1c\xc5\xe5\xd3\x9e\xb5\xc7\xc6\x18\x01\xa9\x83\xf0'
 b'\xa1}\x9aL\xf6\x05\xbf')

{'A1': {'B1': 1996553416250585303,
        'B2': 60,
        'B3': -12701,
        'B4': {'C1': -97, 'C2': 1475267602, 'C3': 246, 'C4': 3990539364},
        'B5': {'D1': 44308,
               'D2': -0.02989134006202221,
               'D3': 4432367296055099023,
               'D4': 9757,
               'D5': 'yvqcywt'},
        'B6': 30684,
        'B7': 0.30020344257354736},
 'A2': [{'E1': [13493553728230025424, 1546235137361077795],
         'E2': 243,
         'E3': -10966,
         'E4': [-102, -63]},
        {'E1': [7844026299997068313, 3003481417296372595],
         'E2': 101,
         'E3': -24747,
         'E4': [-18, -88]},
        {'E1': [4224253310024048653, 11336603041454255201],
         'E2': 25,
         'E3': 12122,
         'E4': [70, 112]},
        {'E1': [14390582817262476469, 9052781174258211014],
         'E2': 154,
         'E3': -2484,
         'E4': [5, -65]}],
 'A3': 1493797510,
 'A4': 214}

(b'2NBP*\x00G\x00\\\x00q\x00\x86\x00\xc0\x9c\\\xa9\xfc\x07`A\xcf\xc2'
 b'\xbed\x86\xa8\xf2y\x10\x18\x91\xf2\xb7yrpjfci\xc66\nLA\xf2+U9Z\x17\xbc\xa9*'
 b"~\x18\x1f\xd0~=\xed\x13\x00NE\x05\xdb\xe8>\xc5\xb7lv\x1fR\x1d\x10'"
 b'\x17L\x00\xa5C(\x15)7\x99\xa5\xf5\t!\xa8\xb7-\xa4\tM \xf5,/WS\xca\xae'
 b'D\xb5c\x93/Z\xf3\x92\xe6\xc3\x15\x93h\x121`\xf3.\xd0\xa1\x0c\x8d\x97W'
 b'\x83\xc3\xc6\xb8\x0b\xa0M\x9f\xa4|\x19qV\xb3f\xa7EH6\xf5\x8c\xf0 ')

{'A1': {'B1': 6137265279484966598,
        'B2': 57,
        'B3': 5978,
        'B4': {'C1': -68, 'C2': 410921641, 'C3': 31, 'C4': 3980230352},
        'B5': {'D1': 24583,
               'D2': -0.38048747181892395,
               'D3': -7991619422820727196,
               'D4': -18446,
               'D5': 'yrpjfci'},
        'B6': 17742,
        'B7': 0.4547959864139557},
 'A2': [{'E1': [1161174574015756229, 1524542849818564391],
         'E2': 41,
         'E3': -26313,
         'E4': [-91, -11]},
        {'E1': [5551148531972579593, 12594970941813749024],
         'E2': 68,
         'E3': 25525,
         'E4': [-109, 47]},
        {'E1': [7535390532652168026, 910237499775791378],
         'E2': 141,
         'E3': 22423,
         'E4': [-125, -61]},
        {'E1': [8981478712630032582, 5207752603661136153],
         'E2': 54,
         'E3': -29451,
         'E4': [-16, 32]}],
 'A3': 2841418944,
 'A4': 252}

Вариант №4

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

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

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

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

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

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

(b'!ADD\xc0hZ\xdc\x11\xecK\x82\xb5\xeb\x03\x9c\x08c\xc6\x9f\x96\x8d\xe1\x81'
 b'\x0e\xc8\xf1\xd7"\xd9\xdd\xacU\xceEZl\xdb\'\x0em.\xf7\x0e\xd7\x92\x1b\xe4'
 b'\xa6\x00\xd8+\xbb\xf1\xdan\x9f\x86\x8f\xf6uL\xef\x02Z\xa6\xa9\x12'
 b'\xfd#\x1c\xe5\xe9\x1b\xa1\x0cz\x00\xdf\xa8C\x14\xacoq\xdak\xe7\xd45\xde\xd5'
 b'd\x96\xd6\tm\xcb\xa2\x14\xd4g\xe3\x07\x90nN2\xba\x1bTFmD\x0ef'
 b'\x0c\xe6\x97\xf0~}(\xd3\xf4)m\x07\x1b\x7f\xf4?\xee\xe7\x07\xee-`gm'
 b'j\xd1\xff\x9e\xf6\x93')

{'A1': -64,
 'A2': [104, 90, 220, 17, 236, 75],
 'A3': 46466,
 'A4': {'B1': [{'C1': 235, 'C2': 10202517680268286979},
               {'C1': 225, 'C2': 15985846663198019201},
               {'C1': 172, 'C2': 1020025099040181845},
               {'C1': 109, 'C2': 12025767222473324334},
               {'C1': 0, 'C2': 9700594009016839128},
               {'C1': 143, 'C2': 12224557207194990070},
               {'C1': 18, 'C2': 910039291090707453}],
        'B2': {'D1': [54056, 10740, 1901, 32539, 16372, 59374, 60935, 24621],
               'D2': 28007,
               'D3': 53610,
               'D4': 2482413311},
        'B3': 43231,
        'B4': [1873548355, -412362127, -706857516, 165058148],
        'B5': 568412138555755373,
        'B6': 5067705967220518544},
 'A5': -1110165842197330835,
 'A6': 126,
 'A7': 125}

(b'!ADDe\xca\xde\xf3\xa1k\x92\xd2f\x1e\xf2o\x06@}e\x00v\xed\x82ma{-'
 b'\xac\x84$\x98\xc7\x0e\x17\xeb\xcf\x1f\xa4A\x93\xb2n\x80P\xa3:Qr\xf4\x85c'
 b'\xacq\xef\xdc\x99\xa61\x1c\xfb\x12.\xa2\x8c\x8c\x1fv\xccI\xc4\xe8'
 b'\x1a\x1b\x81$z\x00\xab\x04x\xed4\x89,\x05^/2+\xcfV!\xffR\x92\xcf\xd1\x131'
 b'\x84\x8f\xe9\x1d\xb7\x9f\x91\xd3\xd99O1cy/\xf8\xe5(\x97\r\x08\x98\nG'
 b'\x10\xedy\xcc\xd5ef\x93\xe3\xde!\x026\xae{\x8c4\x8b\x8d\x9fu\xd5')

{'A1': 101,
 'A2': [202, 222, 243, 161, 107, 146],
 'A3': 26322,
 'A4': {'B1': [{'C1': 30, 'C2': 8502907685094977522},
               {'C1': 237, 'C2': 2631417393634700674},
               {'C1': 152, 'C2': 4729940486508711623},
               {'C1': 147, 'C2': 8237429666542022322},
               {'C1': 244, 'C2': 12004869202695185285},
               {'C1': 49, 'C2': 2273346540100844316},
               {'C1': 118, 'C2': 2630413459749358028}],
        'B2': {'D1': [18186, 60688, 52345, 26069, 37734, 57059, 545, 44598],
               'D2': 35963,
               'D3': 35636,
               'D4': 3581255565},
        'B3': 1195,
        'B4': [-1993020040, 794690860, 1456417586, -1840054495],
        'B5': 2155411694595330511,
        'B6': 3553122238738833335},
 'A5': 979296412152854883,
 'A6': 8,
 'A7': 152}

Вариант №5

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

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

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

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

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

Поле	Описание
1	float
2	Структура E
3	uint8

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

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

(b'\xebRLF\x00\x00\x004\xb9\xca\x90\xaf\x00\x00\x00G\xbe\xbd\x01\x92|\xe5"['
 b'\xcfZ\xf4V\x8c\xe2\t5\xd3#\xdd\x01\xd0\x00V\x00v\x00\x96?*\xda\x06poxuq'
 b'\xac\xf1\x00\x00\x00\x05\x00/\x08\x8fo\xf0\xd28a\xe0watY\x8e\xa9\x9d%'
 b'd\x80\xc1\x00\x03\x00DF\x8e\x8d\x9a\x19 j\xd4\xfbU\xbf\x00\x00\x00\x02\x00T'
 b'\xf07\x1f_0\x97\xf5\xcb\xfd\xc4\x8a\xb0\x04\x15%aS\x8e\x03Q\xdb\x88\xd0e'
 b'Yy\x00\x00\x00\x02\x00t\xf4BoM\xa6\x9a@\xf2\x8b\xd0\xd4\x1b3IV\xa7\xdc\xdf5l'
 b'7EP\xc4@)\x00\x00\x00\x02\x00\x940\x10\x10\xfe*P\xa8wJ\xca)\xdc\x13\xea|?')

{'A1': {'B1': -21263, 'B2': 'poxuq', 'B3': 616834754082791904},
 'A2': 47562,
 'A3': -28497,
 'A4': {'C1': 6453281808470802625, 'C2': 'wat', 'C3': 70},
 'A5': {'D1': -0.36915260553359985,
        'D2': {'E1': 8999637208086017110, 'E2': 10151686636826778881},
        'D3': 208},
 'A6': [{'F1': 11103941999470532031,
         'F2': [142, 141],
         'F3': -4041,
         'F4': 2260578967185259972,
         'F5': 35504,
         'F6': 1045,
         'F7': 9569},
        {'F1': 239213635885685113,
         'F2': [83, 142],
         'F3': -3006,
         'F4': 8020249692861533136,
         'F5': 54299,
         'F6': 13129,
         'F7': 22183},
        {'F1': 3849512552342241321,
         'F2': [220, 223],
         'F3': 12304,
         'F4': 1224462674603494090,
         'F5': 10716,
         'F6': 5098,
         'F7': 31807}],
 'A7': 0.6673892736434937}

(b'\xebRLF\x00\x00\x004\x04a\xf6\xf4\x00\x00\x00G\xbe\x8a#h)\xddO\x18'
 b'\x02\x8e\xe4\x14\xa3\x1d\xe2g\xb0\xe8\xa0-\xd1\x00V\x00v\x00\x96\xbf'
 b'\x01\x9a\xc1szmnh\x99;\x00\x00\x00\x05\x00/\x9f8\x87y\xfah\x8c\x9ayjz\xe3'
 b'xk\x84\xc1\xc0\xfe\xd7\x00\x03\x00DK\xaa\xbc\xe9\x89f+\x93\xbe'
 b'\xdb\xc6\x00\x00\x00\x02\x00T(\xb2\xff\xd4\xb1\x0e\xbdL\xe7\xd8J\xb9'
 b"\xb0\x95\\.\xa8\x87U\xb7\xe7\xddf\x04C\xa1\x00\x00\x00\x02\x00t'\xe3-\xc1"
 b'\x80\xabX\xfe\x1b\xa9\xa4A\x1b\xfb\x818\x16\x06\xc3\xec\x1f\xe0\xd5\xdf'
 b'\x88\xe6\x00\x00\x00\x02\x00\x94\xa8\x9eF\x83\xf3\x18\xa5\xd5L\xe9|\t'
 b'\xad\xdc\xc8\x93')

{'A1': {'B1': -26309, 'B2': 'szmnh', 'B3': -6973675065021264742},
 'A2': 1121,
 'A3': -2316,
 'A4': {'C1': 16390969061745426135, 'C2': 'yjz', 'C3': 75},
 'A5': {'D1': -0.26980137825012207,
        'D2': {'E1': 3016654289948828692, 'E2': 11753799537484406829},
        'D3': 209},
 'A6': [{'F1': 16828093819994954694,
         'F2': [170, 188],
         'F3': 10418,
         'F4': 18434553851597875160,
         'F5': 19129,
         'F6': 45205,
         'F7': 23598},
        {'F1': 6176660352047268769,
         'F2': [168, 135],
         'F3': 10211,
         'F4': 3297057875632724905,
         'F5': 42049,
         'F6': 7163,
         'F7': -32456},
        {'F1': 14117693982420994278,
         'F2': [22, 6],
         'F3': -22370,
         'F4': 5081172091791035625,
         'F5': 31753,
         'F6': 44508,
         'F7': -14189}],
 'A7': -0.5062676072120667}

Вариант №6

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

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

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

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

Поле	Описание
1	int32
2	int16
3	uint16
4	float
5	int64
6	float

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

(b'LRGgmbopwm\x10\xc8qg\x96w\x00\xd8\x19N\x01K\x89\xbe\x00\x00\x00\x02'
 b'\x00\x00\x00W\xd5d\xea\xd7\xe22t\xd1\xd9\x92l\xaa\xf8\xcc\xbb\xbf\xea\xff5x'
 b'd\xc6\x8a\x00\x04\x00\x00\x00\x87\xce\xca\xd6v\xbe\xc0\xa7\xc2\xf4\x1f2'
 b'\xcd*\x00\x02\x00\x00\x00\x97=\x00\x00\x00\x02\x00\x9b\xc8\xe8\xfc\xc0\xcf'
 b'\n\xb7\xe0>A\xd9\xbch#\x10\x93\xee\xed\x04\x0b>\x9c&\x7f\xc7\xf6\xf9\xe7\x8b'
 b'\xf0/X\xbe\x03\x0cp\xae\xbb\x9d\xcb{g\x1e\xca<Ly\x1e\xbe*\x87\xab\xbf\x0eNj?'
 b'0\xd1\xe1?8\xf1[\x0c\xac\x12\x17\xbf;,\xc1>\xd0\xf4.')

{'A1': 'gmbopwm',
 'A2': 4296,
 'A3': {'B1': 8171665486746491214,
        'B2': 21727678,
        'B3': [{'C1': -924255040,
                'C2': -12534,
                'C3': 47072,
                'C4': 0.18930715322494507,
                'C5': 7503859631684125707,
                'C6': 0.30498120188713074},
               {'C1': -940115481,
                'C2': -29712,
                'C3': 12120,
                'C4': -0.1279771327972412,
                'C5': -5855913393190920502,
                'C6': 0.012480048462748528}],
        'B4': {'D1': -43,
               'D2': 7271861914852184537,
               'D3': -28052,
               'D4': -1426535237,
               'D5': -0.8436534263075413,
               'D6': [-0.16653315722942352,
                      -0.5558840036392212,
                      0.690702497959137,
                      0.7224327921867371],
               'D7': -825567626},
        'B5': -0.37627989053726196,
        'B6': -12},
 'A4': 7986,
 'A5': 52522,
 'A6': [3244, 4631],
 'A7': 61,
 'A8': [-0.7311516404151917, 0.40811294317245483]}

(b'LRGhncuvuy\x14\x88%\x17\xf8i\xd3b0$d\x1e\x96\x9e\x00\x00\x00\x02'
 b"\x00\x00\x00W\x91\xba\x9f'\xa4V\x9b\x00\x18\xbd\xa3\x8f6}\x97\xbf\xe1q\xd9:"
 b':S\xc6\x00\x04\x00\x00\x00\x87\r\xd0\x16@\xbe\xd0Cl.\x99D\xc7W\x00\x02'
 b'\x00\x00\x00\x97\x08\x00\x00\x00\x02\x00\x9b<{\xf0\xe5\xbd\x7fj\xef='
 b'\xfdg\xcd.Y\xf4\xabwx\x05?\xbf\x1c\x97\xcf\x89\x12y\xd87\x96\xfb\xcb\xbe'
 b'\x91\xca\xe7\x1b\xc0\xf4\xc1\xf4\x1eU\xf1?0#\xd9?A\xc3\x88?\x0bZ\xcc?'
 b'&\xe2z\xbfL\xf5\xa4\xcb5\xa1\x81\xbf\x0e\x14\xcd\xbe\x9f\x8c\xa1')

{'A1': 'hncuvuy',
 'A2': 5256,
 'A3': {'B1': 2672878037269360676,
        'B2': 1679726238,
        'B3': [{'C1': 1014755557,
                'C2': -17025,
                'C3': 27375,
                'C4': 0.12373314052820206,
                'C5': 3339969615952872767,
                'C6': -0.611691415309906},
               {'C1': -1995277864,
                'C2': 14230,
                'C3': 64459,
                'C4': -0.28475114703178406,
                'C5': 1999867348413994481,
                'C6': 0.6880469918251038}],
        'B4': {'D1': -111,
               'D2': -4999233474576842728,
               'D3': -16989,
               'D4': -1892254313,
               'D5': -0.5451475274336353,
               'D6': [0.756889820098877,
                      0.5443542003631592,
                      0.6518932580947876,
                      -0.8006231784820557],
               'D7': 231740992},
        'B5': -0.4067643880844116,
        'B6': 46},
 'A4': 39236,
 'A5': 51031,
 'A6': [-13515, -24191],
 'A7': 8,
 'A8': [-0.555004894733429, -0.3116197884082794]}

Вариант №7

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

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

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

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

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

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

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

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

(b'\x85JWLM-k\xcc\x14\x19J f\x02`i;.\xa2\xbf\xcd\xbf\x86\xa6s\x7f\xa7\x97'
 b'\x88\x14\xf0/Ch\x1d\x9f\xda\xbfmldxbqkul\xb4v\x00\x00\x00\x13"\xd0\xc2'
 b'.r\xdc\xafN\xae\\:6\xcd\xd4_\xe3@\xf6\xa11\x8a\x99\xe1\xc1\xd1\xbfi'
 b'3\xd5O\x16\xf9r}Z\x92C\x9b\xf2\x87\xed\xceb\xafG\xf4\xbe\xc3Y\xd4c\x8bcl\xd8'
 b'c\x0eO+DV\xd5\xe0\xe7\xbd\x05\x00\x00\x00b\x00\x00\x00 C')

{'A1': 45,
 'A2': {'B1': [{'C1': 172861138320804971, 'C2': -0.23241069085527055},
               {'C1': 1479599223244826246, 'C2': -0.4159616010845175}],
        'B2': 'mldxbqku',
        'B3': -19348,
        'B4': {'D1': [1506000628,
                      1670079444,
                      241424492,
                      1447308111,
                      3186090197],
               'D2': 17184},
        'B5': {'E1': 8723, 'E2': 1915667152},
        'B6': {'F1': 2924392412,
               'F2': 14940,
               'F3': 1607781686,
               'F4': [16611, -24074, -30159, -7783, -11839],
               'F5': [27071, -10957]},
        'B7': 4869053641987266127},
 'A3': 5165455938505142939}

(b'\x85JWLM\xbc+\xfa\x8d\xc9\r\xc3\x9a<\x9cz^\xc4#\xa9\xd8\xbf\xd1\x0c'
 b'\xc5\x9d\xa6\xdeqe|b\xb2\\t\xec\xd2?klgvmtvm\xa8\nn\x00\x00\x00i\x1a\xd5\xbe'
 b"\xbe\x0fH\x13\xd2!';\x02\x1a\x9b\xccP\\G\xc3\x97\x89r{\x1a\xd1m\xd6"
 b'\x17A\xe1\x07!S7Er\xc5\xa5|?\x93p\xc4*\x97\xdd\xf4jD\x12W\xe3\x1a\x08\xe9'
 b'q\xdb\x03\x00\x00\x00b\x00\x00\x00\xab\x07')

{'A1': -68,
 'A2': {'B1': [{'C1': 4367017252672633387, 'C2': -0.38532346893945557},
               {'C1': 7309868477391899857, 'C2': 0.2956820397608124}],
        'B2': 'klgvmtvm',
        'B3': 2728,
        'B4': {'D1': [1147860189, 451106578, 3681675528], 'D2': 1963},
        'B5': {'E1': 6761, 'E2': 264158933},
        'B6': {'F1': 567415624,
               'F2': 15143,
               'F3': -862250494,
               'F4': [23632, -15545, -30313, 31602, -12006],
               'F5': [-10643, 16663]},
        'B7': -4219233796972541983},
 'A3': -7554009437174793051}

Вариант №8

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

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

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

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

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

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

(b'PZRUz\x10\xe9\xd3\x06\xac\xe6\x9a\xa4\xef`%\x03\x00\x00\x00:\x00\x00\x00'
 b'\xc5\xa3n\xbf&trkX\x00\x05\xb0\xd1\xbda\xe4\xa3\xbe-\x1f\xdf>\xcc\x99'
 b'\x17\xbf\x91\xe3\xe3>. \x01>\x02\x00\x00\x00"\x00w\x02\xeb|\x02\x00\x00\x00'
 b'*\x00\x0b\x1a\xccx\x02\x00\x00\x002\x00\xbaW\xfcE\xda\xf3\x83y]\x17\xe8?'
 b'U\xdb\xcb+l?\xb8\xe9\xcf\x06\x84\xb9\xdb?\xeaf\xc8N\xe0\xeb\xe1\xbf\x90\x92'
 b'mE\xf7"\xc2?\x94+\xb5;\xeaD\xe8\xbf\xc7!\xee\xb5[\xd2R\xbbq\xae')

{'A1': -6585697878552614640,
 'A2': 24815,
 'A3': 37,
 'A4': {'B1': [{'C1': [-0.10238651186227798, -0.3201017677783966],
                'C2': 2095776375},
               {'C1': [0.4357847273349762, -0.5921905040740967],
                'C2': 2026641931},
               {'C1': [0.44509556889533997, 0.12609931826591492],
                'C2': 1174165434}],
        'B2': -0.9321864247322083,
        'B3': 38},
 'A5': 'trk',
 'A6': {'D1': 0.7528521893833571,
        'D2': -9387,
        'D3': 0.9225432276725769,
        'D4': [0.4331979815030098,
               -0.5600434817053757,
               0.1416920746807091,
               -0.7584124723592702],
        'D5': -4948661749190614585,
        'D6': 44657}}

(b'PZRUzRu\xab]\xc8\xaf\xf8\xe1&\x1f\x8d\x02\x00\x00\x002\x00\x00\x00'
 b'\xb4g\x84\xbe\x94fjwF\x00\xb9\xeb*\xbf]\xa0\x03?\x9d\x9e\x02?\xae\xf8'
 b'\xd0\xbc\x02\x00\x00\x00"\x00\x8c\xb2g\xc7\x02\x00\x00\x00*\x00\xda\x93'
 b'^\xc4\x08X\x8e\xfdE\x0f\xdf?U\xc7b\xfc\x16\xbf\x00H_\x0b(@\x85?\xa8T\xdb\xd4'
 b'\xdc\xef\xda\xbf\xf4M\xc2\x8e\xfck\xda?0\x80Y%5\xac\xeb?\x8d\xa9\xcb\xdb'
 b'\x88z\xf9\xd2h\x9c')

{'A1': -2163786345851685550,
 'A2': 7974,
 'A3': -115,
 'A4': {'B1': [{'C1': [-0.667659342288971, 0.5141656994819641],
                'C2': 3345461900},
               {'C1': [0.5102327466011047, -0.02550920471549034],
                'C2': 3294532570}],
        'B2': -0.25860369205474854,
        'B3': -108},
 'A5': 'fjw',
 'A6': {'D1': 0.4853072143681634,
        'D2': -14507,
        'D3': -0.589788556098938,
        'D4': [0.010376274916698236,
               -0.42089005266945856,
               0.41284097615536486,
               0.8647714356884588],
        'D5': -3244427328322033267,
        'D6': 40040}}

Вариант №9

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

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

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

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

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

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

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

(b'OUYOe\x00\x9b\xeb\xdbW\\s\xed\x98\xd3\x9fD^\xcc\x8d;\xbc\xc1\x7f'
 b'F\x08\xfe\xf6\r\xa8\xc8\xb6\x9a\xa9\xf4t\xbag?\xff\xe1\x0esft\xe7(u'
 b'\x10OI\x1fnR<j\x8c\twN\xe1\xbf\xb2\xbc\xbf[\xc7RD]-\xec.YDq\x10\x8b\x03\x00'
 b'\x14\x00\x0f\x84K\xbf\xd4!S1\xf8\xe9"\x1f\x11\x02\x00,\x00\x00'
 b'\x00\x05\x00\x00\x00\n\x00\x00\x004\x005\xf6@[\x8b\x0f\xc8\xf6\xf9\xef9_-'
 b'\xbb\xf9a\xe7\x93\xd4\xf2')

{'A1': {'B1': [{'C1': 92, 'C2': 115},
               {'C1': -19, 'C2': -104},
               {'C1': -45, 'C2': -97},
               {'C1': 68, 'C2': 94},
               {'C1': -52, 'C2': -115}],
        'B2': {'D1': 21102,
               'D2': -0.5408282457822859,
               'D3': 6720587560134884530,
               'D4': {'E1': -8426110364442235859,
                      'E2': [-649072197410636741,
                             8427547284673701901,
                             7382260578003150778],
                      'E3': -0.7949838042259216,
                      'E4': 8660,
                      'E5': [83, 49, 248],
                      'E6': 287253225},
               'D5': [1965614964, 524898064]},
        'B3': 1530983989,
        'B4': 6861779364141862795,
        'B5': -948970999477847251},
 'A2': 1474030491}

(b'OUYO_\x00%E\x03xax0\x16D\xc1\xc9\x0f\xbd\xf3\xe5\xd5\xb84\xb3\x88\x97j'
 b'\xcd\x147h8\xc6\x99c\x84fk\x8b\x8bC|U\xbfK\x85\x9dlQs\x87\x13\xfe\xdb\xbf'
 b'\xa8\xdb\xaa\xf6 ,\xe3\xef\x8bsl$:\xc8\xc6M\x02\x00\x0e\x00\xd5\xce"\xbf'
 b'\x8c\x8e\x9b\x10\x82O\x02\xe6p\x04\x00\x1e\x00\x00\x00\x02\x00\x00\x00\n'
 b'\x00\x00\x00.\x00g+\x08\xb5X)\xe2\xe5)e\x1f\xd6\xaaCo,*\xb8\xe3}')

{'A1': {'B1': [{'C1': 97, 'C2': 120}, {'C1': 48, 'C2': 22}],
        'B2': {'D1': 40325,
               'D2': -0.43738258578857514,
               'D3': -1161035758842487896,
               'D4': {'E1': 5604386938353906571,
                      'E2': [-3033750780624912060, 1498971450050294968],
                      'E3': -0.6359685063362122,
                      'E4': -29044,
                      'E5': [155, 16, 130],
                      'E6': 1894122063},
               'D5': [3325585463, 1719952281, 1133218667, 1270830460]},
        'B3': 3037211495,
        'B4': 15429162079019477336,
        'B5': 9071296565727937450},
 'A2': 2013480229}

Вариант №10

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

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

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

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

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

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

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

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

(b'WHQ\x91\x85o\x00\x00\x0088\xdbk;\xc5\xfe\xeb\x1c\xbf\xe4\xb11[\xb9'
 b'E\xf6\xc6\x96\xe8\x87_\x00\x03\x00\x1a\x9a\x7f\xa2d|\x90\xb7\xe5\xc3'
 b'\x98\x00\x1d\x00\x03\x00\x00\x00#)gw\xad*\x87\xfcX6\x91\x8b\x96D\x1e6kj\x03='
 b'\x13\xe4\x9e\x7fU\xa3\x80\xb8\xcf\x93\xf7\x8d\xb8\x0e=\xbd\xe7\x0eFk'
 b'\xca\x0e\x94\x03\x9e\xa6\xb8q9{\xf8rp\x1c\x1e\xdem\xdf\xb8\x1en~y\xf0'
 b'"\xb2\xa9Z\x05:\x93\xeb\xfe\xb3\x7f?\xfc\xa9\x96J\x99l\xac\xedANn"\xadBW\x04'
 b'\x03\xba\x99\xcf\x00\x00\x00&\x8c\xbf\xed7=rw\x1c ')

{'A1': -31377,
 'A2': {'B1': 12477935235464860043,
        'B2': [{'C1': 2521046582,
                'C2': 7740002470451256959,
                'C3': 6170917445672630157,
                'C4': 184},
               {'C1': 238927335,
                'C2': 1028628080472884126,
                'C3': -6433267575991799184,
                'C4': 28},
               {'C1': 517893599,
                'C2': -5179581031938776398,
                'C3': -6243672184247812429,
                'C4': 127},
               {'C1': 1073523094,
                'C2': 5375447120214052462,
                'C3': 2498726309757434521,
                'C4': 207}],
        'B3': {'D1': 100,
               'D2': [31888, -18459, -15464],
               'D3': {'E1': -30881, 'E2': [198, 150, 232]},
               'D4': [154, 127, 162],
               'D5': 41,
               'D6': 26487},
        'B4': -116,
        'B5': -0.9129931674623357},
 'A3': {'F1': 4096986190492658460, 'F2': -0.6466299811820011}}

(b'WHQ\x91_q\x00\x00\x008\x1c\x97\x0bl\x9b\x1d\xd7\xd3\xbf\xc2`\x8d/u\xf2\xa8j!'
 b'\xb0M\x19\x00\x03\x00\x1a\x07\x0eTVZ\xff\xa1\x01%C\x00\x1d\x00'
 b'\x03\x00\x00\x00#\xa3\x1ep\xe9\xfd\x87"\xcb\xe4\tz\x7f\x9f\xa8K'
 b'\xbf\xa0\xce\x0f}#\x06\x96\xfe\xcb\x91\xae\xdd\xfej\xb5@V\x9ct\xe4\x90\xb27'
 b'\xcdv\xda\x91\x1b\xe6\xfb!\\m9d_\xf3\x1cB\xc1\xd7\xefE\x9aA\r\xff\xf0uWJ'
 b'\x17\xdd\xb6p\xe9\xb1\xc0\xf0\xddY\xaa\x1c\x9d\x9f\x1ewmg\x05+\x95}\n\xf1'
 b';d\xf1\xbe\x00\x00\x00&\x15?\xef\xb9\x19\xebu\t\xb0')

{'A1': 24433,
 'A2': {'B1': 16860781163464362362,
        'B2': [{'C1': 2141169739,
                'C2': -4638481050272332138,
                'C3': -86815587568817483,
                'C4': 64},
               {'C1': 1453094116,
                'C2': -8020286630791573221,
                'C3': -1802810544978566049,
                'C4': 243},
               {'C1': 474137047,
                'C2': -1205387721053310859,
                'C3': 6289866070592383409,
                'C4': 192},
               {'C1': 4041038250,
                'C2': 2061979157607048965,
                'C3': 3140553801111135473,
                'C4': 190}],
        'B3': {'D1': 86,
               'D2': [23295, -24319, 9539],
               'D3': {'E1': 19737, 'E2': [106, 33, 176]},
               'D4': [7, 14, 84],
               'D5': 163,
               'D6': 7792},
        'B4': 21,
        'B5': 0.9913453673146275},
 'A3': {'F1': 2060127915632089043, 'F2': -0.1435715181104531}}

Вариант №11

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

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

(b'\xc2NMB\x05\x00\x00\x00\x16\x00\x00\x00+\x00b\x00\x00\x00\xf4\xad\x0c?kgvnvB'
 b'Fw+\xa2\x02\xb5J\x1b\x00\x1d\x00\x1f\x00!\x00\x04\x00#\x00\x9f?\xc5\xe8\t'
 b'5\xf9\x93\x82Q\xf6\x8c\x04R\xd0\xda\x9b\xbc-.A\xa5\xa7a$>\x13\xd9\x92'
 b'\xee5*\xa5\x9fm\x1d\xe0\ny\x03\x00:\x00\x00\x00\x04\x00\x00\x00R\x00\xd03'
 b"$'\x03\x007\x00V\x00")

{'A1': 'kgvnv',
 'A2': {'B1': [{'C1': 66, 'C2': 70},
               {'C1': 119, 'C2': 43},
               {'C1': -94, 'C2': 2},
               {'C1': -75, 'C2': 74}],
        'B2': -7784132164256972897},
 'A3': {'D1': 656683984,
        'D2': [130, 81, 246],
        'D3': {'E1': [3295680391428572300,
                      1386585737119744302,
                      7899213872143176409],
               'E2': [29, -32, 10, 121]}},
 'A4': 1057795572}

(b"\xc2NMB\x05\x00\x00\x00\x16\x00\x00\x00'\x00g\x00\x00\x00\x00\xe4\xeaxxw"
 b'bgf\xf1\x08]$)\xc7\x1b\x00\x1d\x00\x1f\x00\x03\x00!\x00E\xd3\xdd\xf3\xfc'
 b'4\x04\x1b\xd2\xbeegDC!`\xba\xea*\x9d\xfb]\x7fa\xc3m\xe2T\xc0\x7f\xb0\xc9\x97'
 b'~\xa8\x1f\xf5\xf7\x88\tWK\x8a&T\xb2Q\xdc\x04\x007\x00\x00\x00\x04\x00\x00'
 b'\x00W\x00\x13z\x91\xcc\x04\x003\x00[\x00')

{'A1': 'xwbgf',
 'A2': {'B1': [{'C1': -15, 'C2': 8},
               {'C1': 93, 'C2': 36},
               {'C1': 41, 'C2': 199}],
        'B2': 1946739199958700869},
 'A3': {'D1': -862881261,
        'D2': [210, 190, 101, 103],
        'D3': {'E1': [-7121621774535408828,
                      6116571929844342267,
                      2281212401652105152,
                      2777114957421541365],
               'E2': [84, -78, 81, -36]}},
 'A4': 2028659712}

Вариант №12

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

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

(b'\xc7NPFBnsbzsEkP\x84\xbe\xbf\xd4\xb1\x94?h\xb1\x00z\x8e\xa3H\x9f\xe5Y\xe5~'
 b'\x8e\x87\xbf=\xa3@?e\x0b\xec>\x83<{P\x1a\x00\x00\x00\x05\x00\x00\x00\x18'
 b'\x06\x8c{\xa3\x00\x00\x00\x03\x00\x00\x00"q\x192T\x14(<\xf6\x12\xc4\x99\xf0'
 b'\xb9\xdf\xdf\x13\xbc\xd8\x98:=\xcd\xb5\xd4\xad\xab\x00\x00\x00\x04\x00\x00'
 b'\x00L5\x8d\x08\t\x00\x00\x00\x02\x00\x00\x00T\xa8$_\x13#W\\\x02\x00\x00'
 b'\x00.\x00\x00\x00\\<\xaa\x8d\xc9E?I\xf5=?*+\x07\x8d\xd7\x12\x95\xab'
 b'\x84\xb6\xc0\xbah\xf2\x07\xc7T?_\xf4\xac')

{'A1': 'nsbzs',
 'A2': 1164660868,
 'A3': -0.3746695816516876,
 'A4': -1807783759,
 'A5': {'B1': [{'C1': 20506,
                'C2': [-29021, 18591, -6823, -6786, -29049],
                'C3': 109869987,
                'C4': [-0.7407722473144531,
                       0.8947131633758545,
                       0.2563208043575287],
                'C5': 8149600337400446198},
               {'C1': 44459,
                'C2': [4804, -26128, -17953, -8429],
                'C3': 898435081,
                'C4': [-0.02643977478146553, 0.10044446587562561],
                'C5': 12115913433335421954}],
        'B2': 0.020819561555981636,
        'B3': 69,
        'B4': 0.7888982892036438,
        'B5': {'D1': 0.6647190451622009,
               'D2': 2379682453,
               'D3': 12359204216288899591},
        'B6': -950780065,
        'B7': -2900}}

(b'\xc7NPFBwmwoi\xb3\x1f\x8d@\xbdc\xb3\xd3\xd3aJ/\x00\x8c\x93\xc5\xe3\x90'
 b'\xdc\xbaX\x03\xfer\x991?BI\xf3\xbe\xcf\x05|?C\x84O\xbfR\x8fI>\xcbVO'
 b'/\xbe\x00\x00\x00\x06\x00\x00\x00\x18%\xac}<\x00\x00\x00\x05\x00\x00'
 b'\x00$\xff\x1akB\x9cM\x8e\x9d\\-_3\xbf\x06\x14\xaf\xbe\x86<\xf7<\xcb'
 b'\xb6\xbf>\x1b\xa8\x1d\xbf\x06b\xe4\xa1\x17\x00\x00\x00\x02\x00\x00\x00V'
 b'T\xd7\xfd\x98\x00\x00\x00\x05\x00\x00\x00Zv\x1bxl\x8bI$A\x00\x00\x008'
 b'\x00\x00\x00n\xbf;\x8b\x9d\xe3\xbd\xcfY\x16\xbe\xba\xa7\xd1x\x8fq]\x96yV'
 b'\n\xe7\xf5W\xc3\x14N>\xcd\xac\xb0')

{'A1': 'wmwoi',
 'A2': -1289777856,
 'A3': -0.055591415613889694,
 'A4': -748598737,
 'A5': {'B1': [{'C1': 12222,
                'C2': [-27707, -7280, -9030, 22531, -398, -26319],
                'C3': 632061244,
                'C4': [0.7589408755302429,
                       -0.4043387174606323,
                       0.7637376189231873,
                       -0.8224988579750061,
                       0.39714285731315613],
                'C5': 18382122762900442781},
               {'C1': 41239,
                'C2': [23597, 24371],
                'C3': 1423441304,
                'C4': [-0.5237531065940857,
                       -0.26218387484550476,
                       0.024867413565516472,
                       0.15200848877429962,
                       -0.5249464511871338],
                'C5': 8510528328435311681}],
        'B2': -0.7325990796089172,
        'B3': -29,
        'B4': -0.10124413669109344,
        'B5': {'D1': -0.3645615875720978,
               'D2': 2022666589,
               'D3': 10842792182712457155},
        'B6': 340672205,
        'B7': -21328}}

Вариант №13

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

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

(b'YVA\x07\xd6V\xaa\xbf\xa5Q\x00S>\xe6\x80-\xa1P\x84\xcbT\x00\x00\x00'
 b'\x8d\xd0]\xe1\x06>j\x06r\x8d\x00\xe3\xdf?\x01\xb0\x15w\x00\xdf\x8b\xbfO\xf9'
 b'*\x05\xc4O\xbc?^l\xaex\xacJ\x80>9\xd2n\xba\xaa.\xba9\xfe\xb1#\xe3y\x00'
 b'\x02\x00A\x00\x08\x00C\x00\x19\x00!\x00)\x001\x009nszxl<\x96)\xdc\x00K'
 b'\xde\x83\xbb\xc3??\xa0\xf2\x04+\xffE\xf5\x81\xac\xe1N\xe3\xaf\xa0D\x89pA'
 b'\x89%\xf4-?\xcaJ\x1c\x84\xe98\xf0\xb8F[\xff\x81?\xdf\xe08\x94G\xf8'
 b'\xc4\xa1j\x10\xfe\xe0\xfe\nX\xbc\xb3\xb9\xc8n\xd6\xb0\xa51\xa7\t\xa5')

{'A1': 131487402,
 'A2': 191,
 'A3': -23215,
 'A4': {'B1': [{'C1': -799153914, 'C2': 0.22854021191596985},
               {'C1': -1929321505, 'C2': 0.5065930485725403},
               {'C1': 1996545931, 'C2': -0.8123956918716431},
               {'C1': 96751548, 'C2': 0.8688458204269409},
               {'C1': 2024557184, 'C2': 0.18146678805351257}],
        'B2': 'nszx',
        'B3': 108,
        'B4': 1016474076,
        'B5': {'D1': [186, 170], 'D2': [46, -70, 57, -2, -79, 35, -29, 121]},
        'B6': [-561792061,
               1061134578,
               69992261,
               -176050975,
               1323544480,
               1149857857,
               -1994001363],
        'B7': 0.20538670053287644,
        'B8': -72},
 'A5': 0.45019665360450745,
 'A6': 161,
 'A7': 1350880084,
 'A8': {'E1': 18011,
        'E2': -1,
        'E3': 129,
        'E4': 0.4980603645380024,
        'E5': -6815616399189341608,
        'E6': -0.021939173340797424,
        'E7': 1859563685,
        'E8': 833030565}}

(b'YVA\xf5\xdaYa\xd4%u\x00N\xbfC\xf2}!\xb4\xe4\x84\xc4\x00\x00\x00\x88\x8dhD'
 b'\xae\xbf\x06\x00\xbfN\x14\x80\x8e=\xe8\xc4!\xa7\xea\xdc\xef\xbd\x81\xbb'
 b'\xe6\x89\xaa\xa6\x19\xbe\xef\xd6/\xa8b\xfc\xcb\xbfZ?\xbe\xc2\xba\xf5'
 b'\x81\xba\x00\x02\x00A\x00\x03\x00C\x00\x19\x00!\x00)\x001\x009sfzf&\xb5\x91*'
 b'\x1e\x00F\xe66\x19\xfdE<H\xf7\xe5r$\x99\xb6P\x17\xd3ZB\x0bC=\x107\xc1\xfb'
 b'A^\xaa?\xd3Y\xb8-|\xc0<\xfet\x12sc?\xe1\xf4\xeeYf\xb1\xfc\x04\xee49'
 b'7\xb5\x1e\x06\xbf\x0c\x85\x07\xd7\x0f\x10\xfe>0\xb9\x02')

{'A1': -170239647,
 'A2': 212,
 'A3': 9589,
 'A4': {'B1': [{'C1': -1922546514, 'C2': -0.5234488844871521},
               {'C1': 1309966478, 'C2': 0.11365533620119095},
               {'C1': -1477780241, 'C2': -0.06334666907787323},
               {'C1': -1985305063, 'C2': -0.4684309661388397},
               {'C1': -1469907765, 'C2': -0.8525351285934448}],
        'B2': 'sfzf',
        'B3': 38,
        'B4': 3046189598,
        'B5': {'D1': [194, 186], 'D2': [-11, -127, -70]},
        'B6': [-432662019,
               1161578743,
               -445504359,
               -1236265005,
               1514277699,
               1024473025,
               -79602006],
        'B7': 0.30235104028816173,
        'B8': -2},
 'A5': -0.7654188275337219,
 'A6': 33,
 'A7': 3034875076,
 'A8': {'E1': 29714,
        'E2': 115,
        'E3': 99,
        'E4': 0.5611488100162769,
        'E5': 355278840961244678,
        'E6': -0.5489048361778259,
        'E7': 3608088830,
        'E8': 1043380482}}

Вариант №14

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

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

(b'WGQU\x88\x03\xa8Q+\x9b\xe8\t\xd5\xbf\x02\x00"\x00\x00\x00$\x00\x00\x00'
 b'\x02\x00j\x00\xdeH~1\xdc\xf5vcR\x07`\xe9XT\xad\x92\xdd\x13\xa9l\xb3\xab\x88*'
 b'\xd8t\x89\xe7\xdc{R\xe6[\xef\x02\x00(\x00\x00\x00\xf88\x00\x00\x00\xcbBu'
 b'\xdd\xf7/$7}\xf9\xe6\xe6oOZ\xb5\xcb\xb2\xf8\x0fDg\x02\x00I\x00\x00\x00jY\x00'
 b'\x00\x00D\x00e\x00')

{'A1': -3095687515696158717,
 'A2': 191,
 'A3': 'vc',
 'A4': {'B1': 1874, 'B2': 59744},
 'A5': [{'C1': -8,
         'C2': {'D1': [31708, 58962, 61275],
                'D2': [7829811269529850968, 16683994766346070963]}},
        {'C1': 106,
         'C2': {'D1': [45771, 4088, 26436],
                'D2': [3973353512866497227, 13067844610802776445]}}],
 'A6': 18654,
 'A7': 12670,
 'A8': -2596}

(b'WGQU\x88\xd9\x8d\xe9~\x8d.2|\xc5\x02\x00"\x00\x00\x00$\x00\x00\x00'
 b'\x02\x00j\x00\xc9\xa5\xd4\x0bg\xa1do\xec\x00\xc0\xc8\xa6\x1d\xe3\xf1'
 b'7\x07G\x16m\x0c-\xdaiT\xf6G\xd3\xc7\x9e.N\x1b\x02\x00(\x00\x00\x00`8\x00\x00'
 b'\x00&,\xf1\xc86&\xf7Q\xe1K6\x0e\x01\x96\x04@\x1c\xa6\x0eS\xd6\x95\x02'
 b'\x00I\x00\x00\x00\x82Y\x00\x00\x00D\x00e\x00')

{'A1': 8949266594793098713,
 'A2': 197,
 'A3': 'do',
 'A4': {'B1': 236, 'B2': 51392},
 'A5': [{'C1': 96,
         'C2': {'D1': [51155, 11934, 6990],
                'D2': [1605259729043660198, 5185424834572389485]}},
        {'C1': -126,
         'C2': {'D1': [42524, 21262, 38358],
                'D2': [5906231453061032998, 4612976849611803617]}}],
 'A6': -23095,
 'A7': 3028,
 'A8': -24217}

Вариант №15

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

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

(b'QVTQ\xa8\xec\x12\xf8-\x97\xd4?\x02\x00\x00\x00x\x00umpipgxp\xc7R'
 b'\xf8\x1d\xaf\x07\x89\xe5\xd6\x89\x15\x11S+P*\x84\x8b\x1c%\xc0\x02'
 b'\xc3B\x1b\xf3\x06\x00|\x00\x96\xd6\x97\xdb\x94\x95z3\x82\x00\x00\x00'
 b'\x05\x00\x98\x00\x00\x00q\x1bz\x06\xb7\xa1\xac8\xea\xbfj\xed\x18\x93'
 b'l\xd60\x7f\xb8\r\x0eC\xea\xb9\xc9?\x91\x92\xb5>\xcb\xf9\xda\x04\xd5L\x9dc'
 b"\x057\xa7\x1est\xf1\x9bh\x00p\x00\xb8\xfd\x8e\x0b\xae\x01'\xe7\xd4=\xa8\xe6"
 b'\xd4 $\xba\xdf\xb4\x16\xdf\xea?\xe2\x00i?\xca\x89\x9d\x15\xbbT\xfc')

{'A1': 0.3217272684666548,
 'A2': [{'B1': 81459659, 'B2': 1671253205},
        {'B1': 514275077, 'B2': -1678674829}],
 'A3': 'umpipgxp',
 'A4': -1906984518511209785,
 'A5': 3048984583498729942,
 'A6': -29820,
 'A7': -929075492789672676,
 'A8': {'C1': [184, 253, 142, 11, 174, 1],
        'C2': [-106, -42, -105, -37, -108, -107, 122],
        'C3': 51,
        'C4': {'D1': 0.10395651310682297,
               'D2': 168,
               'D3': 54502,
               'D4': 32,
               'D5': 0.8397325070089363,
               'D6': 0.9101697206497192,
               'D7': 202,
               'D8': 137},
        'C5': {'E1': [-99, 21, -69, 84, -4],
               'E2': 7025,
               'E3': -0.8194182547087643,
               'E4': 9165061003511655786},
        'C6': 0.20098617815174946,
        'C7': 0.3546338379383087}}

(b'QVTQ\x802\xc4\xa8\xa6\xc5\xad\xbf\x02\x00\x00\x00x\x00oluzaloy\xb6\xc1'
 b'Ka\x16\x07e\xea\xcd\x85:\xafb\x9f\xb1cfZS%\xb7\xf9{\x92\x01:\x08\x00|\x00'
 b'\\\xa6N\xd0#\xe8Fy\x84\x00\x00\x00\x08\x00\x9a\x00\x00\x001>\xac/\xaaL'
 b'l\xe7\xe9?\xd8\xdb\xba!0\xdca\xe6\\\x95\xd8a\x9b\xc6\xe9\xbfJ\xa6e\xbf'
 b']\x9f~\xf3/g\xc0@mK\xc4\xfa\x996\xa5\x80h\x00p\x00l\xcdGc1Z\xe0{\xc91\xde>'
 b'h\x01+\xfct$\xc2u\xe4)\xee\xbf\xbdyQ>\x8e@\xb2G\xcc*\xdf\xf4\x80+')

{'A1': -0.05814858255516686,
 'A2': [{'B1': -209805475, 'B2': 1086351151},
        {'B1': -87798931, 'B2': -2136656231}],
 'A3': 'oluzaloy',
 'A4': -1556830303483608650,
 'A5': 7183698126828111309,
 'A6': 23142,
 'A7': 4179782990344693075,
 'A8': {'C1': [108, 205, 71, 99, 49, 90, 224, 123],
        'C2': [92, -90, 78, -48, 35, -24, 70],
        'C3': 121,
        'C4': {'D1': 0.4339735805988312,
               'D2': 104,
               'D3': 11009,
               'D4': -4,
               'D5': -0.9426138210266246,
               'D6': 0.20456595718860626,
               'D7': 142,
               'D8': 64},
        'C5': {'E1': [-78, 71, -52, 42, -33, -12, -128, 43],
               'E2': 15921,
               'E3': 0.809499883399885,
               'E4': -1845952272962757672},
        'C6': -0.8054940138869529,
        'C7': -0.8970686197280884}}

Вариант №16

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

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

(b'YWB{\xb9L#\x9d\xbc\xb5\xe0\xd1?m\x00\xef\r\n\xd9"\xfc\x0bc\x91\xfd[\xd3\x92'
 b'+#<\xaf\xcd"\x91\x08\x9f%\x10}l\xbe\xc3\xfe&\xee\x83\xc8\x15\x03\x81\xb4'
 b'\x81\xc3a=u\x05\x00\x0f\x00=7^\xb4\x93A \xc7z\x9d\xffd\xa7)\xa2^S_}'
 b'\xcc\xf8\xccV`\x99\x98\x05\xf0\xcb>\xc2\x02\x00>\x00\x1e#\x00F\x00q\x1e\x1b'
 b']\xe1\x1c\xb5\x8a\xb3b\xb9\\\x97\xed\xa2\xf0\xa3L\x19>\xd8\xa5*\x91]\x04\xe3'
 b'?j\xb7\xde5\xc8\x1f\x96$\xda\xe3\xcf\xdc\xfd\xca\xd7\x15\x96\xf4\x02'
 b'\x00a\x00\x00\x00\xf1\xab\x16\x9b\xd9\x84\x13?\xb7J\x98>\x04\x00\x00'
 b'\x00e\x00\x00\x00\xdb\xcc')

{'A1': 185,
 'A2': 0.2793402044231257,
 'A3': {'B1': {'C1': 17339682749681328819,
               'C2': 1041845411,
               'C3': 0.5942828974995633,
               'C4': 903788394,
               'C5': -2535557539130105912,
               'C6': 366463741,
               'C7': -2922},
        'B2': [{'D1': [8, 159, 37, 16, 125],
                'D2': 4274241132,
                'D3': {'E1': 38,
                       'E2': -18,
                       'E3': -14205,
                       'E4': 3028353813,
                       'E5': 0.05511808767914772},
                'D4': 117,
                'D5': [3641314799,
                       1661729826,
                       3546021265,
                       1008937874,
                       2434977199],
                'D6': 61},
               {'D1': [157, 255, 100, 167, 41],
                'D2': 1599299234,
                'D3': {'E1': 125,
                       'E2': -52,
                       'E3': -13064,
                       'E4': 2560188502,
                       'E5': 0.39831557869911194},
                'D4': -62,
                'D5': [2478071351, 2059870273],
                'D6': 30}],
        'B3': -1693013007,
        'B4': 0.5762458443641663,
        'B5': 0.29744502902030945,
        'B6': [7793, 23835, 7393, -30027],
        'B7': 52443}}

(b'YWB{\xe7\x00\x88\xab\xa0\xea+\xe0\xbfm\x00\xa0\x91{\xabl\\\xca\xad\x88'
 b"9\xe5\x01_\x82\xae'It\xf7|\xda\nW\x96)\xe6'z\xd8\xa8\xf8\x90I!\x15h\xbe"
 b'\x98\x04\x00\x0f\x00\x07Z\x89\xf5Z\x85M9\x01\xab*UZ=|\x89\x8b\xd7\xe3'
 b'=\xa0\xa9\r\xa4\xdc\x8b\xb6z\xbd\xbd\x9b\xb1\x0e\xbe\xf9\x03\x00:\x00'
 b'u\x1f\x00F\x00]\xadj]h"JlA2O\x87\xf4\x8e\x8c[LH\x87-\x04X\xc2\xca\x138\xee'
 b'\xbfp{AF\x9d\x92\xc0\xa7\x00m\xde\x86_\xb7+\xa8Q\x93\x02\x00a\x00\x00'
 b'\x00XJ\xb7\xeb\x07\xb8\x94\xbe\xec\xc5\xa4>\x04\x00\x00\x00e\x00\x00'
 b'\x00\xd0\x9f')

{'A1': 231,
 'A2': -0.5053609026037975,
 'A3': {'B1': {'C1': 6596804735084212801,
               'C2': 763840588,
               'C3': -0.9443453750743633,
               'C4': 1178696560,
               'C5': -8728419178215599459,
               'C6': 2821437279,
               'C7': -27823},
        'B2': [{'D1': [73, 116, 247, 124, 218],
                'D2': 697718538,
                'D3': {'E1': 230,
                       'E2': 39,
                       'E3': -10118,
                       'E4': 1234237608,
                       'E5': -0.22664310038089752},
                'D4': -104,
                'D5': [2877002144, 2915720300, 31799688, 665748063],
                'D6': 7},
               {'D1': [61, 124, 137, 139, 215],
                'D2': 2845851107,
                'D3': {'E1': 13,
                       'E2': -92,
                       'E3': -29732,
                       'E4': 3183311542,
                       'E5': -0.13934938609600067},
                'D4': -7,
                'D5': [1526040922, 20532613, 1515530923],
                'D6': 117}],
        'B3': -340309416,
        'B4': -0.2904665172100067,
        'B5': 0.32182252407073975,
        'B6': [-21155, 23914, 8808, 27722],
        'B7': 40912}}

Вариант №17

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

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

(b'FWY\x9b)v\x90^\x92\xceM\x00\x02\x009o\x92\x00\x03\x00;\xac=\x00\x03\x00>\x87'
 b'z\x00\x02\x00A\xdd\xb3\x00\x02\x00C\xe5\x18\x00\x03\x00E\xb1\x89\x00'
 b'\x91N\x8a\xe3\x9e\xb3\xcdI\x0bqlmozleymjlylmlh\x10\xf6\x1f\xff\xd2\xfdp'
 b'>\xbd*\x81\x97E\xa1\xca?\xdd\x92\xaa\xb5\xf9o\x90\xbfE\xb2\x06'
 b'\x00\x00\x00\x04\x00\x00\x00H=j\xce\xb4o\xbe\xdb\x00\x03\x00l\x00'
 b'\x00\x00\x02\x00\x00\x00ob>nX\x83*>\xc4h\xd7\xc2\xbf\x84\x02z\x9am'
 b':\x00\x00\x00P\x00\x00\x00q\xfb\x9a')

{'A1': 11180597912358014541,
 'A2': [{'B1': 'ql', 'B2': 111, 'B3': 146},
        {'B1': 'moz', 'B2': -84, 'B3': 61},
        {'B1': 'ley', 'B2': -121, 'B3': 122},
        {'B1': 'mj', 'B2': -35, 'B3': 179},
        {'B1': 'ly', 'B2': -27, 'B3': 24},
        {'B1': 'lml', 'B2': -79, 'B3': 137}],
 'A3': {'C1': {'D1': 0.3694649040699005,
               'D2': 2537923018,
               'D3': 0.4620768334477754,
               'D4': -0.7722476720809937,
               'D5': [26640, 63007, 65490, 64880]},
        'C2': {'E1': -16677,
               'E2': [61, 106, 206],
               'E3': [-76, 111],
               'E4': 98,
               'E5': 0.2327595204114914,
               'E6': 42,
               'E7': 0.38361236453056335,
               'E8': 14033080110091496762},
        'C3': -1126},
 'A4': 5659586152505362699}

(b'FWYDM\x05\r\xf5\x9c\x87/\x00\x02\x009\x9e\xe2\x00\x03\x00;\xa5\xc0\x00'
 b'\x03\x00>F\xe6\x00\x02\x00A\xfd\xe1\x00\x02\x00C\xcb\x88\x00\x03\x00'
 b"E\x83'\x00\x97\x89\xf0R\x1am\x0c\xb7Ievdkvjgoepvqoav[\xf8\xcb\x84"
 b'\xaf/\xd4\xe3~\xc9=eP\xf8\x7fz\xdd\x9d\xbf\xd8\xa3\xb6\x8b+\x08\x08\xbfq'
 b'\xae\xfd\x00\x00\x00\x05\x00\x00\x00H&c\x11\xa9\xce6M\x06A\x8e'
 b'\xe4\x00\x05\x00n\x00\x00\x00\x04\x00\x00\x00s\xe4=/\xe9\x1c\xb0\xbe'
 b'\x18\xf4iE\xebn\xe4\x8f\x12\x15\x12\x00\x00\x00R\x00\x00\x00w\xf3r')

{'A1': 4921595525299210031,
 'A2': [{'B1': 'ev', 'B2': -98, 'B3': 226},
        {'B1': 'dkv', 'B2': -91, 'B3': 192},
        {'B1': 'jgo', 'B2': 70, 'B3': 230},
        {'B1': 'ep', 'B2': -3, 'B3': 225},
        {'B1': 'vq', 'B2': -53, 'B3': 136},
        {'B1': 'oav', 'B2': -125, 'B3': 39}],
 'A3': {'C1': {'D1': 0.05598542094230652,
               'D2': 2138758557,
               'D3': -0.3849922522605316,
               'D4': -0.9440763592720032,
               'D5': [23544, 52100, 44847, 54499, 32457]},
        'C2': {'E1': -28956,
               'E2': [38, 99, 17, 169, 206],
               'E3': [54, 77, 6, 65],
               'E4': -28,
               'E5': 0.04294691979885101,
               'E6': 176,
               'E7': -0.14936985075473785,
               'E8': 5038242536075957522},
        'C3': -3214},
 'A4': 9939534651058861897}

Вариант №18

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

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

(b'\x10IRPH\xbe\x0cD<\xff\xe6\xafx^\x00\x00\x00\xb1\x00lj\t?-\x93\x04\xe9\x11'
 b'(\x1b2\xc7%Wd\x03.p\xd4\xb5p\x95w\xbf\x17\xf8\xf2z\xe4K\xd7\xfay\x0c\x93\x81'
 b'\xc0\x0f\x9a\xa6H\xd1\x08O\xd9\x84\xc1\xf1\x83\xefh\xda\xa6\x1d%,\x07\xa4\tW'
 b'p"\xce{\x1c\xf2_4k?\xe2\xbf\x9f9G\x02\x00\x00\x00,\x00\x00\x00\xaa'
 b'\x94\x8f\xbe\xf5U\xa3\xbe\xea\xc8U?\x8a\x99Q\x12\x99\xa5\xa9\xac\x99'
 b'S\xbd\x81\xcd\xd7F\xce\xbe\x03\x00\x00\x00<\x00\x00\x00\xac*\x01\xbf'
 b"i\xec'\xbc\x9a4y\xbd\x15\xf5\x9c\xfd\xeb\x0e\xf9.HIK\x8f<~\x01\xcf6\x8a\xcb("
 b'9T\x00\x00\x00\xf2\xc1\xbak\x11')

{'A1': {'B1': -66,
        'B2': 17420,
        'B3': 2951151420,
        'B4': 120,
        'B5': {'C1': 71,
               'C2': [{'D1': [-371744999547406313, -6441818997518037895],
                       'D2': [-0.2804310917854309, -0.31901517510414124],
                       'D3': 0.8350969552993774,
                       'D4': [-6005086551265928822, -3582939175881714791],
                       'D5': -66},
                      {'D1': [-1026393171195014840,
                              3180981314273210243,
                              8921105777759462407],
                       'D2': [-0.5045573711395264, -0.010249235667288303],
                       'D3': -0.06084118038415909,
                       'D4': [3384753001680663829, -3530401834314544824],
                       'D5': 54}],
               'C3': -118,
               'C4': [203, 40, 57],
               'C5': {'E1': -0.5702415488190726, 'E2': 14751}},
        'B6': {'F1': 1807401458, 'F2': 17}},
 'A2': 0.5367801189422607,
 'A3': 45,
 'A4': -4093179252413234029,
 'A5': 56907557,
 'A6': 28718,
 'A7': 46548,
 'A8': -0.9671239852905273}

(b'\x10IRPH\x00e\x9b\x18\x88\x98\xe7<^\x00\x00\x00\xb1\x00\xaa\x02\x0f?]'
 b'\xe1]{\xb7L\xb8\xb5y\xb4\xec\x02D\x824\x9e\xc2\xe9\xa7o?\xab\x0c\xdc\x17'
 b'\x1c\xbb\xa1\xda\xac\xf0`3\xc7I\x0b\xcb\xc1N6l$\xb8\xec\xa2\xc3\xcf\xf8\xfc'
 b'\x19\x1a\xa3/\xeb\xb5\x8f\xbb&\xfd\xa9h\xe0q\x1bZ.%\xa3\xbf+\x9aC\x02'
 b'\x00\x00\x00,\x00\x00\x00Ir.\xbb\x8e\xa4\xe2\xbe\x13\x90Y?`J\x97\xf0$X\xa3L|'
 b'\xc9\xbaf/T(\xf9\xf3\x03\x00\x00\x00<\x00\x00\x007d\xa0>\xadD|\xbfZ\xbc\xce>'
 b'0;W\x89"\xdd\xdff\xb5\xad\x125F\xe7\xf6>\xa9\xa1H\x1e\xc6T\x00\x00'
 b'\x00\x94\x03\xd6\xf7Q')

{'A1': {'B1': 0,
        'B2': 39781,
        'B3': 3885533208,
        'B4': 60,
        'B5': {'C1': 67,
               'C2': [{'D1': [-2692665372857070421, -3815875139357052756],
                       'D2': [-0.0026618412230163813, -0.44266170263290405],
                       'D3': 0.8498546481132507,
                       'D4': [5522354483764873824, -493051596633355908],
                       'D5': -13},
                      {'D1': [-6706783278487679295,
                              3432616039907119043,
                              7541837393805948395],
                       'D2': [0.3132645785808563, -0.9854229092597961],
                       'D3': 0.4037807583808899,
                       'D4': [7412886652077947696, 4537067963346496949],
                       'D5': -87}],
               'C3': -95,
               'C4': [72, 30, 198],
               'C5': {'E1': -0.03739304399434551, 'E2': -26069}},
        'B6': {'F1': 4157997972, 'F2': 81}},
 'A2': 0.5586344003677368,
 'A3': 93,
 'A4': 8770118489009249761,
 'A5': 1141042356,
 'A6': 13442,
 'A7': 49822,
 'A8': 0.9361558556556702}

Вариант №19

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

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

(b'CTRU\xd7UV\xbe\x99\xbc\x95\xbe\xb8\t\x8f\x97\xc4\xbd\xe3H\xe5\x9e\xce8'
 b'\x84\xdcP\x00\x00\x00z\x00\x00\x00\x02\x00\x00\x00\x9e\x00\x00\x00banwev'
 b'\xb4\xfc\xee\x94\xf8\xd1\x02\x00\x00\x00\xa0\x00\x00\x00\xa9\xe0*[m\xdb'
 b'l\xdfSy\xacB\xac\xcb,\xe7\xe5\xd0J\x00\x00\x00h\xb6\xa3\x06\xdc\x1elx'
 b'\x0f%\xbb,\x18\x19\xdb\\\x94\xca\xd2?\xb7\x19`?\xf1"\x99\xc0=\xd61\xbf'
 b'y\x94u\xb6]\xb2t\x00\x00\x00vi\x1b7\xfa\xd3\xbe"\xcb\t\xfc\xac\xbas'
 b'^\xce\xee\x1d\xe6?O\x97\xfb>E\x8a\x03/\xe8\xd1\x89bsa\xea\xda\xae\xdc'
 b'\x1b\x85\xbf\xb2')

{'A1': -0.2093118280172348,
 'A2': -0.2924545109272003,
 'A3': 2488,
 'A4': {'B1': -0.09599220007658005,
        'B2': 15889887845350197475,
        'B3': [{'C1': {'D1': 52140, 'D2': 3504727852},
                'C2': 104,
                'C3': 1114759787570439094,
                'C4': 47909,
                'C5': {'E1': 44,
                       'E2': 0.29361447399095786,
                       'E3': 0.8753923773765564,
                       'E4': 13777028295815668465}},
               {'C1': {'D1': 38009, 'D2': 2992486005},
                'C2': 118,
                'C3': 14637471556552825705,
                'C4': 64521,
                'C5': {'E1': -84,
                       'E2': 0.6911539106982822,
                       'E3': 0.4913887679576874,
                       'E4': 7100437082677676613}}]},
 'A5': 'sa',
 'A6': 'banwev',
 'A7': 2498690228,
 'A8': {'F1': 53752,
        'F2': [-592520470, -1296071397],
        'F3': -2347260043039416151,
        'F4': 1118599507}}

(b'CTRUn\\\xed\xbe\xf1\xd07?\xfa\xe8\xb6\x7f^\xbfi9\xe9\xc0E\x9e\x16\xedP\x00'
 b'\x00\x00z\x00\x00\x00\x03\x00\x00\x00\x9e\x00\x00\x00pkabrb\x9bABJ'
 b'u\xb3\x05\x00\x00\x00\xa1\x00\x00\x00\x03\xf5\x8dq\xf9#\x0b\xde~\xee'
 b'\xaa3\xb9\xa9\xa6\xbeO\x14J\x00\x00\x00m\x0cT\x8eU\xa7R/\xe9\x1dyQ^\x06\xc7<'
 b'7\xdb\xee\xbf8\x89F\xbf\x04x\xef\xe1F\\*\x04\xcc\xb8\xb5\x11]Jt\x00'
 b'\x00\x00\x1c\xaeQ\x9d\x9f\xae\x1a$P\xab\xf6v\xec\xb2\x9e\xc3$6\xe1\xbfuZ'
 b'\xb8> Ym.\x12\xc0\xec\nlul#\xfaX\x91\x89\xff\xcb\x9c=H\x95\xcf\xe25K'
 b"\x91'\xc1^>")

{'A1': -0.46359580755233765,
 'A2': 0.7180319428443909,
 'A3': 59642,
 'A4': {'B1': -0.8691362142562866,
        'B2': 17084016258902997353,
        'B3': [{'C1': {'D1': 43449, 'D2': 340770470},
                'C2': 109,
                'C3': 16802739613391016972,
                'C4': 31005,
                'C5': {'E1': 81,
                       'E2': -0.9642597376880067,
                       'E3': -0.7755312919616699,
                       'E4': 300153784681592836}},
               {'C1': {'D1': 47308, 'D2': 1247613365},
                'C2': 28,
                'C3': 5774769959500337582,
                'C4': 63147,
                'C5': {'E1': 118,
                       'E2': -0.537859327383186,
                       'E3': 0.36006513237953186,
                       'E4': 787215219203856672}}]},
 'A5': 'lul',
 'A6': 'pkabrb',
 'A7': 1245856155,
 'A8': {'F1': 45941,
        'F2': [-1856439773, -1664352375, -812300227, -1857341982, 1046397223],
        'F3': -2446822418286775037,
        'F4': 866840190}}

Вариант №20

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

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

(b'\x15POJGD\x00\x88\xe8\xfb)E\xeb\xe2?O\x00\xc7\x93\xcaf\x00\x02\x00'
 b'\x00\x00\x80\x00\x0e\xf9\xba\t\xf8ou-b\xe8\xe8?[(\xe5H\xe5}R\xde'
 b'm\xc3\xbf\x81\xad\xefr?y9\x89x\xa3.i\xbf\xd6\x1d\xc6\xfff\x02\x00\x00'
 b'\x004\x00\xabf \xb7\xeev\xf7\r?TFu>\x02\x93b\x1c\xc0\xf8\xff\xf5\xf3\xe1G,'
 b'\xf5\x80[Q}?\xdeE\x10Q\x04\x89\xefD\x92\xd0\xe6\xd1@j\xd6* w6\xb2\xea\xbf'
 b'V\xd7\x1f\xb5\xb7\xb6.\xb0\xf7\xb46\x8dQ\xc7\x11\xb7')

{'A1': {'B1': {'C1': 102,
               'C2': [{'D1': 0.9489696621894836, 'D2': 2022259065},
                      {'D1': -0.9108678698539734, 'D2': -3793450}],
               'C3': -1222613333},
        'B2': 0.5912195034027414,
        'B3': {'E1': 238,
               'E2': 0.554557204246521,
               'E3': 0.23952609300613403,
               'E4': 476222210,
               'E5': 63680,
               'E6': -504105473,
               'E7': -2131415993},
        'B4': 199,
        'B5': {'F1': 147,
               'F2': 202,
               'F3': {'G1': 0.9895226359367371,
                      'G2': [222, 69, 16, 81, 4, 137],
                      'G3': 7656350155801773295,
                      'G4': -0.8342544867203638},
               'F4': [-5751458773971511466, -5255200137089207049],
               'F5': 163248398},
        'B6': 0.778367127215005,
        'B7': 91,
        'B8': [40, -27]},
 'A2': -0.15179041889113365,
 'A3': -127}

(b'\x15POJGL\x00da\xbe\xa9\xba\xc3\xda\xbfW\x00\xe8$\xc1n\x00\x02\x00'
 b'\x00\x00\x88\x00\x89\tF\xd4H\xf0Z\xf7\xaam\xc0\xbf2\x9d0`8\xb2\x87\xf4'
 b'c\xb5?\xfdN\xbdH\xbfu\xf9v\x1f\x9d~\x10\xbf\x17c\xa5eK\x0fm?h\x8d\x0b\x95'
 b',\x03\x00\x00\x004\x00\x9a-\xaf\x99d\xb6FF\xbfW\xd4\x7f?\x1f\xf5\xbe?J4\xe06'
 b'\xc1\xa9\xff\xc4\xc96!\x18\xac>#R6\xae\xcf<n6+\tu\x87\x8f9T\x890\xf1'
 b'u\x0b\xef?r\x16"\x17\xe1\xe7Z:\x88e\xbe\xda4S\xfd4')

{'A1': {'B1': {'C1': 44,
               'C2': [{'D1': -0.784138560295105, 'D2': 527890805},
                      {'D1': -0.5644319653511047, 'D2': 1705337623},
                      {'D1': 0.9260146021842957, 'D2': -1794405016}],
               'C3': -1716572774},
        'B2': -0.418196359410578,
        'B3': {'E1': 100,
               'E2': -0.7745164632797241,
               'E3': 0.9993337988853455,
               'E4': 1069479199,
               'E5': 13386,
               'E6': -1446955296,
               'E7': 919192831},
        'B4': 232,
        'B5': {'F1': 36,
               'F2': 193,
               'F3': {'G1': 0.3361215889453888,
                      'G2': [35, 82, 54, 174, 207, 60],
                      'G3': 4147682718566266478,
                      'G4': 0.9701490126356398},
               'F4': [4204928156045547122, 3818299545553364360],
               'F5': -733607543},
        'B6': -0.12834679677860295,
        'B7': 50,
        'B8': [-99, 48]},
 'A2': 0.08355644524473993,
 'A3': -3}

Вариант №21

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

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

(b"UNWX'k\xa1^\xbf_\x17\xbe\x00\x03\x00\x00\x00#\x00\x00\x00bM\xdf>1\xbf\xc4"
 b"\xfc%J\x97\x88\x08\x0fecm\xe75\xf0\x01v\xb4v5=Q\x8b\xa3Iw\x87'\xf7P"
 b'\xfe\x17\xbfIms\xab\xaf\x12\x8b\xc8\x1cIV\xbf\x17\x96\xdb\xbd\xf6'
 b'\xff\xd9>\xbc[\xdf\xbe1\xa4u?eq\'?C\xdfG>\x1b"\xcd\x00\x03\x00&DO\xc4<\x12E'
 b'\xfb\x8bvP{\xb3@\x9ew\x8f\xf8J\x80\xc22\xe4\xd6\x10\x0cn\xf8A\x0c\xe1'
 b'\x90\x8c\x1f[\rK\xbc\xf2x\xdf\x92\xd2\x86<4\x00\x06\x00J\xe8\xa4\xf5t\xde'
 b'\tS\x9f\xd1\x01\xf8\xc8\x0bS\xdd%')

{'A1': {'B1': 661365086, 'B2': -0.8714560270309448},
 'A2': 'ecm',
 'A3': {'C1': [{'D1': 16660486285604189749, 'D2': 0.05115855857729912},
               {'D1': 5293848492720061975, 'D2': -0.7868263125419617},
               {'D1': 12371127092977092950, 'D2': -0.5921456217765808}],
        'C2': 17487,
        'C3': -1002696123,
        'C4': -5,
        'C5': 2339786875,
        'C6': {'E1': -19648,
               'E2': -7027990396923755982,
               'E3': [-455733236,
                      1861763340,
                      -510620641,
                      1527598012,
                      -226959470],
               'E4': -762954700,
               'E5': [-0.12060517817735672,
                      0.3678884208202362,
                      -0.17347891628742218,
                      0.8962578177452087,
                      0.7651256918907166,
                      0.151499941945076],
               'E6': 16763793595269993375},
        'C7': -3386151906738709211},
 'A4': 1306476081,
 'A5': -0.1639448751657826,
 'A6': 15}

(b'UNWX\xd9\xe2\xaf\xa4\xbeK\xed>\x00\x02\x00\x00\x00#\x00\x00\x00Q)\xa0'
 b'\xef\x0c\xbf\xd8\xbf\xf5\n\x80\xd30\xdfadE\xf36\xafv ()?-V\x99\x11\xeam'
 b'e\xa5\xa5\xfc\x01\xbfxo\r\xbfr\xac\x9b\xbfE\x03g?\x10\xcb\x01\xbe\xcel'
 b'\xd2\xbf\x00\xff\x8e\x00\x02\x00%\xc4\xb1Y\xcf5z\xe0\xf2\t\xf3\xcf'
 b'\x88\xe2\xf9\xe0\xa3`\x91\xc2PH\xb5r\xc9\n\xe7f[\xbc\xf5}\x8e\x81\xf7\x87'
 b'\x10\x05w\x02&?\xe0`c\n\x00\x05\x00=\x8b5u\x93\xf9\r\x01\xa6\xd5?\xf8&e\x9c'
 b'\xe6\x10')

{'A1': {'B1': -639455324, 'B2': -0.19914719462394714},
 'A2': 'ad',
 'A3': {'C1': [{'D1': 5040432535186712617, 'D2': 0.6771026253700256},
               {'D1': 1290964526533311489, 'D2': -0.9704445004463196}],
        'C2': -15183,
        'C3': 1506751866,
        'C4': -32,
        'C5': 4060738511,
        'C6': {'E1': -30494,
               'E2': -441173128324689848,
               'E3': [-1250768630,
                      -412722244,
                      -176320895,
                      -142143483,
                      1996629567],
               'E4': -530554102,
               'E5': [-0.9479462504386902,
                      -0.7695831656455994,
                      0.5655975937843323,
                      -0.4031739830970764,
                      -0.5038994550704956],
               'E6': 10031053023436669350},
        'C7': -3080470776300902896},
 'A4': 698412812,
 'A5': -0.38671613717751807,
 'A6': 223}

Вариант №22

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

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

(b'VQW\xfe\xc7B\x7f\x00\x00\x00\x87\xa0\xdb?\xd0\xca\xf7~$\x7fl\x00\x00\x00'
 b'\x02\x00\x00\x00\x99\x7f\x06\x18\x11\xa8\xd8s{\xe3zo\xdb@\xefy\xb7)\xb2\x9e'
 b'\x8a\x13*\xa9/\x8d\xf9\xb2w\xc3\x92H7Q\xee\xad\xe3I\xcc\xaf\xcc\x8a\x0e\xec'
 b'\xa0a?\xe3\x0cP_K6\xca\xd9\x9f\x00\x02\x00<\xf2\xbfZS\x92|\xca?\xd1\xcfo\x12'
 b'c*\xf8S\xcf\x00\x02\x00@\xe6\xbe\xb4\xda\xb6\x85\x98\xbf\xdc<\x10'
 b'$\x11\xbf\xcc4\xcb\x00\x02\x00DU\xbe\x86\x1d\x92\xbe\x96\x19)\xbe)e\xfdc'
 b'\x85"m\xab\xc3\x00\x03\x00Hwi')

{'A1': 4274471551,
 'A2': {'B1': -0.29316070675849915,
        'B2': -0.16542811691761017,
        'B3': 25477,
        'B4': 8813,
        'B5': -21565,
        'B6': [{'C1': 41057,
                'C2': 0.5952531682211994,
                'C3': -9825,
                'C4': [14161, 61101],
                'C5': -14,
                'C6': -0.8528376817703247},
               {'C1': 31946,
                'C2': 0.27828575893060714,
                'C3': 21455,
                'C4': [58185, 52399],
                'C5': -26,
                'C6': -0.35323113203048706},
               {'C1': 34200,
                'C2': -0.44116595766444955,
                'C3': 13515,
                'C4': [52362, 3820],
                'C5': 85,
                'C6': -0.26194435358047485}]},
 'A3': -24357,
 'A4': 0.2623881084309605,
 'A5': 'wi',
 'A6': 127,
 'A7': 439120380552248291,
 'A8': {'D1': 122,
        'D2': [111, 219, 64, 239],
        'D3': 8770524646468096810,
        'D4': 2838466041,
        'D5': 178,
        'D6': [30659, 37448]}}

(b'VQWG>Tj\x00\x00\x00n_\x0b\xbf\xde\x112\x14\xf4q\x14\x00\x00\x00'
 b'\x02\x00\x00\x00\x80\xf3\xc3z\xc6@@\xd8u\xd6U&\x0f\xaaA\xdf\x06\xac`\xca'
 b'\x0e\x9bv\xde\xd5H\xcdd\xb5l\x16\x901\xd2\x8e\xecF\xc5"\x9b\xf7\xd1?\xee'
 b"dP\xeb|WZ\xac \x00\x02\x00<\x96>\x07\xb6\x9b'\xe2\xbf\xde!\x87\xd3"
 b'\xa6*\xf4\x95\xe4\x00\x02\x00@>\xbe\x06\xca\xc7\xbe\x05\xde\xe4?R\xd5tp\x9c'
 b':N\xc7X\x00\x02\x00Drb')

{'A1': 1195267178,
 'A2': {'B1': -0.13073307275772095,
        'B2': 0.8235695362091064,
        'B3': 28828,
        'B4': 14926,
        'B5': -14504,
        'B6': [{'C1': 63441,
                'C2': 0.9497456168489677,
                'C3': -21472,
                'C4': [12754, 36588],
                'C5': -106,
                'C6': 0.1325325220823288},
               {'C1': 10210,
                'C2': -0.47079654377800684,
                'C3': -27164,
                'C4': [18117, 8859],
                'C5': 62,
                'C6': -0.13163290917873383}]},
 'A3': 24331,
 'A4': -0.46979953810093034,
 'A5': 'rb',
 'A6': -13,
 'A7': -4360955309886769706,
 'A8': {'D1': 85,
        'D2': [38, 15, 170, 65],
        'D3': -2376022221684565130,
        'D4': 3738519757,
        'D5': 100,
        'D6': [46444, 5776]}}

Вариант №23

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

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

(b'RVQO;6n\xd1\xf66I_\x03\x00\x00\x00q?\xe3MzK\xc0\x06\xc2\xf2\x82\xe7'
 b"\x0elI\xcb.\xf9\xc4\x17#(\xa6:EB%%\xb4\x00\x02\x00#\x00\x00\x00\x03\x00'Q"
 b'Jkv\x85r\xee\xc0\xc0J\xdb\xe7A\x0f\xe06\x00\x03\x007\x00\x00\x00\x05\x00'
 b'=\x00\x00\x00-\x00\x00\x00G\xd3\x89|o\x9cI\xca\x96\x10\x7f\x0f\xb5\xae\xd8w'
 b"\xb0\xef\x16\x08h\xc1\x1c'\xbf\x02\xbe\x90\x91q\xd6?\xdfN\xa2\xb4KV\xb4\xac"
 b'\xee\x00\x02\x00\x00\x00Q\x00\x03\x00Y\xbf\xe6\x07\xbd\x83$\xd8\x0e\x96\xf1')

{'A1': 913232374,
 'A2': 910778115,
 'A3': {'B1': {'C1': 2,
               'C2': -0.28235962986946106,
               'C3': -42,
               'C4': 0.4891745339094584,
               'C5': 44270,
               'C6': [{'D1': [5923, 10406], 'D2': [14917, 16933, 9652]},
                      {'D1': [20810, 27510, -31374],
                       'D2': [61120, 49226, 56295, 16655, 57398]}],
               'C7': [15242851232617450134,
                      1188686099646019504,
                      17227966670561879999]},
        'B2': -0.6884448586849901,
        'B3': 38641},
 'A4': 0.6032077292913629,
 'A5': 17474783553283279662,
 'A6': 63940}

(b'RVQO;\x80\x11\xe0\xa9s\xc4\xb26\x00\x00\x00m?\xeb<\x94\xfe\xbb\xad\x84s\x0c1'
 b'#~n\xbb\xe3\xf7I\x7f\x97\xdc\x8ci\x14\x83\xa0\xc3-Q6\x0fY\x9c\xa1\x00'
 b'\x03\x00#\x00\x00\x00\x05\x00)E{rx\xb3\xfc\x1f\xd8\x90M\xeb\x00\x9f\x95\x00'
 b'\x03\x00=\x00\x00\x00\x04\x00C\x00\x00\x003\x00\x00\x00K\xb7\xf4\r'
 b'\xc7\xc9\x8ft\x8137`\x98\xcb\x98\x8f\x15H\xbe\x05{e\xa6?lc\x08\x03'
 b'"\xb6\x00\xd72\x00\x02\x00\x00\x00U\x00\x02\x00]?\xd2)\\M\xcayD\x1ah')

{'A1': 2148655273,
 'A2': 1942270518,
 'A3': {'B1': {'C1': 72,
               'C2': -0.13035352528095245,
               'C3': -90,
               'C4': 0.0034651905526377202,
               'C5': 55090,
               'C6': [{'D1': [32663, -9076, 26900],
                       'D2': [33696, 49965, 20790, 3929, 40097]},
                      {'D1': [17787, 29304, -19460],
                       'D2': [8152, 36941, 60160, 40853]}],
               'C7': [13255234754989487233, 3690524629020479253]},
        'B2': 0.2837744483639606,
        'B3': 6760},
 'A4': 0.8511452651268177,
 'A5': 8290055042597043171,
 'A6': 63305}

Вариант №24

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

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

(b'\xecGMKT\x05\x00l\x00v\x00\x00\x00\x08\x00\x00\x00\x91\x00\x0f\xb4\xfdz\xa3'
 b'\x07\x00\x00\x00\x99\x00x.9\xa7\xf8\xc0\xef\xbf\x90\x94\x0e\\\xd0\xf5'
 b'\xcc?\xa0\x00{\x1c{\xe5\xf2\xad\xf5V\xec\xaa\xe8\xbf\xeb\xc4\x06\xf4'
 b'T\xaa\xbc\xcc\xa3*\xe3?\xc3\xa1\x93&\xa02\xc7\x05\xd6\xec\xc6?\xc7\x13T<'
 b'\x84\x08\xf4\xb0\xdf\xd1\xdb?\xc7;\xd7\x82\xd0\x10=P\x02\x11\xe4\xbf'
 b'0\x00<\x00H\x00T\x00`\x00\xce/\x8fBQ\x99\x01\xe7\x80\x15\xbe\x99\xb9X'
 b'\xbfK\xc7\r?\xacPX\xbfE \x9c\xbezbbjaeif\x07b\x8d\xca\xb5\xd3\x00'
 b'\xc9\xca\xf1\xcas\xc1|>')

{'A1': [{'B1': -444916613, 'B2': -0.7708646486693722},
        {'B1': -200882965, 'B2': 0.5989550589341186},
        {'B1': 647209411, 'B2': 0.1791026619161089},
        {'B1': 1012143047, 'B2': 0.4346846797999506},
        {'B1': -2099823673, 'B2': -0.6270762984427396}],
 'A2': {'C1': 12238,
        'C2': -113,
        'C3': 26825026,
        'C4': [-0.14599953591823578,
               -0.8465819954872131,
               0.5538222193717957,
               -0.8449809551239014,
               -0.30493369698524475]},
 'A3': 'zbbjaeif',
 'A4': 15,
 'A5': -1552220748,
 'A6': [7, 98, 141, 202, 181, 211, 0],
 'A7': [-0.9923060670930246, 0.22625164504021145],
 'A8': {'D1': 3404843721, 'D2': 0.24683170020580292}}

(b'\xecGMKT\x05\x00l\x00v\x00\x00\x00\x07\x00\x00\x00\x91\x00/O\xacIv'
 b'\x05\x00\x00\x00\x98\x00\x02W\t\x8d?\xd6\xe5\xbf\xf4(\xb4\xff\xe3\x0e'
 b'\xef\xbf\x9d\x00\xe1\xb1\x8c_X \x03\x8d\x1c\xdf\xed\xbfu\xbb\x1d$'
 b'\x00\xd5\xbaV\xc3\x16\x95?tmS\xb8\xcc \xdf\x81\x12\xff\xe0\xbft\x9eY\xb7'
 b'\xb8\xa1{e\xa9\x94\xd3\xbf`\xd7NP\xa0Z?\x0e\x92\xb4\xd5\xbf0\x00<\x00'
 b'H\x00T\x00`\x00\xbd\xd5N\xda\xe1\x12#\xad\xbf\x7f\xbf}\xc2\xba<m\xfdM'
 b'\xbf\xb6\x7f/\xbf\xa74B\xbcddhssgv\xa0=)J\xef?\xd2\xdc\x9c\xdc\xce\x03?')

{'A1': [{'B1': 1603056097, 'B2': -0.9334852937836429},
        {'B1': 605928309, 'B2': 0.020594646614616074},
        {'B1': -1202492044, 'B2': -0.5311367546610426},
        {'B1': -1218863500, 'B2': -0.30594859037821776},
        {'B1': 1347344224, 'B2': -0.3391461505065454}],
 'A2': {'C1': -10819,
        'C2': 78,
        'C3': 588440026,
        'C4': [-0.9990184903144836,
               0.02279781736433506,
               -0.804648220539093,
               -0.6855424642562866,
               -0.011853373609483242]},
 'A3': 'ddhssgv',
 'A4': 47,
 'A5': 1984539727,
 'A6': [160, 61, 41, 74, 239],
 'A7': [-0.6824033503168894, -0.9705677026952615],
 'A8': {'D1': 2631717439, 'D2': 0.5148751735687256}}

Вариант №25

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

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

(b'AKFG\xef\xbd^GA`\x00\x00\x00Br\x06k\x1b&\xe5\xbfaK\x912\xac&\xbf\x90Ai\x10'
 b'\x1c\xc5\xf5\xa3\x06\x00\x00\x00\x8d\x00\x00\x00\x02\x00\x93\x00\x00\x00<R'
 b'U<\xcab\x11Y\xcct\x94\xa3:m\x91P\xbf\\\xefHyH\xa8E\x9b\x122\x00\x00\x00'
 b'?\x00\x00\x00\x0e\xe0\x15Q\xac\xcf\x9a\xf0p\x13p\xeb\x15$\xa0\xc7'
 b'\x02\x00L\x00\x00\x00oU\xb26\xa7\xbd\x03\x00T\x00\xbf\xfdf|\x8d a\xb2aR\xbd`'
 b'\xd7\x19k\xb5\xbc\x98\x0c\t\xd1\xdcP\xb4lrtfbcp\x18}N\x92d8\x90\x1d')

{'A1': 1095196349,
 'A2': {'B1': -945806315,
        'B2': {'C1': [{'D1': 0.013020094484090805,
                       'D2': -6659569527957658934,
                       'D3': 58},
                      {'D1': -0.814719021320343,
                       'D2': -7258210195211751588,
                       'D3': 18}],
               'C2': 21871,
               'C3': {'E1': -0.08164729177951813,
                      'E2': [1360388110, 4036677548, 3949990768],
                      'E3': 12853590603541708223,
                      'E4': 13072570756204679777},
               'C4': -5453616358387574596},
        'B3': 108},
 'A3': {'F1': -0.6609017458282056, 'F2': 19297, 'F3': -111},
 'A4': -0.6510649919509888,
 'A5': 275333520,
 'A6': -1544174308,
 'A7': 'rtfbcp',
 'A8': [2454617368, 495990884]}

(b'AKFG\xef\xd0\xfcy\xd1\x82\x00\x00\x00\xd4\x92g\xb9\xdf\xbe\xef\xbf\x19QJ'
 b'\xae\xa3?\xbeC)\x9ca}\x13\xeb\xb8\x05\x00\x00\x00\xaf\x00\x00\x00'
 b"\x02\x00\xb4\x00\x00\x00\xf8\x9bl\xbe43$\x9bx\xa1f\x96#W\xe6\x01=\xf3#\\{'"
 b'\xe6\xc1\xbfDI\xc4>\xbe,^\xde\xbe\xc1wQ\x9d!b\x8eV\xbd*\xf2\x8f\x97\xe7\xa7@'
 b'G\xd72\x00\x00\x00?\x00\x00\x00L\x00\x00\x00Y\x00\x00\x00DDS\xe7\xb9\x0e'
 b'[\xb2\x05\xc0\xa5\xb7\x8c\x9a\xe36\x04\x00f\x00\x00\x00\xe8"\xac\xf9'
 b'\xcd\xbe\x03\x00v\x00\xf67\xa6\x9ab\xcc6G7\xe6\xcf\x8e\xb0\xed\xbc!\n='
 b'\x8c\x12\x9b\xd8\xa8\xb8.nenpfG\xb0\xe6\x05\xf8\xe1f\x9d')

{'A1': 3514432720,
 'A2': {'B1': 920885900,
        'B2': {'C1': [{'D1': -0.23106372356414795,
                       'D2': -7609216981024885964,
                       'D3': 35},
                      {'D1': 0.031713809818029404,
                       'D2': -4629165884712410125,
                       'D3': 68},
                      {'D1': -0.18629564344882965,
                       'D2': -7110770662626664916,
                       'D3': 33},
                      {'D1': -0.05238188058137894,
                       'D2': 5134288188324442666,
                       'D3': 215}],
               'C2': 8936,
               'C3': {'E1': -0.40229547023773193,
                      'E2': [3880993860, 2992311993, 3081093125],
                      'E3': 5131513549308704758,
                      'E4': 2431079241439241783},
               'C4': -5140620814100710134},
        'B3': 46},
 'A3': {'F1': -0.9920500394042286, 'F2': 20761, 'F3': 74},
 'A4': -0.1871478259563446,
 'A5': 1637624131,
 'A6': -1192553603,
 'A7': 'nenpf',
 'A8': [99004487, 2640765432]}

Вариант №26

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

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

(b'GHEC\xa2\x02\xe6\xea@`\xe6`Rgxilsyj\xf6\x03+\xda\x00\x8d\xbf$]S\xc3\x03'
 b'\xa6\xda\xde\x0fF\xf0\xbf<\t\xbfg"\xb5\xbfT\x7fpp\xf0\xb79NkE1\xc9\xdbZ'
 b'\xbf|C[>\xb7\xf8B\xe9\x8a\xc1\xd2\x1e1\xe3\x0e\tW$\xbfe\x18\xd4?'
 b'\x18\xa2\xa3\xea\xac\xcd\xb7\x18?\xc7\xcf\x8f\xb2\x83MX?\xeaG\x15'
 b'@\xec\xed\xee\xbf\xd1B\x97\x80\x1f\x1b\xfcP\xfdB\xf2\x91[\xd9\x9b'
 b'\xa5\r\xa2\xaa\xef\x1chq\xbd\x7f\xfbZ\xc0^\xfe\xfaD\x11{\t\x0bV\rE}|')

{'A1': 48687680,
 'A2': {'B1': 1625710674,
        'B2': 'gxilsyj',
        'B3': 4127402970,
        'B4': {'C1': 1259610465073186173, 'C2': 124},
        'B5': [{'D1': -0.6420490145683289,
                'D2': -15613,
                'D3': [-90, -38, -34, 15, 70, -16, -65, 60],
                'D4': 9,
                'D5': -0.9028733372688293},
               {'D1': -0.8300695419311523,
                'D2': 28912,
                'D3': [-73, 57, 78, 107, 69, 49, -55, -37],
                'D4': 90,
                'D5': -0.9854027628898621},
               {'D1': 0.3593159317970276,
                'D2': -5750,
                'D3': [-63, -46, 30, 49, -29, 14, 9, 87],
                'D4': 36,
                'D5': -0.8949100971221924}],
        'B6': {'E1': 0.5962316393852234, 'E2': -357773897},
        'B7': 24},
 'A3': {'F1': [0.18602176872682707, 0.8211771267010002, -0.2696894408404089],
        'F2': 80,
        'F3': [4249023121,
               1540987813,
               228764399,
               476606909,
               2147179200,
               1593768516]}}

(b"GHEC\xa2*\xe1\xf0\x18\xfa\xd12rzcwogwl\xba\x82\x98j\x00\x8d?'\xd1:^p"
 b'\x99\xd6\x99\xaaq\x19\x9d\xd6\xb6\xbfa F>6U\x17\xb0l3\x86\xcdh7\x87\xce3\xb2'
 b"?P\xe3\xa6>\x9b\x164\xd2Pk\xa2\xcd\xb2\xb2\x83CU'\xbf\x1e\x0c\xfa\xbe"
 b'\x19\x1e!d\x17"t\x1a\xbf\xa2\xf7\xb2F\xf1\xf3\x80?\xc4\xff\x86\x87?\xdd\x10'
 b'\xbf\xeb\x90\x93\x07xs2?sL\xbd(\xc8`_\x9b\xca7`\xdbDUP\xb6|*\x84\x9bC\xfd0'
 b'w\xde\x9c\xe4gr\xa7\x10\x85g')

{'A1': 719450136,
 'A2': {'B1': -86953358,
        'B2': 'zcwogwl',
        'B3': 3129120874,
        'B4': {'C1': 16040947105743179909, 'C2': 103},
        'B5': [{'D1': 0.6555362939834595,
                'D2': 24176,
                'D3': [-103, -42, -103, -86, 113, 25, -99, -42],
                'D4': -74,
                'D5': -0.8793987035751343},
               {'D1': 0.17805896699428558,
                'D2': -20372,
                'D3': [51, -122, -51, 104, 55, -121, -50, 51],
                'D4': -78,
                'D5': 0.8159736394882202},
               {'D1': 0.30290377140045166,
                'D2': -11696,
                'D3': [107, -94, -51, -78, -78, -125, 67, 85],
                'D4': 39,
                'D5': -0.6173855066299438}],
        'B6': {'E1': -0.14952899515628815, 'E2': 1679237748},
        'B7': 26},
 'A3': {'F1': [-0.03704602352170294, 0.16404801944711567, -0.8613982339771609],
        'F2': 63,
        'F3': [1934409000,
               3361759131,
               3392626907,
               1146441910,
               2083161243,
               1140666487]}}

Вариант №27

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

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

(b'VKD\x10\x10\xc7\xa0DP\x98fz\xf5\x9d\x13H(jC\xfb\x98\x8ck|H\xc1\x93\x02'
 b'\x08\x81\xc1\x1cGo\xc3DVCn]\xb4\xf3\xaf\x99\xcf \xeb\xf7U\xb2\xbe\xecu\xba{|'
 b'\xe5*^\xa6\x91V\x98\xa5\x80\xb6\xf4lj\xad\xa7s8\x08\xc8\x9dJ8\x92\x90mP1\x0b'
 b'Z)7v\x94\x99\xad\xcc\xc3S\xe0\x00\x00\x00\x02\x00o\x00\x00\x00\x02\x00q9'
 b'\x1a\xab\xf3qa\xda\x8c')

{'A1': 16,
 'A2': 14384572322766289653,
 'A3': 157,
 'A4': {'B1': 19,
        'B2': [{'C1': 72, 'C2': 40, 'C3': 7657240424069430344},
               {'C1': -63, 'C2': 147, 'C3': 146509654292656067},
               {'C1': 68, 'C2': 86, 'C3': 4858924079743211983},
               {'C1': 32, 'C2': 235, 'C3': -624396440240276869},
               {'C1': 124, 'C2': 229, 'C3': 3053060740557088128},
               {'C1': -74, 'C2': 244, 'C3': 7812247438331742408},
               {'C1': -99, 'C2': 74, 'C3': 4076479411894946650}]},
 'A5': 10551,
 'A6': 8544623364772418528,
 'A7': 'qa',
 'A8': {'D1': [-38, -116], 'D2': [14618, 44019]}}

(b'VKD\x10z\x03\xdf\x07J\x0f|!t\x89f\xffc1\xba\x11H\x8eT\xf6\xb3\x14\xa6\xa5'
 b'U\x0folO\x06\xb2\xf0\xbd\xe0o\xfcZ\x0e\xfeT[\x8d|\xe26"\x1b\xdb\xd1\xab"v'
 b'>\x8e[s\xa1+u\x1f\xc8@6\xe0\xbb\xef\xfb)\xe9*w]\xd5\xb4\xd8\x1d'
 b'\xf2\x05\x99\xb98\x1ai\x02P\x1dF\xd1\xdf\xacq\x00\x00\x00\x03\x00'
 b'o\x00\x00\x00\x02\x00r\xac\x19\xde\x1etbv\x8d\xb4')

{'A1': 122,
 'A2': 278949716589027700,
 'A3': 137,
 'A4': {'B1': 102,
        'B2': [{'C1': -1, 'C2': 99, 'C3': 3583195456849901235},
               {'C1': 20, 'C2': 166, 'C3': -6533298713198131534},
               {'C1': -16, 'C2': 189, 'C3': -2274321823070006181},
               {'C1': -115, 'C2': 124, 'C3': -2146490669348050142},
               {'C1': 118, 'C2': 62, 'C3': -8188824361387089976},
               {'C1': 64, 'C2': 54, 'C3': -2252943326549824905},
               {'C1': 93, 'C2': 213, 'C3': -5415545626599769800}]},
 'A5': 6761,
 'A6': 166665376218721393,
 'A7': 'tbv',
 'A8': {'D1': [-115, -76], 'D2': [44057, 56862]}}

Вариант №28

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

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

(b'RZV\x00a\x00\x07\x00\x00\x00\xaa\xda\xbaf\xf3\xa6V\x04-\x80J\xf5\xaf\xff'
 b')\xf9b\xfeB=\x1dK\xe3R\x11{Y\xefd\x81 \x89 \x00\x00\x00\x08\x00\x0bwJ\xa3'
 b'\x0b9]\xcfl\x92\x11\x83\xa017\xaf\xd7\x04bVp=\xc0\xa3Qm\xd8\x89\x1a`\xdc9'
 b'\xf3\x00\x00\x00\x07\x005\x1a\x7f\xcb\x9f\x17U\xa3\xa4\xe0&?\xe1\xda'
 b'\xb1Q=\xcc6*\xa7\xe3:\x97n[\xbf\xdc\r3\x0b\xc8J<`\xfdJ9\xc2\xad\xd48'
 b'\xe3\xd8\x92!\xdb\xe4\xe3\xea\xb5\x9a:\x0c\x0f\xb4u\x00\x00\x00+\x00'
 b'\x00\x00Q\xee3\xe9\xad\xcf>&\xf3mA^X\xeew\x81\x00\x03\x00[4\xfa'
 b'\xea\xbb\xe3\xc9\xa0')

{'A1': {'B1': {'C1': 0.5579458796258965,
               'C2': 10919,
               'C3': 227,
               'C4': 983002715,
               'C5': {'D1': -0.4383056273519832,
                      'D2': 1627212345,
                      'D3': -4418642318574710239,
                      'D4': -37},
               'C6': -6941,
               'C7': 16912593549760902261,
               'C8': [{'E1': [-625318157,
                              -1504312275,
                              -2142571089,
                              -14026398,
                              -29213411,
                              1273188881,
                              2069491556,
                              -2128574176],
                       'E2': 2001380107},
                      {'E1': [962449260,
                              -1844345952,
                              825733079,
                              73553520,
                              1036034897,
                              1842907418,
                              1625045491],
                       'E2': 444582815}]},
        'B2': [-4557, -5715, -12482, 9971, 27969, 24152, -4489],
        'B3': 129,
        'B4': [5973, -23644, -8154]},
 'A2': [52, 250, 234, 187, 227, 201, 160]}

(b'RZV\x00A\x00\x03\x00\x00\x00\x8a\x9a\xf2\xd7\x1e\x00)\xa44\xee\xc2\x10L\xcb'
 b'\x11\xb0&\x00\x00\x00\x04\x00\x0b\xc3\n\x14\xfft{\x9c\xd2$\xb3\xa6'
 b'\xa6\xef"\xfc\x11\x00\x00\x00\x03\x00%\x08*2\xdf\xf9\xc1\x13m{g?\xe0\x9d'
 b'\x1b\xbc#<\xa6\x0e\x97\xafb\x11\xf45?\xe2\x07\x08\xd2w\xfc\x98\xd7Vp\x1d'
 b'\x8a\x91\xd1t\xbf\x1fCTL\xc0\x80a\xc0\r\xee\x14\x919p\x00\x00\x00\x1b\x00'
 b'\x00\x0010co-3\xb4\x04\xc3\xf5#\x1f\xee\xbct\xb5\x00\x03\x00;\r\xca\x1d')

{'A1': {'B1': {'C1': 0.5191782640994418,
               'C2': 3735,
               'C3': 175,
               'C4': 1645343797,
               'C5': {'D1': 0.5633586989132651,
                      'D2': 3612766237,
                      'D3': -8461751925499542700,
                      'D4': 76},
               'C6': -16256,
               'C7': 7043645133405895024,
               'C8': [{'E1': [-1695361250, 2729012, -289271732, -888033242],
                       'E2': -1022749441},
                      {'E1': [1954258130, 615753382, -282919919],
                       'E2': 136983263}]},
        'B2': [12387, 28461, 13236, 1219, -2781, 8174, -17292],
        'B3': 181,
        'B4': [-1599, 4973, 31591]},
 'A2': [13, 202, 29]}

Вариант №29

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

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

(b'TTOHN\xb9[\x8d\x85B\x0f<\x98M/\x02\xc9\xb8\xe9\xb2\xf5\xd9\xdd\x1c'
 b'\r\xf1\x83\xbf*\x00\x00\x00@6\x80\xec\x04\x00;\x00\x00\x00\xf8\x84'
 b'\x80\n\xec\x0bw7\x9b\x84\x12\xd4$jHt\x00vzd\x9b\xdaP\xbf0\x8a\xd9\xd7qS'
 b'\x08\x85?\x03\x00\x00\x00/\x00\x00\x00th\xaaQ\x7f\xd3\xad\xb9d\x03\xb3\xa6I'
 b'\x1e\x1aX\x02\x00\x00\x002\x00\x00\x00qmVsoZ\xcag\xee\x06\xf4\r\x91'
 b'\xbdkl\x05\x00\x00\x004\x00\x00\x00ku\xf7\xf5\xba\xae\x1e\xb3S\xa6\x05~;'
 b'+<Y\x02\x00\x00\x009\x00\x00\x00')

{'A1': {'B1': 78,
        'B2': -7477084502958974023,
        'B3': 3372363597,
        'B4': -172824136,
        'B5': -39,
        'B6': 4044168413,
        'B7': 131,
        'B8': -65},
 'A2': {'C1': -8, 'C2': 32900, 'C3': 60426},
 'A3': 3967825472,
 'A4': [{'D1': 'vz',
         'D2': -25756,
         'D3': [817844442, 1909971338, 1065683027],
         'D4': [11, 119, 55]},
        {'D1': 'th',
         'D2': 20906,
         'D3': [-1179790465, -1498217628, 1478106697],
         'D4': [155, 132]},
        {'D1': 'qm',
         'D2': 29526,
         'D3': [1741314671, 234096366, 1819000209],
         'D4': [18, 212, 36, 106, 72]},
        {'D1': 'ku',
         'D2': -2569,
         'D3': [-1289834822, 2114299475, 1497115451],
         'D4': [116, 0]}]}

(b"TTOH\xb0k\x94\n\xae'\x1b\xe4\x99\xb3\x16]|\xd0z\x90\x89\xd4\xe9\xfc"
 b'\x98\xe4RE*\x00\x00\x00\xfd\xad\x02*\x02\x00:\x00\x00\x00YC\xf4\x91eu'
 b'\xb5\x01G\xde\xe0\x8b;\xd8Q\x1dyuH\xd6MDt\x94\xd6\x88\xfe(\xf7?'
 b"\xaa\xc5\x08\x00\x00\x00/\x00\x00\x00kn\x1d\xb5\xf1\xf3\xdc\x90?\xd9>'\xf42"
 b'\x04=\x03\x00\x00\x007\x00\x00\x00')

{'A1': {'B1': -80,
        'B2': -7357726033978944405,
        'B3': 2086475443,
        'B4': -1987020080,
        'B5': -44,
        'B6': 3835231465,
        'B7': 82,
        'B8': 69},
 'A2': {'C1': 89, 'C2': 62531, 'C3': 26001},
 'A3': 704818685,
 'A4': [{'D1': 'yu',
         'D2': -10680,
         'D3': [-1804319667, 687769814, -978698249],
         'D4': [117, 181, 1, 71, 222, 224, 139, 59]},
        {'D1': 'kn',
         'D2': -19171,
         'D3': [-1864567823, 658430271, 1023685364],
         'D4': [216, 81, 29]}]}

Вариант №30

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

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

(b'7LGXP3\xa1\x00\x00\x00\x02\x00\x00\x00-\x00\x02\x00?\x7fX\xb9\xd6\xa8'
 b'\x11\xa2\xfaRO}\xc0u\xb3\x02C?I\xd8W\xbf\xfa\x00\x00\x00k\xea\\\xe8'
 b'\x89\x81\xd4\x93\x1a\xd2\xd3\x1b\xeb\xcfW\xa2\xfd\xf3sxo\xfd\t\x08'
 b"\x18\xd2?\x0b\xdbM\x10\xec\x9dw\x81n\xcfm\x0e\xdb\xdc\xfa\x8a'"
 b'\x97\xe8\x11\xa4\xb6B\x82\ty\xf6\nE\xbf\xe86qQ7\x1c\x00\x04\x00\x00\x00'
 b'A?\xbb\xbd\xda\x1ecQP\x00I')

{'A1': 13217,
 'A2': [{'B1': -1559115693690678502, 'B2': 210},
        {'B1': -3234732631574512141, 'B2': 115}],
 'A3': 'xo',
 'A4': 2136521174,
 'A5': -6336104004727112256,
 'A6': 8481125011116644439,
 'A7': -16390,
 'A8': {'C1': [64777, 2072, 53823, 3035],
        'C2': 0.1083656620206217,
        'C3': {'D1': 19728,
               'D2': [-4963, 30593, 28367, 27918, -9252, -1398, 10135],
               'D3': -6127,
               'D4': 2763408002,
               'D5': 682847342503651382,
               'D6': 29009,
               'D7': 14108}}}

(b'7LGXP\xbb\r\x00\x00\x00\x02\x00\x00\x00-\x00\x02\x00?\xbe\xaa|\xe4\xdc'
 b'\x86\x827\x86U\xf8\x00\xef,\xc7k\xd1+\xc4\x8d\x8a8\x00\x00\x00m\x0fbA'
 b'5\xf9\xd6\xa6b\x0cY`\xa4\x89`\xa0\x84\xf7\xd7gn]Zm\xf9S\xbe%\xcd&\xfe('
 b"H!q\x97\xae\x06\x0f\xa1\x81JM\x17\x14\xb2ti\xf5_\xae('\x01\x1eh\xb5m\xa8\xf7"
 b'{\xd6a[w\x00\x05\x00\x00\x00A?\xef\xfe\xf7\xe7\xa0Sx\x00K')

{'A1': -17651,
 'A2': [{'B1': 1108520158367229538, 'B2': 12},
        {'B1': 6440328377078416631, 'B2': 215}],
 'A3': 'gn',
 'A4': 3198844132,
 'A5': -2556212563497584640,
 'A6': -1212374933784771443,
 'A7': -30152,
 'A8': {'C1': [23898, 28153, 21438, 9677, 9982],
        'C2': 0.9998740695906312,
        'C3': {'D1': 10312,
               'D2': [8561, -26706, 1551, -24191, 19021, 5908, -19852],
               'D3': 27125,
               'D4': 1605249063,
               'D5': 80616971777406843,
               'D6': -10655,
               'D7': 23415}}}

Вариант №31

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

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

(b'BVPB\x00\x00\x00\xe7\xe8*\xd1c\x0f`\xed\xc3oI1vgJ\x19\xee\x93\xbe\x8f\xff'
 b'\x87\xaak\xba\xf4\xdb\x1f}\x06\xb15\xee\xfe\x04\xe1?\x83\xb3\x03\x00'
 b'\x00\x00\x1a\x00\x00\x00\x1d\x00\x00\x00\x9b,\x93\x02}p\xc8\x86\x05\x00'
 b'\x00\x00\x0b\x00\x00\x00$\x00\x00\x00\xd8a~q\x1e\x81\xd7?Ts\xa7\x8c#\xa2'
 b'EQ\xff\xc8\xf7#7\xbd9]H<qN\xc1\xbb\x1f\x86\x8b\x83\xcfa\x80\xbb'
 b'\xa0\xdc\xd2\xb7$\x0b')

{'A1': {'B1': [{'C1': 99, 'C2': 24591},
               {'C1': 237, 'C2': 28611},
               {'C1': 73, 'C2': 30257},
               {'C1': 103, 'C2': 6474},
               {'C1': 238, 'C2': 48787}],
        'B2': {'D1': 0.5318598415883862,
               'D2': -19581,
               'D3': [-113, -1, -121],
               'D4': {'E1': 27562, 'E2': [-70, -12, -37, 31], 'E3': 125},
               'D5': -8734607795068654437},
        'B3': 0.36725579341284975,
        'B4': [-1935183020,
               1363517987,
               603441407,
               1564065079,
               1316043848,
               -2044740671],
        'B5': 1640989579,
        'B6': 802968749851327360},
 'A2': -785717017}

(b'BVPG\x00\x00\x00u\xcb\xbc\xe6\xce\xd6\xee5/%\xd2\xdc\x01\xa5;Mk\x89\xbcC\xe2'
 b'v\x0e.\x1b\x13W\x1f\x14:}7\xb0\x16\x8eV[\xd3t\xc6\xe0?\x17\xbd\x05'
 b'\x00\x00\x00\x1d\x00\x00\x00"\x00\x00\x00~\x94.\xff\xb1\x86\xc3D\x06'
 b'\x00\x00\x00\x0b\x00\x00\x00)\x00\x00\x002@\x9b\x9b\x02p\xec\xbf2'
 b"\x8e\xf0\x195S\x13!\x11\xcbf\x81\x99!\xab75\xe6\x80\x00'2\xdd\xd8>\xd3iVQ"
 b'c\xe3\xf1%\x05\xc2\x83')

{'A1': {'B1': [{'C1': 206, 'C2': 61142},
               {'C1': 53, 'C2': 9519},
               {'C1': 210, 'C2': 476},
               {'C1': 165, 'C2': 19771},
               {'C1': 107, 'C2': 48265},
               {'C1': 67, 'C2': 30434}],
        'B2': {'D1': 0.5242256286680502,
               'D2': -17129,
               'D3': [14, 46, 27, 19, 87],
               'D4': {'E1': 5151, 'E2': [58, 125, 55, -80], 'E3': 22},
               'D5': 4954952114086253694},
        'B3': -0.8886731185139125,
        'B4': [435195442,
               554914613,
               -2123969775,
               933962137,
               8447541,
               -656592345],
        'B5': 1449775934,
        'B6': 9494156624980566865},
 'A2': -423834763}

Вариант №32

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

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

(b'OORx?\xb6A\x84\x85\x9d\x02\x002\x00\x1d\xa7nW\x04\x004\x00\xe2\x9a'
 b'9\xb6\x02\x008\x00\xac\x82\xfa \x02\x00:\x00P\x00\x00\x00Zx_l\xc9\x996czl'
 b'qnsubeon\x9a\xbbd?&\x1e\x16?\x1c\xb6\x92>\x93\xf7"\xbf\xd7uu\xbf$Qs\xbf'
 b'\xde\x0fN\xb3\x03\x00\x00\x00<\x00\x17\xd3\x9e*i\xbf\x02\x00\x00\x00'
 b'H\x00\x00\x00\xd5\xcd\x8e\xa5.sF\xa5\x95\x8b')

{'A1': 63,
 'A2': -74,
 'A3': [{'B1': 2642773057, 'B2': 'zl'},
        {'B1': 1466869533, 'B2': 'qnsu'},
        {'B1': 3057228514, 'B2': 'be'},
        {'B1': 553288364, 'B2': 'on'}],
 'A4': {'C1': {'D1': -0.9504568576812744,
               'D2': -1286729762,
               'D3': [0.8934875726699829,
                      0.5863975286483765,
                      0.28654563426971436],
               'D4': -11497,
               'D5': -0.9108065366744995,
               'D6': [-0.6365901827812195, -0.9588293433189392]},
        'C2': -6537411164898406955,
        'C3': 35733},
 'A5': 30810,
 'A6': 2580114527,
 'A7': [54, 99]}

(b'OORx\xd5r\xabu}\x8c\x04\x002\x00\x07\x81\x81\xe5\x03\x006\x00\xc9\x9e'
 b'~\xd9\x02\x009\x00\xad\xf2\xfe\xf7\x04\x00;\x00S\x00\x00\x00\xf6-\n\x9a\xabt'
 b'\xeb\xa7sfgnvcnaultwn\xa8\xeb_\xbf\xcfX\xe1<vO^>$\xdc\xd0\xbe<kl\xbf\x06'
 b'\x14\xd2>D\xf7Yv\x03\x00\x00\x00?\x00\xcdU\xcd\x86\xf2\xbe\x02\x00\x00\x00K'
 b'\x00\x00\x00\xc1\xff\xc5\xb7\x1a\x95\x07\x86\xc3\xa0')

{'A1': 213,
 'A2': 114,
 'A3': [{'B1': 2357032363, 'B2': 'sfgn'},
        {'B1': 3850469639, 'B2': 'vcn'},
        {'B1': 3648954057, 'B2': 'au'},
        {'B1': 4160680621, 'B2': 'ltwn'}],
 'A4': {'C1': {'D1': 0.4103090167045593,
               'D2': 1985607492,
               'D3': [-0.8746895790100098,
                      0.027508167549967766,
                      0.21709999442100525],
               'D4': 21965,
               'D5': -0.473684698343277,
               'D6': [-0.40792953968048096, -0.923511266708374]},
        'C2': -8788892205805338687,
        'C3': 41155},
 'A5': 11766,
 'A6': 1957403146,
 'A7': [235, 167]}

Вариант №33

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

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

(b'NTR\x1e7\xde\xb4juM\xdd)\x88\x02pH\xe8\xa5b\x1c3}W\xbd\x01\x06\xc5^'
 b'\xf1\x9a1\x00\x00\x00j\xf7\xa6\x02\x00Q\x00q\x00\x00\x00&\xd0\xba'
 b'\xa3\xea\xb7r\xf7\xef\x80I\xb8+K\\\x19\x89\x03\x15\x86;<<\xb4=\x02\x98'
 b'\x01\xf6=\xbf\x0b\xedJc\x1f\xa8\xb6\x87\xe3\xa4\xf0\xb4xD:*/\xd7\x1f\xd2'
 b'\x8f@\x9b}\x80\x13\xa7\xaci\xb7\xf8|\xf8\xcb\xe7c\xc5C\xd5\x16?\xdb@\xa9'
 b'\xe8y\x11+b\xb3\xab\xf7X')

{'A1': 14110,
 'A2': -34,
 'A3': -76,
 'A4': 'ju',
 'A5': {'B1': 77,
        'B2': -6491859216938554915,
        'B3': 2100501602,
        'B4': {'C1': 11164809151530515799,
               'C2': {'D1': 13279286744415647722,
                      'D2': 425478955,
                      'D3': 12987321651779928969,
                      'D4': 846463381766931005,
                      'D5': 526600941}},
        'B5': 106,
        'B6': 42743,
        'B7': [{'E1': 8697841371341895336,
                'E2': [68, 58, 42, 47, -41, 31, -46, -113]},
               {'E1': 7614644772178598720,
                'E2': [-73, -8, 124, -8, -53, -25, 99, -59]}]},
 'A6': {'F1': 0.5891916155815125,
        'F2': [-37, 64, -87, -24],
        'F3': 6410781381519675769},
 'A7': 2746929190}

(b'NTRm\x95\xefMhg\xed4d\xbfiwb\xbbgC\xde\xb6~r\xedw^\xe9z\xc2o1\x00'
 b'\x00\x00\xc8\x8a\xdd\x02\x00Q\x00q\x00\x00\x00\xf0\xd7,h\xe2>\xd48\xccs8'
 b'\xa0<}\x89\xf3Z\x06\xf2+w\xeb\x17\xca\x0fn(0\xf4\xf2[\x87e\x01JS)Yt'
 b'f&\xb1\x9a\x96\x1e\x99\xb6\xccj\xe6\xe4\xb7\xd3\xa52\xe3\xbe@K\x8f3f\xfb'
 b'\r\xcf\xe9@\xa2I8\xad\xbe*g\xa4\x0c_\xcd\x1e.8\x82\x9dZ')

{'A1': -27283,
 'A2': -17,
 'A3': 77,
 'A4': 'hg',
 'A5': {'B1': -19,
        'B2': 7474676271566251060,
        'B3': 2125913667,
        'B4': {'C1': 8053134226422754674,
               'C2': {'D1': 11545104965728222946,
                      'D2': -209093316,
                      'D3': 14562366817196705370,
                      'D4': 9753656548594839055,
                      'D5': 1397358949}},
        'B5': 200,
        'B6': 56714,
        'B7': [{'E1': -7594563043121145559,
                'E2': [30, -103, -74, -52, 106, -26, -28, -73]},
               {'E1': -8121326314432846381,
                'E2': [51, 102, -5, 13, -49, -23, 64, -94]}]},
 'A6': {'F1': -0.3383200466632843,
        'F2': [42, 103, -92, 12],
        'F3': 6529518212560637279},
 'A7': 1747769328}

Вариант №34

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

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

(b"PFM\xac?\xef\xc7\xe1\xbb\x1c]\x88Z'\xc4\x13\xc3\x86\x1b\xcc\xa7\xd7EZ"
 b'\x0bi\xfc4\x188\xbb\x0b\x0e\xe4\x95]\x9b\x96FN\xfc>&\x17\x15\xfa\xbc\xa3'
 b'\xf1\x1d\x0f\xee\xc6\xb8b\x00\x00\x00x\xbe+\xce\x07\x110\x1b\xdej'
 b'\xfc\xa9\xdc\xc4\x00\x02\x00\x00\x00\x81?\xe5\xea\x05\xd1\xd4\xb8\xa4:\x8f'
 b'|\xa19\x90u[\xf8\xdf[\xad\x90\xc5\xc6\xae\xd8F\xde\xa1j\\\x89]I\x13'
 b'\xda\x11g2mo\xdflukstL\xceb2t0\xc2^P')

{'A1': 0.9931496290691237,
 'A2': [{'B1': 90, 'B2': 667161539, 'B3': 9663542446696782347, 'B4': 105},
        {'B1': 252, 'B2': 874002619, 'B3': 796825514262894150, 'B4': 78},
        {'B1': 252, 'B2': 1042683669, 'B3': 18067496061073616582, 'B4': 184}],
 'A3': 98,
 'A4': {'C1': 'ukst', 'C2': 1288593970, 'C3': 116},
 'A5': {'D1': -1104425465,
        'D2': 17,
        'D3': 3466608889278618820,
        'D4': [12482, 24144],
        'D5': 0.684817228151378,
        'D6': [982482081, 965768539, 4175387565, 2428880558, 3628523169]},
 'A6': {'E1': 27228, 'E2': 2304592147, 'E3': -2733290032555106452}}

(b'PFM\xac\xbf\xe5d\xf5Xm\x86\xc4\xd9`Q\xe8iY\x05@MXI\xb8\xba\\u\xca'
 b'\xa1P\xd1\x0e\xa8\x1f\xff\x88\xd9\xc1\n\x808\xa9\xa9{\xbc:t\xe0\xea:\xf5\x1f'
 b"=\n\x86\x00\x00\x00x\xee\xb8I\xeb\x07\xf46\n'\x8ad\xda\x8d\x00\x04\x00\x00"
 b'\x00\x81?\xd0\xdc\xe3+\xe2@\x10\x84R_\x9e\x9a\xc8\xc0\xfc\xc1\x96\x9c/\xd2/'
 b'\x82\x1fKd=l\x18\xf2\xd1j\xdc\xae$\x11\xa8\xd7,h{\x0cjixs\xba\xa8n<'
 b'\xe7\x16I\x80[O\xba\x1c?')

{'A1': -0.6685740210634425,
 'A2': [{'B1': 217, 'B2': 1615980649, 'B3': 6414603945197025466, 'B4': 92},
        {'B1': 117, 'B2': 3399569617, 'B3': 1056129294991474954, 'B4': 128},
        {'B1': 56, 'B2': 2846456764, 'B3': 4212238848114368317, 'B4': 10}],
 'A3': -122,
 'A4': {'C1': 'jixs', 'C2': 3131600444, 'C3': 231},
 'A5': {'D1': -289912341,
        'D2': 7,
        'D3': -849480314770892147,
        'D4': [5705, 32859, 20410, 7231],
        'D5': 0.26348189626242036,
        'D6': [2219990942, 2596847868, 3247873071, 3526328863, 1264860524]},
 'A6': {'E1': 6386, 'E2': 3513441454, 'E3': 2599044102085966604}}

Вариант №35

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

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

(b'\x00PGGF\xff%\x1c-h\xd8\x8a\xb5\x8b\x99\x00\x00\x000\x00\x00\x00=\x00'
 b'\x00\x00J\x00\x00\x00W\x00k\x80\xfa:\xb0\x90\x05\xfe\n\x00w\x0e`\xbeE+'
 b'\xedd\xaa_\x00\x00\x00+j\xb6S\x9b@\xad$\xe7\xef\x00\x00\x008*\x9d\x19'
 b'!\xf1\xde]\x8a\x15\x00\x00\x00E\xccS\xbf\xe3F\x04n\x91\xe2\x00\x00\x00R?'
 b'i\x94.b\xb0\xca\xa5\x0c\xd2\\\xe8:/+\xf2\x8a\x00\x00\x03\x00\x00\x00_('
 b'\xeat4\x1b\xfa\xbeY|\xa6"\xd2\x9e\xc8\x93i\xe4\x9f\xd9\xcb\x890[Gy'
 b'\x81w\xfe\xb5\x9f\x9a\xba?\xd9\xc9l\x1b\x0f\x98\x8c')

{'A1': -219,
 'A2': [28, 45, 104, -40, -118, -75, -117, -103],
 'A3': [{'B1': -312169889, 'B2': {'C1': 14, 'C2': 1623082283}},
        {'B1': -1390090257, 'B2': {'C1': 106, 'C2': 3058932544}},
        {'B1': -564295147, 'B2': {'C1': 42, 'C2': 2635670001}},
        {'B1': 74355170, 'B2': {'C1': -52, 'C2': 1405084486}}],
 'A4': {'D1': 976169970,
        'D2': 35328,
        'D3': [1063883822, 1655753381, 215112936]},
 'A5': -9152938762672144886,
 'A6': {'E1': [2948296673223949913,
               8981904794839454569,
               -1972618643561751737,
               8755411086437489338],
        'E2': 0.40291884081524}}

(b'\x00PGGFl\x9cl\xb4\x05\x94\xeft+B\x00\x00\x000\x00\x00\x00=\x00\x00\x00J\x00'
 b'\x00\x00W\x00oG\x7f$a\x1f\x7feN\x00{lJ\xad\xee\xbf\x1d\xd1\xf7"\x00\x00\x00+'
 b'\xbb\xb7EL`Y\xf0\xea\xc9\x00\x00\x008w\x0c\x81_\x80\x1f\xb6$\x0e\x00\x00'
 b'\x00E\xf2\x1au\xeaB\xbd(\xd4\xdf\x00\x00\x00R\xbeI,\xd3\xaeL\x87\xdc\x82'
 b'\xd4\x1b\xd7,L\xc2\xd2&\x930\x1ey\xab\x00\x04\x00\x00\x00_\x85{\x190\xa6'
 b'x\x8b\xa8A\xb2\x83\x8b\xf2\n\xe1Q\xf7R\x19\x0c\x86s\x16\xacHS[\xd3\xca'
 b'.\x16\xcc\xbf\xeb\xdc\xc6\xf0:7\x86')

{'A1': 27804,
 'A2': [108, -76, 5, -108, -17, 116, 43, 66],
 'A3': [{'B1': 500299554, 'B2': {'C1': 108, 'C2': 1252912831}},
        {'B1': 1508960969, 'B2': {'C1': -69, 'C2': 3074772064}},
        {'B1': 532030478, 'B2': {'C1': 119, 'C2': 209805184}},
        {'B1': -1121397537, 'B2': {'C1': -14, 'C2': 443935298}}],
 'A4': {'D1': 647180318,
        'D2': 31147,
        'D3': [3192466643, 2924251100, 2194938839, 743228114]},
 'A5': 5151876498294007118,
 'A6': {'E1': [-8828434947787682904,
               4733990795404304721,
               -625409856665086292,
               5211610158986041036],
        'E2': -0.8707003299657436}}

Вариант №36

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

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

(b'HYA\x00\x00\x00V\x00\x00\x00a\x00\x00\x00l\xbf\xe7\\\xf9\xf4\xfcI\xae\xfc'
 b'\x19\\S\xa9l\x08\xeb\xe3zC\xf4\x8aR\r\xdb\x8d1\xce\xa3mI\xe6}r\r\xbd\xd7\xa4'
 b'nF\xd3\x96\xf4\x00\x03\x00\x00\x00w\x84\x062\xedG\xdd\xa3ME\xb990\xc2'
 b'\n\xbb\xb1\x8e(U\xf55b\x0f?:\xd9\x93ywrzbyj>\x923vxnptnhn?i!\xe8sqqenso\x8a'
 b'\xcaBq\x02\x01Y7\xb2$9XgG\xd7\xa9n\x13\x82\xcf#\xd0?\xf2')

{'A1': [{'B1': 0.7298824191093445, 'B2': 'ywrzbyj'},
        {'B1': 0.2855488657951355, 'B2': 'xnptnhn'},
        {'B1': 0.9106736183166504, 'B2': 'sqqenso'}],
 'A2': -0.7300996575234444,
 'A3': {'C1': 64537,
        'C2': [1548986732,
               149676922,
               1140099666,
               232492337,
               3466816841,
               3866980877],
        'C3': 48599,
        'C4': [164, 110, 70, 211, 150],
        'C5': 244,
        'C6': [-8445865098047563465, -5610296183944128599, 7931827194900266994],
        'C7': -124},
 'A4': 1586,
 'A5': -4793,
 'A6': 15970693665441525954,
 'A7': {'D1': 2747, 'D2': -5652536132652146161}}

(b'HYA\x00\x00\x00V\x00\x00\x00a\x00\x00\x00l\xbf\xd83\x0c?\xfeU|\x10'
 b'\x1b\x8c\x05LN\xb94\xdd\xe1\x1c2\x12Ig\xc9\xf6U\x9d\xfaW\x91\xc3,\x93'
 b'\xd9g\xf8&E\xc9R\xfc5\x00\x02\x00\x00\x00w=\x03\x05C\x87\xf72<\x06w\x14w\x11'
 b'\xa0\xf6\xa2\x9c\x11cVrQ)?qy!xtzfqhh?0\x96\xbdbwylkwi\xbe"\x87\x94celkrqu#'
 b'\xa7\xe7\x81ho\xc2\xe3\xca\xe1\x89\xcb\xc6ZK3')

{'A1': [{'B1': 0.9432545304298401, 'B2': 'xtzfqhh'},
        {'B1': 0.6898000836372375, 'B2': 'bwylkwi'},
        {'B1': -0.15872031450271606, 'B2': 'celkrqu'}],
 'A2': -0.37811571359028284,
 'A3': {'C1': 4123,
        'C2': [2349157454,
               3107249633,
               473043529,
               1741289045,
               2650429329,
               3274478553],
        'C3': 26616,
        'C4': [38, 69, 201, 82, 252],
        'C5': 53,
        'C6': [2569276655427109603, -3827626699989038285],
        'C7': 61},
 'A4': 773,
 'A5': 17287,
 'A6': 17812365474669033233,
 'A7': {'D1': -24330, 'D2': -6729484624848596695}}

Вариант №37

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

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

(b'TDV\xaa\xbfwDy\xce$J\x1d\xaf\xd4N\xee)\xbc\x92JZ\x00\x02\x00\x00\x00hgnjsz'
 b'sin\x12\xf4%\x9bFP/\xe0|\x91.\x92\xdc\xd3 \xcc\x1c&\xb0\xe32=\x84\xeeV'
 b'\xe8\xf7\xf3\xedM\xca4\x1514\xfc\x12\xe4#p\xda<\n\xce\xf6\xf8\xcaW\r'
 b'RT\xe9\x81\x0e\xa5\x8f\xbbr\x80\x1a>\xa1\xc3H\xdc\xbe\xd5z\x9a\x00^\x00c')

{'A1': 3212264569,
 'A2': -50,
 'A3': {'B1': 608837039,
        'B2': -733024727,
        'B3': 3163703898,
        'B4': [{'C1': 26, 'C2': 0.31594300270080566},
               {'C1': -36, 'C2': -0.4169510006904602}]},
 'A4': 'gnjszsin',
 'A5': {'D1': 317990299,
        'D2': [70, 80, 47],
        'D3': [16175963590826447648,
               14707673024253017476,
               17174170380670946762,
               3752959968120333347,
               8131878094290483402,
               6272760380645248677],
        'D4': 2411426432}}

(b'TDV\xaa\xb9K\xad\x91J^\xe0\xbe\xa8!j:\x16j}-\xe8\x00\x02\x00\x00\x00hmhrkm'
 b"vfqM\x960\xe0\xd1\xe42\xfa'\xff\xb7\x7f\x9fi\xb0\x0b\x99\x0f\x8e\xde\xe4"
 b'\xa0\xfb\x9e\x96\xc98$.\xbcB?\xa8jf3\x82\x07\x13\x18\xf7\xe9"\xe7\n\xbcn9V'
 b'T\xdc\x90\xf1\x85b&\x81\x853\xd6\xbfy\xac\x87r?$\xb9\xa4\x00^\x00c')

{'A1': 3108744593,
 'A2': 74,
 'A3': {'B1': 1591787176,
        'B2': 560609814,
        'B3': 1786588648,
        'B4': [{'C1': -42, 'C2': -0.9752888083457947},
               {'C1': 114, 'C2': 0.6434576511383057}]},
 'A4': 'mhrkmvfq',
 'A5': {'D1': 1301688544,
        'D2': [-47, -28, 50],
        'D3': [18025657197158951344,
               835716312153235707,
               11427542347461606466,
               4587033207660218131,
               1799162912272202862,
               4131583014460294498],
        'D4': 646022451}}

Вариант №38

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

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

(b'\xcaSRUN$\x00\x00\x00\x02\x00\x00\x00s\x00=\x97+?\x03\x00\x91\x00\xb4'
 b'\x9e\xc5\x16s]\xa9E\x18dzav\xc9\xa1t\xa44y\xdfb\x83\xc4\xb3L\xbfP\xd1\x87'
 b':8\xc5\xc1?*\x07\x04\x00\x00\x00 \x00\x10n\x98\x98j\xb9\xb9?/@\xe3'
 b'\xc7>\xac\x03\xd1>\xbc\xf0\xc9\x1c\x9aa\xd5\xbf\xf4)\xab~\xbe\xb0'
 b'\xec?\xad\x1b^\r?SED?: \x97\x9d\xfc\x7f\xe2\xbfA\x00h\xd5\x1a'
 b'\xa9\x88\x19\xc9\xbf\xf8\\\xdc4\xbfZ\x004\x94o\x8bj\xe1\xdf?\xe1\xae`\xb0'
 b'\xbc\x0f\xaf\xf8\xe4\x07r\xd7\x0f5\x882Z')

{'A1': {'B1': 201,
        'B2': 9467375078353433761,
        'B3': -0.7996180057525635,
        'B4': 0.13883116586624533,
        'B5': 1834,
        'B6': 'dzav'},
 'A2': [{'C1': {'D1': 0.10048547959780074,
                'D2': 47,
                'D3': [0.39040565490722656, 0.40823113918304443],
                'D4': -0.3340821534291185},
         'C2': -0.19609173066207153,
         'C3': 248,
         'C4': -0.7064874172210693},
        {'C1': {'D1': 0.8965752099987285,
                'D2': 173,
                'D3': [0.5522171854972839, 0.7666828036308289],
                'D4': -0.5781233861862412},
         'C2': 0.4981333123853944,
         'C3': 225,
         'C4': -0.021530475467443466}],
 'A3': {'E1': 0.6702764630317688,
        'E2': [3841502991, 265777671, 1513261109],
        'E3': -76,
        'E4': 1748990249131230622}}

(b'\xcaSRUN#\x00\x00\x00\x02\x00\x00\x00r\x00\x9f\x01\x90\xbe\x02\x00\x90\x00+'
 b'\x9c#\xddjP\xceJ\x04huq\x08\x8e\xb3\x0f\xb8\x8d$\xda\xb2\xba\xda\xf1>'
 b'\xa0\xa5\xa5YG?\xdd?{\xf4\x03\x00\x00\x00 \x00t(/\x96\xca\xfa\xec\xbfb{r\xf3'
 b'<\xcb\xe2\t\xbf\xbc\xe6\x93\xcd\x9b\x8c\xd1?\x92\xc5\xc9\x8a\xf6s\xe6'
 b'?\x00\x7f\xb7\x94=\x0f\n\xb0\xbe\x88\x82\x01/\xcb\x1e\xc1?@\x00\x80Gu\x84'
 b'\x14<\xbf?\xf1\xbcM\xc5>Y\x00\x98\xdf\xb6&\x9c\x8d\xc4?\xb7e\xd0\x9b\xbc'
 b'\xa22D\xcf\xe0:>,')

{'A1': {'B1': 8,
        'B2': 12887653474771121038,
        'B3': 0.4723718762397766,
        'B4': 0.4569872260531955,
        'B5': 62587,
        'B6': 'huq'},
 'A2': [{'C1': {'D1': -0.9056141789708492,
                'D2': 98,
                'D3': [0.02971767447888851, -0.5386168360710144],
                'D4': 0.27420706821395036},
         'C2': 0.12201050027695537,
         'C3': 241,
         'C4': 0.38535869121551514},
        {'C1': {'D1': 0.7016556463915313,
                'D2': 0,
                'D3': [0.0726156160235405, -0.3438267409801483],
                'D4': 0.13375224871835578},
         'C2': 0.16057159319256864,
         'C3': 183,
         'C4': -0.019020268693566322}],
 'A3': {'E1': -0.2812623679637909,
        'E2': [3477353122, 742275808],
        'E3': 43,
        'E4': 309286369213883292}}

Вариант №39

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

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

(b'\xe4EIO\x89n\xe4l\x00\x03\x00I>*E3\xbc\xa0Q\x97\xbf|k\x15?#!.\xbe9\x96\xfb'
 b'(\xe1("\xa3\x15\x1d\xc9\x9d\x0c\xe8\x8e\xea\xe2q\xdd:<\xbf\xadw\xe1\x90\n'
 b"n\xc0\x87\x00\xa9\x81\x84\xb7\x01m<'\x96wS\xef\x99~)\x00\x00\x00\x08\x00"
 b'\x00\x00:\x0e\x7f\x99D\x8eU\xcc\t\x19\x85\\\x97\xfa\x91\xf0?\x1b'
 b'\xb0\x9d\x80\x00\x00\x00\x02\x00\x00\x00B\x8d\xe9\xde\x06;\x90dR\xd4'
 b'd\xc9\xfc\xe9\xbf\x92a\xdd\xc5(#\x00\x00\x00\x05\x00\x00\x00Dm\xd4\x1c\x85y'
 b'!\xaa-\x9f\x14\xd1YPy97\xdc5')

{'A1': {'B1': -1989221268,
        'B2': [{'C1': 32297,
                'C2': [-121, 0, -87, -127, -124, -73, 1, 109],
                'C3': 3711,
                'C4': 153,
                'C5': {'D1': 68,
                       'D2': [36437, 52233, 6533, 23703, 64145],
                       'D3': 4030667696}},
               {'C1': -25216,
                'C2': [60, 39],
                'C3': 36329,
                'C4': 222,
                'C5': {'D1': 6,
                       'D2': [15248, 25682, 54372, 51708, 59839],
                       'D3': 2455887301}},
               {'C1': 10275,
                'C2': [-106, 119, 83, -17, -103],
                'C3': 28116,
                'C4': 28,
                'C5': {'D1': -123,
                       'D2': [31009, 43565, 40724, 53593, 20601],
                       'D3': 959962165}}],
        'B3': 0.166279599070549,
        'B4': [-0.019570155069231987,
               -0.9860089421272278,
               0.6372250318527222,
               -0.1812400072813034],
        'B5': 2945679760507084233,
        'B6': -7130068409510628899},
 'A2': 14908,
 'A3': -0.05755524524030653}

(b'\xe4EIOY\xc2\x18\xcb\x00\x02\x00G\xbd\x8cE]\xbfH\xd9N\xbfR\xcc\xa4'
 b'\xbe\xc2\xd1\x0e>\xa8\x05\xd0\xe1\xdb#\xfa{\xe3\xf5b\x86\xb4\x9b$\xa7[H\xec'
 b'?\x85\xbf\xe3G\x8b\xa7\xe1\x18\xbe5es\x86_\x84\x1b\xf0h3\x0bz+\r'
 b',\x00\x00\x00\x06\x00\x00\x00:\xbf\xfb\xa2\x98\xf7u/\xd8\t6/V\xc7ze'
 b'\xce\xc8\xb6\xa0\xb2\x00\x00\x00\x07\x00\x00\x00@g\r.\x01\xa4\xa6qU0\xeap'
 b'F<\x06N\xc8\xc5\x98')

{'A1': {'B1': 1505892555,
        'B2': [{'C1': 3372,
                'C2': [53, 101, 115, -122, 95, -124],
                'C3': 49147,
                'C4': 162,
                'C5': {'D1': -104,
                       'D2': [63349, 12248, 2358, 12118, 51066],
                       'D3': 1708050614}},
               {'C1': -24398,
                'C2': [27, -16, 104, 51, 11, 122, 43],
                'C3': 26381,
                'C4': 46,
                'C5': {'D1': 1,
                       'D2': [42150, 29013, 12522, 28742, 15366],
                       'D3': 1321780632}}],
        'B3': -0.06849167495965958,
        'B4': [-0.784565806388855,
               -0.8234350681304932,
               -0.3805012106895447,
               0.3281693458557129],
        'B5': 16274641237160752482,
        'B6': -8740190395090384660},
 'A2': 16261,
 'A3': -0.6024835852520238}

Вариант №40

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

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

(b"ZANTQ\x0fd\x0fc!8\xac\xda?\x02\x00A\x00\x00\x00l'~C@H\x15\xfe\xbc3\xe2\x08"
 b'\xfa\x05\x00\x00\x00e\x00\x00\x00\x00\x07\x00\x00\x00j\x00\xb6\x91\xf6\x95'
 b'\xf1m\xe6{\x8b6\xeaW\x1d\xbc\x12Q\x000l;\x89x\x17\xbb?u4\xf2d\xb7\xbe\xb7'
 b'?>\xc0\x849\xfa\x9du\x81\xeb?`\xcd\xba\x03\xf5\xbe\xbbV\x85\xf3\x94~\x05'
 b'3,\x97\xab<?O%\xd0>\xaf7\x01\xbf|\xaeF?\xb7\xd3\xd5>z\xcd \xbf\xd2@\x03\xbf')

{'A1': {'B1': 15,
        'B2': 0.41676142940945327,
        'B3': [{'C1': 0.10582688665765327,
                'C2': 13429,
                'C3': -0.3581920266151428,
                'C4': [183, 63, 62, 192]},
               {'C1': 0.8595531545159223,
                'C2': 52576,
                'C3': -0.47854405641555786,
                'C4': [187, 86, 133, 243]}],
        'B4': 108,
        'B5': {'D1': -4828398350434599385, 'D2': 57907},
        'B6': -1528,
        'B7': [148, 126, 5, 51, 44]},
 'A2': 0,
 'A3': [0.7369932532310486,
        0.4065346419811249,
        -0.5047559142112732,
        0.7760999202728271,
        0.4176308810710907,
        -0.6281353235244751,
        -0.5127078294754028],
 'A4': -74,
 'A5': 10050880353286354577,
 'A6': 22820072269015606}

(b'ZANTQ\xf3\xa8\xc8U\x1c\xa5\x8b\xc6?\x02\x00A\x00\x00\x00\xa2\t\x88\x19'
 b'\xaf\x86\x92>\xa3\x12@\xddD\x03\x00\x00\x00e\x00\x00\x00\x1f\x05\x00'
 b'\x00\x00h\x00\xc6c\xcf\xa0\xfftNl\xf53S\x1a\x08\xbb\x95\x90(\xf0r\x07'
 b'z\x00\x03\xb6?\x11\x84\x83\xa8/?\xbd*\x11\xb5\xa8\xd4>\xbfq\x81\xe2?\x18'
 b'h/\x08\x01\xbfN\x1e\xa8\xf1F\xbc\xc0\x92\xf9\xfe>\xb7\xa1U\xbc\xc6\x98\x0e?'
 b'Q\xfc>\xbf\x93G\xfa\xbc')

{'A1': {'B1': 243,
        'B2': 0.17613662608670677,
        'B3': [{'C1': 0.08598330477930083,
                'C2': 33809,
                'C3': 0.6861650347709656,
                'C4': [189, 42, 17, 181]},
               {'C1': 0.5783013091337539,
                'C2': 26648,
                'C3': -0.5040311217308044,
                'C4': [78, 30, 168, 241]}],
        'B4': 162,
        'B5': {'D1': -6683743689810278391, 'D2': 16402},
        'B6': 17629,
        'B7': [70, 188, 192]},
 'A2': 31,
 'A3': [0.49799782037734985,
        -0.013039044104516506,
        0.5570186376571655,
        -0.7460375428199768,
        -0.03055170737206936],
 'A4': -58,
 'A5': 17684596101188996963,
 'A6': 2923000788690817843}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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