; 
;  ***************************************************
;  *                                                 *
;  *    Generator liczb pseudolosowych               *
;  *    Procesor: i8085                              *
;  *    Napisal: A. P.                               *
;  *    Licencja: CC BY 3.0                          *
;  *                                                 *
;  ***************************************************
; 
        .i8085
;
;  +---------+---------+---------+---------+---------+---------+
;  |         |         |         |         |         |         |
;  |    1    |    2    |    3    |  Enter  |  Start  |  Stop   |
;  |         |         |         |         |         |         |
;  +---------+---------+---------+---------+---------+---------+
;  |         |         |         |         |         |         |
;  |    4    |    5    |    6    |  Pause  | StrRE   |  StrFE  |
;  |         |         |         |         |         |         |
;  +---------+---------+---------+---------+---------+---------+
;  |         |         |         |         |         |         |
;  |    7    |    8    |    9    |  Cont   |  Back   |  Next   |
;  |         |         |         |         |         |         |
;  +---------+---------+---------+---------+---------+---------+
;  |         |         |         |         |         |         |
;  |    0    |   NC    | Bascksp |   ECS   |   Step  | SelDel  |
;  |         |         |         |         |         |         |
;  +---------+---------+---------+---------+---------+---------+
;
;  +------------+------------+------------+------------+------------+------------+
;  | 01111111 0 | 10111111 4 | 10111111 0 | 11011111 4 | 11011111 0 | 11101111 4 |
;  +------------+------------+------------+------------+------------+------------+
;  | 01111111 1 | 10111111 5 | 10111111 1 | 11011111 5 | 11011111 1 | 11101111 5 |
;  +------------+------------+------------+------------+------------+------------+
;  | 01111111 2 | 10111111 6 | 10111111 2 | 11011111 6 | 11011111 2 | 11101111 6 |
;  +------------+------------+------------+------------+------------+------------+
;  | 01111111 3 | 10111111 7 | 10111111 3 | 11011111 7 | 11011111 3 | 11101111 7 |
;  +------------+------------+------------+------------+------------+------------+
;
ResetEntry              .equ    00000h
RST1Entry               .equ    00008h
RST2Entry               .equ    00010h
RST3Entry               .equ    00018h
RST4Entry               .equ    00020h
TRAPEntry               .equ    00024h
RST5Entry               .equ    00028h
RST55Entry              .equ    0002Ch
RST6Entry               .equ    00030h
RST65Entry              .equ    00034h
RST7Entry               .equ    00038h
RST75Entry              .equ    0003Ch
RAMSpace                .equ    08000h
;*******************************************
Enable75Inter           .equ    00001011b
;*******************************************
Stack_top               .equ	0fffeh
;*******************************************
;   A7 A6 A5
;    1  0  0   8253
;    1  0  1   8255
;    1  1  0   8255
;    1  1  1   ---
;*******************************************
Timer8253               .equ	080h
LCDPort                 .equ    0C0h
KBDPort                 .equ    0C0h
RNDPort                 .equ    0A0h
;*******************************************
Port8255        .struct
        PortA   .byte
        PortB   .byte
        PortC   .byte
        Control .byte
                .endstruct
Port8253        .struct
        TimerA  .byte
        TimerB  .byte
        TimerC  .byte
        Control .byte
                .endstruct
;*******************************************
Timer0Divider           .equ    200	; 2000
Timer1Prescaler         .equ    100
DividerFor100ms         .equ    7 ;13
TimeIntervalLimit       .equ    99
Tim0WaveGenMode         .equ    00110110b                      
Tim1IrqGenMode          .equ    01110000b
LifeLedDelay            .equ    33
;*******************************************
LS373Strobe             .equ    00000010b
LS373HiZOff             .equ    00000001b
RunLedOn                .equ    01000000b
PauseLedOn              .equ    00100000b
LifeLED                 .equ    00000100b
RisingEdgeLed           .equ    00010000b
FallingEdgneLed         .equ    00001000b
ExternStrobe            .equ    10000000b
;*******************************************
P8255A_out              .equ    0000000b
P8255A_inp              .equ    0010000b
P8255B_out              .equ    0000000b
P8255B_inp              .equ    0000010b
P8255CL_out             .equ    0000000b
P8255CH_out             .equ    0000000b
P8255CL_inp             .equ    0000001b
P8255CH_inp             .equ    0001000b
;*******************************************
SetLCDEBit              .equ    00000101b
ClrLCDEBit              .equ    00000100b
SetLCDRWBit             .equ    00000011b
ClrLCDRWBit             .equ    00000010b
SetLCDRSBit             .equ    00000001b
ClrLCDRSBit             .equ    00000000b
;*******************************************
ClrRow0                 .equ    00001000b
ClrRow1                 .equ    00001010b
ClrRow2                 .equ    00001100b
ClrRow3                 .equ    00001110b
SetRow0                 .equ    00001001b
SetRow1                 .equ    00001011b
SetRow2                 .equ    00001101b
SetRow3                 .equ    00001111b
;*******************************************
NumberSize              .equ    12
;*******************************************
KbdBuffSz       .equ    16
KbdCyclicRecT   .struct                 ; KbdCyclicRecT = record
        CycFr   .byte                   ;                  CycFr : byte ;
        CycTo   .byte                   ;                  CycTo : byte ;
        Buffer  .byte   KbdBuffSz       ;                  Buffer : array [ 0 .. KbdBuffSz - 1 ] of char ;
                .endstruct              ;                 end (* record *) ;
;*******************************************
RndBuffSize             .equ    2048
MaxDeepLevel            .equ    256
RndCyclicRecT     .struct                 ; RndCyclicRecT = record
        RndCycFr  .word                   ;                  RndCycFr  : word ;
        RndCycTo  .word                   ;                  RndCycTo  : word ;
        RndBuffer .word   RndBuffSize     ;                  RndBuffer : array [ 0 .. RndBuffSize - 1 ] of word ;
                  .endstruct              ;                 end (* record *) ;
;*******************************************
KbdIdle        .equ    1
KbdWaitOnPress .equ    2
KbdReady       .equ    3
KbdActive      .equ    4
KbdWaitOnFree  .equ    5
;*******************************************
KbdDelayLimit  .equ    2
;*******************************************
RowCounterLmt  .equ    8
;*******************************************
KbdModInstanceT         .struct                            ; KbdCyclicRecT = record
        KbdCyclic         .byte  sizeof ( KbdCyclicRecT )  ;                  KbdCyclic         : KbdCyclicRecT ;
        ExtraKbdReadSrv   .word        ; pointer           ;                  ExtraKbdReadSrv   : procedure ;
        HardwKbdReadSrv   .word        ; pointer           ;                  HardwKbdReadSrv   : function : byte ;
        HardwKbdSetRowSrv .word        ; pointer           ;                  HardwKbdSetRowSrv : procedure ( byte ) ;
        EncodeTableRow0   .word        ; pointer           ;                  EncodeTableRow0   : ^ char ;
        EncodeTableRow1   .word        ; pointer           ;                  EncodeTableRow1   : ^ char ;
        EncodeTableRow2   .word        ; pointer           ;                  EncodeTableRow2   : ^ char ;
        EncodeTableRow3   .word        ; pointer           ;                  EncodeTableRow3   : ^ char ;
        EncodeTableRow4   .word        ; pointer           ;                  EncodeTableRow4   : ^ char ;
        EncodeTableRow5   .word        ; pointer           ;                  EncodeTableRow5   : ^ char ;
        EncodeTableRow6   .word        ; pointer           ;                  EncodeTableRow6   : ^ char ;
        EncodeTableRow7   .word        ; pointer           ;                  EncodeTableRow7   : ^ char ;
        KbdState          .byte                            ;                  KbdState          : byte ;
        KbdDelayCt        .byte                            ;                  KbdDelayCt        : byte ;
        RowCounter        .byte                            ;                  RowCounter        : byte ;
        LastKeybInp       .byte                            ;                  LastKeybInp       : byte ;
                        .endstruct                         ;                 end (* record *) ;
;*******************************************
;*******************************************
        .org    ResetEntry
        di
        lxi     sp , Stack_top
        call    Main
;*******************************************
        .org    RST75Entry
        jmp     RST75Service
;*******************************************
HelloMessage            .defb   'Generator liczb losowych' , 0
InputDelayText          .defb   'Okres w milisekundach' , 0
RunRandomText           .defb   'Uruchomienie generatora' , 0
NewValuePrompt          .defb   'Wartosc: ' , 0
DelayIntervalTxt        .defb   'Okres=' , 0
EmptyDataText           .defb   'Wprowadzone dane sa puste' , 0
AnyKeyText              .defb   'Nacisnij dowolny klawisz' , 0
NumberToSmallText       .defb   'Liczba jest za mala' , 0
NoDelayIntervaTxt       .defb   'Brak wielkosci okresu' , 0
UnitText                .defb   ' ms' , 0
PauseGenerText          .defb   'Pauza w generacji' , 0
RelativeIndexTxt        .defb   'Index= ' , 0
StepInfoText            .defb   'Krok' , 0
HardwarePauseText       .defb   'Sprzetowa pauza' , 0
;-------------------------------------------
Digit0Ch                .equ        '0'    ;
Digit1Ch                .equ        '1'    ;
Digit2Ch                .equ        '2'    ;
Digit3Ch                .equ        '3'    ;
Digit4Ch                .equ        '4'    ;
Digit5Ch                .equ        '5'    ;
Digit6Ch                .equ        '6'    ;
Digit7Ch                .equ        '7'    ;
Digit8Ch                .equ        '8'    ;
Digit9Ch                .equ        '9'    ;
EnterCh                 .equ        00Dh   ;
EscCh                   .equ        01Bh   ;
BackSpaceCh             .equ        008h   ;
SelectDelayIntervalCh   .equ        'A'    ;
StartRandomCh           .equ        'B'    ;
StopRandomCh            .equ        'C'    ;
PauseRandomCh           .equ        'D'    ;
ContinueRandomCh        .equ        'E'    ;
RisingEdgeStrobeCh      .equ        'F'    ;
FallingEdgneStrobeCh    .equ        'G'    ;
BackControlCh           .equ        'H'    ;
NextControlCh           .equ        'I'    ;
StepCh                  .equ        'J'    ;
NotConnectedCh          .equ        '?'    ;
;-------------------------------------------
Row0EncodeTable         .defb   01111111b , Digit1Ch
                        .defb   10111111b , Digit3Ch
                        .defb   11011111b , StartRandomCh
                        .defb   0 , 0
;-------------------------------------------
Row1EncodeTable         .defb   01111111b , Digit4Ch
                        .defb   10111111b , Digit6Ch
                        .defb   11011111b , RisingEdgeStrobeCh
                        .defb   0 , 0
;-------------------------------------------
Row2EncodeTable         .defb   01111111b , Digit7Ch
                        .defb   10111111b , Digit9Ch
                        .defb   11011111b , BackControlCh
                        .defb   0 , 0
;-------------------------------------------
Row3EncodeTable         .defb   01111111b , Digit0Ch
                        .defb   10111111b , BackSpaceCh
                        .defb   11011111b , StepCh
                        .defb   0 , 0
;-------------------------------------------
Row4EncodeTable         .defb   10111111b , Digit2Ch
                        .defb   11011111b , EnterCh
                        .defb   11101111b , StopRandomCh
                        .defb   0 , 0
;-------------------------------------------
Row5EncodeTable         .defb   10111111b , Digit5Ch
                        .defb   11011111b , PauseRandomCh
                        .defb   11101111b , FallingEdgneStrobeCh
                        .defb   0 , 0
;-------------------------------------------
Row6EncodeTable         .defb   10111111b , Digit8Ch
                        .defb   11011111b , ContinueRandomCh
                        .defb   11101111b , NextControlCh 
                        .defb   0 , 0
;-------------------------------------------
Row7EncodeTable         .defb   10111111b , NotConnectedCh
                        .defb   11011111b , EscCh
                        .defb   11101111b , SelectDelayIntervalCh 
                        .defb   0 , 0
;*******************************************
RST75Service                               ;ISR RST75Service ;
                                           ;begin (* RST75Service *)
        push    psw                        ;
        push    b                          ;
        push    d                          ;
        push    h                          ;
        lxi     h , LifeLEDTimer           ; LifeLEDTimer := LifeLEDTimer + 1 ;
        mov     a , m                      ;
        inr     a                          ;
        mov     m , a                      ;
        cpi     LifeLedDelay               ; if LifeLEDTimer = LifeLEDTimer then
        jnz     RST75Ser_1                 ;  begin
        mvi     a , 0                      ;   LifeLEDTimer := 0 ;
        mov     m , a                      ;
        lxi     h, LedPortCopy             ;   LedPortCopy . LifeLED := not LedPortCopy . LifeLED ;
        mov     a , m                      ;
        xri     LifeLED                    ;   RNDPort.PortC := LedPortCopy ;
        mov     m , a                      ;
        out     RNDPort + Port8255.PortC   ;
RST75Ser_1                                 ;  end ;
        lxi     d , RandomSeed             ; RandomSeed := RandomSeed + 1 ;
        lhlx                               ;
        lxi     b , 1                      ;
        dad     b                          ;
        shlx                               ;
        mvi     a , 1                      ; IRQFlag := 1 ;
        sta     IRQFlag                    ;
        call    KeybService                ; KeybService ;
