OPTION BINARY   ; We want a binary file, not an HP48 one.
      ALIGN OFF       ; And we don't want auto alignement, as some
                      ; data can be made of bytes instead of words.
         
          LD  V0, 0
          LD  V1, 0
         
      LOOP:
          LD  I,  LEFT    ; We draw a left line by default, as the random number
                          ; is 0 or 1. If we suppose that it will be 1, we keep
                          ; drawing the left line. If it is 0, we change register
                          ; I to draw a right line.
         
          RND V2, 1       ; Load in V2 a 0...1 random number
         
          SE  V2, 1       ; It is 1 ? If yes, I still refers to the left line
                          ; bitmap.
         
          LD  I,  RIGHT   ; If not, we change I to make it refer the right line
                          ; bitmap.
         
          DRW V0, V1, 4   ; And we draw the bitmap at V0, V1.
         
          ADD V0, 4       ; The next bitmap is 4 pixels right. So we update
                          ; V0 to do so.
         
          SE  V0, 64      ; If V0==64, we finished drawing a complete line, so we
                          ; skip the jump to LOOP, as we have to update V1 too.
         
          JP  LOOP        ; We did not draw a complete line ? So we continue !
         
          LD  V0, 0       ; The first bitmap of each line is located 0, V1.
         
          ADD V1, 4       ; We update V1. The next line is located 4 pixels doan.
         
          SE  V1, 32      ; Have we drawn all the lines ? If yes, V1==32.
          JP  LOOP        ; No ? So we continue !
         
      FIN:    JP FIN      ; Infinite loop...
         
      RIGHT:              ; 4*4 bitmap of the left line
         
          DB $1.......
          DB $.1......
          DB $..1.....
          DB $...1....
         
      LEFT:               ; 4*4 bitmap of the right line
                          ; And YES, it is like that...
          DB $..1.....
          DB $.1......
          DB $1.......
          DB $...1....
       

      Display : Array [0..64*32-1] of Byte; //video memory
        Memory : Array [0..4095] of Byte; //RAM memory
        Stack  : Array [0..15] of Word; //stack
        Registers : Array [0..15] of Byte; //registers
        rI  : Word = $200;      // I register
        SP  : Byte = 0;         // stack counter
        PC  : Word = $200;      // mem offset counter
        delay_timer : Byte = 255; // delay timer;
        sound_timer : Byte = 255; // sound timer;
   

FillChar(Memory,4096,0); // очищаем основную память
Move(Font,Memory,80); // копируем в нее шрифт по смещению 000h
FillChar(Stack,16,0); // очищаем стек
FillChar(Registers,16,0); // сбрасываем регистры в ноль
     
rI  := $200;      // адресный регистр I на начало программы
PC  := $200;      // смещение массива
     
SP  := 0;         // счетчик стека
delay_timer := 0; // таймеры в нули
sound_timer := 0;
   

Procedure ExecuteOpcode(opcode :word);
Begin
      case (op_code and $F000) shr 12 of  // выделяем из опкода первые 4 бита
          $00: Begin // опкод начался с нуля
                    Case op_code and $00FF of
                          // Это у нас опкод 00E0 - очистка экрана
                          $E0:  Begin
                     //Делаем дела, то есть  тупо очищаем экран
                     exit;
                     End;
                          // А это - 00EE - выход из процедуры
                          $EE:  Begin
                     // Восстанавливаем из стека адрес, прыгаем на него
                     exit;
                     End;
                    End;
                    // А сюда попадем, если опкод начался с нуля, но не закончился ни E0, ни EE
                    // Поэтому либо трапаемся, либо выводим сообщение Invalid Opcode
                    exit;
               End; //конец проверка на нулевой опкод
          $01: Begin // первые четыре бита опкода равно 1 (опкод начался с единицы)
                     // Это JMP, jump. Прыгаем на нужный адрес
                    PC := op_code and $0FFF;
                    exit;
               End;
          $02: Begin // первые четыре бита опкода равны 2 (опкод начался с двойки)
                     // Вызываем подпрограмму.
                     // увеличиваем указатель стека
                     // заносим в стек текущий адрес
                     // и пыгаем на подпрограмму
               End;
         //
         // Так продолжается до опкода, который начинается с 7.
         //
     
          $08: Begin  // опкод начался с 8. Здесь нужно смотреть на 4 последних бита
                 case op_code and $000F of  // последние 4 бита опкода
                  // mov vx, vy
                  $00: Begin
                          // Занесем в регистр VX значение VY
                          exit;
                       End;
                  // or vx, vy
                  $01: Begin
                          // VX = VX or VY
                          exit;
                       End;
                  //
                  // так продолжается до 0E
                  //
     
                 End; // конец проверки последних 4 бит опкода
                 // сюда попадаем, если Invalid Opcode
                exit;
              End; // конец проверки, если опкод начался на 8