; File Name   : HORROR.OVL.bin
; Format      : Binary file

; Processor:        К1801ВМ1
; Target assembler: Turbo8 Cross Assembler

; оптимизированный вариант оверлея игры HORROR SHOW

; ═══════════════════════════════════════════════════════════════════════════

; ячейки в игре
WideCharMode    = 44    ; байт, флаг вывода символов удвоенной ширины
HighCharMode    = 45    ; байт, флаг вывода символов увеличенной высоты
                        ; масштаб задаётся в другой ячейке.
CharVertScale   = 200   ; слово, масштаб увеличения символов по высоте.

Temp1           = 126   ; временная ячейка, в которой может быть что угодно
Temp2           = 176   ; временная ячейка в меню, адрес начала таблицы адресов звёзд
CurPressKey     = 146   ; код текущей нажатой клавиши
PrevPressKey    = 150   ; код предыдущей нажатой клавиши
TempCurManScrAdr = 142  ; адрес экрана ГГ перед попыткой движения
MenuItemsCount  = 144   ; счётчик пунктов меню

; ячейки в редакторе
LabArrayBase    = 130   ; адрес хранения начала массива лабиринтов
CurCellScrAddr  = 132   ; адрес экрана текущей ячейки в редакторе лабиринтов
CurEditLab      = 136   ; адрес текущего редактируемого лабиринта
CurLabCell      = 176   ; адрес клетки в распакованном буфере лабиринта

; Переменные монитора БК-0010
AS              =   160 ; Адрес символа
MASCW           =   214 ; Маска цвета

; ───────────────────────────────────────────────────────────────────────────
                jmp     EntryPoint$         ; делаем файл автономным
                                            ; можно без загрузчика
; ───────────────────────────────────────────────────────────────────────────
SprManStayLt:   .word 4, 30                 ; человечек стоит влево
                .byte 0, 25, 121, 1
                .byte 100, 120, 4, 4
                .byte 100, 1, 1, 21
                .byte 20, 0, 0, 21
                .byte 20, 24, 0, 104
                .byte 100, 361, 17, 100
                .byte 0, 300, 377, 100
                .byte 0, 300, 377, 100
                .byte 0, 374, 377, 20
                .byte 0, 374, 77, 20
                .byte 0, 60, 17, 4
                .byte 0, 300, 3, 1
                .byte 0, 360, 77, 4
                .byte 0, 360, 77, 4
                .byte 0, 60, 374, 20
                .byte 0, 300, 363, 20
                .byte 0, 360, 274, 4
                .byte 0, 274, 52, 1
                .byte 0, 300, 77, 0
                .byte 0, 300, 17, 0
                .byte 0, 300, 17, 0
                .byte 0, 100, 5, 0
                .byte 0, 240, 12, 0
                .byte 0, 250, 12, 0
SprManStayLtEnd:
SprManSize = SprManStayLtEnd-SprManStayLt

SprManStepLt:   .word 4, 30                 ; человечек идёт влево
                .byte 0, 25, 25, 1
                .byte 100, 120, 21, 4
                .byte 0, 0, 101, 20
                .byte 20, 20, 0, 21
                .byte 20, 4, 0, 101
                .byte 100, 361, 17, 100
                .byte 0, 60, 377, 100
                .byte 0, 60, 377, 100
                .byte 0, 374, 377, 20
                .byte 0, 374, 77, 20
                .byte 0, 60, 17, 4
                .byte 0, 0, 17, 4
                .byte 0, 300, 377, 4
                .byte 0, 60, 374, 20
                .byte 0, 317, 363, 20
                .byte 0, 374, 74, 4
                .byte 0, 0, 77, 1
                .byte 0, 250, 152, 0
                .byte 0, 314, 77, 0
                .byte 0, 74, 77, 0
                .byte 0, 60, 63, 0
                .byte 0, 124, 224, 0
                .byte 0, 50, 250, 0
                .byte 200, 52, 52, 0
SprManStepLt2:  .word 4, 30                 ; человечек идёт влево 2
                .byte 100, 25, 25, 0
                .byte 20, 120, 104, 0
                .byte 104, 1, 21, 1
                .byte 4, 4, 20, 1
                .byte 4, 3, 100, 4
                .byte 20, 374, 103, 4
                .byte 100, 314, 77, 4
                .byte 0, 314, 77, 4
                .byte 0, 377, 77, 1
                .byte 0, 377, 17, 1
                .byte 0, 314, 103, 0
                .byte 0, 360, 103, 0
                .byte 360, 374, 77, 1
                .byte 74, 377, 377, 0
                .byte 74, 377, 377, 3
                .byte 0, 200, 17, 17
                .byte 0, 250, 12, 14
                .byte 0, 377, 3, 0
                .byte 300, 377, 14, 0
                .byte 0, 77, 117, 50
                .byte 100, 305, 117, 50
                .byte 0, 0, 123, 50
                .byte 240, 12, 0, 12
                .byte 250, 12, 200, 12
SprManStayRt:   .word 4, 30                 ; человечек стоит вправо
                .byte 100, 105, 124, 0
                .byte 20, 21, 5, 1
                .byte 104, 100, 100, 1
                .byte 104, 0, 0, 4
                .byte 21, 0, 24, 4
                .byte 1, 360, 117, 1
                .byte 1, 377, 3, 0
                .byte 1, 377, 3, 0
                .byte 4, 377, 77, 0
                .byte 4, 374, 77, 0
                .byte 20, 360, 14, 0
                .byte 100, 300, 3, 0
                .byte 20, 374, 17, 0
                .byte 20, 374, 17, 0
                .byte 4, 77, 14, 0
                .byte 4, 317, 3, 0
                .byte 20, 77, 17, 0
                .byte 100, 250, 76, 0
                .byte 0, 374, 3, 0
                .byte 0, 360, 3, 0
                .byte 0, 360, 3, 0
                .byte 0, 120, 1, 0
                .byte 0, 240, 12, 0
                .byte 0, 240, 52, 0
SprManStepRt:   .word 4, 30                 ; человечек идёт вправо
                .byte 100, 125, 124, 0
                .byte 20, 104, 5, 1
                .byte 4, 101, 0, 1
                .byte 104, 0, 4, 4
                .byte 101, 0, 20, 4
                .byte 1, 360, 117, 1
                .byte 1, 377, 14, 0
                .byte 1, 377, 14, 0
                .byte 4, 377, 77, 0
                .byte 4, 374, 77, 0
                .byte 20, 360, 14, 0
                .byte 20, 360, 0, 0
                .byte 20, 377, 3, 0
                .byte 4, 77, 14, 0
                .byte 4, 317, 363, 0
                .byte 20, 74, 77, 0
                .byte 100, 374, 0, 0
                .byte 0, 251, 52, 0
                .byte 0, 374, 63, 0
                .byte 0, 374, 74, 0
                .byte 0, 314, 14, 0
                .byte 0, 26, 25, 0
                .byte 0, 52, 50, 0
                .byte 0, 250, 250, 2
SprManStepRt2:  .word 4, 30                 ; человечек идёт вправо 2
                .byte 0, 124, 124, 1
                .byte 0, 21, 5, 4
                .byte 100, 104, 100, 21
                .byte 100, 4, 20, 20
                .byte 20, 1, 300, 20
                .byte 20, 301, 77, 4
                .byte 20, 374, 63, 1
                .byte 20, 374, 63, 0
                .byte 100, 374, 377, 0
                .byte 100, 360, 377, 0
                .byte 0, 301, 63, 0
                .byte 0, 301, 17, 0
                .byte 100, 374, 77, 17
                .byte 0, 377, 377, 74
                .byte 300, 377, 377, 74
                .byte 360, 360, 377, 0
                .byte 60, 240, 52, 0
                .byte 0, 300, 377, 0
                .byte 0, 60, 377, 3
                .byte 50, 361, 374, 0
                .byte 50, 361, 123, 1
                .byte 50, 305, 0, 0
                .byte 240, 0, 240, 12
                .byte 240, 2, 240, 52

SprBrickWall:   .word 4, 30                 ; Стена
SprBrickWallData:.byte 334, 335, 335, 15
                .byte 63, 63, 63, 63
                .byte 315, 314, 314, 34
                .byte 63, 163, 63, 63
                .byte 335, 335, 335, 34
                .byte 167, 167, 67, 63
                .byte 334, 335, 335, 15
                .byte 0, 0, 0, 0
                .byte 167, 167, 3, 167
                .byte 314, 314, 314, 314
                .byte 63, 63, 107, 63
                .byte 335, 314, 314, 335
                .byte 167, 67, 107, 167
                .byte 335, 335, 314, 335
                .byte 167, 167, 3, 167
                .byte 0, 0, 0, 0
                .byte 335, 300, 335, 335
                .byte 63, 63, 63, 63
                .byte 314, 321, 314, 314
                .byte 63, 63, 63, 67
                .byte 315, 321, 335, 335
                .byte 67, 163, 167, 167
                .byte 335, 300, 335, 335
                .byte 0, 0, 0, 0
SprDoor:        .word 4, 30                 ; дверь
SprDoorData:    .byte 0, 242, 212, 0
                .byte 240, 242, 212, 12
                .byte 250, 242, 212, 52
                .byte 252, 242, 212, 252
                .byte 252, 242, 212, 252
                .byte 0, 10, 40, 252
                .byte 252, 242, 12, 0
                .byte 252, 242, 12, 77
                .byte 250, 242, 312, 300
                .byte 250, 242, 312, 374
                .byte 250, 242, 12, 77
                .byte 0, 10, 40, 0
                .byte 250, 242, 212, 52
                .byte 250, 242, 212, 52
                .byte 250, 242, 212, 52
                .byte 10, 10, 40, 40
                .byte 240, 242, 212, 12
                .byte 250, 242, 212, 52
                .byte 250, 242, 212, 52
                .byte 0, 4, 40, 0
                .byte 250, 242, 212, 52
                .byte 252, 242, 212, 252
                .byte 252, 242, 212, 252
                .byte 0, 0, 0, 0
SprFlower:      .word 4, 30                 ; цветок
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 60, 17, 0
                .byte 0, 360, 63, 0
                .byte 0, 314, 75, 0
                .byte 0, 174, 305, 0
                .byte 0, 314, 375, 0
                .byte 0, 360, 63, 0
                .byte 0, 40, 17, 0
                .byte 50, 40, 0, 0
                .byte 212, 10, 50, 0
                .byte 42, 10, 242, 0
                .byte 210, 250, 210, 0
                .byte 50, 52, 42, 0
                .byte 240, 210, 10, 0
                .byte 200, 242, 2, 0
                .byte 0, 252, 2, 0
                .byte 0, 50, 0, 0
SprCross:       .word 4, 30                 ; могильный крест
                .byte 0, 0, 0, 0
                .byte 0, 0, 144, 0
                .byte 300, 44, 223, 1
                .byte 60, 223, 117, 6
                .byte 360, 314, 77, 20
                .byte 360, 317, 77, 6
                .byte 300, 377, 217, 11
                .byte 0, 377, 117, 2
                .byte 0, 374, 17, 0
                .byte 0, 374, 77, 6
                .byte 10, 377, 317, 30
                .byte 40, 377, 77, 103
                .byte 342, 377, 374, 230
                .byte 302, 77, 62, 46
                .byte 374, 117, 11, 31
                .byte 376, 217, 2, 0
                .byte 374, 143, 41, 2
                .byte 374, 223, 200, 40
                .byte 374, 144, 50, 40
                .byte 374, 30, 2, 10
                .byte 12, 44, 250, 202
                .byte 242, 242, 42, 52
                .byte 50, 252, 252, 250
                .byte 242, 250, 50, 212
SprMouthOpen:   .word 4, 20                 ; открытая глотка
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 360, 17, 0
                .byte 0, 74, 76, 0
                .byte 0, 117, 373, 0
                .byte 300, 23, 354, 3
                .byte 360, 4, 260, 17
                .byte 60, 1, 300, 16
                .byte 60, 0, 0, 17
                .byte 60, 0, 0, 17
                .byte 60, 1, 300, 16
                .byte 360, 4, 260, 16
                .byte 300, 23, 254, 3
                .byte 0, 117, 353, 0
                .byte 0, 74, 72, 0
                .byte 0, 360, 17, 0
SprMouthOpenEnd:
TreasureSprSize = SprMouthOpenEnd - SprMouthOpen

SprMouthClose:  .word 4, 20                 ; закрытая глотка
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 360, 17, 0
                .byte 0, 74, 72, 0
                .byte 0, 117, 352, 0
                .byte 300, 23, 252, 3
                .byte 360, 104, 252, 16
                .byte 60, 21, 377, 17
                .byte 60, 0, 0, 14
                .byte 60, 21, 377, 17
                .byte 360, 104, 252, 16
                .byte 300, 23, 252, 3
                .byte 0, 117, 352, 0
                .byte 0, 74, 72, 0
                .byte 0, 360, 17, 0
SprChebura:     .word 4, 20                 ; шар с ушами
                .byte 0, 0, 0, 0
                .byte 120, 1, 100, 5
                .byte 124, 4, 20, 25
                .byte 124, 4, 20, 25
                .byte 124, 360, 17, 25
                .byte 124, 74, 77, 25
                .byte 24, 317, 377, 24
                .byte 24, 317, 377, 24
                .byte 24, 377, 377, 24
                .byte 24, 377, 377, 24
                .byte 124, 374, 77, 25
                .byte 124, 360, 17, 25
                .byte 124, 4, 20, 25
                .byte 124, 4, 20, 25
                .byte 120, 1, 100, 5
                .byte 0, 0, 0, 0
SprCheburaH:    .word 4, 20                 ; шар с ушами горизонтально
                .byte 0, 0, 0, 0
                .byte 120, 125, 125, 5
                .byte 124, 125, 125, 25
                .byte 124, 5, 120, 25
                .byte 4, 240, 12, 20
                .byte 120, 50, 52, 5
                .byte 0, 212, 252, 0
                .byte 0, 212, 252, 0
                .byte 0, 252, 252, 0
                .byte 0, 252, 252, 0
                .byte 120, 250, 52, 5
                .byte 4, 240, 12, 20
                .byte 124, 5, 120, 25
                .byte 124, 125, 125, 25
                .byte 120, 125, 125, 5
                .byte 0, 0, 0, 0
SprLadder:      .word 4, 10                 ; лестница, только чёт маленькая
SprLadderData:  .byte 114, 0, 0, 23
                .byte 34, 0, 0, 7
                .byte 114, 0, 0, 23
                .byte 34, 377, 377, 7
                .byte 114, 104, 104, 23
                .byte 34, 21, 21, 7
                .byte 114, 0, 0, 23
                .byte 34, 0, 0, 7
SprFlyMouse:    .word 4, 20                 ; летучая мышь (крылья вниз)
                .byte 0, 1, 20, 0
                .byte 0, 5, 24, 0
                .byte 0, 125, 25, 0
                .byte 0, 104, 4, 0
                .byte 0, 24, 5, 0
                .byte 100, 124, 105, 0
                .byte 120, 121, 121, 1
                .byte 120, 17, 174, 1
                .byte 24, 14, 14, 5
                .byte 24, 0, 0, 5
                .byte 4, 0, 0, 4
                .byte 1, 0, 0, 20
                .byte 1, 0, 0, 20
                .byte 1, 0, 0, 20
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
SprFlyMouse2:   .word 4, 20                 ; летучая мышь (крылья верх)
                .byte 1, 0, 0, 20
                .byte 5, 0, 0, 24
                .byte 4, 0, 0, 4
                .byte 24, 0, 0, 5
                .byte 120, 0, 100, 1
                .byte 120, 1, 120, 1
                .byte 100, 5, 124, 0
                .byte 100, 125, 125, 0
                .byte 0, 105, 24, 0
                .byte 0, 24, 5, 0
                .byte 0, 124, 5, 0
                .byte 0, 120, 1, 0
                .byte 0, 17, 74, 0
                .byte 0, 14, 14, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
SprGhost1:      .word 4, 20
                .byte 0, 200, 11, 0
                .byte 0, 144, 146, 0
                .byte 0, 231, 231, 1
                .byte 0, 102, 6, 2
                .byte 200, 0, 1, 10
                .byte 100, 14, 62, 4
                .byte 200, 0, 1, 10
                .byte 100, 102, 6, 6
                .byte 220, 231, 231, 31
                .byte 140, 146, 146, 46
                .byte 230, 231, 231, 31
                .byte 146, 146, 146, 146
                .byte 231, 231, 231, 231
                .byte 144, 146, 146, 46
                .byte 0, 230, 31, 0
                .byte 0, 140, 6, 0
SprGhost2:      .word 4, 20
                .byte 0, 200, 11, 0
                .byte 0, 144, 146, 0
                .byte 0, 231, 231, 1
                .byte 0, 102, 6, 2
                .byte 200, 0, 1, 10
                .byte 100, 60, 302, 4
                .byte 200, 0, 1, 10
                .byte 100, 102, 6, 6
                .byte 200, 231, 231, 11
                .byte 140, 146, 146, 46
                .byte 220, 231, 231, 31
                .byte 144, 146, 146, 146
                .byte 231, 231, 231, 231
                .byte 146, 46, 140, 146
                .byte 231, 11, 200, 31
                .byte 144, 2, 0, 6
SprBubble:      .word 6, 30                 ; шар
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 240, 12, 0, 0
                .byte 0, 200, 12, 240, 2, 0
                .byte 0, 50, 0, 0, 50, 0
                .byte 0, 202, 12, 0, 200, 0
                .byte 200, 240, 242, 2, 40, 2
                .byte 200, 50, 250, 0, 0, 2
                .byte 40, 0, 52, 0, 200, 10
                .byte 40, 12, 0, 0, 0, 10
                .byte 210, 202, 2, 0, 0, 40
                .byte 210, 242, 0, 0, 0, 42
                .byte 10, 240, 0, 0, 0, 40
                .byte 10, 0, 0, 0, 40, 42
                .byte 10, 0, 0, 0, 210, 40
                .byte 10, 0, 0, 0, 42, 42
                .byte 10, 0, 0, 210, 210, 42
                .byte 40, 0, 0, 242, 252, 10
                .byte 40, 0, 200, 250, 252, 10
                .byte 200, 0, 40, 252, 52, 2
                .byte 200, 200, 210, 250, 212, 0
                .byte 0, 2, 42, 252, 50, 0
                .byte 0, 250, 250, 212, 12, 0
                .byte 0, 200, 252, 52, 0, 0
                .byte 0, 0, 0, 0, 0, 0
SprMonstrStepRt:.word 6, 30                 ; ящер шагает влево
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 100, 125, 125, 1
                .byte 0, 0, 125, 125, 101, 5
                .byte 0, 120, 125, 125, 5, 5
                .byte 0, 124, 125, 125, 125, 5
                .byte 0, 25, 105, 125, 1, 5
                .byte 100, 125, 25, 125, 24, 0
                .byte 100, 125, 25, 125, 5, 0
                .byte 120, 121, 125, 120, 1, 0
                .byte 120, 121, 125, 5, 0, 0
                .byte 120, 104, 125, 125, 5, 0
                .byte 120, 21, 125, 125, 125, 0
                .byte 120, 105, 124, 125, 5, 1
                .byte 100, 25, 1, 125, 25, 0
                .byte 100, 125, 104, 0, 20, 0
                .byte 0, 125, 25, 5, 0, 0
                .byte 100, 120, 125, 25, 0, 0
                .byte 20, 1, 125, 25, 0, 0
                .byte 104, 104, 100, 125, 0, 0
                .byte 21, 5, 100, 125, 0, 0
                .byte 125, 1, 120, 125, 0, 0
                .byte 125, 25, 120, 125, 1, 0
SprMonstrStayRt:.word 6, 30                 ; ящер стоит влево
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 120, 125, 125, 1
                .byte 0, 100, 125, 125, 5, 5
                .byte 0, 120, 125, 125, 25, 4
                .byte 0, 124, 124, 125, 125, 25
                .byte 0, 105, 25, 125, 5, 24
                .byte 0, 125, 125, 124, 1, 20
                .byte 100, 101, 125, 124, 5, 4
                .byte 100, 104, 125, 124, 125, 0
                .byte 100, 101, 125, 124, 1, 0
                .byte 100, 104, 125, 24, 0, 0
                .byte 0, 101, 125, 100, 1, 0
                .byte 0, 104, 125, 124, 1, 0
                .byte 0, 120, 25, 24, 1, 0
                .byte 0, 4, 24, 0, 1, 0
                .byte 0, 20, 101, 101, 0, 0
                .byte 0, 104, 24, 0, 0, 0
                .byte 0, 124, 25, 0, 0, 0
                .byte 0, 124, 25, 0, 0, 0
                .byte 0, 120, 125, 0, 0, 0
                .byte 0, 120, 105, 1, 0, 0
SprMonstrStepLt:.word 6, 30                 ; ящер шагает вправо
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 100, 125, 125, 1, 0, 0
                .byte 120, 101, 125, 125, 0, 0
                .byte 120, 120, 125, 125, 5, 0
                .byte 120, 125, 125, 125, 25, 0
                .byte 120, 100, 125, 121, 124, 0
                .byte 0, 24, 125, 124, 125, 1
                .byte 0, 120, 125, 124, 125, 1
                .byte 0, 100, 5, 125, 105, 5
                .byte 0, 0, 120, 125, 105, 5
                .byte 0, 120, 125, 125, 21, 5
                .byte 0, 125, 125, 125, 104, 5
                .byte 100, 120, 125, 25, 121, 5
                .byte 0, 124, 125, 100, 124, 1
                .byte 0, 4, 0, 21, 125, 1
                .byte 0, 0, 120, 124, 125, 0
                .byte 0, 0, 124, 125, 5, 1
                .byte 0, 0, 124, 125, 100, 4
                .byte 0, 0, 125, 1, 21, 21
                .byte 0, 0, 125, 1, 120, 104
                .byte 0, 0, 125, 5, 100, 125
                .byte 0, 100, 125, 5, 124, 125
SprMonstrStayLt:.word 6, 30                 ; ящер стоит вправо
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 0, 0, 0, 0, 0, 0
                .byte 100, 125, 125, 5, 0, 0
                .byte 120, 120, 125, 125, 1, 0
                .byte 20, 124, 125, 125, 5, 0
                .byte 124, 125, 125, 25, 25, 0
                .byte 24, 120, 125, 124, 121, 0
                .byte 4, 100, 25, 125, 125, 0
                .byte 20, 120, 25, 125, 101, 1
                .byte 0, 125, 25, 125, 21, 1
                .byte 0, 100, 25, 125, 101, 1
                .byte 0, 0, 24, 125, 21, 1
                .byte 0, 100, 1, 125, 101, 0
                .byte 0, 100, 25, 125, 21, 0
                .byte 0, 100, 24, 124, 5, 0
                .byte 0, 100, 0, 24, 20, 0
                .byte 0, 0, 101, 101, 4, 0
                .byte 0, 0, 0, 24, 21, 0
                .byte 0, 0, 0, 124, 25, 0
                .byte 0, 0, 0, 124, 25, 0
                .byte 0, 0, 0, 125, 5, 0
                .byte 0, 0, 100, 121, 5, 0