RST75Ser_0                                 ;  end ;
        mvi     a , Tim1IrqGenMode         ;
        out     Timer8253 + Port8253.Control
        mvi     a , lo ( Timer1Prescaler ) ;
        out     Timer8253 + Port8253.TimerB;
        mvi     a , hi ( Timer1Prescaler ) ;
        out     Timer8253 + Port8253.TimerB;
        pop     h                          ;
        pop     d                          ;
        pop     b                          ;
        pop     psw                        ;
        ei                                 ;
        ret                                ;end (* RST75Service *) ;
;*******************************************
CallHLService                              ;
        pchl                               ;
;*******************************************
Init_random                                ;procedure Init_random ;
                                           ;begin (* Init_random *)
        lxi     h , RandomSeed             ; RandomV.h := ( RandomSeed.l ) xor ( RandomSeed.l ) ;
        lxi     d , RandomV                ; RandomV.l := RandomSeed.l ;
        mov     a , m                      ;
        push    psw                        ;
        stax    d                          ;
        inx     h                          ;
        inx     d                          ;
        mov     h , m                      ;
        pop     psw                        ;
        xra     h                          ;
        stax    d                          ;
        ret                                ;end (* Init_random *) ;
;*******************************************
CreateNewRandom                            ;function CreateNewRandom ( ) : word [HL]
;    RandomV = ( ( MultConst * RandomV ) + AddConst )
;    MultConst = 129, AddConst = 9
                                           ;begin (* CreateNewRandom *)
        lxi     d , RandomV                ; CreateNewRandom = ( ( MultConst * RandomV ) + AddConst ) ;
        ldax    d                          ;
        mov     l , a                      ;
        inx     d                          ;
        ldax    d                          ;
        mov     h , a                      ;
        push    h                          ;
        pop     b                          ;
        call    ShiftLBC                   ;
        call    ShiftLBC                   ;
        call    ShiftLBC                   ;
        call    ShiftLBC                   ;
        call    ShiftLBC                   ;
        call    ShiftLBC                   ;
        call    ShiftLBC                   ;
        dad     b                          ;
        mvi     a , 09h                    ;
        add     l                          ;
        mov     l , a                      ;
        mvi     a , 0                      ;
        adc     h                          ;
        mov     h , a                      ;
        ret                                ;end (* CreateNewRandom *) ;
;*******************************************
ShiftLBC                                   ;function ShiftLBC ( Arg [BC] : word ) : word [BC]
                                           ;begin (* ShiftLBC *)
        mov     a , c                      ; ShiftLBC := Arg << 1 ;
        ora     a                          ;
        ral                                ;
        mov     c , a                      ;
        mov     a , b                      ;
        ral                                ;
        mov     b , a                      ;
        ret                                ;end (* ShiftLBC *) ;
;*******************************************
FillRandnomTable                           ;procedure FillRandnomTable ;
                                           ;begin (* FillRandnomTable *)
        mvi     a , 0                      ; for RndLoop := 0 to RndBuffSize - MaxDeepLevel - 2 do
        lxi     h , RndLoop                ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
FillRndTab_0                               ;  begin
        call    CreateNewRandom            ;   RandomV := CreateNewRandom ;
        lxi     d , RandomV                ;
        shlx                               ;
        call    AddToRndCyclic             ;   AddToRndCyclic ( RandomV ) ;
        lxi     d , RndLoop                ;  end ;
        lhlx                               ;
        inx     h                          ;
        shlx                               ;
        lxi     b , - ( RndBuffSize - MaxDeepLevel - 2 )
        dad     b                          ;
        mov     a , h                      ;
        ani     080h                       ;
        jnz     FillRndTab_0               ;
        ret                                ;end (* FillRandnomTable *) ;
;*******************************************
AddToRndCyclic                             ;procedure AddToRndCyclic ( Rnd[hl] : word ) ;
                                           ;begin (* AddToRndCyclic *)
        push    h                          ;
                                           ; RndCyclic . RndBuffer [ RndCyclic . RndCycTo ] := Rnd ;
        lxi     d , RndCyclic + RndCyclicRecT . RndCycTo
        lhlx                               ;
        dad     h                          ;
        lxi     b , RndCyclic + RndCyclicRecT . RndBuffer
        dad     b                          ;
        mov     d , h                      ;
        mov     e , l                      ;
        pop     h                          ;
        shlx                               ;
                                           ; RndCyclic . RndCycTo := ( RndCyclic . RndCycTo + 1 ) MOD RndBuffSize ;
        lxi     d , RndCyclic + RndCyclicRecT . RndCycTo
        lhlx                               ;
        inx     h                          ;
        mvi     a , hi ( RndBuffSize - 1 ) ;
        ana     h                          ;
        mov     h , a                      ;
        mvi     a , lo ( RndBuffSize - 1 ) ;
        ana     l                          ;
        mov     l , a                      ;
        shlx                               ;
        ret                                ;end (* AddToRndCyclic *) ;
;*******************************************
GetFromRndCyclic                           ;function GetFromRndCyclic : word[hl] ;
                                           ;var
                                           ; Tmp : word ;
                                           ;begin (* GetFromRndCyclic *)
                                           ; Tmp := RndCyclic . RndBuffer [ RndCyclic . RndCycFr ] ;
        lxi     d , RndCyclic + RndCyclicRecT . RndCycFr
        lhlx                               ;
        dad     h                          ;
        lxi     b , RndCyclic + RndCyclicRecT . RndBuffer
        dad     b                          ;
        mov     d , h                      ;
        mov     e , l                      ;
        lhlx                               ;
        push    h                          ;
                                           ; RndCyclic . RndCycFr := ( RndCyclic . RndCycFr + 1 ) MOD RndBuffSize ;
        lxi     d , RndCyclic + RndCyclicRecT . RndCycFr
        lhlx                               ;
        inx     h                          ;
        mvi     a , hi ( RndBuffSize - 1 ) ;
        ana     h                          ;
        mov     h , a                      ;
        mvi     a , lo ( RndBuffSize - 1 ) ;
        ana     l                          ;
        mov     l , a                      ;
        shlx                               ;
        pop     h                          ;
        ret                                ;end (* GetFromRndCyclic *) ;
;*******************************************
GetFromRndCyclicRelative                   ;function GetFromRndCyclicRelative ( Relative[hl] : word ) : word[hl] ;
                                           ;begin (* GetFromRndCyclicRelative *)
        push    h                          ; TmpIndex := RndCyclic . RndCycFr + Relative ;
        pop     b                          ;
        lxi     d , RndCyclic + RndCyclicRecT . RndCycFr
        lhlx                               ;
        dad     b                          ;
        lxi     d , TmpIndex               ;
        shlx                               ;
        mov     a , h                      ; if TmpIndex < 0 then
        ani     80h                        ;
        jz      GetFrCyCRel_2              ;
        lxi     b , RndBuffSize            ;  TmpIndex := TmpIndex + RndBuffSize ;
        dad     b                          ;
        shlx                               ;
GetFrCyCRel_2                              ;
        lxi     b , - RndBuffSize          ; if TmpIndex >= RndBuffSize then
        dad     b                          ;
        mov     a , b                      ;
        ora     c                          ;
        jz      GetFrCyCRel_0              ;
        mov     a , b                      ;
        ani     80h                        ;
        jnz     GetFrCyCRel_1              ;
GetFrCyCRel_0                              ;
        lxi     d , TmpIndex               ;  TmpIndex := TmpIndex - RndBuffSize ;
        lhlx                               ;
        lxi     b , - RndBuffSize          ;
        dad     b                          ;
        shlx                               ;
GetFrCyCRel_1                              ;
        lxi     d , TmpIndex               ; GetFromRndCyclicRelative := RndCyclic . RndBuffer [ TmpIndex  ] ;
        lhlx                               ;
        dad     h                          ;
        lxi     b , RndCyclic + RndCyclicRecT . RndBuffer
        dad     b                          ;
        mov     d , h                      ;
        mov     e , l                      ;
        lhlx                               ;
        ret                                ;
                                           ;end (* GetFromRndCyclicRelative *) ;
;*******************************************
DispBit                                    ;procedure DispBit ( BitV[A] : byte ) ;
                                           ;begin (* DispBit *)
        cpi     0                          ; if BitV <> 0 then
        jz      DispBI_1                   ; begin
        mvi     a , '1'                    ;  WriteChLCD ( '1' ) ;
        call    WriteChLCD                 ;
        ret                                ;  exit ;
DispBI_1                                   ; end ;
        mvi     a , '0'                    ; WriteChLCD ( '0' ) ;
        call    WriteChLCD                 ;
        ret                                ;end (* DispBit *) ;
;*******************************************
DispByte                                   ;procedure DispByte ( Byte[A] : byte ) ;
                                           ;begin (* DispByte *)
        push   psw                         ; DispBit ( Byte and 10000000b ) ;
        ani    10000000b                   ;
        call   DispBit                     ;
        pop    psw                         ;
        push   psw                         ; DispBit ( Byte and 01000000b ) ;
        ani    01000000b                   ;
        call   DispBit                     ;
        pop    psw                         ;
        push   psw                         ; DispBit ( Byte and 00100000b ) ;
        ani    00100000b                   ;
        call   DispBit                     ;
        pop    psw                         ;
        push   psw                         ; DispBit ( Byte and 00010000b ) ;
        ani    00010000b                   ;
        call   DispBit                     ;
        pop    psw                         ;
        push   psw                         ; DispBit ( Byte and 00001000b ) ;
        ani    00001000b                   ;
        call   DispBit                     ;
        pop    psw                         ;
        push   psw                         ; DispBit ( Byte and 00000100b ) ;
        ani    00000100b                   ;
        call   DispBit                     ;
        pop    psw                         ;
        push   psw                         ; DispBit ( Byte and 00000010b ) ;
        ani    00000010b                   ;
        call   DispBit                     ;
        pop    psw                         ;
        push   psw                         ; DispBit ( Byte and 00000001b ) ;
        ani    00000001b                   ;
        call   DispBit                     ;
        pop    psw                         ;
        ret                                ;end (* DispByte *) ;
;*******************************************
DispWord                                   ;procedure DispWord ( Word[HL] : word ) ;
                                           ;begin (* DispWord *)
        push   h                           ;
        mov    a , h                       ;
        call   DispByte                    ; DispByte ( Hi ( Worh ) ) ;
        pop    h                           ;
        mov    a , l                       ;
        call   DispByte                    ; DispByte ( Lo ( Worh ) ) ;
        ret                                ;end (* DispWord *) ;
;*******************************************
DivHLBy10                                  ;function DivHLBy10 ( Arg[hl] : word ) : word[hl],[a] ;
                                           ;var
                                           ; Rem[b] : byte ;
                                           ; Loop[c] : byte ;
                                           ; IntPart[de] : word ;
                                           ;begin (* DivHLBy10 *)
        lxi    d , 0                       ; IntPart := 0 ;
        mvi    b , 0                       ; Rem := 0 ;
        mvi    c , 0                       ; for Loop := 0 to 15 do
DivHL_0                                    ;  begin
        xra    a                           ;   IntPart := IntPart << 1 ;
        mov    a , e                       ;
        ral                                ;
        mov    e , a                       ;
        mov    a , d                       ;
        ral                                ;
        mov    d , a                       ;
        xra    a                           ;   Rem := Rem << 1 + Arg.15 ;
        mov    a , b                       ;
        ral                                ;
        mov    b , a                       ;
        xra    a                           ;
        mov    a , l                       ;
        ral                                ;
        mov    l , a                       ;
        mov    a , h                       ;
        ral                                ;
        mov    h , a                       ;
        jnc    DivHL_2                     ;
        mov    a , b                       ;
        ori    1                           ;
        mov    b , a                       ;
DivHL_2                                    ;
        mov    a , b                       ;
        cpi    10                          ;   if Rem >= 10 then
        jc     DivHL_1                     ;    begin
        inx    d                           ;     IntPart := IntPart + 1 ;
        mov    a , b                       ;     Rem := Rem - 10 ;
        sui    10                          ;
        mov    b , a                       ;
DivHL_1                                    ;    end ;
        inr    c                           ;  end ;
        mov    a , c                       ;
        cpi    16                          ;
        jc     DivHL_0                     ;
        push   d                           ;
        pop    h                           ;
        mov    a , b                       ;
        ret                                ;end (* DivHLBy10 *) ;
;*******************************************
Abs                                        ;function Abs ( Arg[hl] : word ) : word[hl] ;
                                           ;begin (* Abs *)
        mov     a , h                      ; if Arg >= 0 then
        ani     80h                        ;
        rz                                 ;  Abs := Arg
                                           ; else
        mov     a , l                      ;  Abs := - Arg ;
        cma                                ;
        mov     l , a                      ;
        mov     a , h                      ;
        cma                                ;
        mov     h , a                      ;
        inx     h                          ;
        ret                                ;end (* Abs *) ;
;*******************************************
NegBC                                      ;function NegBC ( Arg[bc] : word ) : word[bc] ;
                                           ;begin (* NegBC *)
        mov    a , b                       ;
        cma                                ;
        mov    b , a                       ;
        mov    a , c                       ;
        cma                                ;
        mov    c , a                       ;
        inx    b                           ;
        ret                                ;end (* NegBC *)
