selfcheck_test/data_init.mem - master - lizz_kuzz/cpu

selfcheck_test/data_init.mem
256 строк30 KB
lizz_kuzz
fix
12 май 2026, 10:52
12 май 2026, 10:52b2cd367
0000 // FLAGS (DATA[00]) — результат последнего `cmp` (используется переходами jl/je/jg)
0000 // TEST00 DST: ячейка, где хранится вычисленный результат операции `sub #02, #03` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[01] сравнивается с EXPECTED в `cmp #01, #04`
1ACF // TEST00 ARG1: первый аргумент для `sub #02, #03`, результат операции сначала пишется в DATA[02] (или копируется в DST через MOV)
890C // TEST00 ARG2/SHIFT: второй аргумент/сдвиг для `sub #02, #03`, читается первой инструкцией блока PC=00..05
91C3 // TEST00 EXPECTED: предвычисленный на Python результат операции `sub #02, #03`. Команда `cmp #01, #04` сравнивает DATA[01] с DATA[04]
0000 // TEST01 DST: ячейка, где хранится вычисленный результат операции `sub #06, #07` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[05] сравнивается с EXPECTED в `cmp #05, #08`
D081 // TEST01 ARG1: первый аргумент для `sub #06, #07`, результат операции сначала пишется в DATA[06] (или копируется в DST через MOV)
8879 // TEST01 ARG2/SHIFT: второй аргумент/сдвиг для `sub #06, #07`, читается первой инструкцией блока PC=06..0B
4808 // TEST01 EXPECTED: предвычисленный на Python результат операции `sub #06, #07`. Команда `cmp #05, #08` сравнивает DATA[05] с DATA[08]
0000 // TEST02 DST: ячейка, где хранится вычисленный результат операции `sr #0A, #0B` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[09] сравнивается с EXPECTED в `cmp #09, #0C`
1388 // TEST02 ARG1: первый аргумент для `sr #0A, #0B`, результат операции сначала пишется в DATA[0A] (или копируется в DST через MOV)
C21C // TEST02 ARG2/SHIFT: второй аргумент/сдвиг для `sr #0A, #0B`, читается первой инструкцией блока PC=0C..11
0001 // TEST02 EXPECTED: предвычисленный на Python результат операции `sr #0A, #0B`. Команда `cmp #09, #0C` сравнивает DATA[09] с DATA[0C]
0000 // TEST03 DST: ячейка, где хранится вычисленный результат операции `add #0E, #0F` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[0D] сравнивается с EXPECTED в `cmp #0D, #10`
AA15 // TEST03 ARG1: первый аргумент для `add #0E, #0F`, результат операции сначала пишется в DATA[0E] (или копируется в DST через MOV)
AE7D // TEST03 ARG2/SHIFT: второй аргумент/сдвиг для `add #0E, #0F`, читается первой инструкцией блока PC=12..17
5892 // TEST03 EXPECTED: предвычисленный на Python результат операции `add #0E, #0F`. Команда `cmp #0D, #10` сравнивает DATA[0D] с DATA[10]
0000 // TEST04 DST: ячейка, где хранится вычисленный результат операции `nand #12, #13` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[11] сравнивается с EXPECTED в `cmp #11, #14`
51BF // TEST04 ARG1: первый аргумент для `nand #12, #13`, результат операции сначала пишется в DATA[12] (или копируется в DST через MOV)
4526 // TEST04 ARG2/SHIFT: второй аргумент/сдвиг для `nand #12, #13`, читается первой инструкцией блока PC=18..1D
BED9 // TEST04 EXPECTED: предвычисленный на Python результат операции `nand #12, #13`. Команда `cmp #11, #14` сравнивает DATA[11] с DATA[14]
0000 // TEST05 DST: ячейка, где хранится вычисленный результат операции `and #16, #17` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[15] сравнивается с EXPECTED в `cmp #15, #18`
AAE7 // TEST05 ARG1: первый аргумент для `and #16, #17`, результат операции сначала пишется в DATA[16] (или копируется в DST через MOV)
7D86 // TEST05 ARG2/SHIFT: второй аргумент/сдвиг для `and #16, #17`, читается первой инструкцией блока PC=1E..23
2886 // TEST05 EXPECTED: предвычисленный на Python результат операции `and #16, #17`. Команда `cmp #15, #18` сравнивает DATA[15] с DATA[18]
0000 // TEST06 DST: ячейка, где хранится вычисленный результат операции `sub #1A, #1B` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[19] сравнивается с EXPECTED в `cmp #19, #1C`
00DA // TEST06 ARG1: первый аргумент для `sub #1A, #1B`, результат операции сначала пишется в DATA[1A] (или копируется в DST через MOV)
DF5F // TEST06 ARG2/SHIFT: второй аргумент/сдвиг для `sub #1A, #1B`, читается первой инструкцией блока PC=24..29
217B // TEST06 EXPECTED: предвычисленный на Python результат операции `sub #1A, #1B`. Команда `cmp #19, #1C` сравнивает DATA[19] с DATA[1C]
0000 // TEST07 DST: ячейка, где хранится вычисленный результат операции `add #1E, #1F` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[1D] сравнивается с EXPECTED в `cmp #1D, #20`
C154 // TEST07 ARG1: первый аргумент для `add #1E, #1F`, результат операции сначала пишется в DATA[1E] (или копируется в DST через MOV)
23C6 // TEST07 ARG2/SHIFT: второй аргумент/сдвиг для `add #1E, #1F`, читается первой инструкцией блока PC=2A..2F
E51A // TEST07 EXPECTED: предвычисленный на Python результат операции `add #1E, #1F`. Команда `cmp #1D, #20` сравнивает DATA[1D] с DATA[20]
0000 // TEST08 DST: ячейка, где хранится вычисленный результат операции `sub #22, #23` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[21] сравнивается с EXPECTED в `cmp #21, #24`
A183 // TEST08 ARG1: первый аргумент для `sub #22, #23`, результат операции сначала пишется в DATA[22] (или копируется в DST через MOV)
E58A // TEST08 ARG2/SHIFT: второй аргумент/сдвиг для `sub #22, #23`, читается первой инструкцией блока PC=30..35
BBF9 // TEST08 EXPECTED: предвычисленный на Python результат операции `sub #22, #23`. Команда `cmp #21, #24` сравнивает DATA[21] с DATA[24]
0000 // TEST09 DST: ячейка, где хранится вычисленный результат операции `mov #26, #27` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[25] сравнивается с EXPECTED в `cmp #25, #28`
1678 // TEST09 ARG1: первый аргумент для `mov #26, #27`, результат операции сначала пишется в DATA[26] (или копируется в DST через MOV)
2F7E // TEST09 ARG2/SHIFT: второй аргумент/сдвиг для `mov #26, #27`, читается первой инструкцией блока PC=36..3B
2F7E // TEST09 EXPECTED: предвычисленный на Python результат операции `mov #26, #27`. Команда `cmp #25, #28` сравнивает DATA[25] с DATA[28]
0000 // TEST10 DST: ячейка, где хранится вычисленный результат операции `add #2A, #2B` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[29] сравнивается с EXPECTED в `cmp #29, #2C`
48CB // TEST10 ARG1: первый аргумент для `add #2A, #2B`, результат операции сначала пишется в DATA[2A] (или копируется в DST через MOV)
40A3 // TEST10 ARG2/SHIFT: второй аргумент/сдвиг для `add #2A, #2B`, читается первой инструкцией блока PC=3C..41
896E // TEST10 EXPECTED: предвычисленный на Python результат операции `add #2A, #2B`. Команда `cmp #29, #2C` сравнивает DATA[29] с DATA[2C]
0000 // TEST11 DST: ячейка, где хранится вычисленный результат операции `sl #2E, #2F` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[2D] сравнивается с EXPECTED в `cmp #2D, #30`
9567 // TEST11 ARG1: первый аргумент для `sl #2E, #2F`, результат операции сначала пишется в DATA[2E] (или копируется в DST через MOV)
DC7C // TEST11 ARG2/SHIFT: второй аргумент/сдвиг для `sl #2E, #2F`, читается первой инструкцией блока PC=42..47
7000 // TEST11 EXPECTED: предвычисленный на Python результат операции `sl #2E, #2F`. Команда `cmp #2D, #30` сравнивает DATA[2D] с DATA[30]
0000 // TEST12 DST: ячейка, где хранится вычисленный результат операции `xor #32, #33` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[31] сравнивается с EXPECTED в `cmp #31, #34`
F42F // TEST12 ARG1: первый аргумент для `xor #32, #33`, результат операции сначала пишется в DATA[32] (или копируется в DST через MOV)
87D8 // TEST12 ARG2/SHIFT: второй аргумент/сдвиг для `xor #32, #33`, читается первой инструкцией блока PC=48..4D
73F7 // TEST12 EXPECTED: предвычисленный на Python результат операции `xor #32, #33`. Команда `cmp #31, #34` сравнивает DATA[31] с DATA[34]
0000 // TEST13 DST: ячейка, где хранится вычисленный результат операции `nand #36, #37` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[35] сравнивается с EXPECTED в `cmp #35, #38`
12D0 // TEST13 ARG1: первый аргумент для `nand #36, #37`, результат операции сначала пишется в DATA[36] (или копируется в DST через MOV)
9C35 // TEST13 ARG2/SHIFT: второй аргумент/сдвиг для `nand #36, #37`, читается первой инструкцией блока PC=4E..53
EFEF // TEST13 EXPECTED: предвычисленный на Python результат операции `nand #36, #37`. Команда `cmp #35, #38` сравнивает DATA[35] с DATA[38]
0000 // TEST14 DST: ячейка, где хранится вычисленный результат операции `sl #3A, #3B` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[39] сравнивается с EXPECTED в `cmp #39, #3C`
F746 // TEST14 ARG1: первый аргумент для `sl #3A, #3B`, результат операции сначала пишется в DATA[3A] (или копируется в DST через MOV)
69E9 // TEST14 ARG2/SHIFT: второй аргумент/сдвиг для `sl #3A, #3B`, читается первой инструкцией блока PC=54..59
8C00 // TEST14 EXPECTED: предвычисленный на Python результат операции `sl #3A, #3B`. Команда `cmp #39, #3C` сравнивает DATA[39] с DATA[3C]
0000 // TEST15 DST: ячейка, где хранится вычисленный результат операции `nor #3E, #3F` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[3D] сравнивается с EXPECTED в `cmp #3D, #40`
A16A // TEST15 ARG1: первый аргумент для `nor #3E, #3F`, результат операции сначала пишется в DATA[3E] (или копируется в DST через MOV)
066C // TEST15 ARG2/SHIFT: второй аргумент/сдвиг для `nor #3E, #3F`, читается первой инструкцией блока PC=5A..5F
5891 // TEST15 EXPECTED: предвычисленный на Python результат операции `nor #3E, #3F`. Команда `cmp #3D, #40` сравнивает DATA[3D] с DATA[40]
0000 // TEST16 DST: ячейка, где хранится вычисленный результат операции `sr #42, #43` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[41] сравнивается с EXPECTED в `cmp #41, #44`
DE67 // TEST16 ARG1: первый аргумент для `sr #42, #43`, результат операции сначала пишется в DATA[42] (или копируется в DST через MOV)
F8E6 // TEST16 ARG2/SHIFT: второй аргумент/сдвиг для `sr #42, #43`, читается первой инструкцией блока PC=60..65
0379 // TEST16 EXPECTED: предвычисленный на Python результат операции `sr #42, #43`. Команда `cmp #41, #44` сравнивает DATA[41] с DATA[44]
0000 // TEST17 DST: ячейка, где хранится вычисленный результат операции `sr #46, #47` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[45] сравнивается с EXPECTED в `cmp #45, #48`
D6C8 // TEST17 ARG1: первый аргумент для `sr #46, #47`, результат операции сначала пишется в DATA[46] (или копируется в DST через MOV)
BFC1 // TEST17 ARG2/SHIFT: второй аргумент/сдвиг для `sr #46, #47`, читается первой инструкцией блока PC=66..6B
6B64 // TEST17 EXPECTED: предвычисленный на Python результат операции `sr #46, #47`. Команда `cmp #45, #48` сравнивает DATA[45] с DATA[48]
0000 // TEST18 DST: ячейка, где хранится вычисленный результат операции `sub #4A, #4B` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[49] сравнивается с EXPECTED в `cmp #49, #4C`
104D // TEST18 ARG1: первый аргумент для `sub #4A, #4B`, результат операции сначала пишется в DATA[4A] (или копируется в DST через MOV)
5CE8 // TEST18 ARG2/SHIFT: второй аргумент/сдвиг для `sub #4A, #4B`, читается первой инструкцией блока PC=6C..71
B365 // TEST18 EXPECTED: предвычисленный на Python результат операции `sub #4A, #4B`. Команда `cmp #49, #4C` сравнивает DATA[49] с DATA[4C]
0000 // TEST19 DST: ячейка, где хранится вычисленный результат операции `and #4E, #4F` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[4D] сравнивается с EXPECTED в `cmp #4D, #50`
F94B // TEST19 ARG1: первый аргумент для `and #4E, #4F`, результат операции сначала пишется в DATA[4E] (или копируется в DST через MOV)
8616 // TEST19 ARG2/SHIFT: второй аргумент/сдвиг для `and #4E, #4F`, читается первой инструкцией блока PC=72..77
8002 // TEST19 EXPECTED: предвычисленный на Python результат операции `and #4E, #4F`. Команда `cmp #4D, #50` сравнивает DATA[4D] с DATA[50]
0000 // TEST20 DST: ячейка, где хранится вычисленный результат операции `sr #52, #53` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[51] сравнивается с EXPECTED в `cmp #51, #54`
AB78 // TEST20 ARG1: первый аргумент для `sr #52, #53`, результат операции сначала пишется в DATA[52] (или копируется в DST через MOV)
AC80 // TEST20 ARG2/SHIFT: второй аргумент/сдвиг для `sr #52, #53`, читается первой инструкцией блока PC=78..7D
AB78 // TEST20 EXPECTED: предвычисленный на Python результат операции `sr #52, #53`. Команда `cmp #51, #54` сравнивает DATA[51] с DATA[54]
0000 // TEST21 DST: ячейка, где хранится вычисленный результат операции `xor #56, #57` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[55] сравнивается с EXPECTED в `cmp #55, #58`
C84A // TEST21 ARG1: первый аргумент для `xor #56, #57`, результат операции сначала пишется в DATA[56] (или копируется в DST через MOV)
2586 // TEST21 ARG2/SHIFT: второй аргумент/сдвиг для `xor #56, #57`, читается первой инструкцией блока PC=7E..83
EDCC // TEST21 EXPECTED: предвычисленный на Python результат операции `xor #56, #57`. Команда `cmp #55, #58` сравнивает DATA[55] с DATA[58]
0000 // TEST22 DST: ячейка, где хранится вычисленный результат операции `add #5A, #5B` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[59] сравнивается с EXPECTED в `cmp #59, #5C`
C67A // TEST22 ARG1: первый аргумент для `add #5A, #5B`, результат операции сначала пишется в DATA[5A] (или копируется в DST через MOV)
AC16 // TEST22 ARG2/SHIFT: второй аргумент/сдвиг для `add #5A, #5B`, читается первой инструкцией блока PC=84..89
7290 // TEST22 EXPECTED: предвычисленный на Python результат операции `add #5A, #5B`. Команда `cmp #59, #5C` сравнивает DATA[59] с DATA[5C]
0000 // TEST23 DST: ячейка, где хранится вычисленный результат операции `mov #5E, #5F` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[5D] сравнивается с EXPECTED в `cmp #5D, #60`
60CC // TEST23 ARG1: первый аргумент для `mov #5E, #5F`, результат операции сначала пишется в DATA[5E] (или копируется в DST через MOV)
2D22 // TEST23 ARG2/SHIFT: второй аргумент/сдвиг для `mov #5E, #5F`, читается первой инструкцией блока PC=8A..8F
2D22 // TEST23 EXPECTED: предвычисленный на Python результат операции `mov #5E, #5F`. Команда `cmp #5D, #60` сравнивает DATA[5D] с DATA[60]
0000 // TEST24 DST: ячейка, где хранится вычисленный результат операции `nand #62, #63` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[61] сравнивается с EXPECTED в `cmp #61, #64`
BA1E // TEST24 ARG1: первый аргумент для `nand #62, #63`, результат операции сначала пишется в DATA[62] (или копируется в DST через MOV)
0691 // TEST24 ARG2/SHIFT: второй аргумент/сдвиг для `nand #62, #63`, читается первой инструкцией блока PC=90..95
FDEF // TEST24 EXPECTED: предвычисленный на Python результат операции `nand #62, #63`. Команда `cmp #61, #64` сравнивает DATA[61] с DATA[64]
0000 // TEST25 DST: ячейка, где хранится вычисленный результат операции `sr #66, #67` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[65] сравнивается с EXPECTED в `cmp #65, #68`
7550 // TEST25 ARG1: первый аргумент для `sr #66, #67`, результат операции сначала пишется в DATA[66] (или копируется в DST через MOV)
CFBA // TEST25 ARG2/SHIFT: второй аргумент/сдвиг для `sr #66, #67`, читается первой инструкцией блока PC=96..9B
001D // TEST25 EXPECTED: предвычисленный на Python результат операции `sr #66, #67`. Команда `cmp #65, #68` сравнивает DATA[65] с DATA[68]
0000 // TEST26 DST: ячейка, где хранится вычисленный результат операции `xor #6A, #6B` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[69] сравнивается с EXPECTED в `cmp #69, #6C`
1E94 // TEST26 ARG1: первый аргумент для `xor #6A, #6B`, результат операции сначала пишется в DATA[6A] (или копируется в DST через MOV)
934D // TEST26 ARG2/SHIFT: второй аргумент/сдвиг для `xor #6A, #6B`, читается первой инструкцией блока PC=9C..A1
8DD9 // TEST26 EXPECTED: предвычисленный на Python результат операции `xor #6A, #6B`. Команда `cmp #69, #6C` сравнивает DATA[69] с DATA[6C]
0000 // TEST27 DST: ячейка, где хранится вычисленный результат операции `and #6E, #6F` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[6D] сравнивается с EXPECTED в `cmp #6D, #70`
777C // TEST27 ARG1: первый аргумент для `and #6E, #6F`, результат операции сначала пишется в DATA[6E] (или копируется в DST через MOV)
F7B6 // TEST27 ARG2/SHIFT: второй аргумент/сдвиг для `and #6E, #6F`, читается первой инструкцией блока PC=A2..A7
7734 // TEST27 EXPECTED: предвычисленный на Python результат операции `and #6E, #6F`. Команда `cmp #6D, #70` сравнивает DATA[6D] с DATA[70]
0000 // TEST28 DST: ячейка, где хранится вычисленный результат операции `nor #72, #73` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[71] сравнивается с EXPECTED в `cmp #71, #74`
4EB9 // TEST28 ARG1: первый аргумент для `nor #72, #73`, результат операции сначала пишется в DATA[72] (или копируется в DST через MOV)
E395 // TEST28 ARG2/SHIFT: второй аргумент/сдвиг для `nor #72, #73`, читается первой инструкцией блока PC=A8..AD
1042 // TEST28 EXPECTED: предвычисленный на Python результат операции `nor #72, #73`. Команда `cmp #71, #74` сравнивает DATA[71] с DATA[74]
0000 // TEST29 DST: ячейка, где хранится вычисленный результат операции `add #76, #77` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[75] сравнивается с EXPECTED в `cmp #75, #78`
EC2E // TEST29 ARG1: первый аргумент для `add #76, #77`, результат операции сначала пишется в DATA[76] (или копируется в DST через MOV)
1698 // TEST29 ARG2/SHIFT: второй аргумент/сдвиг для `add #76, #77`, читается первой инструкцией блока PC=AE..B3
02C6 // TEST29 EXPECTED: предвычисленный на Python результат операции `add #76, #77`. Команда `cmp #75, #78` сравнивает DATA[75] с DATA[78]
0000 // TEST30 DST: ячейка, где хранится вычисленный результат операции `or #7A, #7B` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[79] сравнивается с EXPECTED в `cmp #79, #7C`
44FB // TEST30 ARG1: первый аргумент для `or #7A, #7B`, результат операции сначала пишется в DATA[7A] (или копируется в DST через MOV)
E9A5 // TEST30 ARG2/SHIFT: второй аргумент/сдвиг для `or #7A, #7B`, читается первой инструкцией блока PC=B4..B9
EDFF // TEST30 EXPECTED: предвычисленный на Python результат операции `or #7A, #7B`. Команда `cmp #79, #7C` сравнивает DATA[79] с DATA[7C]
0000 // TEST31 DST: ячейка, где хранится вычисленный результат операции `nand #7E, #7F` (в неё пишется либо сама операция, либо промежуточный результат через MOV). Именно значение DATA[7D] сравнивается с EXPECTED в `cmp #7D, #80`
0AC1 // TEST31 ARG1: первый аргумент для `nand #7E, #7F`, результат операции сначала пишется в DATA[7E] (или копируется в DST через MOV)
8341 // TEST31 ARG2/SHIFT: второй аргумент/сдвиг для `nand #7E, #7F`, читается первой инструкцией блока PC=BA..BF
FDBE // TEST31 EXPECTED: предвычисленный на Python результат операции `nand #7E, #7F`. Команда `cmp #7D, #80` сравнивает DATA[7D] с DATA[80]
DEAD // SLOT_FAIL (DATA[81]) — содержит константу FAIL_CODE=0xDEAD, которую обработчик FAIL пишет в STATUS (DATA[FF])
ACE1 // SLOT_PASS (DATA[82]) — содержит константу PASS_CODE=0xACE1, которую обработчик PASS пишет в STATUS (DATA[FF])
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000 // STATUS (DATA[FF]) — код статуса selftest: PASS=0xACE1, FAIL=0xDEAD