SprAlien:       .word 6, 50                 ; великан-инопланетянин
                .byte 0, 0, 360, 17, 0, 0
                .byte 0, 0, 377, 377, 0, 0
                .byte 0, 300, 377, 377, 3, 0
                .byte 0, 300, 374, 77, 3, 0
                .byte 0, 360, 360, 17, 17, 0
                .byte 0, 360, 363, 317, 17, 0
                .byte 0, 300, 377, 377, 3, 0
                .byte 0, 0, 17, 360, 0, 0
                .byte 0, 252, 360, 17, 252, 0
                .byte 240, 252, 2, 200, 252, 12
                .byte 210, 252, 242, 212, 252, 42
                .byte 250, 200, 212, 242, 2, 52
                .byte 252, 52, 252, 252, 250, 252
                .byte 252, 252, 240, 12, 252, 252
                .byte 252, 250, 252, 252, 52, 252
                .byte 252, 240, 52, 250, 12, 252
                .byte 250, 10, 202, 202, 40, 52
                .byte 52, 240, 252, 252, 12, 250
                .byte 252, 210, 252, 252, 42, 252
                .byte 376, 243, 2, 200, 312, 277
                .byte 374, 217, 250, 52, 362, 77
                .byte 374, 214, 252, 252, 62, 77
                .byte 374, 200, 12, 240, 2, 77
                .byte 360, 243, 252, 252, 312, 17
                .byte 0, 240, 252, 252, 12, 0
                .byte 0, 250, 252, 252, 52, 0
                .byte 0, 250, 252, 252, 52, 0
                .byte 0, 250, 52, 250, 52, 0
                .byte 0, 252, 52, 250, 252, 0
                .byte 0, 252, 12, 240, 252, 0
                .byte 0, 252, 12, 240, 252, 0
                .byte 100, 250, 2, 200, 52, 1
                .byte 0, 21, 0, 0, 104, 0
                .byte 0, 104, 0, 0, 21, 0
                .byte 0, 125, 0, 0, 125, 0
                .byte 0, 125, 0, 0, 125, 0
                .byte 0, 25, 0, 0, 124, 0
                .byte 0, 125, 0, 0, 125, 0
                .byte 100, 124, 1, 100, 25, 1
                .byte 120, 125, 1, 100, 125, 5
SprSkelet:      .word 10, 30                ; прикованный скелет
                .byte 120, 1, 0, 0, 0, 0, 100, 25
                .byte 100, 4, 0, 0, 377, 0, 20, 1
                .byte 100, 1, 0, 300, 377, 3, 120, 74
                .byte 114, 304, 77, 360, 377, 17, 23, 361
                .byte 117, 5, 74, 60, 300, 317, 3, 314
                .byte 17, 0, 360, 360, 303, 317, 0, 0
                .byte 63, 0, 300, 303, 77, 317, 0, 0
                .byte 0, 0, 0, 63, 363, 63, 0, 0
                .byte 0, 0, 360, 60, 74, 14, 0, 0
                .byte 0, 0, 314, 300, 300, 3, 0, 0
                .byte 0, 0, 314, 0, 74, 0, 0, 0
                .byte 0, 0, 314, 0, 17, 0, 0, 0
                .byte 0, 0, 14, 303, 3, 0, 0, 0
                .byte 0, 0, 63, 0, 14, 0, 0, 0
                .byte 0, 0, 303, 360, 3, 14, 0, 0
                .byte 0, 300, 14, 300, 360, 3, 0, 0
                .byte 0, 300, 63, 77, 374, 17, 0, 0
                .byte 0, 300, 377, 0, 374, 0, 0, 0
                .byte 0, 60, 377, 17, 17, 60, 0, 0
                .byte 0, 360, 300, 63, 3, 374, 0, 0
                .byte 0, 360, 0, 374, 0, 317, 3, 0
                .byte 0, 360, 363, 363, 300, 303, 17, 0
                .byte 0, 300, 377, 300, 363, 300, 0, 0
                .byte 0, 300, 3, 0, 77, 0, 0, 0
SprKey:         .word 4, 20                 ; ключ
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 0, 0, 0
                .byte 0, 5, 0, 0
                .byte 100, 24, 100, 124
                .byte 100, 20, 100, 20
                .byte 124, 121, 100, 21
                .byte 5, 125, 125, 125
                .byte 5, 125, 125, 125
                .byte 124, 121, 0, 0
                .byte 100, 20, 0, 0
                .byte 100, 24, 0, 0
                .byte 0, 5, 0, 0
SprDeathStpRt1: .word 4, 20                 ; смерть
                .byte 0, 0, 124, 1
                .byte 0, 100, 125, 5
                .byte 0, 120, 125, 25
                .byte 0, 124, 125, 20
                .byte 100, 125, 25, 20
                .byte 120, 5, 20, 4
                .byte 24, 120, 21, 1
                .byte 0, 124, 104, 0
                .byte 0, 125, 121, 101
                .byte 0, 125, 5, 120
                .byte 0, 105, 125, 125
                .byte 0, 1, 105, 25
                .byte 0, 105, 25, 0
                .byte 100, 105, 125, 5
                .byte 100, 125, 125, 1
                .byte 120, 125, 125, 0
SprDeathStpRt2: .word 4, 20
                .byte 0, 0, 124, 1
                .byte 0, 100, 125, 5
                .byte 0, 124, 125, 25
                .byte 100, 125, 125, 20
                .byte 120, 125, 25, 20
                .byte 125, 1, 24, 4
                .byte 0, 120, 25, 1
                .byte 0, 124, 120, 0
                .byte 0, 25, 121, 0
                .byte 0, 105, 105, 0
                .byte 0, 105, 25, 124
                .byte 0, 1, 121, 25
                .byte 0, 105, 105, 5
                .byte 0, 105, 25, 5
                .byte 120, 125, 125, 0
                .byte 125, 125, 125, 1
SprDeathStpLt1: .word 4, 20
                .byte 100, 25, 0, 0
                .byte 120, 125, 1, 0
                .byte 124, 125, 5, 0
                .byte 4, 125, 25, 0
                .byte 4, 124, 125, 1
                .byte 20, 4, 120, 5
                .byte 100, 104, 5, 24
                .byte 0, 21, 25, 0
                .byte 101, 105, 125, 0
                .byte 5, 120, 125, 0
                .byte 125, 125, 121, 0
                .byte 124, 121, 100, 0
                .byte 0, 124, 121, 0
                .byte 120, 125, 121, 1
                .byte 100, 125, 125, 1
                .byte 0, 125, 125, 5
SprDeathStpLt2: .word 4, 20
                .byte 0, 25, 0, 0
                .byte 120, 125, 1, 0
                .byte 124, 125, 25, 0
                .byte 4, 125, 125, 1
                .byte 4, 124, 125, 5
                .byte 20, 24, 100, 125
                .byte 100, 124, 5, 0
                .byte 0, 5, 25, 0
                .byte 0, 105, 124, 0
                .byte 0, 121, 121, 0
                .byte 25, 124, 121, 0
                .byte 124, 105, 100, 0
                .byte 120, 121, 121, 0
                .byte 120, 124, 121, 0
                .byte 0, 125, 125, 5
                .byte 100, 125, 125, 125
SprHeart:       .word 4, 17
                .byte 300, 17, 374, 0
                .byte 60, 74, 127, 3
                .byte 14, 377, 125, 15
                .byte 314, 177, 125, 15
                .byte 314, 177, 125, 15
                .byte 374, 177, 125, 15
                .byte 374, 177, 125, 15
                .byte 360, 177, 125, 3
                .byte 360, 177, 125, 3
                .byte 300, 177, 325, 0
                .byte 300, 177, 325, 0
                .byte 0, 177, 65, 0
                .byte 0, 174, 15, 0
                .byte 0, 160, 3, 0
                .byte 0, 300, 0, 0
; ───────────────────────────────────────────────────────────────────────────
; Элементы лабиринта
; 0 - Пусто
; 1 - ГГ
; 2 - Стена
; 3 - Дверь
; 4 - Цветок
; 5 - Глотка    \
; 6 - Чебуратор - это сокровища, которые надо собирать
; 7 - Лестница
; 8 - Летучая мышь
; 9 - Призрак
; 10 - Ящер-динозавр
; 11 - Великан-инопланетянин
; 12 - Скелет
; 13 - Шар (Пузырь)
; 14 - Ключ
; 15 - Смерть

LabItemSprTbl:  .word SprManStayRt      ; 1
                .word SprBrickWall      ; 2
                .word SprDoor           ; 3
                .word SprFlower         ; 4
                .word SprMouthClose     ; 5
                .word SprChebura        ; 6
                .word SprLadder         ; 7
                .word SprFlyMouse       ; 8
                .word SprGhost1         ; 9
                .word SprMonstrStepLt   ; 10
                .word SprAlien          ; 11
                .word SprSkelet         ; 12
                .word SprBubble         ; 13
                .word SprKey            ; 14
                .word SprDeathStpRt1    ; 15
                .word 0
; ───────────────────────────────────────────────────────────────────────────
word_14342:     .word ^B0000000100000001
                .word ^B0101000001010000
                .word ^B0000010000000100
                .word ^B0101010101010101
                .word ^B0100000001000000
                .word ^B0000010100000101
                .word ^B0001000000010000
                .word ^b0000000000000000
word_14362:     .word ^B0100000001000000
                .word ^B0000010100000101
                .word ^B0001000000010000
                .word ^B0101010101010101
                .word ^B0000000100000001
                .word ^B0101000001010000
                .word ^B0000010000000100
                .word ^b0000000000000000
word_14402:     .word ^B0000010001000001
                .word ^B0000000101000100
                .word ^B0001000001000100
                .word ^B0000010001010000
                .word ^B0000010001000001
                .word ^B0000000101000100
                .word ^B0001000001000100
                .word ^B0000010001010000
word_14422:     .word ^B0000010001010000
                .word ^B0001000001000100
                .word ^B0000000101000100
                .word ^B0000010001000001
                .word ^B0000010001010000
                .word ^B0001000001000100
                .word ^B0000000101000100
                .word ^B0000010001000001
word_14442:     .word ^B0100000001000001
                .word ^B0000010001000100
                .word ^B0001000101000100
                .word ^B0101010100010000
                .word ^B0000000100000000
                .word ^B0101000001010000
                .word ^B0000010000000000
                .word ^b0000000000000000
word_14462:     .word ^b0000000000000000
                .word ^B0000010000000000
                .word ^B0101000001010000
                .word ^B0000000100000000
                .word ^B0101010100010000
                .word ^B0001000101000100
                .word ^B0000010001000100
                .word ^B0100000001000001
word_14502:     .word ^b0000000000000000
                .word ^B0000000000010000
                .word ^B0000010100000101
                .word ^B0000000001000000
                .word ^B0000010001010101
                .word ^B0001000101000100
                .word ^B0001000100010000
                .word ^B0100000100000001
word_14522:     .word ^B0100000100000001
                .word ^B0001000100010000
                .word ^B0001000101000100
                .word ^B0000010001010101
                .word ^B0000000001000000
                .word ^B0000010100000101
                .word ^B0000000000010000
                .word ^b0000000000000000
; ───────────────────────────────────────────────────────────────────────────
; символы с кодами 77..132
Font1:          .byte 0
                .byte ^B01111100
                .byte ^B11000110
                .byte ^B11001110
                .byte ^B01100000
                .byte ^B00110000
                .byte ^B00000000
                .byte ^B00110000

                .byte ^B00111100
                .byte ^B01000010
                .byte ^B10011001
                .byte ^B10000101
                .byte ^B10000101
                .byte ^B10011001
                .byte ^B01000010
                .byte ^B00111100

                .byte 0
                .byte ^B00110000
                .byte ^B00111000
                .byte ^B01110100
                .byte ^B01100110
                .byte ^B01110011
                .byte ^B01101011
                .byte ^B01100110
                .byte 0
                .byte ^B00011111
                .byte ^B00110110
                .byte ^B00011110
                .byte ^B00110110
                .byte ^B01100110
                .byte ^B01100110
                .byte ^B00111111
                .byte 0
                .byte ^B01110000
                .byte ^B01001100
                .byte ^B00000110
                .byte ^B00000011
                .byte ^B01000011
                .byte ^B01100111
                .byte ^B00111110
                .byte 0
                .byte ^B00000110
                .byte ^B00001110
                .byte ^B00010110
                .byte ^B00110110
                .byte ^B01100110
                .byte ^B01100110
                .byte ^B00111111
                .byte 0
                .byte ^B01111111
                .byte ^B00000110
                .byte ^B00111110
                .byte ^B00100110
                .byte ^B00000110
                .byte ^B01000110
                .byte ^B01111111
                .byte 0
                .byte ^B01111111
                .byte ^B01000110
                .byte ^B00000110
                .byte ^B00111110
                .byte ^B00100110
                .byte ^B00000110
                .byte ^B00000110
                .byte 0
                .byte ^B01110000
                .byte ^B00001100
                .byte ^B00000110
                .byte ^B01100011
                .byte ^B01110011
                .byte ^B01101111
                .byte ^B01100110
                .byte 0
                .byte ^B01100011
                .byte ^B01100011
                .byte ^B01100011
                .byte ^B01111111
                .byte ^B01100011
                .byte ^B01100011
                .byte ^B01100011
                .byte 0
                .byte ^B01111111
                .byte ^B00011100
                .byte ^B00011100
                .byte ^B00011100
                .byte ^B00011100
                .byte ^B00011100
                .byte ^B01111111
                .byte 0
                .byte ^B01111000
                .byte ^B01100000
                .byte ^B01100001
                .byte ^B01100001
                .byte ^B01100011
                .byte ^B01111110
                .byte ^B00111000
                .byte 0
                .byte ^B00100111
                .byte ^B00010110
                .byte ^B00001110
                .byte ^B00011110
                .byte ^B00110110
                .byte ^B00100110
                .byte ^B01100111
                .byte 0
                .byte ^B00001111
                .byte ^B00000110
                .byte ^B00000110
                .byte ^B00000110
                .byte ^B00000110
                .byte ^B01000110
                .byte ^B01111111
                .byte 0
                .byte ^B01100011
                .byte ^B01110111
                .byte ^B01110111
                .byte ^B01101011
                .byte ^B01101011
                .byte ^B01100011
                .byte ^B01100011
                .byte 0
                .byte ^B00110011
                .byte ^B01101011
                .byte ^B01100111
                .byte ^B01100111
                .byte ^B00100011
                .byte ^B00010011
                .byte ^B01111011
                .byte 0
                .byte ^B00011100
                .byte ^B00110110
                .byte ^B01100011
                .byte ^B01000001
                .byte ^B01100011
                .byte ^B00110110
                .byte ^B00011100
                .byte 0
                .byte ^B00011111
                .byte ^B00110110
                .byte ^B01100110
                .byte ^B01101110
                .byte ^B01110110
                .byte ^B00000110
                .byte ^B00000111
                .byte 0
                .byte ^B00011100
                .byte ^B00110110
                .byte ^B01100011
                .byte ^B01100011
                .byte ^B01101011
                .byte ^B00110110
                .byte ^B01101100
                .byte 0
                .byte ^B00011111
                .byte ^B00110110
                .byte ^B01100110
                .byte ^B01101110
                .byte ^B00111110
                .byte ^B00110110
                .byte ^B01100111
                .byte 0
                .byte ^B00011100
                .byte ^B00100110
                .byte ^B00000110
                .byte ^B00111100
                .byte ^B01100001
                .byte ^B01100011
                .byte ^B00111110
                .byte 0
                .byte ^B01111111
                .byte ^B01011001
                .byte ^B00011001
                .byte ^B00011000
                .byte ^B00011000
                .byte ^B00011000
                .byte ^B00011000
                .byte 0
                .byte ^B01101111
                .byte ^B01100100
                .byte ^B01100010
                .byte ^B01110011
                .byte ^B01110011
                .byte ^B01101011
                .byte ^B01100110
                .byte 0
                .byte ^B01000111
                .byte ^B00100110
                .byte ^B00100110
                .byte ^B00010110
                .byte ^B00010110
                .byte ^B00001110
                .byte ^B00000110
                .byte 0
                .byte ^B01100011
                .byte ^B01100011
                .byte ^B01101011
                .byte ^B01101011
                .byte ^B01110111
                .byte ^B01110111
                .byte ^B01100011
                .byte 0
                .byte ^B01100001
                .byte ^B01100011
                .byte ^B00110110
                .byte ^B00011100
                .byte ^B00110110
                .byte ^B01100011
                .byte ^B01000011
                .byte 0
                .byte ^B01100001
                .byte ^B01100110
                .byte ^B01101000
                .byte ^B01110000
                .byte ^B01100000
                .byte ^B00110010
                .byte ^B00011100
                .byte 0
                .byte ^B01111111
                .byte ^B01100001
                .byte ^B00110000
                .byte ^B00011000
                .byte ^B01001100
                .byte ^B01000110
                .byte ^B01111111
; ───────────────────────────────────────────────────────────────────────────
; цифры 0..9
Font2:          .byte 0
                .byte ^B00011100
                .byte ^B00110110
                .byte ^B01110011
                .byte ^B01001001
                .byte ^B01100111
                .byte ^B00110110
                .byte ^B00011100
                .byte 0
                .byte ^B00111000
                .byte ^B00111100
                .byte ^B00111010
                .byte ^B00111000
                .byte ^B00111000
                .byte ^B00111000
                .byte ^B01111110
                .byte 0
                .byte ^B00011100
                .byte ^B00110010
                .byte ^B00110000
                .byte ^B00011110
                .byte ^B01000011
                .byte ^B01000011
                .byte ^B01111111
                .byte 0
                .byte ^B00011100
                .byte ^B00110010
                .byte ^B00110000
                .byte ^B01111100
                .byte ^B01100001
                .byte ^B01100001
                .byte ^B00111111
                .byte 0
                .byte ^B00011000
                .byte ^B00011100
                .byte ^B00011010
                .byte ^B01011001
                .byte ^B01111111
                .byte ^B01011000
                .byte ^B00111110
                .byte 0
                .byte ^B01111111
                .byte ^B01000011
                .byte ^B00000011
                .byte ^B00111111
                .byte ^B01100000
                .byte ^B01100001
                .byte ^B00111110
                .byte 0
                .byte ^B01111000
                .byte ^B01001100
                .byte ^B00000110
                .byte ^B00111011
                .byte ^B01100011
                .byte ^B01100011
                .byte ^B00111110
                .byte 0
                .byte ^B01111110
                .byte ^B01100010
                .byte ^B00110010
                .byte ^B00110000
                .byte ^B00011000
                .byte ^B00011100
                .byte ^B00011111
                .byte 0
                .byte ^B00011100
                .byte ^B00110110
                .byte ^B00110110
                .byte ^B00111110
                .byte ^B01100011
                .byte ^B01100011
                .byte ^B00111110
                .byte 0
                .byte ^B00111110
                .byte ^B01100011
                .byte ^B01100011
                .byte ^B00111110
                .byte ^B01110000
                .byte ^B00111001
                .byte ^B00001111

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


Byte2WordFnt:   mov     R1, -(SP)
                mov     R2, -(SP)
                movb    (R0), R2
                mov     #8., R1

1$:             asr     R2
                ror     (R5)
                asr     (R5)
                sob     R1, 1$
                mov     (SP)+, R2
                mov     (SP)+, R1
                return
; End of function Byte2WordFnt

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


DrawFinalPic:   mov     #44036, ScrAddr1
                mov     PC, R0
                add     #Data1Bgn-., R0
                mov     R0, R1
                add     (R0)+, R1
                cmp     (R0)+, (R0)+
                mov     R0, Base1
                clr     R3

1$:             mov     Height1, R2
                inc     R3
                mov     ScrAddr1, R5

2$:             mov     (R1), R4
                add     Base1, R4
                cmp     R0, R4
                beq     5$
                br      10$
; ───────────────────────────────────────────────────────────────────────────

3$:             add     #100, R5
                sob     R2, 2$

4$:             cmp     R3, Width1
                beq     11$
                add     #2, ScrAddr1
                br      1$
; ───────────────────────────────────────────────────────────────────────────

5$:             movb    (R0)+, R4
                bpl     6$
                com     R4
                comb    R4

6$:             tst     R2
                bne     7$
                add     #2, ScrAddr1
                inc     R3
                mov     ScrAddr1, R5
                mov     Height1, R2

7$:             br      9$
; ───────────────────────────────────────────────────────────────────────────

8$:             add     #100, R5
                dec     R2
                sob     R4, 6$
                cmpb    (R0)+, (R2)+
                tst     (R1)+
                sob     R2, 2$
                br      4$
; ───────────────────────────────────────────────────────────────────────────

9$:             call    Byte2WordFnt
                br      8$
; ───────────────────────────────────────────────────────────────────────────

10$:            call    Byte2WordFnt
                inc     R0
                br      3$
; ───────────────────────────────────────────────────────────────────────────
                .ascii "SV"
; ───────────────────────────────────────────────────────────────────────────

11$:            return
; End of function DrawFinalPic