;*******************************************
ShiftBC2bits                               ;function ShiftBC2bits ( Arg[bc] : word ) ; word [bc] ;
;                                          ;begin (* ShiftBC2bits *)
        ora    a                           ;
        mov    a , b                       ;
        rar                                ;
        mov    b , a                       ;
        mov    a , c                       ;
        rar                                ;
        mov    c , a                       ;
        ora    a                           ;
        mov    a , b                       ;
        rar                                ;
        mov    b , a                       ;
        mov    a , c                       ;
        rar                                ;
        mov    c , a                       ;
        ret                                ;end (* ShiftBC2bits *) ;
;*******************************************
ShiftHLR                                   ;function ShiftHLR ( Arg[hl] : word ) : word[hl] ;
                                           ;begin (* ShiftHLR *)
        ora    a                           ;
        mov    a , h                       ;
        rar                                ;
        mov    h , a                       ;
        mov    a , l                       ;
        rar                                ;
        mov    l , a                       ;
        ret                                ;end (* ShiftHLR *) ;
;*******************************************
BinaryToString                             ;procedure BinaryToString ( Binary[hl] : word ) ;
                                           ;begin (* BinaryToString *)
        push   h                           ;
        lxi    h , BinToStr                ; BinToStr [ 0 ] := ' ' ;
        mvi    a , ' '                     ;
        mov    m , a                       ;
        inx    h                           ; BinToStr [ 1 ] := ' ' ;
        mov    m , a                       ;
        inx    h                           ; BinToStr [ 2 ] := ' ' ;
        mov    m , a                       ;
        inx    h                           ; BinToStr [ 3 ] := ' ' ;
        mov    m , a                       ;
        inx    h                           ; BinToStr [ 4 ] := ' ' ;
        mov    m , a                       ;
        inx    h                           ; BinToStr [ 5 ] := chr ( 0 ) ;
        mvi    m , 0                       ;
        pop    h                           ;
        call   DivHLBy10                   ; BinToStr [ 4 ] := Binary MOD 10 + '0' ;
                                           ; Binary := Binary DIV 10 ;
        adi    '0'                         ;
        sta    BinToStr + 4                ;
        mov    a , h                       ; if Binary = 0 then
        ora    l                           ;
        rz                                 ;  exit ;
        call   DivHLBy10                   ; BinToStr [ 3 ] := Binary MOD 10 + '0' ;
                                           ; Binary := Binary DIV 10 ;
        adi    '0'                         ;
        sta    BinToStr + 3                ;
        mov    a , h                       ; if Binary = 0 then
        ora    l                           ;
        rz                                 ;  exit ;
        call   DivHLBy10                   ; BinToStr [ 2 ] := Binary MOD 10 + '0' ;
                                           ; Binary := Binary DIV 10 ;
        adi    '0'                         ;
        sta    BinToStr + 2                ;
        mov    a , h                       ; if Binary = 0 then
        ora    l                           ;
        rz                                 ;  exit ;
        call   DivHLBy10                   ; BinToStr [ 1 ] := Binary MOD 10 + '0' ;
                                           ; Binary := Binary DIV 10 ;
        adi    '0'                         ;
        sta    BinToStr + 1                ;
        mov    a , h                       ; if Binary = 0 then
        ora    l                           ;
        rz                                 ;  exit ;
        call   DivHLBy10                   ; BinToStr [ 0 ] := Binary MOD 10 + '0' ;
                                           ; Binary := Binary DIV 10 ;
        adi    '0'                         ;
        sta    BinToStr                    ;
        ret                                ;end (* BinaryToString *) ;
;*******************************************
BegOfString                                ;function BegOfString ( String[hl] : string ) : ptr[hl) ;
                                           ;begin (* BegOfString *)
        mov    a , m                       ; if String [ 0 ] <> ' ' then
        cpi    ' '                         ;
        jz     BegOfStr_0                  ;  begin 
                                           ;   BegOfString := Adr ( String [ 0 ] ) ;
        ret                                ;   exit ;
BegOfStr_0                                 ;  end ;
        inx    h                           ;
        mov    a , m                       ; if String [ 1 ] <> ' ' then
        cpi    ' '                         ;
        jz     BegOfStr_1                  ;  begin 
                                           ;   BegOfString := Adr ( String [ 1 ] ) ;
        ret                                ;   exit ;
BegOfStr_1                                 ;  end ;
        inx    h                           ;
        mov    a , m                       ; if String [ 2 ] <> ' ' then
        cpi    ' '                         ;
        jz     BegOfStr_2                  ;  begin 
                                           ;   BegOfString := Adr ( String [ 2 ] ) ;
        ret                                ;   exit ;
BegOfStr_2                                 ;  end ;
        inx    h                           ;
        mov    a , m                       ; if String [ 3 ] <> ' ' then
        cpi    ' '                         ;
        jz     BegOfStr_3                  ;  begin 
                                           ;   BegOfString := Adr ( String [ 3 ] ) ;
        ret                                ;   exit ;
BegOfStr_3                                 ;  end ;
                                           ; BegOfString := Adr ( String [ 4 ] ) ;
        ret                                ;end (* BegOfString *) ;
;*******************************************
Init_hardware                              ;procedure Init_hardware ;
                                           ;begin (* Init_hardware *)
        mvi     a , Tim0WaveGenMode        ; timer 0 jako generator 10 kHz (2 MHz / 2000 )
        out     Timer8253 + Port8253.Control
        mvi     a , lo ( Timer0Divider )   ;
        out     Timer8253 + Port8253.TimerA;
        mvi     a , hi ( Timer0Divider )   ;
        out     Timer8253 + Port8253.TimerA;
        mvi     a , Tim1IrqGenMode         ; timer 1 jako generator przerwan
        out     Timer8253 + Port8253.Control
        mvi     a , lo ( Timer1Prescaler ) ;
        out     Timer8253 + Port8253.TimerB;
        mvi     a , hi ( Timer1Prescaler ) ;
        out     Timer8253 + Port8253.TimerB;
        mvi     a , Enable75Inter          ; EnableInterrupt ( Irq7.5 ) ;
        sim                                ;
        ret                                ;end (* Init_hardware *) ;
;*******************************************
HardvInpKbd                                ;function HardvInpKbd : byte[A] ;
                                           ;begin (* HardvInpKbd *)
        in      KBDPort + Port8255.PortC   ; HardvInpKbd := KBDPort.PortC or 0Fh ;
        ori     0Fh                        ;
        ret                                ;end (* HardvInpKbd *) ;
;*******************************************
HardvSetRowKbd                             ;procedure HardvSetRowKbd ( Row[A] : byte ) ;
                                           ;begin (* HardvSetRowKbd *)
                                           ; case KbdModInstance.RowCounter of
        lda     KbdModInstance + KbdModInstanceT.RowCounter
        cpi     0                          ;  0 :
        jnz     HvdSeRSrv_1                ;
        mvi     a , 11111110b              ;   KBDPort.PortB := 11111110b ;
        out     KBDPort + Port8255.PortB   ;
        jmp     HvdSeRSrv_0                ;
HvdSeRSrv_1                                ;
        cpi     1                          ;  1 :
        jnz     HvdSeRSrv_2                ;
        mvi     a , 11111101b              ;   KBDPort.PortB := 11111101b ;
        out     KBDPort + Port8255.PortB   ;
        jmp     HvdSeRSrv_0                ;
HvdSeRSrv_2                                ;
        cpi     2                          ;  2 :
        jnz     HvdSeRSrv_3                ;
        mvi     a , 11111011b              ;   KBDPort.PortB := 11111011b ;
        out     KBDPort + Port8255.PortB   ;
        jmp     HvdSeRSrv_0                ;
HvdSeRSrv_3                                ;
        cpi     3                          ;  3 :
        jnz     HvdSeRSrv_4                ;
        mvi     a , 11110111b              ;   KBDPort.PortB := 11110111b ;
        out     KBDPort + Port8255.PortB   ;
        jmp     HvdSeRSrv_0                ;
HvdSeRSrv_4                                ;
        cpi     4                          ;  4 :
        jnz     HvdSeRSrv_5                ;
        mvi     a , 11101111b              ;   KBDPort.PortB := 11101111b ;
        out     KBDPort + Port8255.PortB   ;
        jmp     HvdSeRSrv_0                ;
HvdSeRSrv_5                                ;
        cpi     5                          ;  5 :
        jnz     HvdSeRSrv_6                ;
        mvi     a , 11011111b              ;   KBDPort.PortB := 11011111b ;
        out     KBDPort + Port8255.PortB   ;
        jmp     HvdSeRSrv_0                ;
HvdSeRSrv_6                                ;
        cpi     6                          ;  6 :
        jnz     HvdSeRSrv_7                ;
        mvi     a , 10111111b              ;   KBDPort.PortB := 10111111b ;
        out     KBDPort + Port8255.PortB   ;
        jmp     HvdSeRSrv_0                ;
HvdSeRSrv_7                                ;
        cpi     7                          ;  7 :
        jnz     HvdSeRSrv_8                ;
        mvi     a , 01111111b              ;   KBDPort.PortB := 01111111b ;
        out     KBDPort + Port8255.PortB   ;
        jmp     HvdSeRSrv_0                ;
HvdSeRSrv_8                                ; end (* case *) ;
HvdSeRSrv_0                                ;
        ret                                ;end (* HardvSetRowKbd *) ;
;*******************************************
SendDataToPort                             ;procedure SendDataToPort ( Data[hl] : word ) ;
                                           ;begin (* SendDataToPort *)
        mov     a , h                      ; RNDPort.PortB := Hi ( Data ) ;
        out     RNDPort + Port8255.PortB   ;
        mov     a , l                      ; RNDPort.PortA := Lo ( Data ) ;
        out     RNDPort + Port8255.PortA   ;
        di                                 ; DisableInt ;
        lxi     h, LedPortCopy             ; LedPortCopy := LedPortCopy OR RunLedOn ;
        mov     a , m                      ;
        ori     LS373Strobe                ;
        out     RNDPort + Port8255.PortC   ; RNDPort.PortC := LedPortCopy OR LS373Strobe ;
        nop                                ;
        nop                                ;
        nop                                ;
        mov     a , m                      ; RNDPort.PortC := LedPortCopy ;
        out     RNDPort + Port8255.PortC   ;
        lda     RisingEdgeFlag             ; if RisingEdgeFlag then
        cpi     0                          ;
        jz      SeDaToP_0                  ;
        mov     a , m                      ;  RNDPort.PortC := LedPortCopy OR ExternStrobe
        ori     ExternStrobe               ;
        out     RNDPort + Port8255.PortC   ;
        jz      SeDaToP_1                  ;
SeDaToP_0                                  ; else
        mov     a , m                      ;  RNDPort.PortC := LedPortCopy AND ( ~ ExternStrobe ) ;
        ani     ExternStrobe xor 0FFh      ;
        out     RNDPort + Port8255.PortC   ;
SeDaToP_1                                  ;
        nop                                ;
        nop                                ;
        nop                                ;
        mov     a , m                      ; RNDPort.PortC := LedPortCopy ;
        out     RNDPort + Port8255.PortC   ;
        ei                                 ; EnableInt ;
        ret                                ;end (* SendDataToPort *) ;
;*******************************************
ShowData                                   ;procedure ShowData ( Data[hl] : word ) ;
                                           ;var
                                           ; TmpInx[hl] : word ;
                                           ;begin (* ShowData *)
        push    h                          ;
        call    ClrScrLCD                  ; ClrScrLCD ;
        lxi     h , RelativeIndexTxt       ; WriteTextLCD ( RelativeIndexTxt ) ;
        call    WriteTextLCD               ;
        lxi     d , RelativeIndex          ; TmpInx := RelativeIndex + 1 ;
        lhlx                               ;
        inx     h                          ;
        mov     a , h                      ; if TmpInx < 0 then
        ani     80h                        ;
        jz      ShowDa_0                   ;  begin
        mov     a , l                      ;   TmpInx := - TmpInx ;
        cma                                ;
        mov     l , a                      ;
        mov     a , h                      ;
        cma                                ;
        mov     h , a                      ;
        inx     h                          ;
        push    h                          ;
        mvi     a , '-'                    ;   WriteChLCD ( '-' ) ;
        call    WriteChLCD                 ;
        pop     h                          ;
ShowDa_0                                   ;  end ;
        call    BinaryToString             ; BinaryToString ( TmpInx ) ;
        lxi     h , BinToStr               ; WriteTextLCD ( BegOfString ( BinToStr ) ) ;
        call    BegOfString                ;
        call    WriteTextLCD               ;
        call    NewLineLCD                 ; NewLineLCD ;
        pop     h                          ; DispWord ( Data ) ;
        call    DispWord                   ;
        ret                                ;end (* ShowData *) ;
;*******************************************
Init_envir                                 ;procedure Init_envir ;
                                           ;begin (* Init_envir *)
        call    SetLCDOutputDataBus        ; SetLCDOutputDataBus ;
        call    InitLCDEnvir               ; InitLCDEnvir ;
        mvi     a , 0FFh                   ; KBDPort.PortB := 0FFh ;
        out     KBDPort + Port8255.PortB   ;
                                           ; RNDPort.Control := P8255A_out + P8255B_out + P8255CL_out + P8255CH_out ;
        mvi     a , 080h + P8255A_out + P8255B_out + P8255CL_out + P8255CH_out
        out     RNDPort + Port8255.Control ;
        mvi     a , 0                      ; RNDPort.PortA := 0 ;
        out     RNDPort + Port8255.PortA   ;
        out     RNDPort + Port8255.PortB   ; RNDPort.PortB := 0 ;
        out     RNDPort + Port8255.PortC   ; RNDPort.PortC := 0 ;
        ret                                ;end (* Init_envir () ;
;*******************************************
SetLCDOutputDataBus                        ;procedure SetLCDOutputDataBus ;
                                           ;begin (* SetLCDOutputDataBus *)
                                           ; LCDPort.Control.PortA := <output> ;
        mvi     a , 080h + P8255A_out + P8255B_out + P8255CL_out + P8255CH_inp
        out     LCDPort + Port8255.Control ;
        ret                                ;end (* SetLCDOutputDataBus *) ;
;*******************************************
SetLCDInputDataBus                         ;procedure SetLCDInputDataBus ;
                                           ;begin (* SetLCDInputDataBus *)
                                           ; LCDPort.Control.PortA := <input> ;
        mvi     a , 080h + P8255A_inp + P8255B_out + P8255CL_out + P8255CH_inp
        out     LCDPort + Port8255.Control ;
        ret                                ;end (* SetLCDInputDataBus *) ;
;*******************************************
InitLCDEnvir                               ;procedure InitLCDEnvir ;
                                           ;begin (* InitLCDEnvir *)
        mvi     a , ClrLCDEBit             ; LCDPort.PortC[E]:= 0 ;
        out     LCDPort + Port8255.Control ;
        ret                                ;end (* InitLCDEnvir *) ;
;*******************************************
LCDDelay                                   ;procedure LCDDelay ;
                                           ;begin (* LCDDelay *)
        nop                                ;
        nop                                ;
        nop                                ;
        ret                                ;end (* LCDDelay *) ;
;*******************************************
EPulse                                     ;procedure EPulse ;
                                           ;begin (* EPulse *)
        mvi     a , SetLCDEBit             ; LCDPort.PortC[E]:= 1 ;
        out     LCDPort + Port8255.Control ;
        call    LCDDelay                   ; LCDDelay ;
        mvi     a , ClrLCDEBit             ; LCDPort.PortC[E]:= 0 ;
        out     LCDPort + Port8255.Control ;
        ret                                ;end (* EPulse *) ;
;*******************************************
LCDOutC                                    ;procedure LCDOutC ( Data[A] : byte ) ;
                                           ;begin (* LCDOutC *)
        push    psw                        ;
        call    SetLCDOutputDataBus        ; SetLCDOutputDataBus ;
        mvi     a , ClrLCDRSBit            ; LCDPort.PortC[RS]:= 0 ;
        out     LCDPort + Port8255.Control ;
        mvi     a , ClrLCDRWBit            ; LCDPort.PortC[RW]:= 0 ;
        out     LCDPort + Port8255.Control ;
        pop     psw                        ;
        out     LCDPort + Port8255.PortA   ; LCDPort.PortA := Data ;
        call    EPulse                     ; EPulse ;
        ret                                ;end (* LCDOutC *) ;
;*******************************************
LCDInC                                     ;function LCDInC : byte[A] ;
                                           ;var
                                           ; Tmp : byte ;
                                           ;begin (* LCDInC *)
        call    SetLCDInputDataBus         ; SetLCDInputDataBus ;
        mvi     a , ClrLCDRSBit            ; LCDPort.PortC[RS]:= 0 ;
        out     LCDPort + Port8255.Control ;
        mvi     a , SetLCDRWBit            ; LCDPort.PortC[RW]:= 1 ;
        out     LCDPort + Port8255.Control ;
        mvi     a , SetLCDEBit             ; LCDPort.PortC[E]:= 1 ;
        out     LCDPort + Port8255.Control ;
        call    LCDDelay                   ; LCDDelay ;
        in      LCDPort + Port8255.PortA   ; Tmp := LCDPort.PortA ;
        push    psw                        ;
        mvi     a , ClrLCDEBit             ; LCDPort.PortC[E]:= 0 ;
        out     LCDPort + Port8255.Control ;
        pop     psw                        ; LCDInC := Tmp ;
        ret                                ;end (* LCDInC *) ;
;*******************************************
LCDOutD                                    ;procedure LCDOutD ( Data[A] : byte ) ;
                                           ;begin (* LCDOutD *)
        push    psw                        ;
        call    SetLCDOutputDataBus        ; SetLCDOutputDataBus ;
        mvi     a , SetLCDRSBit            ; LCDPort.PortC[RS]:= 1 ;
        out     LCDPort + Port8255.Control ;
        mvi     a , ClrLCDRWBit            ; LCDPort.PortC[RW]:= 0 ;
        out     LCDPort + Port8255.Control ;
        pop     psw                        ;
        out     LCDPort + Port8255.PortA   ; LCDPort.PortA := Data ;
        call    EPulse                     ; EPulse ;
        ret                                ;end (* LCDOutD *) ;
;*******************************************
WaitAccept                                 ;procedure WaitAccept ;
                                           ;var
                                           ; Tmp : byte ;
                                           ;begin (* WaitAccept *)
WaitAccept_1                               ; repeat
        call    LCDInC                     ;  Tmp := LCDInC ;
        ani     080h                       ; until Tmp.7 = 1 ;
        cpi     080h                       ;
        jnz     WaitAccept_0               ;
        nop                                ;
        jmp     WaitAccept_1               ;
WaitAccept_0                               ;
        ret                                ;end (* WaitAccept *) ;
;*******************************************
InitialiseLCD                              ;procedure InitialiseLCD ;
                                           ;begin (* InitialiseLCD *)
        mvi     a , 038h                   ; LCDOutC ( 038h ) ;
        call    LCDOutC                    ;       ; set : dl = 8 bits
                                           ;       ;       li = 2 line
					   ;       ;       5 X 7 dot
        call    WaitAccept                 ; WaitAccept ;
        call    SetCursonOff               ; SetCursonOff ;
        mvi     a , 006h                   ; LCDOutC ( 06h ) ;
        call    LCDOutC                    ;       ; set : autoincrement
				           ;       ;       non shift mode
        call    WaitAccept                 ; WaitAccept ;
        ret                                ;end (* InitialiseLCD *) ;
;*******************************************
ClrScrLCD                                  ;procedure ClrScrLCD ;
                                           ;begin (* ClrScrLCD *)
        mvi     a , 001h                   ; LCDOutC ( 01h ) ;
        call    LCDOutC                    ;
        call    WaitAccept                 ; WaitAccept ;
        ret                                ;end (* ClrScrLCD *) ;
;*******************************************
HomeLCD                                    ;procedure HomeLCD ;
                                           ;begin (* HomeLCD *)
        mvi     a , 002h                   ; LCDOutC ( 02h ) ;
        call    LCDOutC                    ;
        call    WaitAccept                 ; WaitAccept ;
        ret                                ;end (* HomeLCD *) ;
;*******************************************
SetCursorOn                                ;procedure SetCursorOn ( BlinkMode[A] : boolean ) ;
                                           ;begin (* SetCursorOn *)
        cpi     0                          ; if BlinkMode then
        jnz     SetCursorOn_0              ;
        mvi     a , 00Eh                   ;  LCDOutC ( 0Eh )
        call    LCDOutC                    ;       ; set : display on
					   ;       ;       cursor on
					   ;       ;       cursor blink off
        jmp    SetCursorOn_1               ; else
SetCursorOn_0                              ;
        mvi     a , 00Fh                   ;  LCDOutC ( 0Fh ) ;
        call    LCDOutC                    ;       ; set : display on
					   ;       ;       cursor on
					   ;       ;       cursor blink on
SetCursorOn_1                              ;
        call    WaitAccept                 ; WaitAccept ;
        ret                                ;end (* SetCursorOn *) ;
;*******************************************
SetCursonOff                               ;procedure SetCursonOff ;
                                           ;begin (* SetCursonOff *)
        mvi     a , 00Ch                   ; LCDOutC ( 0Ch ) ;
        call    LCDOutC                    ;       ; set : display on
					   ;       ;       cursor on
					   ;       ;       cursor blink off
        call    WaitAccept                 ; WaitAccept ;
        ret                                ;end (* SetCursonOff *) ;
;*******************************************
SetCursorPos                               ;procedure SetCursorPos ( Col[B] : byte ;
                                           ;                         Row[C] : byte ) ;
                                           ;var
                                           ; Control : byte ;
                                           ;begin (* SetCursorPos *)
        mov     a , b                      ; Col := Col and 03fh ;
        ani     3Fh                        ;
        mov     a , b                      ;
        mov     a , c                      ; if Row <> 0 then
        cpi     0                          ;
        jz      SetCursPos_0               ;
        mvi     a , 0C0h                   ;  Control := 0C0h
        jmp     SetCursPos_1               ; else
SetCursPos_0                               ;
        mvi     a , 80h                    ;  Control = 080h ;
SetCursPos_1                               ;
        add     b                          ; LCDOutC ( Control + Col ) ;
        call    LCDOutC                    ;
        call    WaitAccept                 ; WaitAccept ;
        ret                                ;end (* SetCursorPos *) ;
;*******************************************
NewLineLCD                                 ;procedure NewLineLCD ;
                                           ;begin (* NewLineLCD *)
        mvi     a , 0C0h                   ; LCDOutC ( 0C0h ) ;
        call    LCDOutC                    ;
        call    WaitAccept                 ; WaitAccept ;
        ret                                ;end (* NewLineLCD *) ;
;*******************************************
WriteChLCD                                 ;procedure WriteChLCD ( Ch[A] : byte )
                                           ;begin (* WriteChLCD *)
        call    LCDOutD                    ; LCDOutD ( Ch ) ;
        call    WaitAccept                 ; WaitAccept ;
        ret                                ;end (* WriteChLCD *) ;
;*******************************************
WriteTextLCD                               ;procedure WriteTextLCD ( Text[HL] : pointer to char ) ;
                                           ;begin (* WriteTextLCD *)
WriteTextLCD_0                             ; repeat
        mov     a , m                      ;  if Text ^ = chr(0) then
        cpi     0                          ;
        rz                                 ;   return ;
        push    h                          ;
        call    WriteChLCD                 ;  WriteChLCD ( Text ^ ) ;
        pop     h                          ;
        inx     h                          ;  Text := succ ( Text ) ;
        jmp     WriteTextLCD_0             ; until false ;
                                           ;end (* WriteTextLCD *) ;
;*******************************************
KeyPressed                                 ;function KeyPressed : boolean[A] ;
                                           ;begin (* KeyPressed *)
                                           ; if KbdModInstance.KbdCyclic.CycFr = KbdModInstance.KbdCyclic.CycTo then
        lda     KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.CycFr
        lxi     h , KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.CycTo
        cmp     m                          ;
        jnz     KeyPre_0                   ;
        mvi     a , 0                      ;  KeyPressed := False
        ret                                ;
KeyPre_0                                   ; else
        mvi     a , 1                      ;  KeyPressed := True ;
        ret                                ;end (* KeyPressed *) ;
;*******************************************
ReadKey                                    ;function ReadKey : char[A] ;
                                           ;var
                                           ; Tmp : char ;
                                           ;begin (* ReadKey *)
        call    KeyPressed                 ; if KeyPressed then
        cpi     0                          ;
        jz      ReadK_0                    ;  begin
                                           ;   Ch := KbdModInstance.KbdCyclic.Buffer[KbdModInstance.KbdCyclic.CycFr] ;
        lda     KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.CycFr
        mvi     b , 0                      ;
        mov     c , a                      ;
        lxi     h , KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.buffer
        dad     b                          ;
        mov     a , m                      ;
        push    psw                        ;
                                           ;   KeybModInstance.KBDCyclic.CycFr := KeybModInstance.KBDCyclic.CycFr + 1 ;
        lxi     h , KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.CycFr
        inr     m                          ;
        mov     a , m                      ;
        cpi     KbdBuffSz                  ;   if KeybModInstance.KBDCyclic.CycFr >= KbdBuffSz then
        jnz     ReadK_1                    ;
        mvi     a , 0                      ;
        mov     m , a                      ;    KeybModInstance.KBDCyclic.CycFr := 0 ;
ReadK_1                                    ;
        pop     psw                        ;   ReadKey := Ch ;
        ret                                ;
ReadK_0                                    ;  end ;
        mvi     a , 0                      ;  ReadKey := 0 ;
        ret                                ;end (* ReadKey *) ;
;*******************************************
StoreKey                                   ;procedure StoreKey ( NexCh[A] : char ) ;
                                           ;begin (* StoreKey *)
        push    psw                        ;
                                           ; KbdModInstance.KBDCyclic.Buffer[KbdModInstance.KBDCyclic.CycTo] := NewCh ;
        lda     KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.CycTo
        mvi     b , 0                      ;
        mov     c , a                      ;
        lxi     h , KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.buffer
        dad     b                          ;
        pop     psw                        ;
        mov     m , a                      ;
                                           ; KeybModInstance.KBDCyclic.CycTo := KeybModInstance.KBDCyclic.CycTo + 1 ;
        lxi     h , KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.CycTo
        inr     m                          ;
        mov     a , m                      ;
        cpi     KbdBuffSz                  ; if KeybModInstance.KBDCyclic.CycTo >= KbdBuffSz then
        jnz     StoKe_0                    ;
        mvi     a , 0                      ;  KeybModInstance.KBDCyclic.CycTo := 0 ;
        mov     m , a                      ;
StoKe_0                                    ;
                                           ; if KbdModInstance.ExtraKbdReadSrv <> nil then
        lxi    d , KbdModInstance + KbdModInstanceT.ExtraKbdReadSrv
        lhlx                               ;
        mov    a , h                       ;
        ora    l                           ;
        jz     StoKe_1                     ;
        call   CallHLService               ;  KbdModInstance.ExtraKbdReadSrv ( ) ;
StoKe_1                                    ;
        ret                                ;end (* StoreKey *) ;
;*******************************************
AnyKeyActive                               ;function AnyKeyActive : boolean ;
                                           ;begin (* AnyKeyActive *)
                                           ; if KbdModInstance.HardwKbdReadSrv <> nil then
        lxi    h , KbdModInstance + KbdModInstanceT.HardwKbdReadSrv
        mov    e , m                       ;
        inx    h                           ;
        mov    d , m                       ;
        push   d                           ;
        pop    h                           ;
        mov    a , h                       ;
        ora    l                           ;
        jz     AnyKAc_0                    ;
        call   CallHLService               ;  if KbdModInstance.HardwKbdReadSrv <> 0FFh then
        cpi    0FFh                        ;
        jz     AnyKAc_1                    ;
        mvi    a , 1                       ;   return true ;
        ret                                ;
AnyKAc_1                                   ;
AnyKAc_0                                   ;
        mvi    a , 0                       ; return false ;
        ret                                ;end (* AnyKeyActive *) ;
;*******************************************
DecodeKey                                  ;procedure DecodeKey ( KbdCode[A] : byte ) ;
                                           ;var
                                           ; EncodeTable[de] : pointer ;
                                           ;begin (* DecodeKey *)
        mov     c , a                      ;
                                           ;  case KbdModInstance.RowCounter of
        lda     KbdModInstance + KbdModInstanceT.RowCounter
        cpi     0                          ;  0 :
        jnz     DecKe_1                    ;
                                           ;   EncodeTable := KbdModInstance.EncodeTableRow0 ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow0
        lhlx                               ;
        jmp     DecKe_0                    ;
DecKe_1 cpi     1                          ;  1 :
        jnz     DecKe_2                    ;
                                           ;   EncodeTable := KbdModInstance.EncodeTableRow1 ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow1
        lhlx                               ;
        jmp     DecKe_0                    ;
DecKe_2 cpi     2                          ;  2 :
        jnz     DecKe_3                    ;
                                           ;   EncodeTable := KbdModInstance.EncodeTableRow2 ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow2
        lhlx                               ;
        jmp     DecKe_0                    ;
DecKe_3 cpi     3                          ;  3 :
        jnz     DecKe_4                    ;
                                           ;   EncodeTable := KbdModInstance.EncodeTableRow3 ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow3
        lhlx                               ;
        jmp     DecKe_0                    ;
DecKe_4                                    ;
        cpi     4                          ;  4 :
        jnz     DecKe_5                    ;
                                           ;   EncodeTable := KbdModInstance.EncodeTableRow4 ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow4
        lhlx                               ;
        jmp     DecKe_0                    ;
DecKe_5                                    ;
        cpi     5                          ;  5 :
        jnz     DecKe_6                    ;
                                           ;   EncodeTable := KbdModInstance.EncodeTableRow5 ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow5
        lhlx                               ;
        jmp     DecKe_0                    ;
DecKe_6                                    ;
        cpi     6                          ;  6 :
        jnz     DecKe_7                    ;
                                           ;   EncodeTable := KbdModInstance.EncodeTableRow6 ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow6
        lhlx                               ;
        jmp     DecKe_0                    ;
DecKe_7                                    ;
        cpi     7                          ;  7 :
        jnz     DecKe_8                    ;
                                           ;   EncodeTable := KbdModInstance.EncodeTableRow7 ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow7
        lhlx                               ;
        jmp     DecKe_0                    ;
DecKe_8                                    ;
                                           ;  else
        ret                                ;   return ;
DecKe_0                                    ; end (* case *) ;
                                           ; if EncodeTable <> nil then
        mov     a , h                      ;
        ora     l                          ;
        jz      DecKe_50                   ;  begin
DecKe_62                                   ;   while EncodeTable ^ . Scan <> 0 do
        mov     a , m                      ;
        ora     a                          ;
        jz      DecKe_60                   ;    begin
        cmp     c                          ;     if EncodeTable ^ . Scan = KbdCode then
        jnz     DecKe_61                   ;      begin
        inx     h                          ;       StoreKey ( EncodeTable ^ . Char ) ;
        mov     a , m                      ;
        call    StoreKey                   ;
        ret                                ;       return ;
DecKe_61                                   ;      end ;
        inx     h                          ;     EncodeTable := EncodeTable + 2 ;
        inx     h                          ;
        jmp     DecKe_62                   ;
DecKe_60                                   ;    end ;
DecKe_50                                   ;  end ;
        ret                                ;end (* DecodeKey *) ;
;*******************************************
KeybService                                ;procedure KeybService ;
                                           ;begin (* KeybService *)
                                           ; case KbdModInstance.KbdState of
        lda    KbdModInstance + KbdModInstanceT.KbdState
        cpi    KbdIdle                     ;  KbdIdle :
        jnz    KyebSrv_2                   ;   begin
        call   AnyKeyActive                ;    if AnyKeyActive ( ) then
        cpi    0                           ;
        jz     KyebSrv_12                  ;     begin
        mvi    a , KbdWaitOnPress          ;      KbdModInstance.KbdState := KbdWaitOnPress ;
        sta    KbdModInstance + KbdModInstanceT.KbdState
        mvi    a , KbdDelayLimit           ;      KbdModInstance.KbdDelayCt := KbdDelayLimit ;
        sta    KbdModInstance + KbdModInstanceT.KbdDelayCt
        jmp    KyebSrv_13                  ;     end
KyebSrv_12                                 ;    else
                                           ;     begin
                                           ;      KbdModInstance.RowCounter := KbdModInstance.RowCounter + 1 ;
        lxi    h , KbdModInstance + KbdModInstanceT.RowCounter
        inr    m                           ;
        mov    a , m                       ;
        cpi    RowCounterLmt               ;      if KbdModInstance.RowCounter = RowCounterLmt then
        jnz    KyebSrv_14                  ;
        mvi    a , 0                       ;       KbdModInstance.RowCounter := 0 ;
        mov    m , a                       ;
KyebSrv_14                                 ;
                                           ;      if KbdModInstance.HardwKbdSetRowSrv <> nil then
        lxi     d , KbdModInstance + KbdModInstanceT.HardwKbdSetRowSrv
        lhlx                               ;
        mov     a , h                      ;
        ora     l                          ;
        jz      KyebSrv_15                 ;
                                           ;       KbdModInstance.HardwKbdSetRowSrv ( KbdModInstance.RowCounter ) ;
        lda     KbdModInstance + KbdModInstanceT.RowCounter
        call    CallHLService              ;
KyebSrv_15                                 ;
KyebSrv_13                                 ;     end ;
        jmp    KyebSrv_0                   ;   end ;
KyebSrv_2                                  ;
        cpi    KbdWaitOnPress              ;  KbdWaitOnPress :
        jnz    KyebSrv_3                   ;   begin
                                           ;    KbdModInstance.KbdDelayCt := KbdModInstance.KbdDelayCt - 1 ;
        lxi    h , KbdModInstance + KbdModInstanceT.KbdDelayCt
        dcr    m                           ;
        mov    a , m                       ;
        cpi    0                           ;    if KbdModInstance.KbdDelayCt = 0 then
        jnz    KyebSrv_21                  ;    begin
        call   AnyKeyActive                ;     if AnyKeyActive ( ) then
        cpi    0                           ;
        lxi    h , KbdModInstance + KbdModInstanceT.KbdState
        jz     KyebSrv_22                  ;
        mvi    m , KbdReady                ;      KbdModInstance.KbdState := KbdReady ;
        jmp    KyebSrv_23                  ;
KyebSrv_22                                 ;     else
        mvi    m , KbdIdle                 ;      KbdModInstance.KbdState := KbdIdle ;
KyebSrv_23                                 ;
KyebSrv_21                                 ;    end ;
        jmp    KyebSrv_0                   ;   end ;
KyebSrv_3                                  ;
        cpi    KbdReady                    ;  KbdReady :
        jnz    KyebSrv_4                   ;   begin
                                           ;    if KbdModInstance.HardwKbdReadSrv <> nil then
        lxi    d , KbdModInstance + KbdModInstanceT.HardwKbdReadSrv
        lhlx                               ;
        mov    a , h                       ;
        ora    l                           ;
        jz     KyebSrv_31                  ;
                                           ;     KbdModInstance.LastKeybInp := KbdModInstance.HardwKbdReadSrv ;
        call   CallHLService               ;
        sta    KbdModInstance + KbdModInstanceT.LastKeybInp
        jmp    KyebSrv_32                  ;
KyebSrv_31                                 ;    else
                                           ;     KbdModInstance.LastKeybInp := 0FFh ;
        mvi    a , 0FFh                    ;
        sta    KbdModInstance + KbdModInstanceT.LastKeybInp
KyebSrv_32                                 ;
        mvi    a , KbdActive               ;    KbdModInstance.KeybState := KbdActive ;
        sta    KbdModInstance + KbdModInstanceT.KbdState
        jmp    KyebSrv_0                   ;   end ;
KyebSrv_4                                  ;
        cpi    KbdActive                   ;  KbdActive :
        jnz    KyebSrv_5                   ;   begin
                                           ;    DecodeKey ( KbdModInstance.LastKeybInp ) ;
        lda    KbdModInstance + KbdModInstanceT.LastKeybInp
        call   DecodeKey                   ;
        mvi    a , KbdWaitOnFree           ;    KbdModInstance.KeybState := KbdWaitOnFree ;
        sta    KbdModInstance + KbdModInstanceT.KbdState
        jmp    KyebSrv_0                   ;   end ;
KyebSrv_5                                  ;
        cpi    KbdWaitOnFree               ;  KbdWaitOnFree :
        jnz    KyebSrv_6                   ;   begin
        call   AnyKeyActive                ;    if not AnyKeyActive ( ) then
        cpi    0                           ;
        jnz    KyebSrv_61                  ;
        mvi    a , KbdIdle                 ;     KbdModInstance.KeybState := KbdIdle ;
        sta    KbdModInstance + KbdModInstanceT.KbdState
KyebSrv_61                                 ;
KyebSrv_6                                  ;   end ;
KyebSrv_0                                  ; end (* case *) ;
        ret                                ;end (* KeybService *) ;
;*******************************************
SetEncodeTable                             ;procedure SetEncodeTable ( RowNo[A] : byte ,
                                           ;                           Table[HL] : pointer ) ;
                                           ;begin (* SetEncodeTable *)
                                           ; case RowNo of
        cpi     0                          ;
        jnz     SeEnT_1                    ;  0 :
                                           ;   KbdModInstance.EncodeTableRow0 := Table ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow0
        shlx                               ;
        jmp     SeEnT_0                    ;
SeEnT_1 cpi     1                          ;  1 :
        jnz     SeEnT_2                    ;
                                           ;   KbdModInstance.EncodeTableRow1 := Table ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow1
        shlx                               ;
        jmp     SeEnT_0                    ;
SeEnT_2 cpi     2                          ;  2 :
        jnz     SeEnT_3                    ;
                                           ;   KbdModInstance.EncodeTableRow2 := Table ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow2
        shlx                               ;
        jmp     SeEnT_0                    ;
SeEnT_3 cpi     3                          ;  3 :
        jnz     SeEnT_4                    ;
                                           ;   KbdModInstance.EncodeTableRow3 := Table ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow3
        shlx                               ;
        jmp     SeEnT_0                    ;
SeEnT_4 cpi     4                          ;  4 :
        jnz     SeEnT_5                    ;
                                           ;   KbdModInstance.EncodeTableRow4 := Table ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow4
        shlx                               ;
        jmp     SeEnT_0                    ;
SeEnT_5 cpi     5                          ;  5 :
        jnz     SeEnT_6                    ;
                                           ;   KbdModInstance.EncodeTableRow5 := Table ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow5
        shlx                               ;
        jmp     SeEnT_0                    ;
SeEnT_6 cpi     6                          ;  6 :
        jnz     SeEnT_7                    ;
                                           ;   KbdModInstance.EncodeTableRow6 := Table ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow6
        shlx                               ;
        jmp     SeEnT_0                    ;
SeEnT_7 cpi     7                          ;  7 :
        jnz     SeEnT_8                    ;
                                           ;   KbdModInstance.EncodeTableRow7 := Table ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow7
        shlx                               ;
SeEnT_8                                    ;
SeEnT_0                                    ; end (* case *) ;
        ret                                ;end (* SetEncodeTable *) ;
;*******************************************
SoftKbdInit                                ;procedure SoftKbdInit ( HardwKReadSrv[DE]   : pointer ,
                                           ;                        HardwKSetRowSrv[HL] : pointer ) ;
                                           ;begin (* SoftKbdInit *)
        push    h                          ;
        mvi     a , KbdIdle                ; KbdModInstance.KbdState := KbdIdle ;
        sta     KbdModInstance + KbdModInstanceT.KbdState
        mvi     a , 0                      ; KbdModInstance.KbdDelayCt := 0 ;
        sta     KbdModInstance + KbdModInstanceT.KbdDelayCt
                                           ; KbdModInstance.KbdCyclic.CycFr := 0 ;
        sta     KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.CycFr
                                           ; KbdModInstance.KbdCyclic.CycTo := 0 ;
        sta     KbdModInstance + KbdModInstanceT.KbdCyclic + KbdCyclicRecT.CycTo
                                           ; KbdModInstance.HardwKbdReadSrv := HardwKReadSrv ;
        lxi     h , KbdModInstance + KbdModInstanceT.HardwKbdReadSrv
        mov     m , e                      ;
        inx     h                          ;
        mov     m , d                      ;
        pop     d                          ; KbdModInstance.HardwKbdSetRowSrv := HardwKSetRowSrv ;
        lxi     h , KbdModInstance + KbdModInstanceT.HardwKbdSetRowSrv
        mov     m , e                      ;
        inx     h                          ;
        mov     m , d                      ;
        lxi     h , 0                      ; KbdModInstance.ExtraKbdReadSrv := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.ExtraKbdReadSrv
        shlx                               ;
                                           ; KbdModInstance.EncodeTableRow0 := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow0
        shlx                               ;
                                           ; KbdModInstance.EncodeTableRow1 := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow1
        shlx                               ;
                                           ; KbdModInstance.EncodeTableRow2 := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow2
        shlx                               ;
                                           ; KbdModInstance.EncodeTableRow3 := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow3
        shlx                               ;
                                           ; KbdModInstance.EncodeTableRow4 := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow4
        shlx                               ;
                                           ; KbdModInstance.EncodeTableRow5 := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow5
        shlx                               ;
                                           ; KbdModInstance.EncodeTableRow6 := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow6
        shlx                               ;
                                           ; KbdModInstance.EncodeTableRow7 := NIL ;
        lxi     d , KbdModInstance + KbdModInstanceT.EncodeTableRow7
        shlx                               ;
                                           ; KbdModInstance.RowCounter := 0 ;
        sta     KbdModInstance + KbdModInstanceT.RowCounter
        ret                                ;end (* SoftKbdInit *) ;
;*******************************************
StringToCard                               ;function StringToCard  ( Number[DE] : pointer ) : word [HL] ;
                                           ;var
                                           ; TempWord[hl] : word ;
                                           ; Ch : byte ;
                                           ; Loop : byte ;
                                           ;begin (* StringToCard *)
        lxi     h , 0                      ; TempWord := 0 ;
                                           ; Loop := 0 ;
StrTC_1                                    ; repeat
        ldax    d                          ;   Ch := Number [ Loop ] ;
        inx     d                          ;   Loop := Loop + 1 ;
        cpi     0                          ;   if Ch = 0 then
        jnz     StrTC_0                    ;   begin
        ret                                ;    StringToCard := TempWord ;
                                           ;    exit ;
StrTC_0                                    ;   end ;
        sui     '0'                        ;   Ch := Ch - '0' ;
        dad     h                          ;   TempWord := TempWord * 10 + Ch ;
        push    h                          ;
        pop     b                          ;
        dad     h                          ;
        dad     h                          ;
        dad     b                          ;
        mov     c , a                      ;
        mvi     b , 0                      ;
        dad     b                          ;
        jmp     StrTC_1                    ; until false ;
                                           ;end (* StringToCard *) ;
;*******************************************
ClearBuffer                                ;procedure ClearBuffer ;
                                           ;var
                                           ; Loop[b] : byte ;
                                           ;begin (* ClearBuffer *)
        mvi     a , 0                      ; NumberIndex := 0 ;
        lxi     h , NumberIndex            ;
        mov     m , a                      ;
        mvi     a , NumberSize + 1         ; for Loop := Numbersize downto 0 do
        mvi     b , 0                      ;
        lxi     h , Number                 ;
CleaBu_1                                   ;  begin
        mov     m , b                      ;   Number [ Loop ] := chr ( 0 ) ;
        dcr     a                          ;
        ora     a                          ;
        jz      CleaBu_0                   ;
        inx     h                          ;
        jmp     CleaBu_1                   ;
CleaBu_0                                   ;  end ;
        ret                                ;end (* ClearBuffer *) ;
;*******************************************
AddChToNumber                              ;procedure AddChToNumber ( Ch[A] : byte ) ;
                                           ;begin (* AddChToNumber *)
        mov     d , a                      ;
        lxi     h , NumberIndex            ; if NumberIndex <= NumberSize then
        mov     a , m                      ;
        cpi     NumberSize                 ;
        jc      AddCh_1                    ;
        jz      AddCh_2                    ;
AddCh_1                                    ;  begin
        lxi     h , Number                 ;   Number [ NumberIndex ] := Ch ;
        mvi     b , 0                      ;
        mov     c , a                      ;
        dad     b                          ;
        mov     m , d                      ;
        lxi     h , NumberIndex            ;   NumberIndex := NumberIndex + 1 ;
        inr     m                          ;
AddCh_2                                    ;  end ;
        ret                                ;end (* AddChToNumber *) ;
;*******************************************
DisplayInputData                           ;procedure DisplayInputData ;
                                           ;begin (* DisplayInputData *)
        mvi     b , 0                      ; SetCursorPos ( 0 , 1 ) ;
        mvi     c , 1                      ;
        call    SetCursorPos               ;
        lxi     h , NewValuePrompt         ; WriteTextLCD ( NewValuePrompt ) ;
        call    WriteTextLCD               ;
        lxi     h , Number                 ; WriteTextLCD ( Number ) ;
        call    WriteTextLCD               ;
        ret                                ;end (* DisplayInputData *) ;
;*******************************************
Message                                    ;procedure Message ( Text[hl] : string ) ;
                                           ;begin (* Message *)
        push    h                          ;
        call    ClrScrLCD                  ; ClrScrLCD ;
        pop     h                          ;
        call    WriteTextLCD               ; WriteTextLCD ( Text ) ;
        call    NewLineLCD                 ; NewLineLCD ;
        lxi     h , AnyKeyText             ; WriteTextLCD ( AnyKeyText ) ;
        call    WriteTextLCD               ;
Mess_1                                     ; repeat
        call    KeyPressed                 ;  if KeyPressed then
        ora     a                          ;
        jz      Mess_2                     ;   begin
        call    ReadKey                    ;    ? := ReadKey ;
        ret                                ;    exit ;
Mess_2                                     ;   end ;
        jmp     Mess_1                     ; until false ;
                                           ;end (* Message *) ;
;*******************************************
DisplayInterval                            ;procedure DisplayInterval ;
                                           ;begin (* DisplayInterval *)
        lxi     h , DelayIntervalTxt       ; WriteTextLCD ( DelayIntervalTxt ) ;
        call    WriteTextLCD               ;
        lxi     d , TimeInterval           ; BinaryToString ( TimeInterval ) ;
        lhlx                               ;
        call    BinaryToString             ;
        lxi     h , BinToStr               ; WriteTextLCD ( BegOfString ( BinToStr ) ) ;
        call    BegOfString                ;
        call    WriteTextLCD               ;
        lxi     h , UnitText               ; WriteTextLCD ( UnitText ) ;
        call    WriteTextLCD               ;
        ret                                ;end (* DisplayInterval *) ;
;*******************************************
HelloScreen                                ;procedure HelloScreen ;
                                           ;begin (* HelloScreen *)
        call    ClrScrLCD                  ; ClrScrLCD ;
        lxi     d , TimeInterval           ; if TimeInterval = 0 then
        lhlx                               ;
        mov     a , h                      ;
        ora     l                          ;
        jnz     HelloScr_0                 ;  begin
        lxi     h , HelloMessage           ;   WriteTextLCD ( HelloMessage ) ;
        call    WriteTextLCD               ;
        call    NewLineLCD                 ;   NewLineLCD ;
        jmp     HelloScr_1                 ;  end
HelloScr_0                                 ; else
                                           ;  begin
        call    DisplayInterval            ;   DisplayInterval ;
HelloScr_1                                 ;  end ;
        ret                                ;end (* HelloScreen *) ;
;*******************************************
StartInputData                             ;procedure StartInputData ;
                                           ;begin (* StartInputData *)
        call    ClrScrLCD                  ; ClrScrLCD ;
        lxi     h , InputDelayText         ; WriteTextLCD ( InputDelayText ) ;
        call    WriteTextLCD               ;
        call    NewLineLCD                 ; NewLineLCD ;
        call    ClearBuffer                ; ClearBuffer ;
        mvi     a , 1                      ; SetCursorOn ( 1 ) ;
        call    SetCursorOn                ;
        call    DisplayInputData           ; DisplayInputData ;
        ret                                ;end (* StartInputData *) ;
;*******************************************
InputNumericService                        ;procedure InputNumericService ( Ch[A] : char ) ;
                                           ;begin (* InputNumericService *)
                                           ; case ( Ch ) of
        cpi     EnterCh                    ;  EnterCh :
        jnz     InpNumSrv_1                ;   begin
        call    SetCursonOff               ;    SetCursonOff ;
        lxi     h , Number                 ;    if Number [ 0 ] = chr ( 0 ) then
        mov     a , m                      ;
        cpi     0                          ;
        jnz     InpNumSrv_11               ;     begin
        lxi     h , EmptyDataText          ;      Message ( EmptyDataText ) ;
        call    Message                    ;
        call    StartInputData             ;      StartInputData ;
        ret                                ;      exit ;
InpNumSrv_11                               ;     end ;
        lxi     d , Number                 ;    TimeInterval := StringToCard ( Number ) ;
        call    StringToCard               ;
        lxi     d , TimeInterval           ;
        shlx                               ;
        mov     a , h                      ;    if TimeInterval < TimeIntervalLimit then
        cpi     0                          ;
        jnz     InpNumSrv_12               ;
        mov     a ,l                       ;
        cpi     TimeIntervalLimit          ;
        jnc     InpNumSrv_12               ;     begin
        lxi     h , NumberToSmallText      ;      Message ( NumberToSmallText ) ;
        call    Message                    ;
        call    StartInputData             ;      StartInputData ;
        ret                                ;      exit ;
InpNumSrv_12                               ;     end ;
        lxi     d , TimeInterval           ;    IntervalToCompare := TimeInterval DIV 10 ;
        lhlx                               ;
        call    DivHLBy10                  ;
        lxi     d , IntervalToCompare      ;
        shlx                               ;
        call    HelloScreen                ;    HelloScreen ;
        lxi     d , GlobalService          ;    GlobalService := GlobalLevelService ;
        lxi     h , GlobalLevelService     ;
        shlx                               ;
        jmp     InpNumSrv_0                ;   end ;
InpNumSrv_1                                ;
        cpi     EscCh                      ;  EscCh :
        jnz     InpNumSrv_2                ;   begin
        call    SetCursonOff               ;    SetCursonOff ;
        call    HelloScreen                ;    HelloScreen ;
        lxi     d , GlobalService          ;    GlobalService := GlobalLevelService ;
        lxi     h , GlobalLevelService     ;
        shlx                               ;
        jmp     InpNumSrv_0                ;   end ;
InpNumSrv_2                                ;
        cpi     BackSpaceCh                ;  BackSpaceCh :
        jnz     InpNumSrv_3                ;   begin
        lxi     h , NumberIndex            ;    if NumberIndex <> 0 then
        mov     a , m                      ;
        cpi     0                          ;
        jz      InpNumSrv_21               ;    begin
        dcr     a                          ;     NumberIndex := NumberIndex  - 1 ;
        mov     m , a                      ;
        lxi     h , Number                 ;     Number [ NumberIndex ] := 0 ;
        mov     c , a                      ;
        mvi     b , 0                      ;
        dad     b                          ;
        mov     m , b                      ;
        mvi     b , 9                      ;     SetCursorPos ( 9 , 1 ) ;
        mvi     c , 1                      ;
        call    SetCursorPos               ;
        mvi     a , ' '                    ;     WriteChLCD ( ' ' ) ;
        call    WriteChLCD                 ;
        mvi     a , ' '                    ;     WriteChLCD ( ' ' ) ;
        call    WriteChLCD                 ;
        mvi     a , ' '                    ;     WriteChLCD ( ' ' ) ;
        call    WriteChLCD                 ;
        mvi     a , ' '                    ;     WriteChLCD ( ' ' ) ;
        call    WriteChLCD                 ;
        mvi     a , ' '                    ;     WriteChLCD ( ' ' ) ;
        call    WriteChLCD                 ;
        call    DisplayInputData           ;     DisplayInputData ;
InpNumSrv_21                               ;    end ;
        jmp     InpNumSrv_0                ;   end ;
InpNumSrv_3                                ;
        cpi     '0'                        ; '0' .. '9' :
        jc      InpNumSrv_4                ;
        cpi     '9' + 1                    ;
        jnc     InpNumSrv_4                ;  begin
        call    AddChToNumber              ;   AddChToNumber ( Ch ) ;
        call    DisplayInputData           ;   DisplayInputData ;
        jmp     InpNumSrv_0                ;  end ;
InpNumSrv_4                                ;
InpNumSrv_0                                ; end (* case *) ;
        ret                                ;end (* InputNumericService *) ;
;*******************************************
RealCheckHoldReq                           ;function RealCheckHoldReq : boolean ;
                                           ;begin (* RealCheckHoldReq *)
        rim                                ; if HoldReq then
        ani     80h                        ;
        jnz     ReChekHold_1               ;  begin
        mvi     a , 1                      ;   RealCheckHoldReq := true ;
        ret                                ;   exit ;
ReChekHold_1                               ;  end ;
        mvi     a , 0                      ;  RealCheckHoldReq := false ;
        ret                                ;end (* RealCheckHoldReq *) ;
;*******************************************
WaitOnPassiveState                         ;function WaitOnPassiveState : boolean ;
                                           ;begin (* WaitOnPassiveState *)
        call    RealCheckHoldReq           ; if RealCheckHoldReq then
        cpi     0                          ;
        jz      WaOnPaSta_0                ;
        call    SetHoldCheckToRealCheck    ;  SetHoldCheckToRealCheck ;
WaOnPaSta_0                                ;
        mvi     a , 0                      ; WaitOnPassiveState := false ;
        ret                                ;end (* WaitOnPassiveState *) ;
;*******************************************
SetHoldCheckToNil                          ;procedure SetHoldCheckToNil ;
                                           ;begin (* SetHoldCheckToNil *)
        lxi     d , HoldCheckSerw          ; HoldCheckSerw := NIL ;
        lxi     h , 0                      ;
        shlx                               ;
        ret                                ;end (* SetHoldCheckToNil *) ;
;*******************************************
SetHoldCheckToRealCheck                    ;procedure SetHoldCheckToRealCheck ;
                                           ;begin (* SetHoldCheckToRealCheck *)
        lxi     d , HoldCheckSerw          ; HoldCheckSerw := RealCheckHoldReq ;
        lxi     h , RealCheckHoldReq       ;
        shlx                               ;
        ret                                ;end (* SetHoldCheckToRealCheck *) ;
;*******************************************
RealRunRandomSrv                           ;procedure RealRunRandomSrv ;
                                           ;var
                                           ; CycRandom[hl] : word ;
                                           ;begin (* RealRunRandomSrv *)
        lxi     d , HoldCheckSerw          ; if HoldCheckSerw <> NIL then
        lhlx                               ;
        mov     a , h                      ;
        ora     l                          ;
        jz      ReRunRSrv_2                ;  begin
        call    CallHLService              ;   if HoldCheckSerw then
        cpi     0                          ;
        jz      ReRunRSrv_3                ;    begin
        lxi     d , RelativeIndex          ;     RelativeIndex := 0 ;
        lxi     h , 0                      ;
        shlx                               ;
        lxi     d , GlobalService          ;     GlobalService := RunPauseService ;
        lxi     h , RunPauseService        ;
        shlx                               ;
        call    ClrScrLCD                  ;     ClrScrLCD ;
        lxi     h , HardwarePauseText      ;     WriteTextLCD ( HardwarePauseText ) ;
        call    WriteTextLCD               ;
        call    NewLineLCD                 ;     NewLineLCD ;
        lxi     h , -1                     ;     DispWord ( GetFromRndCyclicRelative ( -1 ) ) ;
        call    GetFromRndCyclicRelative   ;
        call    DispWord                   ;
        lxi     d , RandomService          ;     RandomService := NIL ;
        lxi     h , 0                      ;
        shlx                               ;
        lxi     h, LedPortCopy             ;     LedPortCopy := LedPortCopy OR PauseLedOn;
        mov     a , m                      ;
        ori     PauseLedOn                 ;
        mov     m , a                      ;
        out     RNDPort + Port8255.PortC   ;     RNDPort.PortC := LedPortCopy ;
ReRunRSrv_3                                ;   end ;
ReRunRSrv_2                                ;  end ;
        lxi     h , IRQFlag                ; if IRQFlag = 1 then
        mov     a , m                      ;
        cpi     0                          ;
        jz      ReRunRSrv_0                ;  begin
        mvi     m , 0                      ;   IRQFlag = 0 ;
        lxi     d , IRQCounter             ;   IRQCounter := IRQCounter + 1 ;
        lhlx                               ;
        lxi     b , 1                      ;
        dad     b                          ;
        shlx                               ;
        lxi     d , IntervalToCompare      ;   if IRQCounter = IntervalToCompare then
        ldax    d                          ;
        cmp     l                          ;
        jnz     ReRunRSrv_1                ;
        inx     d                          ;
        ldax    d                          ;
        cmp     h                          ;
        jnz     ReRunRSrv_1                ;   begin
        lxi     d , IRQCounter             ;    IRQCounter := 0 ;
        lxi     h , 0                      ;
        shlx                               ;
        call    GetFromRndCyclic           ;    CycRandom := GetFromRndCyclic ;
        call    SendDataToPort             ;    SendDataToPort ( CycRandom ) ;
        call    CreateNewRandom            ;    RandomV := CreateNewRandom ;
        lxi     d , RandomV                ;
        shlx                               ;
        call    AddToRndCyclic             ;    AddToRndCyclic ( RandomV ) ;
        lxi     d , SampleCounter          ;    SampleCounter := SampleCounter + 1 ;
        lhlx                               ;
        inx     h                          ;
        shlx                               ;
ReRunRSrv_1                                ;   end ;
ReRunRSrv_0                                ;  end ;
        ret                                ;end (* RealRunRandomSrv *) ;
;*******************************************
StopRunOperation                           ;procedure StopRunOperation ;
                                           ;begin (* StopRunOperation *)
        call    HelloScreen                ; HelloScreen ;
        call    SetHoldCheckToNil          ; SetHoldCheckToNil ;
        lxi     d , GlobalService          ; GlobalService := GlobalLevelService ;
        lxi     h , GlobalLevelService     ;
        shlx                               ;
        lxi     d , RandomService          ; RandomService := NIL ;
        lxi     h , 0                      ;
        shlx                               ;
        lxi     h, LedPortCopy             ; LedPortCopy := LedPortCopy AND ( ~ ( PauseLedOn OR RunLedOn ) ) ;
        mov     a , m                      ;
        ani     ( PauseLedOn or RunLedOn ) xor 0FFh
        ori     LS373HiZOff                ; LedPortCopy := LedPortCopy OR LS373HiZOff ;
        mov     m , a                      ;
        out     RNDPort + Port8255.PortC   ; RNDPort.PortC := LedPortCopy ;
        ret                                ;end (* StopRunOperation *) ;
;*******************************************
RunPauseService                            ;procedure RunPauseService ( Ch[A] : char ) ;
                                           ;var
                                           ; CycRandom[hl] : word ;
                                           ;begin (* RunPauseService *)
                                           ; case ( Ch ) of
        cpi     StopRandomCh               ;  StopRandomCh :
        jnz     RunPause_1                 ;   begin
        call    StopRunOperation           ;    StopRunOperation ;
        jmp     RunPause_0                 ;   end ;
RunPause_1                                 ;
        cpi     ContinueRandomCh           ;  ContinueRandomCh :
        jnz     RunPause_2                 ;   begin
        call    ClrScrLCD                  ;    ClrScrLCD ;
        lxi     h , RunRandomText          ;    WriteTextLCD ( RunRandomText ) ;
        call    WriteTextLCD               ;
        call    NewLineLCD                 ;    NewLineLCD ;
        call    DisplayInterval            ;    DisplayInterval ;
        lxi     d , RandomService          ;    RandomService := RealRunRandomSrv ;
        lxi     h , RealRunRandomSrv       ;
        shlx                               ;
        lxi     d , GlobalService          ;    GlobalService := RunRandomService ;
        lxi     h , RunRandomService       ;
        shlx                               ;
        lxi     d , IRQCounter             ;    IRQCounter := 0 ;
        lxi     h , 0                      ;
        shlx                               ;
        lxi     h, LedPortCopy             ;    LedPortCopy := LedPortCopy AND ( ~ PauseLedOn ) ;
        mov     a , m                      ;
        ani     PauseLedOn xor 0FFh        ;
        mov     m , a                      ;
        out     RNDPort + Port8255.PortC   ;    RNDPort.PortC := LedPortCopy ;
        call    SetHoldCheckToRealCheck    ;    SetHoldCheckToRealCheck ;
        jmp     RunPause_0                 ;   end ;
RunPause_2                                 ;
        cpi     BackControlCh              ;  BackControlCh :
        jnz     RunPause_3                 ;   begin
        lxi     d , RelativeIndex          ;    if Abs ( RelativeIndex ) < MaxDeepLevel then
        lhlx                               ;
        call    Abs                        ;
        lxi     b , - MaxDeepLevel         ;
        dad     b                          ;
        mov     a , h                      ;
        ani     80h                        ;
        jz      RunPause_21                ;     begin
                                           ;      if RelativeIndex < 0 then
        lxi     d , RelativeIndex          ;
        lhlx                               ;
        mov     a , h                      ;
        ani     80h                        ;
        jz      RunPause_22                ;
        call    Abs                        ;        if Abs ( RelativeIndex ) > SampleCounter then
        push    h                          ;
        lxi     d , SampleCounter          ;
        lhlx                               ;
        push    h                          ;
        pop     b                          ;
        call    NegBC                      ;
        pop     h                          ;
        dad     b                          ;
        mov     a , h                      ;
        ani     80h                        ;
        rz                                 ;         exit ;
RunPause_22                                ;
        lxi     d , RelativeIndex          ;      RelativeIndex := RelativeIndex - 1 ;
        lhlx                               ;
        dcx     h                          ;
        shlx                               ;
        call    GetFromRndCyclicRelative   ;      CycRandom := GetFromRndCyclicRelative ( RelativeIndex ) ;
        call    ShowData                   ;      ShowData ( CycRandom ) ;
        jmp     RunPause_0                 ;     end ;
RunPause_21                                ;    else
        lxi     d , RelativeIndex          ;     if RelativeIndex > 0 then
        lhlx                               ;
        mov     a , h                      ;
        ani     80h                        ;
        jnz     RunPause_24                ;
        dcx     h                          ;      RelativeIndex := RelativeIndex - 1 ;
        shlx                               ;
RunPause_24                                ;
        jmp     RunPause_0                 ;   end ;
RunPause_3                                 ;
        cpi     NextControlCh              ;  NextControlCh :
        jnz     RunPause_4                 ;   begin
        lxi     d , RelativeIndex          ;    if Abs ( RelativeIndex ) < MaxDeepLevel then
        lhlx                               ;
        call    Abs                        ;
        lxi     b , - MaxDeepLevel         ;
        dad     b                          ;
        mov     a , h                      ;
        ani     80h                        ;
        jz      RunPause_31                ;     begin
        lxi     d , RelativeIndex          ;      CycRandom := GetFromRndCyclicRelative ( RelativeIndex ) ;
        lhlx                               ;
        call    GetFromRndCyclicRelative   ;
        call    ShowData                   ;      ShowData ( CycRandom ) ;
        lxi     d , RelativeIndex          ;      RelativeIndex := RelativeIndex + 1 ;
        lhlx                               ;
        inx     h                          ;
        shlx                               ;
        jmp     RunPause_0                 ;     end
RunPause_31                                ;    else
        lxi     d , RelativeIndex          ;     if RelativeIndex < 0 then
        lhlx                               ;
        mov     a , h                      ;
        ani     80h                        ;
        jz      RunPause_32                ;
        inx     h                          ;      RelativeIndex := RelativeIndex + 1 ;
        shlx                               ;
RunPause_32                                ;
        jmp     RunPause_0                 ;   end ;
RunPause_4                                 ;
        cpi     StepCh                     ;  StepCh :
        jnz     RunPause_5                 ;   begin
        call    ClrScrLCD                  ;    ClrScrLCD ;
        lxi     h , StepInfoText           ;    WriteTextLCD ( StepInfoText ) ;
        call    WriteTextLCD               ;
        call    NewLineLCD                 ;    NewLineLCD ;
        call    GetFromRndCyclic           ;    CycRandom := GetFromRndCyclic ;
        push    h                          ;
        call    SendDataToPort             ;    SendDataToPort ( CycRandom ) ;
        pop     h                          ;    DispWord  ( CycRandom ) ;
        call    DispWord                   ;
        lxi     d , RelativeIndex          ;    RelativeIndex := 0 ;
        lxi     h , 0                      ;
        shlx                               ;
        lxi     d , SampleCounter          ;    SampleCounter := SampleCounter + 1 ;
        lhlx                               ;
        inx     h                          ;
        shlx                               ;
        call    CreateNewRandom            ;    RandomV := CreateNewRandom ;
        lxi     d , RandomV                ;
        shlx                               ;
        call    AddToRndCyclic             ;    AddToRndCyclic ( RandomV ) ;
        jmp     RunPause_0                 ;   end ;
RunPause_5                                 ;
        cpi    RisingEdgeStrobeCh          ; RisingEdgeStrobeCh :
        jnz    RunPause_6                  ;  begin
        call   SetRisingEdge               ;   SetRisingEdge ;
        jmp    RunPause_0                  ;  end ;
RunPause_6                                 ;
        cpi    FallingEdgneStrobeCh        ; FallingEdgneStrobeCh :
        jnz    RunPause_7                  ;  begin
        call   SetFallingEdge              ;   SetFallingEdge ;
        jmp    RunPause_0                  ;  end ;
RunPause_7                                 ;
RunPause_0                                 ; end (* case *) ;
        ret                                ;end (* RunPauseService *) ;
;*******************************************
RunRandomService                           ;procedure RunRandomService ( Ch[A] : char ) ;
                                           ;begin (* RunRandomService *)
                                           ; case ( Ch ) of
        cpi     StopRandomCh               ;  StopRandomCh :
        jnz     RunRndSrv_1                ;   begin
        call    StopRunOperation           ;    StopRunOperation ;
        jmp     RunRndSrv_0                ;   end ;
RunRndSrv_1                                ;
        cpi     PauseRandomCh              ;  PauseRandomCh :
        jnz     RunRndSrv_2                ;   begin
        lxi     d , RelativeIndex          ;    RelativeIndex := 0 ;
        lxi     h , 0                      ;
        shlx                               ;
        lxi     d , GlobalService          ;    GlobalService := RunPauseService ;
        lxi     h , RunPauseService        ;
        shlx                               ;
        call    ClrScrLCD                  ;    ClrScrLCD ;
        lxi     h , PauseGenerText         ;    WriteTextLCD ( PauseGenerText ) ;
        call    WriteTextLCD               ;
        call    NewLineLCD                 ;    NewLineLCD ;
        lxi     h , -1                     ;    DispWord ( GetFromRndCyclicRelative ( -1 ) ) ;
        call    GetFromRndCyclicRelative   ;
        call    DispWord                   ;
        lxi     d , RandomService          ;    RandomService := NIL ;
        lxi     h , 0                      ;
        shlx                               ;
        lxi     h, LedPortCopy             ;    LedPortCopy := LedPortCopy OR PauseLedOn;
        mov     a , m                      ;
        ori     PauseLedOn                 ;
        mov     m , a                      ;
        out     RNDPort + Port8255.PortC   ;    RNDPort.PortC := LedPortCopy ;
        jmp     RunRndSrv_0                ;   end ;
RunRndSrv_2                                ;
RunRndSrv_0                                ; end (* case *) ;
        ret                                ;end (* RunRandomService *) ;
;*******************************************
SetRisingEdge                              ;procedure SetRisingEdge ;
                                           ;begin (* SetRisingEdge *)
        lxi     h , RisingEdgeFlag         ; RisingEdgeFlag := 1 ;
        mvi     a , 1                      ;
        mov     m , a                      ;
        lxi     h, LedPortCopy             ; LedPortCopy := LedPortCopy OR RisingEdgeLed ;
        mov     a , m                      ;
        ori     RisingEdgeLed              ;
        ani     FallingEdgneLed xor 0FFh   ; LedPortCopy := LedPortCopy AND ( ~ FallingEdgneLed ) AND ( ~ ExternStrobe ) ;
        ani     ExternStrobe xor 0FFh      ;
        mov     m , a                      ;
        out     RNDPort + Port8255.PortC   ; RNDPort.PortC := LedPortCopy ;
        ret                                ;end (* SetRisingEdge *) ;
;*******************************************
SetFallingEdge                             ;procedure SetFallingEdge ;
                                           ;begin (* SetFallingEdge *)
        lxi     h , RisingEdgeFlag         ; RisingEdgeFlag := 0 ;
        mvi     a , 0                      ;
        mov     m , a                      ;
        lxi     h, LedPortCopy             ; LedPortCopy := LedPortCopy OR FallingEdgneLed OR ExternStrobe ;
        mov     a , m                      ;
        ori     FallingEdgneLed OR ExternStrobe
        ani     RisingEdgeLed xor 0FFh     ; LedPortCopy := LedPortCopy AND ( ~ RisingEdgeLed ) ;
        mov     m , a                      ;
        out     RNDPort + Port8255.PortC   ; RNDPort.PortC := LedPortCopy ;
        ret                                ;end (* SetFallingEdge *) ;
;*******************************************
GlobalLevelService                         ;procedure GlobalLevelService ( Ch[A] : char ) ;
                                           ;begin (* GlobalLevelService *)
                                           ; case ( Ch ) of
        cpi     SelectDelayIntervalCh      ;  SelectDelayIntervalCh :
        jnz     GlobLvSrv_1                ;   begin
        lxi     d , GlobalService          ;    GlobalService := InputNumericService ;
        lxi     h , InputNumericService    ;
        shlx                               ;
        call    StartInputData             ;    StartInputData ;
        jmp     GlobLvSrv_0                ;   end ;
GlobLvSrv_1                                ;
        cpi     StartRandomCh              ;  StartRandomCh :
        jnz     GlobLvSrv_2                ;   begin
        lxi     d , TimeInterval           ;    if TimeInterval = 0 then
        lhlx                               ;
        mov     a , h                      ;
        ora     l                          ;
        jnz     GlobLvSrv_11               ;     begin
        lxi     h , NoDelayIntervaTxt      ;      Message ( NoDelayIntervaTxt ) ;
        call    Message                    ;
        call    HelloScreen                ;      HelloScreen ;
        ret                                ;      exit ;
GlobLvSrv_11                               ;     end ;
        call    ClrScrLCD                  ;    ClrScrLCD ;
        lxi     h , RunRandomText          ;    WriteTextLCD ( RunRandomText ) ;
        call    WriteTextLCD               ;
        call    NewLineLCD                 ;    NewLineLCD ;
        call    DisplayInterval            ;    DisplayInterval ;
        lxi     d , GlobalService          ;    GlobalService := RunRandomService ;
        lxi     h , RunRandomService       ;
        shlx                               ;
        lxi     d , RandomService          ;    RandomService := RealRunRandomSrv ;
        lxi     h , RealRunRandomSrv       ;
        shlx                               ;
        call    SetHoldCheckToRealCheck    ;    SetHoldCheckToRealCheck ;
        lxi     h , IRQFlag                ;    IRQFlag := 0 ;
        mvi     m , 0                      ;
        lxi     h , IRQCounter             ;    IRQCounter := 0 ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        lxi     d , SampleCounter          ;    SampleCounter := 0 ;
        lxi     h , 0                      ;
        shlx                               ;
        call    ClearRndCyclic             ;    ClearRndCyclic ;
        call    Init_random                ;    Init_random ;
        call    FillRandnomTable           ;    FillRandnomTable ;
        lxi     h, LedPortCopy             ;    LedPortCopy := LedPortCopy OR RunLedOn ;
        mov     a , m                      ;
        ori     RunLedOn                   ;
        ani     LS373HiZOff xor 0FFh       ;    LedPortCopy := LedPortCopy and ( ~ LS373HiZOff ) ;
        mov     m , a                      ;
        out     RNDPort + Port8255.PortC   ;    RNDPort.PortC := LedPortCopy ;
        jmp     GlobLvSrv_0                ;   end ;
GlobLvSrv_2                                ;
        cpi    RisingEdgeStrobeCh          ; RisingEdgeStrobeCh :
        jnz    GlobLvSrv_3                 ;  begin
        call   SetRisingEdge               ;   SetRisingEdge ;
        jmp    GlobLvSrv_0                 ;  end ;
GlobLvSrv_3                                ;
        cpi    FallingEdgneStrobeCh        ; FallingEdgneStrobeCh :
        jnz    GlobLvSrv_4                 ;  begin
        call   SetFallingEdge              ;   SetFallingEdge ;
        jmp    GlobLvSrv_0                 ;  end ;
GlobLvSrv_4                                ;
GlobLvSrv_0                                ; end (* case *) ;
        ret                                ;end (* GlobalLevelService *) ;
;*******************************************
ClearRndCyclic                             ;procedure ClearRndCyclic ;
                                           ;begin (* ClearRndCyclic *)
        mvi     a , 0                      ; RndCyclic . RndCycFr := 0 ;
        lxi     h , RndCyclic + RndCyclicRecT . RndCycFr
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
                                           ; RndCyclic . RndCycTo := 0 ;
        lxi     h , RndCyclic + RndCyclicRecT . RndCycTo
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        ret                                ;end (* ClearRndCyclic *) ;
;*******************************************
Init_variable                              ;procedure Init_variable ;
                                           ;begin (* Init_variable *)
        lxi     d , HardvInpKbd            ; SoftKbdInit ( HardvInpKbd , HardvSetRowKbd ) ;
        lxi     h , HardvSetRowKbd         ;
        call    SoftKbdInit                ;
        mvi     a , 0                      ; SetEncodeTable ( 0 , Row0EncodeTable ) ;
        lxi     h , Row0EncodeTable        ;
        call    SetEncodeTable             ;
        mvi     a , 1                      ; SetEncodeTable ( 1 , Row1EncodeTable ) ;
        lxi     h , Row1EncodeTable        ;
        call    SetEncodeTable             ;
        mvi     a , 2                      ; SetEncodeTable ( 2 , Row2EncodeTable ) ;
        lxi     h , Row2EncodeTable        ;
        call    SetEncodeTable             ;
        mvi     a , 3                      ; SetEncodeTable ( 3 , Row3EncodeTable ) ;
        lxi     h , Row3EncodeTable        ;
        call    SetEncodeTable             ;
        mvi     a , 4                      ; SetEncodeTable ( 4 , Row4EncodeTable ) ;
        lxi     h , Row4EncodeTable        ;
        call    SetEncodeTable             ;
        mvi     a , 5                      ; SetEncodeTable ( 5 , Row5EncodeTable ) ;
        lxi     h , Row5EncodeTable        ;
        call    SetEncodeTable             ;
        mvi     a , 6                      ; SetEncodeTable ( 6 , Row6EncodeTable ) ;
        lxi     h , Row6EncodeTable        ;
        call    SetEncodeTable             ;
        mvi     a , 7                      ; SetEncodeTable ( 7 , Row7EncodeTable ) ;
        lxi     h , Row7EncodeTable        ;
        call    SetEncodeTable             ;
        mvi     a , 0                      ; RandomSeed := 0 ;
        lxi     h , RandomSeed             ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        lxi     h , TimeInterval           ; TimeInterval := 0 ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        lxi     h , IntervalToCompare      ; IntervalToCompare := 0 ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        lxi     h , GlobalService          ; GlobalService := NIL ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        lxi     h , RandomService          ; RandomService := NIL ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        lxi     h , IRQFlag                ; IRQFlag := 0 ;
        mov     m , a                      ;
        lxi     h , LedPortCopy            ; LedPortCopy := 0 ;
        mov     m , a                      ;
        lxi     h , IRQCounter             ; IRQCounter := 0 ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        lxi     h , LifeLEDTimer           ; LifeLEDTimer := 0 ;
        mov     m , a                      ;
        lxi     h , SampleCounter          ; SampleCounter := 0 ;
        mov     m , a                      ;
        inx     h                          ;
        mov     m , a                      ;
        call    ClearBuffer                ; ClearBuffer ;
        call    ClearRndCyclic             ; ClearRndCyclic ;
        call    SetRisingEdge              ; SetRisingEdge ;
        call    SetHoldCheckToNil          ; SetHoldCheckToNil ;
        ret                                ;end (* Init_variable *) ;
;*******************************************
Main                                       ;begin (* main *)
        call    Init_variable              ; Init_variable ;
        call    Init_hardware              ; Init_hardware ;
        call    Init_envir                 ; Init_envir ;
        ei                                 ; EnableInt ;
        call    InitialiseLCD              ; InitialiseLCD ;
        call    HelloScreen                ; HelloScreen ;
        lxi     d , GlobalService          ; GlobalService := GlobalLevelService ;
        lxi     h , GlobalLevelService     ;
        shlx                               ;
Main_0                                     ; repeat
        lxi     d , RandomService          ;  if RandomService <> NIL then
        lhlx                               ;
        mov     a , h                      ;
        ora     l                          ;
        jz      main_10                    ;
        call    CallHLService              ;   RandomService ;
main_10                                    ;
        call    KeyPressed                 ;  if KeyPressed then
        ora     a                          ;
        jz      Main_1                     ;   begin
        lxi     d , GlobalService          ;    if GlobalService <> NIL then
        lhlx                               ;
        mov     a , h                      ;
        ora     l                          ;
        jz      Main_11                    ;
        push    h                          ;     GlobalService ( ReadKey ) ;
        call    ReadKey                    ;
        pop     h                          ;
        call    CallHLService              ;
        jmp     Main_2                     ;
Main_11                                    ;    else
        call    ReadKey                    ;     ReadKey ;
Main_2                                     ;
Main_1                                     ;   end ;
       jmp      Main_0                     ; until false ;        
                                           ;end  (* main *).
;*******************************************
        .org    RAMSpace
GlobalService           .word
RandomService           .word
HoldCheckSerw           .word
KbdModInstance          .KbdModInstanceT
BinToStr                .byte       8
RandomSeed              .word
RandomV                 .word
IRQCounter              .word
IRQFlag                 .byte
LifeLEDTimer            .byte
RisingEdgeFlag          .byte
NumberIndex             .byte
Number                  .byte       NumberSize + 1
TimeInterval            .word
IntervalToCompare       .word
RndLoop                 .word
TmpIndex                .word
RelativeIndex           .word
SampleCounter           .word
RndCyclic               .RndCyclicRecT
LedPortCopy             .byte
        .end