; ───────────────────────────────────────────────────────────────────────────
ScrAddr1:       .word 44074
Base1:          .word 0
Data1Bgn:       .word OffsetTbl1-.
Width1:         .word 20
Height1:        .word 264
Data1:          .byte 54, 0, 200, 200, 0, 170, 5, 374
                .byte 370, 360, 340, 300, 200, 200, 237, 0
                .byte 200, 340, 360, 360, 356, 337, 277, 277
                .byte 177, 177, 176, 235, 353, 367, 373, 173
                .byte 277, 337, 357, 357, 357, 237, 376, 374
                .byte 370, 360, 300, 231, 0, 3, 7, 7
                .byte 17, 217, 317, 317, 377, 377, 361, 376
                .byte 377, 377, 347, 331, 336, 337, 357, 377
                .byte 377, 377, 177, 5, 377, 370, 174, 176
                .byte 336, 366, 377, 377, 376, 376, 374, 374
                .byte 370, 370, 360, 340, 300, 200, 176, 0
                .byte 200, 340, 340, 7, 360, 340, 340, 200
                .byte 16, 37, 77, 77, 37, 17, 17, 7
                .byte 7, 6, 3, 1, 1, 0, 1, 1
                .byte 3, 37, 367, 373, 376, 21, 377, 374
                .byte 360, 340, 200, 170, 0, 176, 377, 377
                .byte 347, 331, 276, 376, 336, 336, 355, 353
                .byte 377, 377, 377, 376, 374, 374, 6, 370
                .byte 360, 360, 360, 340, 340, 300, 200, 7
                .byte 0, 7, 37, 77, 177, 177, 22, 377
                .byte 376, 170, 165, 0, 340, 370, 375, 377
                .byte 377, 377, 377, 217, 67, 373, 5, 377
                .byte 237, 117, 17, 237, 373, 367, 10, 377
                .byte 237, 177, 376, 374, 340, 0, 0, 340
                .byte 370, 374, 376, 24, 377, 177, 3, 165
                .byte 0, 6, 377, 177, 77, 277, 13, 377
                .byte 207, 373, 17, 347, 3, 3, 7, 237
                .byte 277, 277, 77, 317, 340, 37, 377, 377
                .byte 370, 7, 23, 377, 374, 377, 370, 367
                .byte 354, 370, 360, 360, 340, 340, 300, 300
                .byte 300, 200, 200, 200, 153, 0, 201, 5
                .byte 377, 370, 367, 6, 377, 363, 351, 341
                .byte 363, 277, 337, 377, 377, 376, 374, 375
                .byte 376, 377, 377, 177, 277, 316, 361, 174
                .byte 177, 277, 317, 361, 376, 11, 377, 177
                .byte 77, 37, 77, 5, 177, 24, 377, 376
                .byte 376, 374, 370, 360, 340, 200, 137, 0
                .byte 360, 376, 377, 307, 273, 171, 173, 167
                .byte 177, 277, 377, 377, 377, 377, 6, 177
                .byte 5, 377, 177, 177, 277, 277, 336, 357
                .byte 367, 373, 375, 376, 14, 377, 17, 1
                .byte 5, 0, 200, 360, 374, 32, 377, 0
                .byte 0, 1, 1, 1, 7, 37, 177, 377
                .byte 377, 377, 377, 376, 374, 370, 370, 360
                .byte 340, 340, 300, 300, 200, 200, 113, 0
                .byte 3, 7, 7, 7, 17, 7, 7, 1
                .byte 0, 0, 0, 0, 300, 360, 374, 376
                .byte 7, 377, 376, 376, 376, 376, 375, 375
                .byte 373, 5, 377, 177, 77, 37, 17, 3
                .byte 0, 0, 0, 0, 200, 300, 300, 200
                .byte 200, 200, 1, 1, 1, 3, 3, 3
                .byte 3, 7, 7, 7, 17, 17, 17, 37
                .byte 37, 37, 77, 177, 6, 377, 177, 17
                .byte 1, 5, 0, 200, 340, 374, 20, 377
                .byte 376, 374, 370, 360, 340, 300, 200, 53
                .byte 0, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 256, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 0, 0, 200
                .byte 340, 360, 374, 0, 177, 377, 377, 125
                .byte 252, 177, 0, 377, 377, 377, 376, 374
                .byte 374, 370, 371, 357, 277, 16, 377, 0
                .byte 377, 377, 377, 125, 252, 377, 0, 7
                .byte 377, 177, 77, 37, 17, 7, 33, 33
                .byte 37, 77, 177, 7, 377, 0, 377, 377
                .byte 377, 125, 252, 377, 77, 17, 7, 3
                .byte 1, 5, 0, 200, 200, 300, 340, 340
                .byte 360, 360, 370, 370, 374, 374, 376, 376
                .byte 377, 377, 0, 377, 377, 377, 125, 252
                .byte 377, 0, 177, 177, 5, 277, 177, 377
                .byte 377, 377, 177, 177, 177, 12, 377, 0
                .byte 377, 377, 377, 125, 252, 377, 0, 5
                .byte 377, 376, 376, 374, 370, 360, 360, 340
                .byte 340, 300, 300, 200, 11, 0, 277, 337
                .byte 357, 345, 362, 367, 160, 160, 160, 160
                .byte 140, 0, 0, 0, 370, 377, 377, 337
                .byte 277, 277, 277, 276, 276, 276, 276, 337
                .byte 337, 56, 361, 6, 377, 277, 352, 16
                .byte 377, 0, 377, 377, 377, 325, 252, 377
                .byte 0, 177, 77, 77, 37, 17, 7, 1
                .byte 14, 0, 1, 3, 7, 17, 37, 0
                .byte 377, 377, 377, 325, 252, 377, 0, 0
                .byte 0, 200, 340, 370, 374, 376, 376, 14
                .byte 377, 375, 366, 372, 372, 0, 377, 377
                .byte 377, 325, 252, 377, 0, 10, 377, 366
                .byte 373, 373, 367, 357, 377, 376, 375, 373
                .byte 367, 357, 337, 337, 277, 177, 177, 0
                .byte 177, 177, 177, 125, 52, 177, 0, 20
                .byte 377, 376, 376, 376, 376, 374, 374, 374
                .byte 376, 377, 367, 373, 175, 276, 276, 336
                .byte 337, 337, 337, 337, 277, 36, 0, 0
                .byte 1, 3, 77, 173, 5, 367, 173, 173
                .byte 73, 4, 17, 3, 1, 5, 0, 1
                .byte 3, 3, 3, 1, 1, 1, 1, 6
                .byte 3, 1, 1, 0, 377, 377, 377, 375
                .byte 252, 377, 32, 0, 377, 377, 377, 375
                .byte 252, 377, 2, 4, 374, 26, 377, 0
                .byte 377, 377, 377, 375, 252, 377, 0, 26
                .byte 377, 177, 11, 377, 275, 353, 27, 377
                .byte 376, 376, 6, 377, 177, 77, 37, 7
                .byte 10, 0, 376, 376, 376, 377, 372, 377
                .byte 32, 0, 377, 377, 377, 377, 372, 377
                .byte 32, 0, 377, 377, 377, 377, 372, 377
                .byte 0, 0, 1, 7, 37, 77, 77, 177
                .byte 177, 10, 377, 177, 177, 77, 77, 77
                .byte 77, 177, 177, 0, 377, 377, 377, 377
                .byte 372, 377, 0, 6, 377, 177, 77, 7
                .byte 3, 3, 7, 7, 17, 17, 37, 77
                .byte 5, 377, 317, 276, 6, 175, 275, 316
                .byte 3, 7, 17, 37, 37, 37, 77, 67
                .byte 157, 167, 177, 177, 77, 77, 37, 17
                .byte 7, 7, 7, 7, 3, 3, 1, 1
                .byte 1, 376, 376, 376, 376, 372, 376, 7
                .byte 0, 136, 76, 136, 56, 136, 76, 76
                .byte 135, 53, 133, 73, 133, 55, 132, 64
                .byte 132, 54, 136, 76, 136, 56, 136, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 76
                .byte 135, 53, 133, 73, 133, 55, 132, 64
                .byte 132, 54, 136, 76, 136, 56, 136, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 76
                .byte 135, 53, 133, 73, 133, 55, 132, 64
                .byte 132, 54, 136, 76, 136, 56, 136, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 76
                .byte 135, 53, 133, 73, 133, 55, 132, 64
                .byte 132, 54, 136, 76, 136, 56, 136, 76
                .byte 136, 56, 136, 56, 136, 56, 136, 56
                .byte 136, 55, 127, 67, 127, 67, 137, 37
                .byte 137, 37, 137, 57, 157, 27, 127, 76
                .byte 136, 56, 136, 76, 136, 56, 136, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 136
                .byte 56, 136, 76, 136, 56, 136, 76, 76
                .byte 135, 53, 133, 73, 133, 55, 132, 64
                .byte 132, 54, 136, 76, 136, 0, 0, 0
OffsetTbl1:     .word 0
                .word 6
                .word 16
                .word 53
                .word 103
                .word 126
                .word 133
                .word 151
                .word 165
                .word 173
                .word 216
                .word 227
                .word 236
                .word 242
                .word 256
                .word 266
                .word 303
                .word 307
                .word 311
                .word 316
                .word 342
                .word 364
                .word 367
                .word 373
                .word 425
                .word 433
                .word 435
                .word 446
                .word 466
                .word 470
                .word 504
                .word 510
                .word 515
                .word 546
                .word 553
                .word 570
                .word 601
                .word 644
                .word 651
                .word 656
                .word 667
                .word 1205
                .word 1217
                .word 1233
                .word 1251
                .word 1304
                .word 1315
                .word 1327
                .word 1344
                .word 1403
                .word 1407
                .word 1430
                .word 1457
                .word 1475
                .word 1527
                .word 1564
                .word 1575
                .word 1607
                .word 1622
                .word 1635
                .word 1647
                .word 1652
                .word 1656
                .word 1662
                .word 1670
                .word 1700
                .word 1710
                .word 1731
                .word 1753
                .word 1770
                .word 1774
                .word 2037

; ───────────────────────────────────────────────────────────────────────────
; Все эти данные должны быть одним куском
WorkBuffer:
; массив сокровищ на карте лабиринта
; размер элемента - 2 слова.
; первое - адрес экрана, 0 - элемент пуст
; второе - адрес спрайта анимации
TreasureArray:  .blkw 19. * 2
TreasureArrayEnd:

; Массив Летучих мышей. Размер - 4 элемента
; элемент - 1 слово и 2 байта, первое слово - адрес экрана, 0 - элемент пуст
; второе слово: мл байт - тип анимации мыши 0 - ^-V !0 - V-^
;               ст.байт - направление движения 0-вправо !0 - влево
FlyMousesArray: .blkw 4 * 2
FlyMousesArrayEnd:

; Массив призраков. Размер - 4 элемента
; элемент - 1 слово и 2 байта, первое слово - адрес экрана, 0 - элемент пуст
; второе слово: мл байт - тип анимации  призрака 0, !0
;               ст.байт - направление движения 0-вправо !0 - влево
GhostsArray:    .blkw 4 * 2
GhostsArrayEnd:

; Массив ящеров. Размер - 4 элемента
; элемент - 1 слово и 2 байта, первое слово - адрес экрана, 0 - элемент пуст
; второе слово: мл байт - тип анимации  призрака 0, !0
;               ст.байт - направление движения 0-вправо !0 - влево
MonstrsArray:   .blkw 4 * 2
MonstrsArrayEnd:

; Массив Инопланетян. Размер - 4 элемента
; элемент - 1 слово и 2 байта, первое слово - адрес экрана, 0 - элемент пуст
; второе слово: мл байт - счётчик
;               ст.байт - состояние 
AliensArray:    .blkw 3 * 2
AliensArrayEnd:

; Массив Шаров. Размер - 5 элементов
; элемент - 2 слова, первое адрес экрана, 0 - элемент пуст
;           второе - приращение к адресу. >0 - движется вниз, <0 - движется вверх
BubblesArray:   .blkw 5 * 2
BubblesArrayEnd:

; Массив Смертей. Размер - 5 элементов
; элемент - 2 слова, первое адрес экрана, 0 - элемент пуст
;           второе - адрес спрайта анимации
DeathsArray:    .blkw 5 * 2
DeathsArrayEnd:
word_6010:      .word 0                 ; буфер для хранения данных спрайта
word_6012:      .word 0                 ; великана-инопланетяна
CurManScrAddr:  .word 0                 ; текущий адрес экрана ГГ
CurSprManAnim:  .word 0                 ; адрес текущего спрайта в анимации ГГ
WorkBufferEnd:
; ───────────────────────────────────────────────────────────────────────────
; таблица адресов экрана для вывода летящих звёзд
; (или падающего снега, фиг знает)
StarsTbl:       .word 43677
                .word 67565
                .word 50445
                .word 52430
                .word 75467
                .word 61175
                .word 57453
                .word 64632
                .word 51326
                .word 67024
                .word 57263
                .word 57144
                .word 54263
                .word 70605
                .word 76464
                .word 53750
                .word 53534
                .word 76025
                .word 40032
                .word 75461
                .word 70114
                .word 66614
                .word 42053
                .word 73603
                .word 55404
                .word 66004
                .word 73303
                .word 75420
                .word 55724
                .word 65011
                .word 71762
                .word 72255
                .word 57011
                .word 65064
                .word 0
; ───────────────────────────────────────────────────────────────────────────
; буфер распакованного лабиринта,занимает 49.*2 байтов
; каждый байт, это тетрада байтов запакованного лабиринта
LabyrBuffer:    .blkw 49.
LabyrBufferEnd:
; ───────────────────────────────────────────────────────────────────────────
KbdKeyCode:     .word 10
                .word 31
                .word 32
                .word 33
JoyCodeTbl:     .word 1
                .word 20
                .word 4
                .word 40000
; ───────────────────────────────────────────────────────────────────────────
CurMenuItemAddr:.word 62226             ; проинициализированная переменная
CurCtrlMenuItem:.word 0
CurJoyAction:   .word 0                 ; Переназначенный из маски код управления от джойстика
CurJoyItemMask: .word 0
; ───────────────────────────────────────────────────────────────────────────
; эти переменные должны идти одним блоком, без изменения и перестановок
RightStepCnt:   .word 0                 ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
LeftStepCnt:    .word 0                 ; счётчик шагов при движении влево, для перехода на следующую клетку лабиринта
UpStepCnt:      .word 0                 ; счётчик шагов при движении вверх, для перехода на следующую клетку лабиринта
DownStepCnt:    .word 0                 ; счётчик шагов при движении вниз, для перехода на следующую клетку лабиринта
; ───────────────────────────────────────────────────────────────────────────
; эти переменные тоже должны идти одним блоком, без изменения и перестановок
Lives:          .word 0                 ; количество жизней
HealthPower:    .word 0                 ; количество энергии
Score:          .word 0                 ; игровой счёт
CurLabNumHi:    .byte 0                 ; номер лабиринта, разряд десятков
CurLabNumLo:    .byte 0                 ; номер лабиринта, разряд единиц
CurrentLab:     .word 0                 ; адрес текущего лабиринта в массиве
HaveKey:        .word 0                 ; Флаг, что ключ подобран? 0 - нет. !0 - да
HealthDownCntr: .word 0                 ; счётчик уменьшения здоровья на 1 пункт
GGPosition:     .word 0                 ; Позиция ГГ в массиве распакованного лабиринта
; ───────────────────────────────────────────────────────────────────────────
strSplashTxt2:  .ascii "@"<31><222>
Secret$:        .asciz "SSV"<31><223>"1991"<221>

strSplashTxt1:  .ascii <22><237><221><36><36><33>"THE"<31><223>"CASTLE"
                .ascii <221><31>"THAT"<25><25><25><25>
                .asciz <31><31><31><31>"MAKE"<31>"A"<31><222>"HORROR"<237><221>

strMenu:        .asciz <31><31>"GAME"<222><1>
                .asciz "KEYBOARD"
                .asciz <223><1>"JOYSTICK"<221><1>
                .asciz <31>"EDITOR"<222><1>
                .asciz <31><31>"EXIT"<221><22>

strMenuCtrl:    .asciz <31>"LEFT"
                .asciz <222>"RIGHT"
                .asciz <31><31><31><221>"UP"
                .asciz <31><223>"DOWN"
                ; GAME OVER
strGameOver:    .asciz <237><221>'G'<222>'A'<223>'M'<221>'E'<31><31><223>'O'<222>'V'<221>'E'<222>'R'<237>
                .even

strYouWin:      .ascii <22><221><36>'Y'<222><31>'O'<31>'U'<25><25><25><25><25><25><25>
                .asciz <31><223>'W'<31><221>'I'<31><222>'N'<25><25><25><25><25><221><25><25><25><25><25>
                .even

.script "YouWin Encode"
        mov #strYouWin, R1
1$:     movb (R1), R0
        beq  2$
        decb R0
        decb R0
        movb R0, (R1)+
        br   1$
2$:
.ends

; CODE   91EX
strCode:        .asciz "CODE"<31><31><223>"91EX"
                .even

.script "Code Encode"
        mov #strCode, R1
1$:     movb (R1), R0
        beq  2$
        incb R0
        movb R0, (R1)+
        br   1$
2$:
.ends

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


Vect30:         mov     R5, -(SP)
                mov     2(SP), R5

                cmp     #104016, -(R5)  ; Это emt 16?
                beq     3$              ; да - перехватим
                cmp     #104000, (R5)   ; Это emt 0?
                beq     2$              ; да - перехватим
                cmp     #104006, (R5)   ; это emt 6?
                beq     6$              ; да - перехватим
1$:             mov     (SP)+, R5
                jmp     @#100112        ; всё остальное - обычным обработчиком
; ───────────────────────────────────────────────────────────────────────────
; перехват emt 6
6$:             call    Emt6Sub
                br      14$
; ───────────────────────────────────────────────────────────────────────────
; перехват emt 0 - вывод текста как emt 20
2$:             movb    (R1)+, R0
                beq     14$
                emt     16
                br      2$
; ───────────────────────────────────────────────────────────────────────────
; перехват emt 16
3$:             cmpb    R0, #'0
                blo     1$              ; если меньше 60 - игнорим
                cmpb    R0, #'9         ; код больше 71?
                bhi     5$              ; да - смотрим дальше
                sub     #'0, R0         ; номер знака
                ; цифры '0..'9 - обработаем
                mov     #Font2, R5
                br      7$
; ───────────────────────────────────────────────────────────────────────────

5$:             cmpb    R0, #'?
                blo     1$              ; коды 72..76 игнорим
                cmpb    R0, #'Z
                bhi     1$              ; коды больше 132 игнорим
                sub     #'?, R0         ; получим номер знака
                ; коды 77..132 - обработаем
                mov     #Font1, R5      ; адрес шрифта

7$:             jsr     R4, @#110346
                mov     @#AS, R3        ; абсолютный адрес экрана
                mov     R0, -(SP)
                mov     #31, R0         ; подвинем курсор на позицию вправо
                emt     16
                tstb    @#WideCharMode  ; режим удвоенной ширины?
                beq     8$              ; выкл.
                emt     16              ; если вкл. - то ещё подвинем курсор.

8$:             mov     (SP)+, R0
                asl     R0
                asl     R0
                asl     R0
                add     R0, R5          ; R5 += R0*8. - адрес буквы
                mov     #8., R2         ; столько байтов занимает знак

                mov     @#MASCW, R4     ; код цвета символа
                com     R4

10$:            movb    (R5)+, R1       ; берём очередной байт
                call    Byte2Word       ; Расширяем байт в слово.
                                        ; Вход: R1 - байт
                                        ; Выход: R1 - слово
                tstb    @#WideCharMode  ; режим удвоенной ширины?
                bne     15$             ; вкл.
                                        ; выкл.
                mov     R1, (R3)        ; выводим очередную строку символа
                bic     R4, (R3)        ; нужным цветом
                add     #100, R3        ; переходим к след.строке

11$:            tstb    @#HighCharMode  ; режим масштабирования по высоте?
                beq     13$             ; нет
                mov     @#CharVertScale, R0 ; да, а сколько масштабировать?
                beq     13$             ; нисколько

12$:            mov     R1, (R3)        ; ещё строку
                bic     R4, (R3)
                add     #100, R3
                sob     R0, 12$         ; и так сколько надо

13$:            sob     R2, 10$         ; и так весь символ
                jsr     R4, @#110362

14$:            mov     (SP)+, R5
                rti
; ───────────────────────────────────────────────────────────────────────────
                ; удвоенная ширина символов
15$:            mov     R1, @#Temp1     ; данные символа сохраним
                movb    @#Temp1, R1     ; теперь расширим слово в 2 слова
                call    Byte2Word       ; Расширяем байт в слово.
                                        ; Вход: R1 - байт
                                        ; Выход: R1 - слово
                bic     R4, R1
                mov     R1, (R3)+
                movb    @#Temp1+1, R1
                call    Byte2Word       ; Расширяем байт в слово.
                                        ; Вход: R1 - байт
                                        ; Выход: R1 - слово
                bic     R4, R1
                mov     R1, (R3)
                add     #76, R3
                mov     -100(R3), (R3)+
                mov     R1, (R3)
                add     #76, R3
                mov     @#CharVertScale, R0 ; масштабирование
                inc     R0

16$:            mov     -100(R3), (R3)+ ; теперь смасштабируем по высоте
                mov     -100(R3), (R3)
                add     #76, R3
                sob     R0, 16$
                br      13$
; End of function Vect30


;; ███████████████ S U B R O U T I N E ███████████████████████████████████████
;
;; Расширяем байт в слово.
;; Вход: R1 - байт
;; Выход: R1 - слово
;
;Byte2WordP:     mov     SprSSV+50, AtByte2Word ; делаем всякую херню, 37700 -> AtByte2Word
;                sub     #37700-Byte2Word, AtByte2Word ; Расширяем байт в слово.
;                                        ; Вход: R1 - байт
;                                        ; Выход: R1 - слово
;; ───────────────────────────────────────────────────────────────────────────
;                jmp     @(PC)+
;AtByte2Word:    .word Byte2Word
;; End of function Byte2WordP

; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Расширяем байт в слово.
; Вход: R1 - байт
; Выход: R1 - слово

Byte2Word:      mov     #8., R0
                mov     R4, -(SP)
1$:             asr     R1
                ror     R4
                asr     R4
                sob     R0, 1$
                mov     R4, R1
                mov     (SP)+, R4
                return
; End of function Byte2Word


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


Emt6Sub:        bit     #100, @#177716  ; клавиша нажата?
                beq     Emt6Sub         ; да - подождём пока отпустят

1$:             bit     #100, @#177716  ; клавиша нажата?
                bne     1$              ; нет - подождём, пока нажмут
                mov     @#177662, R0    ; берём скан-код нажатой клавиши
                jsr     R4, @#110346
                call    Beep2           ; Звучок
                                        ; Без параметров, фиксированный
                jsr     R4, @#110362
                return
; End of function Emt6Sub


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывод спрайта на экран
; Вход: R0 - адрес экрана
;       R1 - адрес спрайта, первые 2 слова которого
; ширина в байтах и высота в строках

OutSprite:      cmp     #40000, R0
                bhi     3$
                mov     (R1)+, R2       ; ширина в байтах
                mov     (R1)+, R3       ; высота в строках

1$:             mov     R2, R4

2$:             movb    (R1)+, (R0)+
                sob     R4, 2$
                add     #100, R0
                sub     R2, R0
                sob     R3, 1$

3$:             return
; End of function OutSprite


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывод спрайта на экран с сохранением регистров
; Вход: R0 - адрес экрана
;       R1 - адрес спрайта, первые 2 слова которого
; ширина в байтах и высота в строках

OutSpriteSR:    jsr     R4, @#110346

                call    OutSprite       ; Вывод спрайта на экран
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                jsr     R4, @#110362
                return
; End of function OutSpriteSR


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывод спрайта на экран xorом
; Вход: R0 - адрес экрана
;       R1 - адрес спрайта, первые 2 слова которого
; ширина в байтах и высота в строках

XorSprite:      cmp     #40000, R0
                bhi     5$
                mov     (R1)+, R2
                mov     (R1)+, R3

1$:             mov     R2, R4

2$:             clr     R5
                bisb    (R1)+, R5
                bit     #1, R0          ; адрес экрана чётный?
                beq     3$              ; да идём туда
                                        ; нет, нечётный
                swab    R5              ; переставляем его в старший байт
                xor     R5, -1(R0)      ; ксорим на экран
                br      4$
; ───────────────────────────────────────────────────────────────────────────

3$:             xor     R5, (R0)        ; ксорим на экран

4$:             inc     R0
                sob     R4, 2$
                add     #100, R0
                sub     R2, R0
                sob     R3, 1$
5$:             return
; End of function XorSprite


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывод спрайта на экран xorом с сохранением регистров
; Вход: R0 - адрес экрана
;       R1 - адрес спрайта, первые 2 слова которого
; ширина в байтах и высота в строках

XorSpriteSR:    mov     R5, -(SP)
                jsr     R4, @#110346
                call    XorSprite       ; Вывод спрайта на экран xorом
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                jsr     R4, @#110362
                mov     (SP)+, R5
                return
; End of function XorSpriteSR


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывод стирание спрайта Xorом.
; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
; Вход: R0 - адрес экрана
;       R1 - адрес спрайта

XorSpriteEvn:   cmp     #40000, R0
                bhi     1$
                mov     R5, -(SP)
                jsr     R4, @#110346
                mov     (R1)+, R2
                mov     (R1)+, R3
                asr     R2

2$:             mov     R2, R4

3$:             mov     (R1)+, R5
                xor     R5, (R0)+
                sob     R4, 3$
                add     #100, R0

                sub     R2, R0
                sub     R2, R0
                sob     R3, 2$
                jsr     R4, @#110362
                mov     (SP)+, R5
1$:             return
; End of function XorSpriteEvn


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Звучок
; Без параметров, фиксированный

Beep2:          mov     #150, R1
; End of function Beep2


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Звучок
; Вход: R1 - длительность звука (больше 105)
;  из длительности делается тон.

Beep1:          mov     R1, R0
                sub     #105, R0
; End of function Beep1


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Звучок
; Вход: R1 - длительность звука
;       R0 - начальный тон

Beep:           mov     R1, R3
                add     #30, R3

1$:             mov     #320, @#177716
                mov     R0, R2

                sob     R2, .
                mov     R3, R4
                mov     #220, @#177716

                sob     R4, .
                inc     R0
                dec     R3
                sob     R1, 1$
                return
; End of function Beep


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


SndEffect2:     call    Beep2           ; Звучок
                                        ; Без параметров, фиксированный
; End of function SndEffect2


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


SndEffect1:     mov     #171, R5

1$:             mov     R5, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                add     #20, R5
                cmp     #250, R5
                bhi     1$
                mov     #200, R1
                mov     #60, R0
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                mov     #310, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                return
; End of function SndEffect1


;; ███████████████ S U B R O U T I N E ███████████████████████████████████████
;
;; Вывод десятичного числа.
;; Вход: R4 - число
;
;OutDecNumP:     mov     R0, -(SP)
;                mov     @#Secret$+1, R0 ; 53123
;                sub     #53123-OutDecNum, R0 ; 53123-30317=22604
;                mov     R0, off_33140
;                mov     (SP)+, R0
;                jmp     @(PC)+
;off_33140:      .word OutDecNum
;; End of function OutDecNumP


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывод десятичного числа.
; Вход: R4 - число

OutDecNum:      mov     R0, -(SP)
                mov     R1, -(SP)
                mov     R2, -(SP)
                mov     R4, -(SP)
                clr     R2
                mov     #Subr1, R1
                mov     #'0, R0

1$:             sub     #10000., R4
                bcs     2$
                inc     R0
                br      1$
; ───────────────────────────────────────────────────────────────────────────

2$:             add     #10000., R4
                call    (R1)
                mov     #'0, R0

3$:             sub     #1000., R4
                bcs     4$
                inc     R0
                br      3$
; ───────────────────────────────────────────────────────────────────────────

4$:             add     #1000., R4
                call    (R1)
                mov     #'0, R0

5$:             sub     #100., R4
                bcs     6$
                inc     R0
                br      5$
; ───────────────────────────────────────────────────────────────────────────

6$:             add     #100., R4
                call    (R1)
                mov     #'0, R0

7$:             sub     #10., R4
                bcs     8$
                inc     R0
                br      7$
; ───────────────────────────────────────────────────────────────────────────

8$:             add     #10., R4
                call    (R1)
                mov     #'0, R0
                add     R4, R0
                call    (R1)
                mov     (SP)+, R4
                mov     (SP)+, R2
                mov     (SP)+, R1
                mov     (SP)+, R0
                return
; ───────────────────────────────────────────────────────────────────────────

Subr1:          cmpb    #'0, R0
                bne     1$
                tst     R2
                bne     2$
                movb    #31, R0
                br      2$
; ───────────────────────────────────────────────────────────────────────────

1$:             inc     R2

2$:             emt     16
                return
; End of function OutDecNum


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


Init:           mov     #40000, R1
                mov     #20000, R0

1$:             clr     (R1)+
                sob     R0, 1$
                mov     #Vect30, @#30
; End of function Init

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


DrawSplashText: mov     #strSplashTxt1, R1
                mov     R1, R4
                clr     R5

1$:             mov     R4, R1
                mov     R5, @#CharVertScale ; масштаб по высоте
                emt     0               ; выведем строку
                inc     R5              ; увеличиваем масштаб
                cmp     #3, R5          ; пока не 3
                bne     1$              ; выводим буквы
                clr     R5
                clr     R4
                mov     #13, R1
                clr     R2
                emt     24
                comb    @#HighCharMode
                mov     #strSplashTxt2, R1
                emt     0
                comb    @#HighCharMode
                return
; End of function DrawSplashText


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


DrawMenu:       mov     #14, R1
                mov     #15, R2
                mov     #1, @#CharVertScale ; масштаб по высоте
                comb    @#HighCharMode  ; включаем масштабирование по высоте
                mov     #strMenu, R3
                mov     #5, R4          ; 5 пунктов меню

1$:             emt     24
                mov     R1, R5
                mov     R3, R1
                emt     0
                mov     R1, R3
                mov     R5, R1
                tst     (R2)+
                sob     R4, 1$
                comb    @#HighCharMode
                call    SndEffect2
                mov     #20, @#177712
                mov     #1, R4          ; начальный цвет звезды
                mov     #StarsTbl, R1   ; адрес таблицы

3$:             mov     (R1)+, R0       ; берём слово, это адрес экрана
                beq     4$              ; 0 - конец таблицы
                tst     (R0)            ; а по этому адресу что?
                bne     3$              ; не 0 - пропускаем
                mov     R4, (R0)        ; 0 - туда R4
                br      3$              ; и дальше смотрим таблицу
; ───────────────────────────────────────────────────────────────────────────

4$:             mov     #StarsTbl, R1   ; снова адрес начала таблицы
                clr     R3              ; скорость движения вниз
                clr     R5              ; флаг мигания звезды цветом

5MenuStarLoop$: mov     (R1), R0        ; получим адрес экрана
                beq     4$              ; 0 - конец таблицы
                cmp     R4, (R0)        ; там уже выведена точка?
                beq     6$              ; да - идём стирать
                cmp     #3, (R0)        ; а там уже такая точка?
                beq     6$              ; да - тоже стирать
                br      7$              ; нет - идём обрабатывать
; ───────────────────────────────────────────────────────────────────────────

6$:             clr     (R0)            ; стираем точку

7$:             mov     R3, R2          ; берём приращение, насколько сместиться вниз
                beq     9$              ; 0 - на 1
                                        ; и 1 - тоже на 1
8$:             add     #100, R0
                sob     R2, 8$          ; смещаем адрес вниз на заданное количество
                br      10$
; ───────────────────────────────────────────────────────────────────────────

9$:             add     #100, R0        ; смещаем на строку вниз

10$:            cmp     R0, #77777      ; ещё в пределах экрана?
                blo     11$             ; да
                mov     @#177710, R0    ; нет - формируем новый адрес
                bic     #177700, R0
                add     #40000, R0      ; с начала экрана

11$:            tst     (R0)            ; что там на экране по этому адресу?
                bne     13$             ;  что-то есть
                com     R5              ; пора менять цвет?
                bne     12$             ; нет
                mov     #3, (R0)        ; да - выводим красную точку
                br      13$
; ───────────────────────────────────────────────────────────────────────────

12$:            mov     R4, (R0)        ; нет -выводим своим цветом - синюю

13$:            mov     R0, (R1)+       ; сохраняем адрес в таблице
                bit     #100, @#177716  ; клавиша нажата?
                beq     14$             ; да
                tst     @#177714        ; нет, а джойстик нажат?
                bne     14$             ; да - обработаем
                mov     #60, R0         ; нет
                sob     R0, .           ; небольшая пауза
                inc     R3              ; увеличиваем скорость
                cmp     #5, R3          ; максимальная?
                bne     5MenuStarLoop$  ; нет - крутимся в цикле
                clr     R3              ; да - снова обнулим
                br      5MenuStarLoop$  ; и крутимся в цикле

14$:            mov     #StarsTbl, R0   ; снова адрес начала таблицы

17$:            mov     (R0)+, R1       ; берём адрес экрана
                beq     19$             ; 0 - конец таблицы
                cmp     #1, (R1)        ; там синяя звезда?
                beq     18$
                cmp     #3, (R1)        ; или красная?
                bne     17$             ; нет - к следующему адресу

18$:            clr     (R1)            ; да - сотрём
                br      17$             ;  и так сотрём всё
; ───────────────────────────────────────────────────────────────────────────

19$:            return    ; да - обработаем
; End of function DrawMenu

; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Выделение текущего пункта меню

MenuSelect:     mov     CurMenuItemAddr, R1
                mov     #22, R2

1$:             mov     #12, R3
                mov     #52525, R5

2$:             xor     R5, (R1)+
                sob     R3, 2$
                add     #54, R1
                sob     R2, 1$
                return
; End of function MenuSelect


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Получение кода действия от нажатых клавиши или джойстика
; Выход: R0 - код

MenuControls:   bit     #100, @#177716  ; клавиша всё ещё нажата?
                beq     0KbdProcess$    ; да
                mov     @#177714, R5    ; уже нет, а джойстик?
                beq     MenuControls    ; ничего не нажато, будем ждать
                ; нажат, пойдём обработаем
; End of function MenuControls


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Получить сопоставление маски нажатой кнопки джойстика
; в соответствии с пользовательским переназначением
; Выход: R0 - код действия клавиши по умолчанию

RemapJoyKeys:   mov     #JoyCodeTbl, R2
                bit     (R2)+, R5       ; первый код?
                bne     0RemapLeft$     ; да - он означает "влево"
                bit     (R2)+, R5       ; второй код?
                bne     0RemapRight$    ; да - он означает "вправо"
                bit     (R2)+, R5       ; третий код?
                bne     0RemapUp$       ; да - он означает "вверх"
                bit     (R2), R5        ; четвёртый код?
                bne     0RemapDown$     ; да - он означает "вниз"
                br      0RemapAction$   ; всё остальное - пробел
; End of function RemapJoyKeys


0KbdProcess$:   mov     @#177662, R0    ; получим код нажатой клавиши

; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Получить сопоставление кода нажатой клавиши
; в соответствии с пользовательским переназначением
; Выход: R0 - код действия клавиши по умолчанию

RemapKbdKeys:   mov     #KbdKeyCode, R2
                cmp     (R2)+, R0       ; первый код?
                bne     1$              ; нет

0RemapLeft$:    mov     #10, R0         ; да - он означает "влево"
                return
; ───────────────────────────────────────────────────────────────────────────

1$:             cmp     (R2)+, R0       ; второй код?
                bne     2$              ; нет

0RemapRight$:   mov     #31, R0         ; да - он означает "вправо"
                return
; ───────────────────────────────────────────────────────────────────────────

2$:             cmp     (R2)+, R0       ; третий код?
                bne     3$              ; нет

0RemapUp$:      mov     #32, R0         ; да - он означает "вверх"
                return
; ───────────────────────────────────────────────────────────────────────────

3$:             cmp     (R2), R0        ; четвёртый код?
                bne     0RemapAction$   ; нет

0RemapDown$:    mov     #33, R0         ; да - он означает "вниз"
                return
; ───────────────────────────────────────────────────────────────────────────

0RemapAction$:  mov     #40, R0         ; всё остальное - пробел
                return
; End of function RemapKbdKeys


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


GetJoystickCode:tst     @#177714
                bne     GetJoystickCode
                jsr     R4, @#110346

1$:             mov     #1600, R1

2$:             mov     @#177714, R0
                beq     1$
                sob     R1, 2$
                mov     R0, CurJoyItemMask
                jsr     R4, @#110362
                return
; End of function GetJoystickCode


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Обработка контроллеров управления
; Выход: R0 - стандартный код управления

GetGameContols: mov     @#177662, R0
                bit     #100, @#177716  ; клавиша нажата?
                bne     3$              ; нет
                cmp     #14, R0         ; да - это СБР?
                beq     2$              ; да - выходим
                cmp     #222, R0        ; это Шифт/АР2/2?
                beq     2$              ; да - выходим
1$:             call    RemapKbdKeys    ; Получить сопоставление кода нажатой клавиши
                                        ; в соответствии с пользовательским переназначением
                                        ; Выход: R0 - код действия клавиши по умолчанию
                clr     CurJoyAction    ; отметим, что код от клавиатуры получен

2$:             return
; ───────────────────────────────────────────────────────────────────────────
; а если ничего не нажато, то возьмём код
; от прошлого нажатия

4$:             mov     CurJoyAction, R0 ; был джойстик?
                bne     2$              ; да, вот его и берём
                mov     @#177662, R0    ; иначе - код от клавиатуры.
                br      1$              ; и пойдём переназначим его как надо

3$:             mov     @#177714, R5    ; а джойстик нажат?
                beq     4$              ; нет
                call    RemapJoyKeys    ; Получить сопоставление маски нажатой кнопки джойстика
                                        ; в соответствии с пользовательским переназначением
                                        ; Выход: R0 - код действия клавиши по умолчанию
                mov     R0, CurJoyAction ; сохраним код от джойстика
                return
; End of function GetGameContols

;; ███████████████ S U B R O U T I N E ███████████████████████████████████████
;
;; Функция получает из 177662 код нажатой клавиши
;
;GetScanCodeSec: mov     SprBrickWallData+4, R0 ; берём данные спрайта стены 31463
;                sub     #31601, R0      ; R0 = 31463 - 31601 = 177662
;                br      loc_33150
;loc_33150:      mov     (R0), R0         ; получаем код нажатой клавиши
;                return
;; End of function GetScanCodeSec


MainMenu:       call    DrawMenu
; ───────────────────────────────────────────────────────────────────────────
; сюда попадаем при нажатии клавиши клавиатуры
; или кнопки джойстика
; и предполагается, что они всё ещё нажаты
MenuKeyProc$:
19$:            call    MenuSelect      ; Выделение текущего пункта меню
                mov     #150, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                mov     #216, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                bis     #100, @#177660  ; внезапно запретим прерывания от клавиатуры
                ; идём обрабатывать нажатые органы управления

20$:            call    MenuControls    ; Получение кода действия от нажатых клавиши или джойстика
                                        ; Выход: R0 - код
                ; теперь выполним действия
21$:            cmp     #33, R0         ; нажали вниз?
                bne     22$             ; нет
                cmp     #74226, CurMenuItemAddr ; да, а уже в самом низу?
                beq     20$             ; да - игнорируем
                call    MenuSelect      ; Выделение текущего пункта меню
                add     #2400, CurMenuItemAddr ; нет - сдвинемся на пункт вниз
                br      19$
; ───────────────────────────────────────────────────────────────────────────

22$:            cmp     #32, R0         ; нажали вверх?
                bne     23$             ; нет
                cmp     #62226, CurMenuItemAddr ; да, а мы уже в самом верху?
                beq     20$             ; да - игнорируем
                call    MenuSelect      ; Выделение текущего пункта меню
                sub     #2400, CurMenuItemAddr ; нет - сдвинемся вверх
                br      19$
; ───────────────────────────────────────────────────────────────────────────

23$:            cmp     #40, R0         ; нажали что-то другое?
                beq     24$             ; да
                cmp     #12, R0         ; или ввод?
                bne     20$

24$:            call    Beep2           ; Звучок
                                        ; Без параметров, фиксированный
                mov     #230, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                mov     #140, R5

25$:            mov     R5, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                add     #10, R5
                cmp     R5, #200
                blo     25$
                cmp     #74226, CurMenuItemAddr ; выбрали "Выход"?
                beq     Exit1$          ; да - выходим из игры
26$:            return                  ; нет - выходим из функции

Exit1$:         clr     R1
                call    100142
                halt                    ; выход
; ───────────────────────────────────────────────────────────────────────────


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Прорисовка границ лабиринта

DrawLabBorder:  mov     #40000, R0
                mov     #20, R4
                mov     #SprBrickWall, R1

1$:             call    OutSpriteSR     ; Вывод спрайта на экран с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                cmp     (R0)+, (R0)+
                sob     R4, 1$

                cmp     -(R0), -(R0)
                mov     #10, R4

2$:             add     #3000, R0
                call    OutSpriteSR     ; Вывод спрайта на экран с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                sob     R4, 2$
                mov     #20, R4

3$:             call    OutSpriteSR     ; Вывод спрайта на экран с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                cmp     -(R0), -(R0)
                sob     R4, 3$
                cmp     (R0)+, (R0)+
                mov     #7, R4

4$:             sub     #3000, R0
                call    OutSpriteSR     ; Вывод спрайта на экран с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                sob     R4, 4$
                return
; End of function DrawLabBorder

; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вход: R5 - адрес текущего лабиринта

UnpackLabyrint: mov     #LabyrBuffer, R4 ; буфер лабиринта
                mov     #49., R3        ; размер запакованного лабиринта

1$:             clr     R0
                bisb    (R5)+, R0       ; берём очередной байт
                mov     R0, R2
                bic     #177760, R0     ; берём младшие 4 бита
                bic     R0, R2
                movb    R0, (R4)+       ; сохраняем в буфер
                ror     R2
                ror     R2
                ror     R2
                ror     R2              ; сдвигаем
                movb    R2, (R4)+       ; сохраняем
                sob     R3, 1$
                return
; End of function UnpackLabyrint



; ███████████████ S U B R O U T I N E ███████████████████████████████████████


ClrBuffers:     mov     #WorkBuffer, R0

1$:             clr     (R0)+
                cmp     #WorkBufferEnd, R0
                bne     1$
                return
; End of function ClrBuffers


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Распаковка лабиринта в буфер и отрисовка
; Вход: R5 - адрес текущего лабиринта

PrepareLabyr:   call    ClrBuffers
                call    UnpackLabyrint ; Вход: R5 - адрес текущего лабиринта
; End of function PrepareLabyr


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Отрисовка лабиринта из буфера распакованного лабиринта

DrawLabyrint:   mov     #LabyrBuffer, R4
                mov     #43004, R0      ; начальный адрес экрана

DL_LabLoop$:    mov     #14., R5        ; ширина лабиринта в клетках

DL_LineLoop$:   ; смотрим, что там в ячейке
                cmpb    #11., (R4)      ; это Великан-инопланетянин?
                beq     38$             ; да
                cmpb    #5, (R4)        ; это Глотка?
                beq     38$             ; да
                cmpb    #6, (R4)        ; это Чебуратор?
                bne     9$              ; нет
38$:            add     #1000, R0       ; к адресу клетки +1000, их с этого адреса выводить надо

9$:             movb    (R4)+, R3       ; берём содержимое клетки лабиринта
                cmpb    #1, R3          ; это ГГ?
                bne     10$             ; нет
                mov     R0, CurManScrAddr ; да - задаём адрес экрана
                mov     #SprManStayRt, CurSprManAnim ; и начальный спрайт анимации
                br      3DrawCell$       ; всё
; ───────────────────────────────────────────────────────────────────────────

10$:            cmpb    #5, R3          ; это Глотка?
                beq     11$             ; да
                cmpb    #6, R3          ; это Чебуратор?
                bne     16$             ; нет
                mov     #SprChebura, R2 ; начальный спрайт Чебуратора
                br      12$
; ───────────────────────────────────────────────────────────────────────────

11$:            mov     #SprMouthClose, R2 ; начальный спрайт Глотки

12$:            mov     #TreasureArray, R1 ; помещаем их в массив сокровищ
13$:            tst     (R1)+
                beq     14$
                tst     (R1)+
                cmp     #TreasureArrayEnd, R1
                bne     13$
                br      32$             ; массив заполнен, не поместилось
; ───────────────────────────────────────────────────────────────────────────

14$:            mov     R2, (R1)        ; второе слово - спрайт
                mov     R0, -(R1)       ; первое слово - адрес
                br      3DrawCell$      ; всё
; ───────────────────────────────────────────────────────────────────────────

16$:            cmpb    #8., R3         ; это летучая мышь?
                bne     19$             ; нет
                mov     #FlyMousesArray, R1 ; помещаем её в массив летучих мышей

17$:            tst     (R1)+
                beq     18$
                tst     (R1)+
                cmp     #FlyMousesArrayEnd, R1
                bne     17$
                br      7SkipDraw$      ; массив заполнен, не поместилось
; ───────────────────────────────────────────────────────────────────────────

18$:            mov     (PC)+, (R1)
                .byte   0,377
                mov     R0, -(R1)
                br      3DrawCell$      ; всё
; ───────────────────────────────────────────────────────────────────────────

19$:            cmpb    #9., R3         ; это призрак?
                bne     22$             ; нет
                mov     #GhostsArray, R1 ; помещаем его в массив призраков

20$:            tst     (R1)+
                beq     21$
                tst     (R1)+
                cmp     #GhostsArrayEnd, R1
                bne     20$
                br      7SkipDraw$      ; массив заполнен, не поместилось
; ───────────────────────────────────────────────────────────────────────────

21$:            mov     (PC)+, (R1)
                .byte   0,377
                mov     R0, -(R1)
                br      3DrawCell$      ; всё
; ───────────────────────────────────────────────────────────────────────────

22$:            cmpb    #10., R3        ; это Ящер-динозавр?
                bne     26$             ; нет
                mov     #MonstrsArray, R1 ; помещаем его в массив ящеров

23$:            tst     (R1)+
                beq     24$
                tst     (R1)+
                cmp     #MonstrsArrayEnd, R1
                bne     23$
                br      7SkipDraw$      ; массив заполнен, не поместилось
; ───────────────────────────────────────────────────────────────────────────

24$:            mov     #SprMonstrStepLt, (R1)
                mov     R0, -(R1)
                br      3DrawCell$      ; всё
; ───────────────────────────────────────────────────────────────────────────

26$:            cmpb    #11., R3        ; это Великан-инопланетянин?
                bne     30$             ; нет
                mov     #AliensArray, R1 ; помещаем его в массив Великанов-инопланетянов

27$:            tst     (R1)+
                beq     28$
                tst     (R1)+
                cmp     #AliensArrayEnd, R1
                bne     27$
                br      7SkipDraw$      ; массив заполнен, не поместилось
; ───────────────────────────────────────────────────────────────────────────

28$:            mov     (PC)+, (R1)
                .byte   1,0
                mov     R0, -(R1)
                br      3DrawCell$      ; всё
; ───────────────────────────────────────────────────────────────────────────

30$:            cmpb    #13., R3        ; это шар?
                bne     35$             ; нет
                mov     #BubblesArray, R1 ; помещаем его в массив шаров

31$:            tst     (R1)+
                beq     33$
                tst     (R1)+
                cmp     #BubblesArrayEnd, R1
                bne     31$
32$:            br      7SkipDraw$      ; массив заполнен, не поместилось
; ───────────────────────────────────────────────────────────────────────────

33$:            mov     #-200, (R1)
                mov     R0, -(R1)
                br     3DrawCell$       ; всё
; ───────────────────────────────────────────────────────────────────────────

35$:            cmpb    #15., R3        ; это Смерть?
                bne     3DrawCell$      ; нет
                mov     #DeathsArray, R1 ; помещаем её в массив смертей

36$:            tst     (R1)+
                beq     37$
                tst     (R1)+
                cmp     #CurManScrAddr, R1
                bne     36$
                br      7SkipDraw$      ; массив заполнен, не поместилось
; ───────────────────────────────────────────────────────────────────────────

37$:            mov     #SprDeathStpRt1, (R1)
                mov     R0, -(R1)
                ; всё

3DrawCell$:     ; вот наконец выводим на экран содержимое клетки
                cmpb    #7, R3          ; это лестница?
                bne     6$              ; нет
                ; да - лестницы рисуем по особому
                mov     #SprLadder, R1
                mov     #3, R2
4$:             call    OutSpriteSR     ; Вывод спрайта на экран с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                add     #1000, R0
                sob     R2, 4$
                sub     #3000, R0
                br      7SkipDraw$      ; переходим к следующей ячейке
; ───────────────────────────────────────────────────────────────────────────

6$:             tstb    R3              ; это пусто?
                beq     7SkipDraw$      ; да - нечего рисовать
                asl     R3              ; нет - рисуем всё остальное
                mov     LabItemSprTbl-2(R3), R1
                call    OutSpriteSR     ; Вывод спрайта на экран с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                cmp     #22., R3
                beq     40$             ; если это Великан-инопланетянин?
                cmp     #10., R3
                beq     40$             ; если это Глотка
                cmp     #12., R3
                bne     41$             ; или Чебуратор
40$:            sub     #1000, R0       ; то адрес экрана -1000
41$:
7SkipDraw$:     cmp     (R0)+, (R0)+    ; движемся вправо
                dec     R5              ; строка закончилась?
                beq     42$             ; да
                jmp     DL_LineLoop$    ; нет - продолжаем
; ───────────────────────────────────────────────────────────────────────────

42$:            add     #2710, R0       ; перейдём на новую строку
                cmp     R0, #66000      ; строки закончились?
                bhis    43$             ; да - конец
                jmp     DL_LabLoop$     ; нет

43$:            return                  ; да - массив отрисован
; End of function DrawLabyrint


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Анимация сокровищ

TreasuresAnim:  mov     #TreasureArray, R5

1$:             mov     (R5)+, R0
                bne     3$
                tst     (R5)+
2$:             cmp     #TreasureArrayEnd, R5
                bne     1$
                return
; ───────────────────────────────────────────────────────────────────────────

3$:             mov     (R5), R4
                cmp     #SprMouthOpen, R4
                beq     4$
                cmp     #SprChebura, R4
                beq     4$
6$:             sub     #TreasureSprSize, R4
                br      5$

4$:             add     #TreasureSprSize, R4 ; размер спрайта

5$:             ; стереть спрайт со старого места и вывести на новом
                mov     (R5), R1
                call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
                mov     R4, R1
                call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
                mov     R1, (R5)+
                br      2$
; End of function TreasuresAnim



; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Анимация Ящеров

MonstrsAnim:    mov     #MonstrsArray, R5

1$:             mov     (R5), R0        ; адрес экрана
                bne     3$

2$:             cmp     (R5)+, (R5)+
                cmp     #MonstrsArrayEnd, R5
                bne     1$
                return
; ───────────────────────────────────────────────────────────────────────────

3$:             mov     2(R5), R1       ; адрес спрайта
                cmp     #SprMonstrStepLt, R1 ; идёт влево?
                beq     4$              ; да - нужны доп.проверки
                cmp     #SprMonstrStayLt, R1 ; нет, стоит и смотрит влево?
                beq     7$              ; да - значит стираем сразу шаг влево
                cmp     #SprMonstrStepRt, R1 ; нет, идёт вправо?
                beq     11$             ; да - нужны доп.проверки
                br      13$             ; нет, значит стоит и смотрит вправо - 
                                        ; значит стираем сразу шаг вправо
; ───────────────────────────────────────────────────────────────────────────
                ; идёт влево, доп. проверки
4$:             tst     -(R0)           ; смотрим, что у нас слева
                cmp     SprBrickWallData+2, 3000(R0)
                beq     5$              ; под ногами стена
                cmp     SprLadderData+2, 3000(R0)
                beq     5$              ; или лестница
                br      0Reverse$       ; что-то другое, нужно развернуться
; ───────────────────────────────────────────────────────────────────────────
                ; смотрим, что слева
5$:             cmp     SprBrickWallData+2, (R0)
                beq     0Reverse$       ; слева стена, нужно развернуться
                cmp     SprDoorData+2, (R0)
                beq     0Reverse$       ; или лестница, нужно развернуться
                ; что-то другое, можно шагать
                tst     (R0)+           ; стираем спрайт со своего места
7$:             call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
                tst     -(R0)           ; шаг влево
                mov     R0, (R5)        ; вот новый адрес
                cmp     #SprMonstrStayLt, R1 ;получаем новый спрайт
                beq     8$              ; в зависимости от предыдущего
                mov     #SprMonstrStayLt, R1
                br      9$
; ───────────────────────────────────────────────────────────────────────────

8$:             mov     #SprMonstrStepLt, R1

9$:             mov     R1, 2(R5)       ; вот новый спрайт
                ; выводим на новом месте
                call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
                br      2$              ; и идём смотреть массив дальше
; ───────────────────────────────────────────────────────────────────────────
                ; идёт вправо
11$:            add     #6, R0          ; смотрим, что у нас справа
                cmp     SprBrickWallData, 3000(R0)
                beq     12$             ; под ногами стена
                cmp     SprLadderData, 3000(R0)
                beq     12$             ; или лестница
                ; что-то другое, нужно развернуться
0Reverse$:      mov     (R5), R0
                call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
                cmp     #SprMonstrStepRt, R1
                bne     17$
                mov     #SprMonstrStayLt, R1
                br      9$
; ───────────────────────────────────────────────────────────────────────────

17$:            mov     #SprMonstrStayRt, R1
                br      9$
; ───────────────────────────────────────────────────────────────────────────
                ; смотрим, что справа
12$:            cmp     SprBrickWallData, (R0)
                beq     0Reverse$       ; справа стена, нужно развернуться
                cmp     SprDoorData, (R0)
                beq     0Reverse$       ; или лестница, нужно развернуться
                ; что-то другое, можно шагать
                sub     #6, R0
13$:            call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
                tst     (R0)+           ; шаг вправо
                mov     R0, (R5)        ; вот новый адрес
                cmp     #SprMonstrStayRt, R1 ;получаем новый спрайт
                beq     14$             ; в зависимости от предыдущего
                mov     #SprMonstrStayRt, R1
                br      9$
; ───────────────────────────────────────────────────────────────────────────

14$:            mov     #SprMonstrStepRt, R1
                br      9$
; ───────────────────────────────────────────────────────────────────────────
; End of function MonstrsAnim


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Анимация шаров

BubblesAnim:    mov     #BubblesArray, R5
                mov     #SprBubble, R1  ; спрайт у нас не меняется

1$:             mov     (R5), R0        ; адрес экрана
                beq     2$

                mov     2(R5), R4       ; направление движения
                bpl     5$              ; движется вниз
                ; нет, движется вверх
                tst     -100(R0)        ; что в верхней клетке?
                bne     6$              ; не пусто - меняем направление
                tst     -74(R0)         ; а в верхней-левой?
                bne     6$              ; тоже не пусто, тоже меняем направление
                ; стираем со старого места
4$:             call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
                add     R4, R0          ; делаем новый адрес
                mov     R0, (R5)
                ; выводим на новом месте
                call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
2$:             cmp     (R5)+, (R5)+
                cmp     R5, #BubblesArrayEnd
                bne     1$
                return

; ───────────────────────────────────────────────────────────────────────────
                ; движется вниз, проверка, можно ли?
5$:             tst     3000(R0)        ; что внизу?
                bne     6$              ; не пусто - меняем направление движения
                tst     3004(R0)        ; а внизу справа?
                beq     4$              ; в клетках внизу и внизу-справа - пусто
                                        ; можно продолжать движение
6$:             neg     R4              ; меняем + на -
                mov     R4, 2(R5)       ; сохраним новое направление
                br      2$              ; и идём смотреть следующий элемент
; End of function BubblesAnim


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Анимация Летучих Мышей

FlyMousesAnim:  mov     #FlyMousesArray, R5 ; начало массива

1$:             mov     (R5), R0        ; берём адрес экрана
                bne     3$              ; элемент не пуст
                ; пуст
2$:             cmp     (R5)+, (R5)+    ; переходим к следующему
                cmp     R5, #FlyMousesArrayEnd
                bne     1$              ; пока массив не кончится
                return
; ───────────────────────────────────────────────────────────────────────────

3$:             tstb    2(R5)           ; смотрим анимацию
                bne     4$
                mov     #SprFlyMouse2, R2 ; будет крылья вверх
                mov     #SprFlyMouse, R1 ; сейчас крылья вниз
                br      5$
; ───────────────────────────────────────────────────────────────────────────

4$:             mov     #SprFlyMouse, R2 ; будет крылья вниз
                mov     #SprFlyMouse2, R1 ; сейчас крылья вверх

5$:             tstb    3(R5)           ; куда движемся?
                beq     9$              ; вправо
                ; влево
                ; что там слева?
                cmpb    SprBrickWallData+3, -1(R0)
                beq     10$             ; стена
                cmp     SprDoorData+2, -2(R0)
                beq     10$             ; дверь
                cmpb    SprLadderData+3, -1(R0)
                beq     10$             ; лестница
                ; нет препятствий
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                dec     R0              ; смещаемся влево

6$:             mov     R0, (R5)        ; сохраним новый адрес
                mov     R2, R1          ; рисуем новый спрайт
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                comb    2(R5)           ; меняем тип анимации 0 <-> 1
                br      2$              ; и идём смотреть следующий элемент
; ───────────────────────────────────────────────────────────────────────────
                ; что там справа?
9$:             cmp     SprBrickWallData, 4(R0)
                beq     10$             ; стена
                cmp     SprDoorData, 4(R0)
                beq     10$             ; дверь
                cmp     SprLadderData, 4(R0)
                beq     10$             ; лестница
                ; нет препятствий
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                inc     R0              ; смещаемся вправо
                br      6$
; ───────────────────────────────────────────────────────────────────────────
                ; встретили препятствие
10$:            comb    3(R5)           ; меняем направление движения
                br      2$              ; и идём смотреть следующий элемент
; End of function FlyMousesAnim


; ███████████████ S U B R O U T I N E ███████████████████████████████████████
; всё почти то же самое, что и для летучих мышей,
; но препятствие - только стена

; Анимация призраков

GhostsAnim:     mov     #GhostsArray, R5

1$:             mov     (R5), R0        ; берём адрес экрана
                bne     3$              ; элемент не пуст

2$:             cmp     (R5)+, (R5)+
                cmp     R5, #GhostsArrayEnd
                bne     1$
                return
; ───────────────────────────────────────────────────────────────────────────

3$:             tstb    2(R5)           ; какой тип анимации?
                bne     4$
                mov     #SprGhost2, R2
                mov     #SprGhost1, R1
                br      5$
; ───────────────────────────────────────────────────────────────────────────

4$:             mov     #SprGhost1, R2
                mov     #SprGhost2, R1

5$:             tstb    3(R5)           ; какое направление движения?
                beq     9$
                cmpb    SprBrickWallData+3, -1(R0)
                beq     10$
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                dec     R0

6$:             mov     R0, (R5)
                mov     R2, R1
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                comb    2(R5)
                br      2$
; ───────────────────────────────────────────────────────────────────────────

9$:             cmp     SprBrickWallData, 4(R0)
                beq     10$
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                inc     R0
                br      6$
; ───────────────────────────────────────────────────────────────────────────

10$:            comb    3(R5)
                br      5$
; End of function GhostsAnim


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Анимация Великана-инопланетяна
; Он глазами моргает

AlienAnim:      mov     #AliensArray, R5 ; начало массива

1$:             mov     (R5)+, R0       ; адрес экрана
                bne     3$              ; элемент не пуст

2$:             tst     (R5)+           ; переходим к следующему
                cmp     R5, #AliensArrayEnd ; пока массив не закончится
                bne     1$
                return
; ───────────────────────────────────────────────────────────────────────────

3$:             incb    (R5)            ; увеличиваем счётчик
                cmpb    #16, (R5)       ; там стало 16?
                beq     4$              ; да
                cmpb    #202, (R5)
                bne     2$

4$:             movb    #1, (R5)
                tstb    1(R5)
                bne     5$
                mov     302(R0), word_6010 ; тут мы сохраняем, содержимое экрана
                mov     502(R0), word_6012
                mov     #-1, 302(R0)    ; тут типо глаза прищурил
                mov     #-1, 502(R0)
                movb    #200, (R5)
                comb    1(R5)
                br      2$
; ───────────────────────────────────────────────────────────────────────────

5$:             mov     word_6010, 302(R0) ; тут восстанавливаем, типо глаза открыл
                mov     word_6012, 502(R0)
                clrb    1(R5)
                br      2$              ; но как? великанов потенциально 3, как можно сохранять
                                        ; для каждого из них в одних и тех же ячейках данные?
                ; допустим, там для всех трёх будут одни и те же данные, тогда это будет
                ; работать
; End of function AlienAnim

; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Анимация движения Смертей

DeathsAnim:     mov     #DeathsArray, R5 ; смотрим массив

1$:             mov     (R5)+, R0       ; берём текущий адрес экрана
                bne     3$              ; элемент не пуст

                tst     (R5)+           ; да - идём к следующему
2$:             cmp     R5, #DeathsArrayEnd ; массив кончился?
                bne     1$              ; нет ещё
                return                  ; да - выход
; ───────────────────────────────────────────────────────────────────────────

3$:             cmp     #SprDeathStpRt1, (R5) ; текущий спрайт такой?
                bne     4$              ; нет
                mov     #SprDeathStpRt2, R2 ; да - значит станет такой
                br      7$
; ───────────────────────────────────────────────────────────────────────────

4$:             cmp     #SprDeathStpRt2, (R5) ; текущий спрайт такой?
                bne     5$              ; нет
                mov     #SprDeathStpRt1, R2 ; да - значит станет такой
                br      7$
; ───────────────────────────────────────────────────────────────────────────

5$:             cmp     #SprDeathStpLt1, (R5) ; текущий спрайт такой?
                bne     6$              ; нет
                mov     #SprDeathStpLt2, R2 ; да - значит станет такой
                br      7$
; ───────────────────────────────────────────────────────────────────────────

6$:             mov     #SprDeathStpLt1, R2 ; нет - значит станет такой

7$:             cmp     #SprDeathStpRt1, (R5) ; движение вправо?
                beq     9$              ; да
                cmp     #SprDeathStpRt2, (R5)
                beq     9$              ; вправо
                ; движение влево
                cmpb    SprBrickWallData+3, -1(R0) ; впереди стена?
                beq     10$             ; да
                cmp     SprDoorData+2, -2(R0) ; или дверь?
                beq     10$             ; да
                ; помех нет
                mov     (R5), R1        ; старый спрайт стираем
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                dec     R0              ; адрес вывода - левее на байт

8$:             mov     R0, -2(R5)      ; сохраним новый адрес вывода
                mov     R2, R1          ; выводим на новом месте новый спрайт
22$:            call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     R1, (R5)+       ; новый спрайт сохраним
                br      2$              ; и продолжим осматривать массив
; ───────────────────────────────────────────────────────────────────────────
                ; движение вправо
9$:             cmp     SprBrickWallData, 4(R0) ; справа стена?
                beq     10$             ; да
                cmp     SprDoorData, 4(R0) ; или дверь
                beq     10$             ; да
                ; помех нет
                mov     (R5), R1        ; старый спрайт стираем
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                inc     R0              ; адрес вывода - правее на байт
                br      8$              ; идём выводить новый спрайт
; ───────────────────────────────────────────────────────────────────────────
                ; встретилась помеха
10$:            cmp     #SprDeathStpRt1, R2 ; был такой спрайт?
                bne     11$             ; нет
                mov     #SprDeathStpLt1, R3 ; да - будет такой, зеркальный
                br      14$
; ───────────────────────────────────────────────────────────────────────────

11$:            cmp     #SprDeathStpRt2, R2 ; был такой спрайт?
                bne     12$             ; нет
                mov     #SprDeathStpLt2, R3 ; да - будет такой, зеркальный
                br      14$
; ───────────────────────────────────────────────────────────────────────────

12$:            cmp     #SprDeathStpLt1, R2 ; был такой спрайт?
                bne     13$             ; нет
                mov     #SprDeathStpRt1, R3 ; да - будет такой, зеркальный
                br      14$
; ───────────────────────────────────────────────────────────────────────────

13$:            mov     #SprDeathStpRt2, R3 ; нет - будет такой, зеркальный

14$:            mov     (R5), R1        ; стираем старый спрайт
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     R3, R1          ; рисуем новый
                br      22$
; End of function DeathsAnim


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вход: R0 - адрес экрана
;       R1 - адрес элемента шириной слово, высотой 8 строк

DrawPrimitive1: mov     R1, -(SP)
                mov     R0, -(SP)
                mov     R2, -(SP)
                mov     #8., R2

1$:             mov     (R1)+, (R0)
                add     #100, R0
                sob     R2, 1$
                mov     (SP)+, R2
                mov     (SP)+, R0
                mov     (SP)+, R1
                return
; End of function DrawPrimitive1


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывести три элемента вертикально
; Вход: R0 - адрес экрана
;       R1 - адрес элемента шириной слово, высотой 8 строк

Draw3Primitve:  mov     #3, R5

1$:             call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                add     #1000, R0
                sob     R5, 1$
                return
; End of function Draw3Primitve


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Прорисовка панели с информацией

DrawPanel:      mov     #73002, R0
                mov     #36, R5
                mov     #word_14342, R1

1$:             call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                tst     (R0)+
                sob     R5, 1$
                mov     #word_14502, R1
                call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                mov     #3, R5
                mov     #word_14422, R1

2$:             add     #1000, R0
                call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                sob     R5, 2$
                add     #1000, R0
                mov     #word_14522, R1
                call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                mov     #36, R5
                mov     #word_14362, R1

3$:             tst     -(R0)
                call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                sob     R5, 3$
                tst     -(R0)
                mov     #word_14442, R1
                call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                mov     #3, R5
                mov     #word_14402, R1

4$:             sub     #1000, R0
                call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                sob     R5, 4$
                sub     #1000, R0
                mov     #word_14462, R1
                call    DrawPrimitive1  ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                add     #1016, R0
                mov     #word_14422, R1
                call    Draw3Primitve   ; Вывести три элемента вертикально
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                sub     #2772, R0
                call    Draw3Primitve   ; Вывести три элемента вертикально
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                sub     #2750, R0
                call    Draw3Primitve   ; Вывести три элемента вертикально
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                mov     #2, R4

5$:             sub     #2772, R0
                call    Draw3Primitve   ; Вывести три элемента вертикально
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес элемента шириной слово, высотой 8 строк
                sob     R4, 5$
                ; Выведем количество жизней
                mov     #74456, R0
                mov     Lives, R4

6$:             mov     #SprHeart, R1
                mov     R0, -(SP)
                mov     (R1)+, R3
                mov     (R1)+, R5

7$:             mov     R3, R2

8$:             movb    (R1)+, (R0)+
                sob     R2, 8$
                add     #100, R0
                sub     R3, R0
                sob     R5, 7$
                mov     (SP)+, R0
                add     #6, R0
                sob     R4, 6$
                ; Выведем номер лабиринта
                mov     #2, @#CharVertScale ; масштаб
                mov     #234, R0
                emt     16
                mov     #222, R0
                emt     16
                mov     #73720, @#AS
                movb    CurLabNumHi, R0
                call    sub_26304

                movb    CurLabNumLo, R0
                emt     16
                mov     #234, R0
                emt     16
                mov     #221, R0
                emt     16
                ; Выведем количество энергии
                mov     #74226, R0
                mov     HealthPower, R5

9$:             mov     R0, R2
                mov     #24, R1

10$:            clrb    (R2)
                comb    (R2)
                add     #100, R2
                sob     R1, 10$
                inc     R0
                sob     R5, 9$
                return
; End of function DrawPanel


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


sub_26304:      cmpb    #'0, R0
                beq     1$              ; если 0, то его не выводим
                mov     @#AS, -(SP)
                emt     16
                mov     (SP)+, @#AS

1$:             add     #2, @#AS
                return
; End of function sub_26304


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывод на экран счёта

DrawScore:      movb    #377, @#HighCharMode
                mov     #221, R0
                emt     16
                mov     #1, @#CharVertScale
                mov     #2, R1
                mov     #25, R2
                emt     24
                mov     Score, R4
                call    OutDecNum       ; Вывод десятичного числа.
                                        ; Вход: R4 - число
                clrb    @#HighCharMode
                return
; End of function DrawScore

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


InitParam:      mov     #Lives, R0
                mov     #3, (R0)+       ; Lives         устанавливаем число жизней
                mov     #26, (R0)+      ; HealthPower   максимальное количество энергии
                clr     (R0)+           ; Score         начальный счёт
                mov     (PC)+, (R0)+    ; CurLabNum     начальный номер лабиринта
                .byte '0, '1
                mov     #Labyrints, (R0)+ ; CurrentLab  задаём адрес текущего лабиринта в массиве
                clr     (R0)+           ; HaveKey       Флаг, что ключ подобран? 0 - нет. !0 - да
                clr     (R0)+           ; HealthDownCntr счётчик уменьшения здоровья на 1 пункт
                mov     #-1, @#PrevPressKey ; код предыдущей нажатой клавиши не должен совпадать
                                        ; с кодом текущей, да и вообще ни с чем
                return
; End of function InitParam


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


Animations:     call    BubblesAnim     ; Анимация шаров
                call    MonstrsAnim     ; Анимация Ящеров
                call    BubblesAnim     ; Анимация шаров
                call    TreasuresAnim   ; Анимация сокровищ
                call    DeathsAnim      ; Анимация движения Смертей
                call    BubblesAnim     ; Анимация шаров
                call    GhostsAnim      ; Анимация призраков
                call    FlyMousesAnim   ; Анимация Летучих Мышей
                call    AlienAnim       ; Анимация Великана-инопланетяна
                                        ; Он глазами моргает
                ; Игровая задержка
GameDelay:      mov     (PC)+, R0
GameSpeed:      .word 0
                sob     R0, .
                return
; End of function Animations


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вычислить игровую задержку в зависимости от
; наличия живности на экране

MakeDelay:      mov     #LabyrBuffer, R1
                mov     #40600, R5      ; базовая задержка

1$:             cmpb    #5, (R1)        ; если сокровище
                beq     2$
                cmpb    #6, (R1)        ; или такое сокровище
                bne     4$
2$:             sub     #164, R5        ; то уменьшаем задержку настолько
                br      9$
; ───────────────────────────────────────────────────────────────────────────

4$:             cmpb    #8., (R1)       ; если летучая мышь
                beq     5$
6$:             cmpb    #9., (R1)       ; или призрак
                beq     5$
                cmpb    #10., (R1)      ; если Ящер-динозавр
                bne     7$
                sub     #1200, R5       ; то уменьшим задержку на столько
                br      9$
; ───────────────────────────────────────────────────────────────────────────

7$:             cmpb    #13., (R1)      ; если шар
                bne     8$
                sub     #2700, R5       ; то уменьшим задержку на столько
                br      9$
; ───────────────────────────────────────────────────────────────────────────

8$:             cmpb    #15., (R1)      ; если смерть
                bne     9$
5$:             sub     #1560, R5       ; то вот настолько

9$:             inc     R1
                cmp     #LabyrBufferEnd, R1 ; буфер закончился?
                bne     1$              ; нет ещё
                mov     R5, GameSpeed
                ;br      CalcManPos      ; Вычислить положение ГГ в массиве лабиринта
; End of function MakeDelay


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вычислить положение ГГ в массиве лабиринта

CalcManPos:     mov     #LabyrBuffer, R1

1$:             cmpb    #1, (R1)+       ; берём только первый найденный элемент.
                beq     2$              ; поэтому, чтобы не усложнять делаем 2 цикла
                cmp     #LabyrBufferEnd, R1
                bne     1$
                mov     #LabyrBuffer, R1

2$:             dec     R1
                mov     R1, GGPosition  ; Позиция ГГ в массиве распакованного лабиринта
                return
; End of function CalcManPos


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Убираем дверь с экрана

DoorUnlocked:   mov     R1, -(SP)
                mov     #SprDoor, R1
                call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
                mov     (SP)+, R1
                return
; End of function DoorUnlocked


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Убираем дверь с карты

RemoveDoor:     clr     HaveKey         ; очищаем флаг ключа
                clrb    (R5)            ; убираем дверь с карты
                return
; End of function RemoveDoor


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Увеличиваем счёт
; Уменьшаем игровую задержку

CatchTreasure2: add     #25., @#Score
                br      NextCatchTreas$
; End of function CatchTreasure2

; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Увеличиваем счёт
; Уменьшаем игровую задержку

CatchTreasure1: add     #20., @#Score
NextCatchTreas$:sub     #-400, @#GameSpeed
                return
; End of function CatchTreasure1


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


GoRigth$:       tst     UpStepCnt       ; если в процессе движения вверх
                bne     5$              ; то не можем идти вправо
                tst     DownStepCnt     ; если в процессе движения вниз
                bne     5$              ; то не можем идти вправо
                mov     LeftStepCnt, R1 ; счётчик шагов при движении влево, для перехода на следующую клетку лабиринта
                beq     11$
                mov     R1, RightStepCnt ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
11$:            mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
                mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                cmp     #SprManStayRt, R1 ; если и так анимация шагания вправо
                beq     12$             ; то ОК - смотрим дальше
                cmp     #SprManStepRt, R1
                beq     12$
                cmp     #SprManStepRt2, R1
                beq     12$
                ; иначе, стираем текущий спрайт с экрана
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                ; и задаём начальный спрайт анимации шагания вправо
                mov     #SprManStayRt, R1
                mov     R1, CurSprManAnim ; адрес текущего спрайта в анимации ГГ
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
12$:            mov     R0, R2          ; текущий адрес экрана ГГ
                bic     #177770, R2
                beq     7$
                cmp     #4, R2
                bne     8$

7$:             mov     GGPosition, R5  ; Позиция ГГ в массиве распакованного лабиринта
                inc     R5
                cmpb    SprBrickWallData, 4(R0) ; если там стена
                beq     StopMan         ; Остановить ГГ
                cmpb    #3, (R5)        ; там дверь?
                bne     8$              ; нет
                tst     HaveKey         ; да, а ключ есть?
                beq     StopMan         ; нет - Остановить ГГ
                cmp     (R0)+, (R0)+
                call    DoorUnlocked    ; Убираем дверь с экрана
                jsr     R4, @#110346
                mov     #123, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                jsr     R4, @#110362
                cmp     -(R0), -(R0)
                call    RemoveDoor      ; Убираем дверь с карты

8$:             mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                mov     R1, R2
                cmp     #SprManStepRt2, R2
                bne     2$
                mov     #SprManStayRt, R2
                br      3$
; ───────────────────────────────────────────────────────────────────────────

2$:             add     #SprManSize, R2 ; размер спрайта

3$:             call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                inc     R0
                mov     R2, R1
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     R1, CurSprManAnim ; адрес текущего спрайта в анимации ГГ
                mov     R0, CurManScrAddr ; текущий адрес экрана ГГ
                inc     RightStepCnt  ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
                cmp     #4, RightStepCnt ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
                bne     4$
                clr     RightStepCnt  ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
                inc     GGPosition    ; Позиция ГГ в массиве распакованного лабиринта
4$:             clr     LeftStepCnt   ; счётчик шагов при движении влево, для перехода на следующую клетку лабиринта
5$:             return
; End of function GoRigth$

; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; остановиться

MakeStay:       mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
; End of function MakeStay


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Остановить ГГ

StopMan:        mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                cmp     #SprManStayRt, R1 ; уже и так стоит?
                beq     4$              ; Ок - ничего не надо делать
                cmp     #SprManStayLt, R1 ; уже и так стоит?
                beq     4$              ; Ок - ничего не надо делать
                cmp     #SprManStepLt, R1 ; шагает влево?
                beq     1$
3$:             cmp     #SprManStepLt2, R1  ; а может так шагает влево
                beq     1$              ; да - точно шагает влево
                mov     #SprManStayRt, R2 ; нет - точно шагает вправо, значит будет стоять вправо
                br      2$
                ; да, шагает влево
1$:             mov     #SprManStayLt, R2 ; значит будет стоять влево

2$:             call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     R2, R1
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     R1, CurSprManAnim ; адрес текущего спрайта в анимации ГГ
4$:             return
; End of function StopMan


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


GoLeft$:        tst     UpStepCnt       ; если в процессе движения вверх
                bne     5$              ; то не можем идти влево
                tst     DownStepCnt     ; если в процессе движения вниз
                bne     5$              ; то не можем идти влево
                mov     RightStepCnt, R1 ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
                beq     11$
                mov     R1, LeftStepCnt ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
11$:            mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
                mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                cmp     #SprManStayLt, R1 ; если и так анимация шагания влево
                beq     12$             ; то ОК - смотрим дальше
                cmp     #SprManStepLt, R1
                beq     12$
                cmp     #SprManStepLt2, R1
                beq     12$
                ; иначе, стираем текущий спрайт с экрана
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                ; и задаём начальный спрайт анимации шагания вправо
                mov     #SprManStayLt, R1
                mov     R1, CurSprManAnim ; адрес текущего спрайта в анимации ГГ
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
12$:            mov     R0, R2          ; текущий адрес экрана ГГ
                bic     #177770, R2
                beq     7$
                cmp     #4, R2
                bne     8$

7$:             mov     GGPosition, R5 ; Позиция ГГ в массиве распакованного лабиринта
                dec     R5
                cmpb    SprBrickWallData+3, -1(R0) ; если там стена
                beq     StopMan         ; Остановить ГГ
                cmpb    #3, (R5)        ; там дверь?
                bne     8$              ; нет
                tst     HaveKey         ; да, а ключ есть?
                beq     StopMan         ; нет - Остановить ГГ
                cmp     -(R0), -(R0)
                call    DoorUnlocked    ; Убираем дверь с экрана
                jsr     R4, @#110346
                mov     #113, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                jsr     R4, @#110362
                cmp     (R0)+, (R0)+
                call    RemoveDoor      ; Убираем дверь с карты

8$:             mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                mov     R1, R2
                cmp     #SprManStepLt2, R2
                bne     2$
                mov     #SprManStayLt, R2
                br      3$
; ───────────────────────────────────────────────────────────────────────────

2$:             add     #SprManSize, R2

3$:             call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                dec     R0
                mov     R2, R1
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     R1, CurSprManAnim ; адрес текущего спрайта в анимации ГГ
                mov     R0, CurManScrAddr ; текущий адрес экрана ГГ
                dec     LeftStepCnt     ; счётчик шагов при движении влево, для перехода на следующую клетку лабиринта
                cmp     #-1, LeftStepCnt ; счётчик шагов при движении влево, для перехода на следующую клетку лабиринта
                bne     4$
                dec     GGPosition      ; Позиция ГГ в массиве распакованного лабиринта
                mov     #3, LeftStepCnt ; счётчик шагов при движении влево, для перехода на следующую клетку лабиринта

4$:             clr     RightStepCnt  ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
5$:             return
; End of function GoLeft$



; ███████████████ S U B R O U T I N E ███████████████████████████████████████


GoUp$:          tst     RightStepCnt    ; если в процессе движения вправо
                bne     6$              ; то не можем двигаться вверх
                tst     LeftStepCnt     ; если в процессе движения влево
                bne     6$              ; то не можем двигаться вверх
                mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
                mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                mov     GGPosition, R5  ; Позиция ГГ в массиве распакованного лабиринта
                call    CheckLadder     ; Проверка, есть ли лестница, чтобы двигаться вверх или вниз
                                        ; Выход: Z = 1 - да, Z = 0 - нет
                bne     6$              ; если лестницы нет, то не можем
                cmp     SprBrickWallData, -3000(R0)
                beq     6$              ; если сверху стена, то не можем
                cmp     SprDoorData+34, -200(R0)
                beq     6$              ; если сверху дверь, то не можем
                cmp     #SprManStepLt2, R1 ; анимация перебирания ногами
                bne     3$
                mov     #SprManStayLt, R2
                br      5$
; ───────────────────────────────────────────────────────────────────────────

3$:             cmp     #SprManStepRt2, R1 ; анимация перебирания ногами
                bne     4$
                mov     #SprManStayRt, R2
                br      5$
; ───────────────────────────────────────────────────────────────────────────

4$:             mov     R1, R2
                add     #SprManSize, R2
                ; стираем спрайт со старого места
5$:             call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                sub     #400, R0        ; поднимаемся вверх
                mov     R2, R1          ; рисуем спрайт на новом месте
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     R0, CurManScrAddr ; текущий адрес экрана ГГ
                mov     R1, CurSprManAnim ; адрес текущего спрайта в анимации ГГ
                dec     UpStepCnt       ; счётчик шагов при движении вверх, для перехода на следующую клетку лабиринта
                cmp     #-1, UpStepCnt  ; счётчик шагов при движении вверх, для перехода на следующую клетку лабиринта
                bne     6$
                sub     #16, GGPosition ; Позиция ГГ в массиве распакованного лабиринта
                mov     #5, UpStepCnt   ; счётчик шагов при движении вверх, для перехода на следующую клетку лабиринта

6$:             return
; End of function GoUp$


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


GoDown$:        tst     RightStepCnt    ; если в процессе движения вправо
                bne     6$              ; то не можем двигаться вниз
                tst     LeftStepCnt     ; если в процессе движения влево
                bne     6$              ; то не можем двигаться вниз
                mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
                mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                mov     GGPosition, R5  ; Позиция ГГ в массиве распакованного лабиринта
                call    CheckLadderDn   ; внизу лестница?
                bne     6$              ; нет
                cmp     SprBrickWallData, 3000(R0)
                beq     6$
                cmp     SprDoorData, 3000(R0)
                beq     6$
                cmp     #SprManStepLt2, R1
                bne     3$
                mov     #SprManStayLt, R2
                br      5$
; ───────────────────────────────────────────────────────────────────────────

3$:             cmp     #SprManStepRt2, R1
                bne     4$
                mov     #SprManStayRt, R2
                br      5$
; ───────────────────────────────────────────────────────────────────────────

4$:             mov     R1, R2
                add     #SprManSize, R2

5$:             call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                add     #400, R0
                mov     R2, R1
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     R0, CurManScrAddr ; текущий адрес экрана ГГ
                mov     R1, CurSprManAnim ; адрес текущего спрайта в анимации ГГ
                inc     UpStepCnt       ; счётчик шагов при движении вверх, для перехода на следующую клетку лабиринта
                cmp     #6, UpStepCnt   ; счётчик шагов при движении вверх, для перехода на следующую клетку лабиринта
                bne     6$
                add     #16, GGPosition ; Позиция ГГ в массиве распакованного лабиринта
                clr     UpStepCnt       ; счётчик шагов при движении вверх, для перехода на следующую клетку лабиринта

6$:             return
; End of function GoDown$


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Проверка, есть ли лестница, чтобы двигаться вверх или вниз
; Выход: Z = 1 - да, Z = 0 - нет

CheckLadder:    tst     UpStepCnt       ; счётчик шагов при движении вверх, для перехода на следующую клетку лабиринта
                bne     CheckLadderDn
                cmpb    #7, (R5)        ; там лестница?
                return
; ───────────────────────────────────────────────────────────────────────────

CheckLadderDn:  cmpb    #7, 16(R5)      ; там лестница?
                return
; End of function CheckLadder


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


CheckFinish:    cmp     CurrentLab, #<Labyrints+4574> ; прошли последний лабиринт?
                bhi     3$              ; да - ОК
                return                  ; нет - выходим
; ───────────────────────────────────────────────────────────────────────────

3$:             mov     #740, SP        ; инициализируем стек, обратно из п/п уже не выходим
                mov     #100000, R5     ; очищаем экран скроллом вниз
                mov     #177664, R3
                mov     (R3), -(SP)

1$:             mov     #40, R0

2$:             clr     -(R5)
                sob     R0, 2$
                dec     (R3)
                mov     #1200, R0

                sob     R0, .
                cmp     R5, #40000
                bhi     1$
                mov     (SP)+, (R3)
                call    DrawFinalPic
                mov     #5, @#CharVertScale
                mov     #strYouWin, R1
                comb    @#WideCharMode

4$:             movb    (R1)+, R0
                beq     5$
                incb    R0
                incb    R0
                emt     16
                br      4$              ; выведем финальное сообщение
; ───────────────────────────────────────────────────────────────────────────

5$:             mov     #3, @#CharVertScale
                mov     #strCode, R1

6$:             movb    (R1)+, R0
                beq     7$
                dec     R0
                emt     16
                br      6$              ; выведем секретный код
; ───────────────────────────────────────────────────────────────────────────

7$:             clrb    @#WideCharMode
                call    Beep2           ; Звучок
                                        ; Без параметров, фиксированный
                mov     #170, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                mov     #160, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                emt     6
                jmp     TrapTo4
; End of function CheckFinish


ClrScrMenu:     mov     #60000, R1      ; почистим экран
5$:             clr     (R1)+
                cmp     #100000, R1
                bne     5$
                return


EntryPoint$:    emt     14
                mov     #232, R0
                emt     16
                mov     #233, R0
                emt     16

TrapTo4:        mov     #1330, @#177664
                mov     #TrapTo4, @#4
                mov     #740, SP
                mtps    #200
                clr     @#WideCharMode
                call    Init            ; Инициализация вектора, вывод названия игры,
                                        ; Меню, обработка меню, выбор заданного пункта

MenuLoop$:      call    MainMenu
                mov     CurMenuItemAddr, R0 ; что выбрали?
                cmp     #62226, R0      ; первый пункт?
                bne     3$              ; нет
                jmp     GameBegin       ; да - начнём игру
; ───────────────────────────────────────────────────────────────────────────
                ; делаем, чтобы точка входа совпадала с оригиналом
                br     EntryPoint$

3$:             cmp     #71626, R0      ; 4-й пункт?
                bne     4$              ; нет
                jmp     GoEditor
; ───────────────────────────────────────────────────────────────────────────

4$:             call    ClrScrMenu
; Выведем меню задания управления
                mov     #13, R1
                mov     #14, R2
                emt     24
                mov     #strMenuCtrl, R3
                cmp     #67226, R0      ; выбрали джойстик?
                bne     SetKeyboard
                ;br      SetJoystick
                
; ███████████████ S U B R O U T I N E ███████████████████████████████████████


SetJoystick:    comb    @#WideCharMode
                clrb    @#CharVertScale


                mov     #JoyCodeTbl, R5
                mov     #223, R0
                emt     16
                mov     #4, @#MenuItemsCount ; счётчик пунктов меню

1$:             emt     26
                jsr     R4, @#110346
                mov     R3, R1
                emt     0
                mov     R1, CurCtrlMenuItem
                call    GetJoystickCode
                mov     CurJoyItemMask, (R5)+
                jsr     R4, @#110346
                mov     #237, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                jsr     R4, @#110362
                jsr     R4, @#110362
                mov     CurCtrlMenuItem, R3
                tst     (R2)+
                inc     R2
                emt     24
                dec     @#MenuItemsCount
                bne     1$
                comb    @#WideCharMode
                br      0Next3$
; End of function SetJoystick

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


SetKeyboard:    comb    @#WideCharMode
                clrb    @#CharVertScale

                mov     #KbdKeyCode, R5
                mov     #223, R0
                emt     16
                mov     #4, @#MenuItemsCount       ; Счётчик пунктов меню

1$:             emt     26
                jsr     R4, @#110346
                mov     R3, R1
                emt     0
                mov     R1, CurCtrlMenuItem
                call    Emt6Sub
                mov     R0, (R5)+
                jsr     R4, @#110362
                mov     CurCtrlMenuItem, R3
                tst     (R2)+
                inc     R2
                emt     24
                dec     @#MenuItemsCount
                bne     1$
                comb    @#WideCharMode

0Next3$:        call    ClrScrMenu
                br      MenuLoop$
; End of function SetKeyboard


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Движение ГГ

MoveMan:        mov     R0, @#CurPressKey ; Код нажатой клавиши сохраним
                call    sub_20720       ; Проверка, можно ли ГГ двигаться.
                                        ; Выход: Z = 1 - можно, иначе - нельзя
                bne     1$
                mov     @#CurPressKey, R0 ; возвращаем код нажатой клавиши
                call    sub_22366       ; пробуем двигаться
                cmp     CurManScrAddr, @#TempCurManScrAdr ; смогли сдвинуться?
                bne     2$              ; да
                mov     @#PrevPressKey, R0 ; нет - берём код предыдущей нажатой клавиши
                br      sub_22366       ; и снова пробуем двигаться
; ───────────────────────────────────────────────────────────────────────────

2$:             mov     @#CurPressKey, @#PrevPressKey ; код нажатой клавиши в код предыдущей нажатой
1$:             return
; End of function MoveMan


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


sub_22366:      cmp     R0, #31
                bne     1$
                mov     #GoRigth$, R5
                br      4$
; ───────────────────────────────────────────────────────────────────────────

1$:             cmp     R0, #10
                bne     2$
                mov     #GoLeft$, R5
                br      4$
; ───────────────────────────────────────────────────────────────────────────

2$:             cmp     R0, #32
                bne     3$
                mov     #GoUp$, R5
                br      4$
; ───────────────────────────────────────────────────────────────────────────

3$:             cmp     R0, #33
                bne     5$
                mov     #GoDown$, R5

4$:             mov     CurManScrAddr, @#TempCurManScrAdr ; текущий адрес экрана ГГ
                call    (R5)
5$:             return
; End of function sub_22366


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Проверка, можно ли ГГ двигаться.
; Выход: Z = 1 - можно, иначе - нельзя

sub_20720:      mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
                cmp     R0, #65000
                bhi     1$
                mov     GGPosition, R5  ; Позиция ГГ в массиве распакованного лабиринта
                movb    16(R5), R5      ; что в ячейке под ГГ?
                mov     #RightStepCnt, R2 ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
                tst     (R2)+           ; ГГ между клетками?
                bne     1$              ; да
                tst     (R2)+           ; точно?
                bne     1$              ; да
                tst     (R2)            ; и даже куда-то вверх лезет?
                bne     1$              ; да
                cmpb    #2, R5          ; под ногами стена?
                beq     1$              ; да, можно двигаться
                cmpb    #3, R5          ; под ногами дверь?
                beq     1$              ; да, можно двигаться
                cmpb    #7, R5          ; под ногами лестница?
                beq     1$              ; да, можно двигаться
                ; в общем, там что-то другое, на чём ГГ стоять не может
                mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                ; стираем спрайт с текущего места
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                add     #1000, R0       ; ГГ падает
                mov     R0, CurManScrAddr ; текущий адрес экрана ГГ
                mov     R0, R3
                bic     #777, R3
                mov     #46000, R4
                ; чё то непонятое, но по логике - определение, насколько вниз упал
3$:             cmp     R3, R4
                beq     4$
                add     #3000, R4
                cmp     #70000, R4
                bne     3$
                br      5$              ; вообще в самый низ упал, дальше некуда
; ───────────────────────────────────────────────────────────────────────────
                ; ГГ упал вниз на клетку
4$:             add     #16, GGPosition ; Позиция ГГ в массиве распакованного лабиринта

5$:             cmp     #SprManStepLt, R1 ; шёл влево?
                beq     6$              ; да
                cmp     #SprManStepLt2, R1 ; точно?
                beq     6$              ; да
                cmp     #SprManStayLt, R1 ; уже стоял влево?
                beq     8$              ; да
                br      7$              ; нет - шёл или стоял вправо
; ───────────────────────────────────────────────────────────────────────────

6$:             mov     #SprManStayLt, R1 ; значит будет стоять влево
                br      8$
; ───────────────────────────────────────────────────────────────────────────

7$:             mov     #SprManStayRt, R1 ; значит будет стоять вправо

8$:             mov     R1, CurSprManAnim ; сохраняем
                ; и выводим на новом месте
                call    XorSpriteSR     ; Вывод спрайта на экран xorом с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                tst     (PC)+           ; двигаться нельзя
1$:             sez                     ; можно продолжать двигаться
                return
; End of function sub_20720


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Проверка на взаимодействие ГГ с интерактивными предметами

CheckInteract:  mov     #RightStepCnt, R3 ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
                tst     (R3)+           ; в процессе движения вправо?
                bne     1$              ; да - выходим
                tst     (R3)+           ; в процессе движения влево?
                bne     1$              ; да - выходим
                tst     (R3)            ; в процессе движения вверх?
                bne     1$              ; да - выходим
                ; находимся в клетке
2$:             mov     GGPosition, R5 ; Позиция ГГ в массиве распакованного лабиринта
                mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
                mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                cmpb    #4, (R5)        ; ГГ наткнулся на цветок?
                bne     4$              ; нет
                ; ГГ наткнулся на цветок
                inc     HealthDownCntr  ; счётчик уменьшения здоровья на 1 пункт
                mov     #SprFlower, R1
                jsr     R4, @#110346    ; звук, что сожрал цветок

3$:             mov     #70, R1
                mov     #20, R0
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                jsr     R4, @#110362

11$:            clrb    (R5)            ; цветок/ключ убираем из карты
                                        ; и с экрана
                call    XorSpriteEvn    ; Вывод стирание спрайта Xorом.
                                        ; Для корректности работы адрес экрана ДОЛЖЕН быть чётным
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта
1$:             return
; ───────────────────────────────────────────────────────────────────────────

4$:             cmpb    #14., (R5)      ; ГГ наткнулся на ключ?
                bne     5$              ; нет
                ; ГГ наткнулся на ключ
                tst     HaveKey         ; ключ уже был подобран?
                bne     1$              ; да, выходим
                inc     HaveKey         ; Флаг, что ключ подобран? 0 - нет. !0 - да
                mov     #SprKey, R1
                jsr     R4, @#110346    ; звук, что сожрал ключ
                mov     #50, R1
                mov     #40, R0
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                mov     #100, R1
                mov     #20, R0
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                br      3$
; ───────────────────────────────────────────────────────────────────────────

5$:             cmpb    #5, (R5)        ; ГГ наткнулся на сокровище Глотка?
                bne     7$              ; нет
                jsr     R4, @#110346    ; звук, что сожрал сокровище
                mov     #70, R1
                mov     #60, R0
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                mov     #20, R1
                mov     #100, R0
                call    CatchTreasure1  ; Увеличиваем счёт
                                        ; Уменьшаем игровую задержку

                br      6$
; ───────────────────────────────────────────────────────────────────────────

7$:             cmpb    #6, (R5)        ; ГГ наткнулся на сокровище Чебуратор?
                bne     1$              ; нет - выходим
                jsr     R4, @#110346
                call    CatchTreasure2

                mov     #140, R1
                mov     #10, R0
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                mov     #100, R1
                mov     #60, R0
6$:             call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                jsr     R4, @#110362

8$:             add     #1000, R0       ; к текущему адресу экрана ГГ прибавляем 1000
                mov     #TreasureArray, R2 ; ищем в массиве адрес

9$:             cmp     R0, (R2)+
                beq     10$
                tst     (R2)+           ; без проверок, предполагается, что он там есть обязательно
                cmp     #TreasureArrayEnd, R2
                bne     9$
                br      1$
; ───────────────────────────────────────────────────────────────────────────

10$:            mov     (R2), R1        ; адрес спрайта анимации сокровища
                clrb    (R5)            ; удаляем его с карты
                clr     -2(R2)          ; очищаем элемент массива
                clr     (R2)

                mov     #LabyrBuffer, R3 ; смотрим в лабиринте

14$:            cmpb    #5, (R3)        ; остались ли ещё сокровища?
                beq     11$             ; да
                cmpb    #6, (R3)+
                beq     11$             ; да, остались
                cmp     R3, #LabyrBufferEnd
                bne     14$
                mov     #740, SP        ; всё собрали
                ;jmp     GoNextLabyr
; End of function CheckInteract

GoNextLabyr:    add     #49., CurrentLab ; переходим к следующему лабиринту
                call    CheckFinish
 
                cmpb    #'9, CurLabNumLo ; теперь увеличим номер лабиринта
                bne     1$
                movb    #'0, CurLabNumLo
                incb    CurLabNumHi
                br      2$
; ───────────────────────────────────────────────────────────────────────────

1$:             incb    CurLabNumLo

2$:             clr     HaveKey         ; Флаг, что ключ подобран? 0 - нет. !0 - да
                mov     #3, @#HealthDownCntr ; счётчик уменьшения здоровья на 1 пункт
                add     #50., @#Score   ; очки за переход на следующий уровень
                mov     #740, SP
                mov     #130, R5

3$:             mov     R5, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                add     #10, R5
                cmp     R5, #220
                bne     3$

ClrScr_ScrlUp:  mov     #330, R5
                mov     #177664, R3     ; очистим экран скроллом вверх
                mov     (R3), -(SP)
                mov     #40000, R1

1$:             mov     #40, R0

2$:             clr     (R1)+
                sob     R0, 2$
                inc     (R3)
                mov     #450, R0
                sob     R0, .
                sob     R5, 1$
                mov     (SP)+, (R3)
                clr     CurJoyAction    ; Переназначенный из маски код управления от джойстика
                jmp     GameLoopLab

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


CheckHealth:    cmp     #26, HealthPower ; Здоровье на максимуме?
                bne     13$             ; нет
                ; да
                tst     HealthDownCntr  ; уменьшать здоровье надо?
                beq     13$             ; пора, идём
                cmp     HealthDownCntr, #1000 ; счётчик уменьшения здоровья на 1 пункт
                bhi     13$             ; если слишком много - то тоже идём
                add     #15., Score     ; Добавим очков
; Управление полоской здоровья
13$:            tst     UpStepCnt       ; в процессе движения вверх?
                bne     5$              ; да
                mov     #RightStepCnt, R1 ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
                mov     GGPosition, R5  ; Позиция ГГ в массиве распакованного лабиринта
                cmpb    #7, (R5)        ; мы на лестнице?
                beq     5$              ; да
                tst     (R1)+           ; нет, в процессе движения вправо?
                bne     1$              ; да
                tst     (R1)            ; нет, в процессе движения влево?
                beq     2$              ; нет
; ───────────────────────────────────────────────────────────────────────────
; когда мы стоим слева от лестницы - иммунитета нету
; а когда стоим справа - есть.
; а по алгоритму - должно быть наоборот.
; и восстановление здоровья, пока стоим на лестнице не работает.
; вообще, чё хотел автор понять сложно.
; HealthDownCntr - тут по сути флаг, 0 - ничего не надо делать, <0 - уменьшаем здоровье
; я считаю игру непроходимой в принципе, из-за того, что нельзя со временем восстановить
; здоровье стоя на лестнице. Цветков не хватает, а монстры двигаются быстрее, от них не убежать

1$:             cmpb    #7, 1(R5)       ; справа лестница?
                beq     5$              ; да
                                        ; нет
2$:             mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
                mov     CurSprManAnim, R1 ; адрес текущего спрайта в анимации ГГ
                cmp     (R1)+, (R1)+    ; адрес текущего спрайта +4
                cmpb    (R0), (R1)      ; чё-то непонятное
                bne     3$              ; но оно ведёт к уменьшению счётчика
4$:             cmpb    503(R0), 27(R1) ; когда будет пора уменьшать здоровье
                beq     5$
3$:             dec     HealthDownCntr  ; уменьшаем счётчик
5$:             tst     HealthDownCntr  ; здоровье уменьшать пора?
                beq     6$              ; нет, выходим
                ble     8$              ; если < 0, то пора уменьшать здоровье
                dec     HealthDownCntr  ; счётчик уменьшения здоровья на 1 пункт
                cmp     HealthPower, #26 ; не даём стать больше максимума
                bhis    9$
                inc     HealthPower     ; повышаем здоровье
                br      9$
; ───────────────────────────────────────────────────────────────────────────
                ; уменьшаем здоровье
8$:             tst     HealthPower     ; ### меняем dec на tst и всё, игра обессмерчена
                ;dec     HealthPower     ; ### меняем dec на tst и всё, игра обессмерчена
                inc     HealthDownCntr  ; счётчик уменьшения здоровья на 1 пункт
                ; рисуем полоску здоровья
9$:             mov     #74225, R5
                mov     HealthPower, R1
                beq     PlayerDeath1
                mov     #24, R2

10$:            inc     R5
                sob     R1, 10$
                mov     R5, R3

11$:            movb    #377, (R5)
                add     #100, R5
                sob     R2, 11$
                cmp     HealthPower, #26
                beq     6$
                inc     R3
                mov     #24, R2

12$:            clrb    (R3)
                add     #100, R3
                sob     R2, 12$
                mov     #25, R1
                mov     #45, R0
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                tst     HealthPower     ; проверим, здоровье не иссякло?
                beq     PlayerDeath1    ; да - умер
                                        ; нет, можно продолжать
6$:             return

PlayerDeath1:   mov     #74050, R0
                mov     Lives, R3
1$:             add     #6, R0
                sob     R3, 1$
                mov     #SprCross, R1
                call    OutSpriteSR     ; Вывод спрайта на экран с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                dec     Lives
                beq     2$
                mov     #26, HealthPower
                mov     CurManScrAddr, R0 ; текущий адрес экрана ГГ
                call    OutSpriteSR     ; Вывод спрайта на экран с сохранением регистров
                                        ; Вход: R0 - адрес экрана
                                        ;       R1 - адрес спрайта, первые 2 слова которого
                                        ; ширина в байтах и высота в строках
                mov     #40, R0
                mov     #150, R1
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                mov     #11, R0
                mov     #130, R1
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                mov     #30, R0
                mov     #167, R1
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                clr     R0
                sob     R0, .
                jmp     ClrScr_ScrlUp
2$:             ;jmp     GameOver
; End of function CheckHealth

GameOver:       mov     #7, R1
                mov     #6, R2
                emt     24
                mov     #2, @#CharVertScale
                mov     #51010, R0
                mov     #60, R2

1$:             mov     #30, R1

2$:             clr     (R0)+
                sob     R1, 2$
                add     #20, R0
                sob     R2, 1$
                mov     #strGameOver, R1
                emt     0
                mov     #2, R5
                mov     R5, -(SP)

4$:             mov     #170, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                mov     #270, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                mov     #40, R0
                mov     #204, R1
                call    Beep            ; Звучок
                                        ; Вход: R1 - длительность звука
                                        ;       R0 - начальный тон
                sob     R5, 4$
                mov     #30000, R0
                sob     R0, .
                mov     (SP)+, R5

5$:             mov     #20000, R0
                sob     R0, .
                mov     #230, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                sob     R5, 5$

6$:             bit     #100, @#177716
                beq     7$
                tst     @#177714
                beq     6$

7$:             jmp     TrapTo4
; ───────────────────────────────────────────────────────────────────────────

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


GameBegin:      call    InitParam

GameLoopLab:    mov     CurrentLab, R5  ; адрес текущего лабиринта в массиве
                mov     #40000, R0
                mov     #15400, R1

1$:             clr     (R0)+
                sob     R1, 1$
                call    PrepareLabyr    ; Распаковка лабиринта в буфер и отрисовка
                                        ; Вход: R5 - адрес текущего лабиринта
                call    DrawLabBorder   ; Прорисовка границ лабиринта
                call    DrawPanel       ; Прорисовка панели с информацией
                call    MakeDelay       ; Вычислить игровую задержку в зависимости от
                                        ; наличия живности на экране
                mov     #RightStepCnt, R1 ; счётчик шагов при движении вправо, для перехода на следующую клетку лабиринта
                clr     (R1)+
                clr     (R1)+
                clr     (R1)+
                clr     (R1)+

2$:             call    Animations
                call    DeathsAnim      ; Анимация движения Смертей
                call    CheckInteract   ; Проверка на взаимодействие ГГ с интерактивными предметами
                ; Индикация очков и здоровья
                call    DrawScore       ; Вывод на экран счёта
                ; Фигасе, счёт в игровом цикле непрерывно выводится
                call    CheckHealth     ; индикация энергии
                call    GetGameContols  ; Обработка контроллеров управления
                                        ; Выход: R0 - стандартный код управления
                mov     R0, -(SP)
                call    MoveMan         ; Движение ГГ
                mov     (SP)+, R0
                cmp     #14, R0         ; клавиша СБР - самоубиться
                bne     3$
                clr     HaveKey         ; Флаг, что ключ подобран? 0 - нет. !0 - да
                jmp     PlayerDeath1
; ───────────────────────────────────────────────────────────────────────────

3$:             cmp     #222, R0        ; клавиши Шифт/АР2/2 - выход из игры
                bne     4$
                jmp     Exit1$
; ───────────────────────────────────────────────────────────────────────────

4$:             cmp     #40, R0         ; клавиша ПРОБЕЛ - остановиться
                bne     2$
                call    MakeStay        ; остановиться
                br      2$
; End of function GameBegin





; ═══════════════════════════════════════════════════════════════════════════
; ═══════════════════════════════════════════════════════════════════════════
; ══════════════  РЕДАКТОР  ═════════════════════════════════════════════════
; ═══════════════════════════════════════════════════════════════════════════
; ═══════════════════════════════════════════════════════════════════════════


GoEditor:       clr     @#177716
                mov     #177000, R3     ; R3 = 177000
                mov     R3, R1          ; R1 = 177000
                add     #662, R1        ; R1 = 177662
                add     #716, R3        ; R3 = 177716
                mov     #150, R5
                mov     #160, R4
                mov     #20, R2

1$:             mov     #320, (R3)
                mov     R2, R0

                sob     R0, .
                mov     #220, (R3)
                mov     R4, R0

                sob     R0, .
                dec     R4
                cmp     (R2)+, (R2)+
                tstb    (R2)+
                sob     R5, 1$

2$:             bit     #100, (R3)      ; клавиша нажата?
                bne     2$              ; нет, ждём нажатия
                cmpb    #'9, (R1)       ; да, это '9'?
                beq     4$              ; да

3$:             halt                    ; нет - неверно
; ───────────────────────────────────────────────────────────────────────────

4$:             bit     #100, (R3)      ; клавиша нажата?
                beq     4$              ; да, ждём пока отпустят

5$:             bit     #100, (R3)      ; клавиша нажата?
                bne     5$              ; нет, ждём нажатия
                cmpb    #'1, (R1)       ; да, это '1'?
                bne     3$              ; нет - неверно

6$:             bit     #100, (R3)      ; клавиша нажата?
                beq     6$              ; да, ждём пока отпустят

7$:             bit     #100, (R3)      ; клавиша нажата?
                bne     7$              ; нет, ждём нажатия
                movb    (R1), R4        ; возьмём код
                tst     (R4)+           ; +2
                mov     R4, -(SP)       ; сохраним
                call    Emt6Sub         ; ждём ещё нажатие
                mov     (SP)+, R4
                add     R0, R4          ; код2 + код1 +2
                mov     R4, -(SP)
                mov     #160, R1
                call    Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
                mov     (SP)+, R4
                sub     #101, R4        ; код2 + код1 + 2 - 101 = 136
                mov     R4, EdSecret$

EditLabyrint:   call    ShowHelp
                mov     #Labyrints, @#LabArrayBase ; Базовый адрес начала лабиринтов
                mov     #strSelNumLabyr, R1
                clr     R2
                emt     0
                ; вводим номер редактируемого лабиринта
2$:             emt     6               ; получим первую цифру номера
                cmp     R0, #'0
                blo     2$
                cmp     R0, #'4
                bhi     2$              ; это должна быть цифра 0..4
                call    OutLbNumDigit   ; выведем на экран
                clr     R3
                sub     #'0, R0
                beq     4$

3$:             add     #490., R3       ; 10. лабиринтов занимает 490. байтов
                sob     R0, 3$

4$:             emt     6               ; получим вторую цифру номера
                cmp     R0, #'0
                blo     4$
                cmp     R0, #'9
                bhi     4$              ; это должна быть цифра 0..9
                call    OutLbNumDigit   ; Выведем на экран
                sub     #'0, R0
                beq     6$

5$:             add     #49., R3        ; один лабиринт занимает 49. байтов
                sob     R0, 5$

6$:             add     @#LabArrayBase, R3 ; адрес лабиринта
                mov     R3, -(SP)
                call    ClearField
                call    PrepareScreen   ; Вывод спрайта SSV и отрисовка границ лабиринта
                mov     (SP)+, R5
                mov     R5, @#CurEditLab
                call    PrepareLabyr    ; Распаковка лабиринта в буфер и отрисовка
                                        ; Вход: R5 - адрес текущего лабиринта
                mov     #43004, @#CurCellScrAddr
                call    SelectCell
                mov     #LabyrBuffer, @#CurLabCell

EditLoop2$:     bit     #100, @#177716  ; ждём нажатия клавиши
                beq     EditLoop2$      ; без повтора
8$:             bit     #100, @#177716
                bne     8$
                mov     @#177662, R0
                cmp     #14, R0         ; клавиша СБР - очистка буфера лабиринта
                bne     10$
                call    ClearField
                call    PrepareScreen   ; Вывод спрайта SSV и отрисовка границ лабиринта
                mov     #LabyrBuffer, R0
                mov     #49., R1

9$:             clr     (R0)+
                sob     R1, 9$
                br      15$
; ───────────────────────────────────────────────────────────────────────────

10$:            cmp     #3, R0          ; клавиша КТ - отмена редактирования
                beq     EditLabyrint
                cmp     #40, R0         ; клавиша пробел - очистить клетку лабиринта
                bne     13$
                mov     #30, R1
                mov     @#CurCellScrAddr, R0

12$:            clr     (R0)
                clr     2(R0)
                add     #100, R0
                sob     R1, 12$
                mov     @#CurLabCell, R1
                clrb    (R1)
15$:            call    SelectCell
                br      EditLoop2$
; ───────────────────────────────────────────────────────────────────────────

13$:            cmp     R0, #'A         ; клавиши 'A'..'O' - установить элемент в клетку
                blo     14$
                cmp     R0, #'O
                bhi     EditLoop2$
                sub     #100, R0
                mov     @#CurLabCell, R2
                movb    R0, (R2)
                call    ClearField
                call    DrawLabBorder   ; Прорисовка границ лабиринта
                call    ClrBuffers
                call    DrawLabyrint    ; Отрисовка лабиринта из буфера распакованного лабиринта
                br      15$
; ───────────────────────────────────────────────────────────────────────────

14$:            call    CheckEdBounds   ; двигаться в нужном направлении можно?
                bcs     EditLoop2$      ; нет
                cmp     #31, R0
                bne     16$
                call    SelectCell
                add     #4, @#CurCellScrAddr
                inc     @#CurLabCell
                br      15$
; ───────────────────────────────────────────────────────────────────────────

16$:            cmp     #10, R0
                bne     17$
                call    SelectCell
                sub     #4, @#CurCellScrAddr
                dec     @#CurLabCell
                br      15$
; ───────────────────────────────────────────────────────────────────────────

17$:            cmp     #33, R0
                bne     18$
                call    SelectCell
                add     #3000, @#CurCellScrAddr
                add     #16, @#CurLabCell
                br      15$
; ───────────────────────────────────────────────────────────────────────────

18$:            cmp     #32, R0
                bne     19$
                call    SelectCell
                sub     #3000, @#CurCellScrAddr
                sub     #16, @#CurLabCell
                br      15$
; ───────────────────────────────────────────────────────────────────────────

19$:            cmp     #12, R0     ; ВВОД - конец редактирования
                bne     EditLoop2$
                ; упаковываем лабиринт обратно
                mov     #LabyrBuffer, R0
                mov     @(PC)+, R1
EdSecret$:     .word    136         ; тут уже нужное значение

                mov     #49., R5
22$:            movb    (R0)+, (R1)
                movb    (R0)+, R2
                aslb    R2
                aslb    R2
                aslb    R2
                aslb    R2
                bisb    R2, (R1)+
                sob     R5, 22$
                jmp     EditLabyrint

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


OutLbNumDigit:  jsr     R4, @#110346
                emt     16
                jsr     R4, @#110362
                return
; End of function OutLbNumDigit


; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; проверка, можно ли перемещаться стрелками по лабиринту

CheckEdBounds:  mov     @#CurCellScrAddr, R5
                cmp     #10, R0
                bne     3$
                bic     #177700, R5
                cmp     #4, R5
                beq     1$
2$:             tst     (PC)+
1$:             sec
                return
; ───────────────────────────────────────────────────────────────────────────

3$:             cmp     #31, R0
                bne     4$
                bic     #177700, R5
                cmp     #70, R5
                beq     1$
                br      2$
; ───────────────────────────────────────────────────────────────────────────

4$:             cmp     #32, R0
                bne     5$
                cmp     R5, #44000
                blo     1$
                br      2$
; ───────────────────────────────────────────────────────────────────────────

5$:             cmp     #33, R0
                bne     2$
                cmp     R5, #64000
                bhi     1$
                br      2$
; End of function CheckEdBounds


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


ShowHelp:       clr     @#WideCharMode
                mov     #40000, R5
                mov     #40077, R4
                mov     #77, R2

1$:             mov     R5, R0

2$:             clrb    (R0)
                add     #101, R0
                cmp     R0, #100000
                blo     2$
                mov     R4, R0

3$:             clrb    (R0)
                add     #77, R0
                cmp     R0, #100000
                blo     3$
                inc     R5
                dec     R4
                sob     R2, 1$
                mov     #1, @#CharVertScale
                mov     #strEdHelp, R1
4$:             movb    (R1)+, R0
                beq     5$
                decb    R0
                emt     16
                br      4$
; ───────────────────────────────────────────────────────────────────────────

5$:             mov     #170, R1
                jmp     Beep1           ; Звучок
                                        ; Вход: R1 - длительность звука (больше 105)
                                        ;  из длительности делается тон.
; End of function ShowHelp
; ───────────────────────────────────────────────────────────────────────────
; это спрайт @SSV
SprSSV:         .byte 360, 17, 300, 77, 300, 77, 300, 1, 14
                .byte 134, 65, 360, 365, 360, 365, 300, 1, 34
                .byte 307, 303, 360, 101, 361, 101, 301, 1, 34
                .byte 67, 315, 361, 1, 360, 1, 300, 1, 34
                .byte 167, 320, 301, 77, 300, 77, 0, 7, 23
                .byte 167, 300, 1, 365, 0, 365, 0, 7, 7
                .byte 167, 314, 1, 360, 1, 360, 1, 7, 7
                .byte 307, 323, 1, 360, 1, 360, 1, 334, 4
                .byte 14, 65, 361, 360, 361, 360, 1, 334, 1
                .byte 360, 117, 300, 177, 300, 177, 0, 60, 1
                .byte 100, 25, 0, 25, 0, 25, 0, 100, 0

SprDataExt:     .byte 0   ;00 00
                .byte 125 ;01 10
                .byte 252 ;10 01
                .byte 377 ;11 11
                .even

; ███████████████ S U B R O U T I N E ███████████████████████████████████████

; Вывод спрайта SSV и отрисовка границ лабиринта

PrepareScreen:  mov     #SprSSV, R5
                mov     #73316, R4
                mov     #13, R3         ; Высота в строках
                
1$:             mov     #11, R0         ; ширина в байтах

2$:             movb    (R5)+, R1       ; берём байт
                mov     #4, -(SP)       ; будем рассматривать каждое двубитие

3$:             clr     R2              ; получим очередные 2 бита
                asrb    R1              ; зеркально
                rol     R2
                asrb    R1
                rol     R2
                movb    SprDataExt(R2), R2
                movb    R2, (R4)+
                movb    R2, 77(R4)
                movb    R2, 177(R4)
                dec     (SP)
                bne     3$
                tst     (SP)+
                sob     R0, 2$
                add     #234, R4
                sob     R3, 1$
                jmp     DrawLabBorder ; Прорисовка границ лабиринта

; End of function PrepareScreen

; ███████████████ S U B R O U T I N E ███████████████████████████████████████


ClearField:     mov     #40000, R1
                mov     #15500, R0

1$:             clr     (R1)+
                sob     R0, 1$
                return
; End of function ClearField


; ███████████████ S U B R O U T I N E ███████████████████████████████████████


SelectCell:     jsr     R4, @#110346
                mov     #30, R1
                mov     @#CurCellScrAddr, R0

1$:             com     (R0)
                com     2(R0)
                add     #100, R0
                sob     R1, 1$
                jsr     R4, @#110362
                return
; End of function SelectCell

; ───────────────────────────────────────────────────────────────────────────
strSelNumLabyr: .asciz <1><223><36>"NUMBER"<31>"OF"<31>"LABYRINTH"<25>"FOR"<31>"EDITOR:"<221>
strEdHelp:      .ascii <22><36><222><234>"@"<31>"SIDOROW"<31>"SERGEJ"<31>"VICTOROVICH"<25><25>
                .ascii <223><31>"NICOLAEV"<31>"1991"<31>"TEL"<31>"23"<31>"69"<31>"55"<234><25><25><25>
                .ascii <221><31>"...."<31>"EDITOR"<31>"OF"<31>"LABYRINTHS"<31>"...."<25><25>
                .ascii <223>"K"<222>"E"<221>"Y"<222><31>":"<31><221>"←"<31>"→"<31>"↑"<31>"↓"<31>
                .asciz "CLS"<31>"KT"<31><222>"A"<221>"-"<222>"O"<31><31>"SPACE"<25><25>
                .even
.script "Help Encode"
        mov #strEdHelp, R1
1$:     movb (R1), R0
        beq  2$
        incb R0
        movb R0, (R1)+
        br   1$
2$:
.ends
; ───────────────────────────────────────────────────────────────────────────
; Один лабиринт занимает 49. байтов, их тут 50 штук
Labyrints:      .byte 0, 0, 100, 0, 120, 360, 0
                .byte 0, 40, 42, 162, 42, 2, 0
                .byte 0, 140, 100, 160, 140, 220, 0
                .byte 47, 42, 42, 42, 42, 42, 162
                .byte 7, 5, 300, 0, 0, 120, 160
                .byte 42, 162, 0, 320, 0, 47, 42
                .byte 42, 162, 20, 0, 100, 47, 42
                .byte 42, 42, 47, 42, 162, 42, 42
                .byte 5, 16, 47, 200, 160, 0, 5
                .byte 42, 42, 67, 160, 162, 42, 42
                .byte 2, 6, 47, 42, 162, 6, 40
                .byte 42, 42, 47, 260, 160, 42, 42
                .byte 0, 1, 7, 0, 160, 100, 140
                .byte 42, 42, 47, 42, 162, 42, 42
                .byte 340, 42, 5, 17, 6, 4, 0
                .byte 166, 14, 42, 47, 42, 42, 7
                .byte 162, 0, 5, 7, 3, 5, 7
                .byte 40, 42, 42, 47, 42, 2, 147
                .byte 120, 140, 100, 7, 206, 40, 42
                .byte 47, 42, 42, 42, 42, 327, 0
                .byte 7, 1, 4, 5, 0, 247, 120
                .byte 0, 0, 7, 0, 17, 0, 347
                .byte 0, 15, 47, 320, 0, 0, 47
                .byte 100, 0, 67, 42, 142, 15, 7
                .byte 40, 162, 162, 144, 45, 47, 2
                .byte 0, 162, 40, 42, 142, 47, 0
                .byte 5, 42, 7, 11, 160, 42, 140
                .byte 2, 12, 7, 20, 160, 0, 40
                .byte 0, 220, 100, 0, 2, 16, 11
                .byte 40, 42, 42, 162, 2, 42, 162
                .byte 65, 0, 130, 160, 2, 2, 160
                .byte 42, 47, 42, 160, 116, 162, 42
                .byte 140, 7, 40, 40, 42, 162, 0
                .byte 42, 42, 47, 40, 0, 162, 2
                .byte 20, 0, 47, 6, 15, 160, 143
                .byte 140, 124, 240, 0, 6, 116, 5
                .byte 47, 42, 42, 42, 42, 42, 162
                .byte 47, 3, 4, 205, 100, 6, 162
                .byte 47, 47, 42, 42, 42, 162, 162
                .byte 47, 147, 0, 0, 0, 162, 162
                .byte 47, 47, 0, 13, 15, 162, 162
                .byte 127, 20, 100, 0, 4, 160, 166
                .byte 7, 140, 0, 11, 345, 4, 6
                .byte 47, 42, 42, 42, 42, 42, 122
                .byte 7, 5, 0, 17, 0, 4, 60
                .byte 42, 42, 162, 42, 47, 42, 42
                .byte 20, 0, 162, 145, 67, 340, 340
                .byte 42, 2, 162, 42, 47, 47, 42
                .byte 120, 3, 160, 42, 127, 140, 5
                .byte 0, 17, 6, 67, 63, 145, 16
                .byte 56, 42, 42, 47, 42, 42, 2
                .byte 120, 163, 56, 67, 63, 145, 6
                .byte 56, 162, 345, 47, 42, 42, 2
                .byte 344, 160, 42, 2, 300, 0, 2
                .byte 42, 160, 0, 320, 0, 0, 2
                .byte 226, 160, 321, 100, 336, 120, 102
                .byte 300, 0, 100, 100, 360, 0, 0
                .byte 120, 100, 50, 163, 346, 345, 166
                .byte 40, 42, 42, 40, 167, 167, 167
                .byte 220, 106, 40, 40, 2, 14, 162
                .byte 42, 42, 60, 105, 2, 0, 162
                .byte 0, 0, 40, 42, 320, 0, 160
                .byte 5, 12, 161, 164, 15, 320, 160
                .byte 17, 165, 6, 164, 4, 166, 5
                .byte 0, 162, 2, 162, 2, 162, 2
                .byte 240, 160, 0, 160, 120, 160, 0
                .byte 162, 162, 162, 162, 162, 162, 162
                .byte 171, 165, 166, 165, 166, 165, 160
                .byte 47, 47, 47, 47, 47, 47, 47
                .byte 27, 0, 127, 247, 60, 147, 7
                .byte 360, 106, 120, 116, 140, 20, 5
                .byte 47, 42, 42, 42, 42, 42, 2
                .byte 47, 0, 6, 131, 4, 3, 2
                .byte 47, 47, 42, 42, 42, 2, 2
                .byte 47, 47, 120, 110, 5, 2, 0
                .byte 47, 7, 43, 42, 162, 2, 15
                .byte 7, 47, 46, 14, 162, 4, 120
                .byte 0, 15, 0, 14, 0, 0, 15
                .byte 15, 0, 0, 0, 15, 0, 0
                .byte 120, 140, 15, 1, 0, 246, 120
                .byte 47, 42, 42, 162, 42, 42, 162
                .byte 127, 46, 42, 162, 42, 102, 164
                .byte 47, 127, 46, 176, 62, 164, 162
                .byte 42, 42, 127, 42, 164, 42, 42
                .byte 0, 15, 0, 160, 17, 100, 0
                .byte 120, 100, 40, 162, 160, 42, 2
                .byte 42, 42, 7, 166, 160, 320, 0
                .byte 0, 0, 47, 42, 160, 120, 60
                .byte 6, 7, 227, 340, 165, 40, 2
                .byte 42, 47, 2, 47, 42, 260, 0
                .byte 1, 7, 5, 7, 110, 0, 120
                .byte 67, 6, 17, 5, 126, 0, 0
                .byte 167, 2, 0, 167, 42, 220, 160
                .byte 167, 7, 164, 160, 40, 0, 162
                .byte 160, 7, 367, 160, 56, 0, 162
                .byte 17, 167, 7, 160, 42, 15, 162
                .byte 260, 300, 260, 160, 40, 140, 162
                .byte 0, 100, 0, 160, 4, 40, 161
                .byte 140, 7, 120, 17, 140, 120, 176
                .byte 165, 7, 167, 160, 167, 160, 167
                .byte 7, 167, 7, 220, 160, 107, 160
                .byte 20, 140, 67, 127, 160, 160, 177
                .byte 160, 167, 147, 160, 167, 0, 167
                .byte 260, 160, 0, 13, 7, 0, 13
                .byte 0, 160, 100, 0, 7, 4, 0
                .byte 100, 120, 0, 1, 0, 17, 0
                .byte 40, 42, 42, 42, 47, 42, 162
                .byte 0, 6, 0, 10, 120, 0, 176
                .byte 40, 42, 7, 42, 42, 2, 42
                .byte 15, 0, 167, 140, 100, 11, 2
                .byte 0, 15, 40, 42, 42, 42, 0
                .byte 245, 60, 0, 0, 0, 4, 120
                .byte 0, 360, 0, 16, 5, 0, 165
                .byte 0, 171, 100, 162, 142, 0, 162
                .byte 160, 42, 40, 162, 42, 322, 160
                .byte 160, 2, 120, 163, 6, 2, 160
                .byte 160, 2, 46, 42, 162, 322, 160
                .byte 160, 162, 2, 15, 162, 2, 160
                .byte 161, 142, 100, 0, 165, 2, 164
                .byte 127, 0, 364, 164, 100, 344, 360
                .byte 47, 160, 47, 167, 46, 167, 165
                .byte 7, 162, 223, 162, 222, 160, 162
                .byte 7, 40, 15, 40, 0, 40, 160
                .byte 327, 40, 100, 65, 326, 40, 160
                .byte 7, 0, 42, 342, 42, 322, 160
                .byte 27, 16, 100, 60, 0, 244, 160
                .byte 110, 104, 104, 104, 104, 104, 164
                .byte 42, 42, 42, 42, 42, 42, 162
                .byte 0, 320, 0, 320, 0, 14, 160
                .byte 0, 15, 320, 0, 0, 0, 160
                .byte 5, 341, 0, 343, 12, 223, 160
                .byte 42, 42, 42, 42, 42, 42, 162
                .byte 104, 104, 7, 10, 160, 104, 164
                .byte 1, 300, 340, 140, 12, 100, 5
                .byte 42, 120, 40, 42, 42, 42, 162
                .byte 120, 42, 140, 0, 0, 0, 160
                .byte 47, 42, 42, 2, 124, 320, 160
                .byte 107, 64, 0, 40, 42, 6, 160
                .byte 47, 42, 265, 0, 0, 42, 162
                .byte 107, 104, 4, 320, 100, 106, 124
                .byte 67, 44, 127, 12, 47, 42, 127
                .byte 47, 42, 47, 42, 47, 42, 47
                .byte 127, 151, 47, 66, 227, 156, 47
                .byte 47, 42, 47, 42, 47, 42, 47
                .byte 67, 46, 107, 110, 67, 45, 147
                .byte 47, 42, 47, 42, 47, 42, 47
                .byte 27, 136, 47, 42, 347, 357, 47
                .byte 5, 304, 360, 60, 0, 100, 0
                .byte 167, 7, 0, 167, 127, 167, 15
                .byte 7, 224, 160, 0, 167, 7, 340
                .byte 7, 167, 240, 0, 7, 0, 167
                .byte 7, 160, 167, 147, 7, 165, 0
                .byte 7, 1, 13, 167, 167, 327, 0
                .byte 147, 122, 0, 100, 160, 4, 140
                .byte 111, 47, 220, 47, 6, 101, 17
                .byte 56, 47, 40, 47, 42, 47, 2
                .byte 65, 327, 140, 127, 64, 0, 4
                .byte 42, 7, 40, 47, 42, 7, 162
                .byte 110, 47, 40, 307, 0, 7, 176
                .byte 56, 47, 40, 7, 13, 7, 162
                .byte 66, 7, 44, 107, 0, 47, 162
                .byte 42, 42, 42, 42, 42, 42, 42
                .byte 42, 0, 140, 100, 360, 0, 42
                .byte 42, 15, 47, 162, 320, 0, 42
                .byte 42, 0, 327, 160, 16, 6, 42
                .byte 42, 0, 7, 40, 42, 2, 42
                .byte 42, 24, 67, 244, 120, 0, 42
                .byte 42, 42, 42, 42, 42, 42, 42
                .byte 4, 0, 163, 360, 104, 65, 140
                .byte 162, 40, 162, 166, 162, 42, 47
                .byte 160, 4, 42, 42, 162, 40, 127
                .byte 40, 2, 2, 347, 162, 10, 47
                .byte 60, 5, 17, 7, 42, 42, 347
                .byte 42, 2, 47, 2, 15, 42, 162
                .byte 1, 16, 67, 16, 12, 60, 164
                .byte 42, 42, 42, 42, 42, 42, 42
                .byte 41, 42, 46, 42, 6, 14, 40
                .byte 0, 2, 7, 42, 162, 204, 40
                .byte 2, 220, 107, 45, 160, 123, 123
                .byte 42, 47, 47, 2, 160, 42, 162
                .byte 2, 0, 17, 320, 160, 203, 160
                .byte 16, 3, 124, 12, 176, 122, 176
                .byte 0, 14, 0, 13, 15, 14, 0
                .byte 0, 0, 0, 0, 0, 0, 0
                .byte 0, 360, 164, 42, 147, 360, 0
                .byte 11, 0, 47, 42, 162, 0, 11
                .byte 0, 176, 2, 104, 64, 127, 0
                .byte 0, 47, 162, 42, 42, 162, 15
                .byte 161, 122, 166, 104, 124, 42, 147
                .byte 41, 42, 40, 42, 40, 42, 40
                .byte 0, 2, 0, 2, 0, 2, 120
                .byte 120, 17, 15, 0, 15, 6, 167
                .byte 160, 167, 7, 167, 167, 100, 7
                .byte 160, 0, 176, 227, 5, 164, 7
                .byte 162, 0, 162, 0, 42, 163, 2
                .byte 42, 40, 42, 40, 42, 46, 42
                .byte 107, 203, 67, 104, 163, 70, 164
                .byte 47, 42, 42, 42, 42, 42, 162
                .byte 67, 100, 203, 64, 204, 343, 162
                .byte 47, 40, 162, 42, 47, 162, 162
                .byte 47, 144, 162, 46, 147, 162, 163
                .byte 47, 42, 42, 42, 42, 42, 42
                .byte 347, 341, 344, 344, 344, 344, 344
                .byte 0, 247, 60, 66, 0, 247, 120
                .byte 42, 42, 47, 42, 47, 42, 42
                .byte 5, 2, 347, 2, 347, 342, 106
                .byte 162, 162, 162, 162, 162, 162, 42
                .byte 162, 161, 162, 176, 162, 176, 104
                .byte 42, 47, 42, 42, 42, 47, 42
                .byte 65, 67, 206, 207, 65, 67, 206
                .byte 7, 15, 7, 0, 160, 15, 176
                .byte 127, 0, 327, 320, 160, 0, 166
                .byte 47, 0, 2, 0, 40, 0, 162
                .byte 7, 60, 7, 15, 160, 3, 160
                .byte 147, 60, 7, 0, 160, 3, 165
                .byte 47, 60, 347, 1, 160, 3, 162
                .byte 7, 70, 47, 42, 162, 203, 160
                .byte 5, 11, 0, 5, 4, 0, 120
                .byte 7, 6, 47, 42, 162, 140, 160
                .byte 47, 42, 2, 14, 40, 42, 162
                .byte 7, 0, 0, 0, 1, 0, 160
                .byte 7, 11, 47, 42, 162, 220, 160
                .byte 42, 42, 7, 150, 160, 42, 42
                .byte 360, 340, 47, 42, 162, 203, 120
                .byte 167, 7, 167, 7, 7, 0, 7
                .byte 7, 7, 347, 7, 7, 0, 7
                .byte 147, 0, 127, 0, 147, 137, 7
                .byte 167, 7, 167, 7, 167, 160, 7
                .byte 5, 7, 6, 227, 166, 165, 12
                .byte 7, 7, 7, 7, 160, 167, 42
                .byte 167, 27, 167, 7, 12, 7, 143
                .byte 56, 42, 42, 42, 42, 0, 120
                .byte 327, 100, 360, 0, 4, 47, 162
                .byte 347, 65, 162, 162, 42, 42, 163
                .byte 42, 2, 165, 0, 122, 126, 47
                .byte 140, 160, 42, 162, 40, 42, 47
                .byte 40, 162, 0, 176, 0, 42, 47
                .byte 5, 160, 20, 162, 12, 65, 47
                .byte 7, 300, 0, 15, 0, 14, 160
                .byte 127, 120, 120, 0, 5, 5, 165
                .byte 67, 67, 67, 124, 163, 163, 163
                .byte 47, 42, 42, 42, 42, 42, 162
                .byte 7, 360, 5, 223, 120, 144, 160
                .byte 47, 42, 42, 162, 42, 42, 162
                .byte 7, 4, 346, 12, 100, 20, 160
                .byte 140, 100, 5, 77, 5, 140, 100
                .byte 42, 47, 162, 42, 162, 40, 162
                .byte 220, 107, 60, 5, 47, 42, 166
                .byte 47, 42, 42, 42, 147, 56, 47
                .byte 107, 150, 160, 15, 42, 47, 127
                .byte 42, 42, 162, 0, 41, 47, 162
                .byte 244, 120, 163, 42, 127, 227, 160
                .byte 100, 6, 147, 24, 147, 100, 7
                .byte 40, 42, 47, 42, 47, 42, 7
                .byte 40, 65, 47, 65, 47, 65, 7
                .byte 40, 42, 47, 42, 47, 42, 7
                .byte 5, 12, 7, 0, 147, 12, 107
                .byte 42, 42, 7, 13, 47, 42, 47
                .byte 344, 200, 347, 0, 47, 236, 107
                .byte 40, 42, 42, 7, 5, 246, 0
                .byte 60, 120, 140, 47, 162, 42, 2
                .byte 160, 42, 42, 107, 140, 137, 0
                .byte 351, 124, 43, 47, 42, 42, 0
                .byte 40, 42, 47, 147, 120, 16, 0
                .byte 0, 13, 0, 47, 42, 2, 0
                .byte 100, 0, 20, 7, 100, 240, 0
                .byte 60, 100, 0, 17, 4, 0, 40
                .byte 160, 42, 162, 42, 162, 320, 0
                .byte 0, 0, 162, 123, 162, 7, 140
                .byte 260, 40, 176, 42, 162, 160, 167
                .byte 0, 0, 162, 6, 162, 120, 14
                .byte 160, 42, 162, 42, 162, 160, 6
                .byte 116, 136, 163, 244, 160, 1, 7
                .byte 40, 2, 4, 42, 120, 40, 40
                .byte 147, 160, 162, 6, 47, 147, 7
                .byte 47, 42, 2, 42, 42, 42, 47
                .byte 7, 204, 5, 2, 365, 6, 7
                .byte 7, 42, 162, 162, 2, 42, 162
                .byte 42, 2, 160, 162, 2, 15, 162
                .byte 136, 220, 163, 161, 3, 5, 166
                .byte 0, 4, 17, 100, 140, 340, 120
                .byte 160, 162, 0, 47, 42, 42, 47
                .byte 160, 162, 13, 147, 0, 5, 4
                .byte 160, 162, 0, 42, 42, 42, 162
                .byte 47, 65, 47, 2, 14, 15, 160
                .byte 47, 42, 7, 15, 0, 0, 160
                .byte 27, 144, 107, 0, 15, 12, 165
                .byte 0, 100, 0, 13, 0, 14, 0
                .byte 160, 42, 7, 0, 16, 0, 0
                .byte 160, 0, 47, 42, 107, 165, 0
                .byte 160, 5, 27, 0, 47, 162, 0
                .byte 47, 42, 162, 15, 147, 160, 0
                .byte 7, 10, 166, 0, 42, 47, 0
                .byte 47, 42, 162, 3, 5, 247, 140
                .byte 1, 6, 225, 122, 46, 360, 5
                .byte 42, 7, 162, 162, 42, 47, 2
                .byte 17, 107, 176, 162, 65, 7, 166
                .byte 40, 42, 42, 42, 42, 42, 162
                .byte 120, 12, 124, 140, 3, 320, 160
                .byte 40, 42, 42, 47, 322, 0, 160
                .byte 16, 140, 0, 47, 5, 10, 164
                .byte 0, 200, 120, 100, 0, 42, 63
                .byte 220, 160, 43, 42, 2, 42, 42
                .byte 47, 42, 0, 127, 0, 42, 63
                .byte 347, 200, 145, 47, 147, 42, 42
                .byte 42, 7, 42, 262, 40, 42, 63
                .byte 1, 7, 240, 0, 0, 42, 42
                .byte 42, 42, 42, 42, 42, 42, 63
                .byte 300, 0, 20, 100, 0, 300, 360
                .byte 0, 0, 45, 47, 142, 0, 0
                .byte 0, 0, 2, 7, 42, 336, 0
                .byte 320, 140, 2, 67, 45, 124, 16
                .byte 0, 44, 65, 47, 42, 42, 6
                .byte 40, 42, 42, 7, 14, 40, 2
                .byte 45, 5, 6, 7, 12, 4, 5
                .byte 0, 5, 0, 300, 0, 0, 0
                .byte 0, 7, 344, 140, 100, 360, 0
                .byte 15, 42, 42, 47, 47, 2, 0
                .byte 0, 343, 45, 27, 47, 65, 15
                .byte 40, 42, 42, 47, 47, 42, 2
                .byte 0, 0, 40, 147, 47, 320, 0
                .byte 320, 240, 100, 47, 7, 11, 5
                .byte 351, 344, 47, 0, 365, 104, 3
                .byte 42, 42, 47, 67, 43, 42, 2
                .byte 136, 106, 47, 47, 126, 126, 103
                .byte 42, 42, 47, 47, 42, 42, 162
                .byte 150, 105, 47, 7, 4, 65, 145
                .byte 162, 42, 42, 42, 47, 42, 42
                .byte 166, 0, 4, 12, 127, 20, 140
                .byte 107, 120, 16, 14, 340, 106, 160
                .byte 167, 42, 2, 0, 40, 42, 167
                .byte 7, 2, 100, 0, 324, 40, 160
                .byte 7, 322, 40, 125, 2, 40, 160
                .byte 7, 3, 6, 63, 144, 40, 160
                .byte 7, 40, 42, 42, 42, 2, 160
                .byte 7, 1, 106, 0, 12, 344, 160
                .byte 20, 0, 344, 0, 12, 340, 100
                .byte 47, 47, 47, 47, 47, 47, 47
                .byte 47, 40, 40, 40, 40, 40, 40
                .byte 47, 40, 56, 40, 40, 56, 40
                .byte 47, 65, 66, 65, 66, 65, 46
                .byte 47, 42, 42, 42, 47, 42, 42
                .byte 7, 224, 107, 200, 140, 7, 130
                .byte 0, 4, 0, 17, 0, 100, 0
                .byte 160, 42, 0, 0, 0, 42, 7
                .byte 160, 14, 15, 13, 15, 14, 7
                .byte 160, 100, 0, 0, 11, 4, 7
                .byte 160, 42, 162, 42, 47, 42, 7
                .byte 160, 0, 2, 0, 40, 0, 7
                .byte 161, 5, 122, 126, 46, 0, 7

                .END
