          .286

          .MODEL    compact

          EXTRN     _FDC:proc
          EXTRN     _SwitchCrt:proc
          EXTRN     _fputc:proc
          EXTRN     _CrtOutput:word
          EXTRN     _VideoMode:word
          EXTRN     _pflag:word
          EXTRN     _printer:dword
          EXTRN     _Control:byte
          EXTRN     _SFlag:byte
          EXTRN     _ak:byte
          EXTRN     _kb:word
          EXTRN     _cb:byte


          .DATA
TEMP      DW        3 dup (0)

          include   ramfont.inc

VideoTab  DW        _CLEAR0
          DW        _CLEAR1A
          DW        MW_mem4
          DW        _CLEAR1
          DW        MW_mem4
          DW        _CLEAR2A
          DW        MW_mem4
          DW        _CLEAR2
          DW        MW_mem4
          DW        _CLEAR3A
          DW        MW_mem4
          DW        _CLEAR3
          DW        MW_mem4
          DW        _CLEAR4A
          DW        MW_mem4
          DW        _CLEAR4
VideoGo   DW        _CLEAR0

VideoMem  DB        82h
          DB        84h
          DB        80h
          DB        84h
          DB        80h
          DB        88h
          DB        80h
          DB        88h
          DB        80h
          DB        8Ch
          DB        80h
          DB        8Ch
          DB        80h
          DB        98h
          DB        80h
          DB        98h
VideoTo   DB        82h

          .CODE
          ASSUME cs:_TEXT,ds:DGROUP,ss:DGROUP

;-- TEXT: schakelt de tekstmodus in ---------------------------------
;-- invoer   : geen
;-- uitvoer  : geen
;-- registers: geen registers worden veranderd

          public        _text8
_text8    proc
          mov   ax,0003h           ; zet scherm in mode 3
          int   10h
          ret
_text8    endp

          public        _text4
_text4    proc
          mov  ax,0001h           ; zet scherm in mode 1
          int  10h
          ret
_text4    endp

;-- GRAFIX: schakelt de grafische weergave aan --------------------------
;-- invoer   : geen
;-- uitvoer  : geen
;-- registers: geen registers worden veranderd

          public        _grafix
_grafix   proc
          mov  ax,0004h           ; zet scherm in mode 4 (320*200*4)
          int  10h
          ret
_grafix   endp

;-- CDEF: definieert de 1e en laatste beeldlijn van de cursor -----
;-- invoer   : CL = eerste beeldlijn
;--            CH = laatste beeldlijn
;-- uitvoer  : geen
;-- registers: AX en DX

cdef      proc
          mov  ah,01h             ; functie 1 van int 10h
          int  10h
          ret
cdef      endp

;-- CLS: hele scherm wissen ---------------------------------------
;-- invoer   : BP = nummer schermpagina (0 of 1)
;-- uitvoer  : geen
;-- registers: alleen FLAGS wordt veranderd

          public        _clscr
_clscr    proc
          jmp _text8            ; is gelijk aan omschakelen naar tekstmode
_clscr    endp

;-- PIXEL: zet een punt in het grafische scherm ------------------------
;-- invoer   : BP = nummer schermpagina (0 of 1)
;--            BX = kolom (0-319)
;--            DX = regel  (0-199)
;--            AL = bewerking (1=zetten,2=inverteren,3=wissen)
;-- uitvoer  : geen
;-- registers: AX, DI en FLAGS worden veranderd

          public        _pixel
_pixel    proc

          cmp  bx,319             ;test of beeldpunt buiten beeld valt
          ja   spix6              ;spring indien buiten beeld
          cmp  dx,199             ;idem voor y-coordinaat
          ja   spix6
          push di
          push es                 ;ES op stack opslaan
          push ax                 ;AX op stack opslaan
          push bx                 ;BX op stack opslaan
          push cx                 ;CX op stack opslaan
          push dx                 ;DX op stack opslaan
          push ax                 ;AX op stack opslaan
          mov  ax,199             ;dx:=199-dx
          sub  ax,dx
          mov  dx,ax
          mov  cx,bx
          pop  ax                 ;haal ax terug
          cmp  ax,1               ;bepaal puntbewerking
          jne  pix1               ;en zet overeenkomstige schermkleur
          mov  al,3
          jmp  short pix4
pix1:     cmp  ax,2
          jne  pix2
          mov  al,83h
          jmp  short pix4
pix2:     mov  al,00h
pix4:     mov  ah,0Ch
          xor  bx,bx              ;alleen schermpagina 0 toegestaan
          int  10h                ;plaats pixel d.m.v. biosfunctie
spix5:    pop  dx                 ;DX weer van stack halen
          pop  cx                 ;CX weer van stack halen
          pop  bx                 ;BX weer van stack halen
          pop  ax                 ;AX weer van stack halen
          pop  es                 ;ES weer van stack halen
          pop  di
spix6:    ret

_pixel    endp


;== einde ===============================================================

;== macro definities ====================================================

initgraph macro
          call      grafix
          mov       ah,0bh      ; selecteer palet 0 (groen/rood/geel)
          mov       bx,0100h
          int       10h
          endm

exitgraph macro
          push ax
          mov  ax,0002h
          int  10h
          pop  ax
          endm

cls       macro
          call      clscr
          endm

;== atom video emulatie =================================================

          public        _CLEAR4
_CLEAR4   proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,9800H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END4                ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
          MOV       BX,00A8H            ; ZET BASISADRES PC-VIDEO
          TEST      DX,0020H            ; TEST OP EVEN/ONEVEN BEELDREGEL
          JZ        EVEN4               ; SPRING INDIEN EVEN
          MOV       BX,20A8H            ; ZET NIEUW BASISADRES
EVEN4:    AND       DX,0FFDFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; ZET EVEN OP STACK
          AND       DX,001FH            ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,6                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,50H              ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       CX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,CX
          XOR       DX,DX               ; RESET DATA REGISTER
          MOV       CX,8                ; LAADT TELLER
DATA4:    SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          PUSHF                         ; BEWAAR CARRY
          RCL       DX,1                ; SCHUIF DATABIT IN DATAREGISTER
          POPF                          ; HAAL CARRY TERUG
          RCL       DX,1                ; SCHUIF NOGMAALS IN DATAREGISTER
          LOOP      DATA4               ; HERHAAL TOT ALLE BITS GELEZEN
          MOV       ES:[BX],DH          ; SCHRIJF HOGE BYTE NAAR SCHERM
          INC       BX                  ; VERHOOG SCHERMPOINTER
          MOV       ES:[BX],DL          ; SCHRIJF LAGE BYTE NAAR SCHERM
END4:     POP       BP
          RET
_CLEAR4   endp

          public        _CLEAR4A
_CLEAR4A  proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,9800H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END4A               ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
          MOV       BX,00A8H            ; ZET BASISADRES PC-VIDEO
          TEST      DX,0020H            ; TEST OP EVEN/ONEVEN BEELDREGEL
          JZ        EVEN4A              ; SPRING INDIEN EVEN
          MOV       BX,20A8H            ; ZET NIEUW BASISADRES
EVEN4A:   AND       DX,0FFDFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; ZET EVEN OP STACK
          AND       DX,001FH            ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,6                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,50H              ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       CX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,CX
          XOR       DX,DX               ; RESET DATA REGISTER
          MOV       CX,4                ; LAADT TELLER
DATA4A:   PUSH      AX                  ; SAVE DATA
          SHL       AL,1                ; SCHUIF KLEURBIT IN CARRY
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          SHL       AL,1                ; NOGMAALS VOOR TWEEDE KLEURBIT
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          POP       AX                  ; HAAL DATA TERUG
          SHL       AL,1                ; SCHUIF KLEURBIT IN CARRY
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          SHL       AL,1                ; NOGMAALS VOOR TWEEDE KLEURBIT
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          LOOP      DATA4A              ; HERHAAL TOT ALLE BITS GELEZEN
          MOV       ES:[BX],DH          ; SCHRIJF HOGE BYTE NAAR SCHERM
          INC       BX                  ; VERHOOG SCHERMPOINTER
          MOV       ES:[BX],DL          ; SCHRIJF LAGE BYTE NAAR SCHERM
END4A:    POP       BP
          RET                           ; EINDE ROUTINE
_CLEAR4A  endp

          public        _CLEAR3
_CLEAR3   proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,8C00H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END3                ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
          MOV       BX,00A8H            ; ZET BASISADRES PC-VIDEO
          TEST      DX,0010H            ; TEST OP EVEN/ONEVEN BEELDREGEL
          JZ        EVEN3               ; SPRING INDIEN EVEN
          MOV       BX,20A8H            ; ZET NIEUW BASISADRES
EVEN3:    AND       DX,0FFEFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; ZET EVEN OP STACK
          AND       DX,000FH            ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,5                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,50H              ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       CX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,CX
          MOV       CX,4                ; LAADT TELLER
DATA3:    XOR       DX,DX               ; RESET DATA REGISTER
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          JNC       DATA3L1             ; SPRING ALS BIT NIET GEZET IS
          OR        DL,0F0H             ; ALS BIT GEZET, ZET PIXELS
DATA3L1:  SHL       AL,1                ; SCHUIF VOLGEND DATABIT IN CARRY
          JNC       DATA3L2             ; SPRING ALS BIT NIET GEZET IS
          OR        DL,0FH              ; ZET PIXELS
DATA3L2:  MOV       ES:[BX],DL          ; SCHRIJF DATA NAAR SCHERM
          INC       BX                  ; VERHOOG SCHERMPOINTER
          LOOP      DATA3
END3:     POP       BP
          RET                           ; EINDE ROUTINE
_CLEAR3   endp

          public        _CLEAR3A
_CLEAR3A  proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,8C00H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END3A               ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
          MOV       BX,00A8H            ; ZET BASISADRES PC-VIDEO
          TEST      DX,0020H            ; TEST OP EVEN/ONEVEN BEELDREGEL
          JZ        EVEN3A              ; SPRING INDIEN EVEN
          MOV       BX,00F8H            ; ZET NIEUW BASISADRES
EVEN3A:   AND       DX,0FFDFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; ZET EVEN OP STACK
          AND       DX,001FH            ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,6                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,0A0H             ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       CX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,CX
          XOR       DX,DX               ; RESET DATA REGISTER
          MOV       CX,4                ; LAADT TELLER
DATA3A:   PUSH      AX                  ; SAVE DATA
          SHL       AL,1                ; SCHUIF KLEURBIT IN CARRY
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          SHL       AL,1                ; NOGMAALS VOOR TWEEDE KLEURBIT
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          POP       AX                  ; HAAL DATA TERUG
          SHL       AL,1                ; SCHUIF KLEURBIT IN CARRY
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          SHL       AL,1                ; NOGMAALS VOOR TWEEDE KLEURBIT
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          LOOP      DATA3A              ; HERHAAL TOT ALLE BITS GELEZEN
          MOV       ES:[BX],DH          ; SCHRIJF HOGE BYTE NAAR SCHERM
          MOV       ES:[BX+2000H],DH
          INC       BX                  ; VERHOOG SCHERMPOINTER
          MOV       ES:[BX],DL          ; SCHRIJF LAGE BYTE NAAR SCHERM
          MOV       ES:[BX+2000H],DL
END3A:    POP       BP
          RET                           ; EINDE ROUTINE
_CLEAR3A  endp

          public        _CLEAR2
_CLEAR2   proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,8600H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END2                ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
          MOV       BX,00A8H            ; ZET BASISADRES PC-VIDEO
          TEST      DX,0010H            ; TEST OP EVEN/ONEVEN BEELDLIJN
          JZ        EVEN2               ; SPRING INDIEN EVEN
          ADD       BX,050H             ; VERHOOG VERTIKALE OFFSET
EVEN2:    AND       DX,0FFEFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; ZET EVEN OP STACK
          AND       DX,000FH            ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,5                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,0A0H             ; LAADT AL MET REGELLENGTE*2
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       CX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,CX
          MOV       CX,4                ; LAADT TELLER
DATA2:    XOR       DX,DX               ; RESET DATA REGISTER
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          JNC       DATA2L1             ; SPRING ALS BIT NIET GEZET IS
          OR        DL,0F0H             ; ALS BIT GEZET, ZET PIXELS
DATA2L1:  SHL       AL,1                ; SCHUIF VOLGEND DATABIT IN CARRY
          JNC       DATA2L2             ; SPRING ALS BIT NIET GEZET IS
          OR        DL,0FH              ; ZET PIXELS
DATA2L2:  MOV       ES:[BX],DL          ; SCHRIJF DATA NAAR EVEN SCHERMREGEL
          MOV       ES:[BX+2000H],DL    ; EN NAAR ONEVEN SCHERMREGEL
          INC       BX                  ; VERHOOG SCHERMPOINTER
          LOOP      DATA2
END2:     POP       BP
          RET                           ; EINDE ROUTINE
_CLEAR2   endp

          public        _CLEAR2A
_CLEAR2A  proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,8800H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END2                ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
          TEST      DX,0020H            ; TEST OP EVEN/ONEVEN BEELDREGEL
          JZ        EVEN2A              ; SPRING INDIEN EVEN
          MOV       BX,20F8H            ; ZET NIEUW BASISADRES
          AND       DX,0FFDFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; BEWAAR EVEN OP STACK
          AND       DX,01FH             ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,6                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,0F0H             ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          PUSH      BX                  ; ZET EERSTE SCHERMADRES OP STACK
          ADD       BX,50H              ; BEREKEN TWEEDE SCHERMADRES
          PUSH      BX                  ; ZET OP STACK
          SUB       BX,2000H            ; BEREKEN DERDE SCHERMADRES
          JMP       SHORT CLEAR2A1      ; GEDWONGEN SPRONG
EVEN2A:   MOV       BX,00A8H            ; ZET BASISADRES PC-VIDEO
          AND       DX,0FFDFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; ZET EVEN OP STACK
          AND       DX,001FH            ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,6                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,0F0H             ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          PUSH      BX                  ; ZET EERSTE SCHERMADRES OP STACK
          ADD       BX,2000H            ; BEREKEN TWEEDE SCHERMADRES
          PUSH      BX                  ; ZET OP STACK
          SUB       BX,1FB0H            ; BEREKEN DERDE SCHERMADRES
CLEAR2A1: MOV       CX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,CX
          XOR       DX,DX               ; RESET DATA REGISTER
          MOV       CX,4                ; LAADT TELLER
DATA2A:   PUSH      AX                  ; SAVE DATA
          SHL       AL,1                ; SCHUIF KLEURBIT IN CARRY
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          SHL       AL,1                ; NOGMAALS VOOR TWEEDE KLEURBIT
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          POP       AX                  ; HAAL DATA TERUG
          SHL       AL,1                ; SCHUIF KLEURBIT IN CARRY
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          SHL       AL,1                ; NOGMAALS VOOR TWEEDE KLEURBIT
          RCL       DX,1                ; SCHUIF KLEURBIT IN DATAREGISTER
          LOOP      DATA2A              ; HERHAAL TOT ALLE BITS GELEZEN
          MOV       ES:[BX],DH          ; SCHRIJF HOGE BYTE NAAR SCHERM
          INC       BX                  ; VERHOOG SCHERMPOINTER
          MOV       ES:[BX],DL          ; SCHRIJF LAGE BYTE NAAR SCHERM
          POP       BX                  ; HAAL TWEEDE SCHERMADRES VAN STACK
          MOV       ES:[BX],DH          ; SCHRIJF HOGE BYTE NAAR SCHERM
          INC       BX                  ; VERHOOG SCHERMPOINTER
          MOV       ES:[BX],DL          ; SCHRIJF LAGE BYTE NAAR SCHERM
          POP       BX                  ; HAAL EERSTE SCHERMADRES VAN STACK
          MOV       ES:[BX],DH          ; SCHRIJF HOGE BYTE NAAR SCHERM
          INC       BX                  ; VERHOOG SCHERMPOINTER
          MOV       ES:[BX],DL          ; SCHRIJF LAGE BYTE NAAR SCHERM
END2A:    POP       BP
          RET                           ; EINDE ROUTINE
_CLEAR2A  endp

          public        _CLEAR1
_CLEAR1   proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,8400H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END2A               ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
          TEST      DX,0010H            ; TEST OP EVEN/ONEVEN BEELDREGEL
          JZ        EVEN1               ; SPRING INDIEN EVEN
;          MOV       CX,DGROUP           ; SET DATA-SEGMENT
;          MOV       DS,CX
          MOV       BX,20F8H            ; ZET NIEUW BASISADRES
          AND       DX,0FFEFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; BEWAAR EVEN OP STACK
          AND       DX,00FH             ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,5                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,0F0H             ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       TEMP+0,BX           ; ZET EERSTE SCHERMADRES OP STACK
          ADD       BX,50H              ; BEREKEN TWEEDE SCHERMADRES
          MOV       TEMP+2,BX           ; ZET OP STACK
          SUB       BX,2000H            ; BEREKEN DERDE SCHERMADRES
          JMP       SHORT CLEAR1_1      ; GEDWONGEN SPRONG
EVEN1:    MOV       BX,00A8H            ; ZET BASISADRES PC-VIDEO
          AND       DX,0FFEFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; ZET EVEN OP STACK
          AND       DX,000FH            ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,5                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,0F0H             ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       TEMP+0,BX           ; ZET EERSTE SCHERMADRES OP STACK
          ADD       BX,2000H            ; BEREKEN TWEEDE SCHERMADRES
          MOV       TEMP+2,BX           ; ZET OP STACK
          SUB       BX,1FB0H            ; BEREKEN DERDE SCHERMADRES
CLEAR1_1: MOV       TEMP+4,BX           ; ZET OP STACK
          MOV       CX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,CX
          XOR       DX,DX               ; RESET DATA REGISTER
          MOV       CX,4                ; LAADT TELLER
DATA1:    XOR       DX,DX               ; RESET DATA REGISTER
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          JNC       DATA1L1             ; SPRING ALS BIT NIET GEZET IS
          OR        DL,0F0H             ; ALS BIT GEZET, ZET PIXELS
DATA1L1:  SHL       AL,1                ; SCHUIF VOLGEND DATABIT IN CARRY
          JNC       DATA1L2             ; SPRING ALS BIT NIET GEZET IS
          OR        DL,0FH              ; ZET PIXELS
DATA1L2:  MOV       BX,TEMP+0
          MOV       ES:[BX],DL          ; SCHRIJF DATA NAAR SCHERM
          MOV       BX,TEMP+2
          MOV       ES:[BX],DL
          MOV       BX,TEMP+4
          MOV       ES:[BX],DL
          INC       TEMP+0              ; VERHOOG SCHERMPOINTER
          INC       TEMP+2
          INC       TEMP+4
          LOOP      DATA1
END1:     POP       BP
          RET                           ; EINDE ROUTINE
_CLEAR1   endp

          public        _CLEAR1A
_CLEAR1A  proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,8400H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END1                ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
          TEST      DX,0010H            ; TEST OP EVEN/ONEVEN BEELDREGEL
          JZ        EVEN1A              ; SPRING INDIEN EVEN
;          MOV       CX,DGROUP           ; SET DATA-SEGMENT
;          MOV       DS,CX
          MOV       BX,20F8H            ; ZET NIEUW BASISADRES
          AND       DX,0FFEFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; BEWAAR EVEN OP STACK
          AND       DX,00FH             ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,5                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,0F0H             ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       TEMP+0,BX           ; ZET EERSTE SCHERMADRES OP STACK
          ADD       BX,50H              ; BEREKEN TWEEDE SCHERMADRES
          MOV       TEMP+2,BX           ; ZET OP STACK
          SUB       BX,2000H            ; BEREKEN DERDE SCHERMADRES
          JMP       SHORT CLEAR1A1      ; GEDWONGEN SPRONG
EVEN1A:   MOV       BX,00A8H            ; ZET BASISADRES PC-VIDEO
          AND       DX,0FFEFH           ; RESET EVEN/ONEVEN BIT
          PUSH      DX                  ; ZET EVEN OP STACK
          AND       DX,000FH            ; BEPAAL HORIZONTALE SCHERMPOSITIE
          SHL       DX,1
          SHL       DX,1
          ADD       BX,DX               ; TEL OP BIJ BASISADRES
          POP       DX                  ; HAAL DX WEER TERUG
          MOV       CL,5                ; LAADT AANTAL SCHUIFOPDRACHTEN
          SHR       DX,CL               ; BEREKEN ADRES/32
          AND       DX,00FFH            ; BEREKEN VERTIKALE POSITIE
          MOV       DH,AL               ; BEWAAR DATA
          MOV       AL,0F0H             ; LAADT AL MET REGELLENGTE
          MUL       DL                  ; VERMENIGVULDIG MET REGELLENGTE
          ADD       BX,AX               ; TEL OP BIJ BASISADRES
          MOV       AL,DH               ; ZET DATA WEER IN AL
          MOV       TEMP+0,BX           ; ZET EERSTE SCHERMADRES OP STACK
          ADD       BX,2000H            ; BEREKEN TWEEDE SCHERMADRES
          MOV       TEMP+2,BX           ; ZET OP STACK
          SUB       BX,1FB0H            ; BEREKEN DERDE SCHERMADRES
CLEAR1A1: MOV       TEMP+4,BX           ; ZET OP STACK
          MOV       CX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,CX
          MOV       CX,4                ; LAADT TELLER
DATA1A:   XOR       DX,DX               ; RESET DATA REGISTER
          PUSH      AX                  ; ZET DATA OP STACK
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          RCL       DL,1
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          RCL       DL,1
          POP       AX
          PUSH      AX                  ; ZET DATA OP STACK
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          RCL       DL,1
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          RCL       DL,1
          POP       AX
          PUSH      AX                  ; ZET DATA OP STACK
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          RCL       DL,1
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          RCL       DL,1
          POP       AX
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          RCL       DL,1
          SHL       AL,1                ; SCHUIF DATABIT IN CARRY
          RCL       DL,1
          MOV       BX,TEMP+0
          MOV       ES:[BX],DL          ; SCHRIJF DATA NAAR SCHERM
          MOV       BX,TEMP+2
          MOV       ES:[BX],DL
          MOV       BX,TEMP+4
          MOV       ES:[BX],DL
          INC       TEMP+0              ; VERHOOG SCHERMPOINTER
          INC       TEMP+2
          INC       TEMP+4
          LOOP      DATA1A
END1A:    POP       BP
          RET                           ; EINDE ROUTINE
_CLEAR1A  endp

          public        _CLEAR0
_CLEAR0   proc
;          ARG       address:WORD,char:BYTE
;          PUSH      BP
;          MOV       BP,SP
;          MOV       DX,[address]        ; ZET ADRES IN DX
;          CMP       DX,8200H            ; TEST OF ADRES BUITEN VIDEO GEBIED
;          JAE       END0                ; SPRING INDIEN ONGELDIG ADRES
;          MOV       AL,[char]           ; LEES GESCHREVEN DATA
;          MOV       CX,DGROUP           ; SET DATA-SEGMENT
;          MOV       DS,CX
          MOV       CH,AL               ; BEWAAR DATA IN CH
          MOV       BX,DX               ; ZET GELEZEN ADRES IN BX
          AND       BX,001FH            ; BEREKEN HORIZONTALE POSITIE
          SHL       BX,1                ; VERMENIGVULDIG MET 2
          ADD       BX,00A8H            ; TEL OFFSET ERBIJ
          MOV       CL,5                ; LAADT TELLER VOOR SCHUIFOPDRACHT
          SHR       DX,CL               ; ADRES := ADRES / 32
          AND       DX,000FH            ; ALLEEN ONDERSTE VIER BITS VAN BELANG
          MOV       AX,01E0H            ; LAADT AX MET REGELLENGTE
          MUL       DX                  ; BEREKEN BEGINADRES VAN REGEL
          ADD       BX,AX               ; BEREKEN BEGINADRES VAN KARAKTER
          MOV       AX,0B800H           ; ZET EXTRA SEGMENT NAAR VIDEORAM
          MOV       ES,AX
          MOV       DL,CH               ; ZET DATA IN DX
          AND       DL,7FH              ; RESET HOOGSTE BIT
          MOV       AL,24               ; BEPAAL BEGINADRES VAN KAR IN FONTRAM
          MUL       DL
          MOV       DI,AX               ; ZET RESULTAAT IN INDEXREGISTER
          MOV       DX,00FFH            ; RESET KLEURMASKER
          TEST      CH,80H              ; BEPAAL HOOGSTE BIT WAARDE
          JZ        CLEAR0L1            ; SPRING INDIEN GEWIST
          MOV       DH,55H              ; ZET NIEUW KLEURMASKER
          TEST      CH,40H              ; BEPAAL EEN NA HOOGSTE BIT
          JZ        CLEAR0L1
          MOV       DL,0AAH             ; NIEUW KLEURMASKER
;          JZ        CLEAR0L1            ; SPRING INDIEN GEWIST
CLEAR0L1: MOV       CX,12               ; LAADT TELLER
CLEAR0L2: MOV       AX,WORD PTR RAMFONT[DI]      ; LEES EERSTE HELFT VAN KARAKTER
          INC       DI                  ; VERHOOG POINTER
          INC       DI                  ; VERHOOG POINTER
          XCHG      AL,AH
          XOR       AH,DH               ; PAS KLEUR AAN
          XOR       AL,DH
          AND       AH,DL
          AND       AL,DL
          MOV       ES:[BX],AX          ; SCHRIJF NAAR VIDEORAM
          TEST      CX,0001H            ; TEST OP EVEN/ONEVEN REGEL
          JZ        CLEAR0L3            ; SPRING ALS EVEN
          SUB       BX,1FB0H            ; BEKENEN ADRES NIEUWE KARAKTERLIJN
          LOOP      CLEAR0L2            ; VOLGENDE LIJN
          JMP       SHORT END0          ; SPRING ALTIJD
CLEAR0L3: ADD       BX,2000H            ; BEREKEN ADRES NIEUWE KARAKTERLIJN
CLEAR0L4: LOOP      CLEAR0L2            ; VOLGENDE LIJN
END0:     POP       BP
          RET                           ; EINDE COMMANDO
_CLEAR0   endp

; ************************************
; ****  Atom memory area / 64 kb  ****
; ************************************
        GROUP  MGROUP MDATA
        FARDATA MDATA
atomm   db 65535 dup (0)

; ************************************
; ****  Atom Schakelkaart memory  ****
; ************************************
        GROUP  RGROUP RDATA
        FARDATA RDATA
atomr   db 08000h dup (0)

        .DATA
mx_rom  db      7               ; Rom nummer op schakelkaart
attrib  db      07h             ; Attribute voor 80 col. display
lockrom db      00h             ; lock CDEF : 1=C, 2=D, 4=E, 8=F
locka   db      00h             ; 1 = A-Rom 0 .... 80 = A-Rom 7
        .CODE
        ASSUME  cs:_TEXT,ds:DGROUP,ss:DGROUP

; ***********************************************
; ************  Atom memory Read  ***************
; ***********************************************

        public  _MRead
_MRead  proc    near
        ARG     address:word
        push    bp
        mov     bp,sp
        mov     bx,[address]
        mov     ch,bh
        and     ch,0F0h
        cmp     ch,0A0h
        je      MR_mem1
        mov     ax,MGROUP
        ASSUME  cs:_TEXT,ds:DGROUP,es:MGROUP,ss:DGROUP
        cmp     ch,0B0h
        je      MR_Bxxx
        cmp     bh,0Ah
        jne     MR_mem2
        jmp     MR_Floppy
MR_mem1:
        and     bx,0FFFh
        add     bh,[mx_rom]
        mov     ax,RGROUP
        ASSUME  cs:_TEXT,ds:DGROUP,es:RGROUP,ss:DGROUP
MR_mem2:
        mov     es,ax
        mov     al,byte ptr es:[bx]
        xor     ah,ah
        pop     bp
        ret

MR_Bxxx:
        cmp     bx,0B001h
        je      MR_B001
        cmp     bx,0B002h
        jne     MR_B01x
        xor     byte ptr es:[bx],80h
        mov     al,byte ptr es:[bx]
        xor     ah,ah
        pop     bp
        ret

MR_B001:
        mov     es,ax
        mov     al,[_cb]
        xor     ah,ah
        mov     cx,6
        mul     cx
        mov     dx,ax
        dec     bx
        mov     ah,es:[bx]
        mov     bx,dx
        and     ah,0Fh
        mov     al,0FFh
        test    [_SFlag],1
        je      MR_B001_1
        add     bx,3
        cmp     ah,_ak[bx + 1]
        jne     MR_B001_2
        mov     al,_ak[bx]
        jmp     MR_B001_2
MR_B001_1:
        cmp     ah,_ak[bx + 1]
        jne     MR_B001_2
        mov     al,_ak[bx]
MR_B001_2:
        test    _ak[bx + 2],01h
        je      MR_B001_3
        and     al,7Fh
MR_B001_3:
        and     al,[_Control]
        xor     ah,ah
        pop     bp
        ret

MR_B01x:
        cmp     bh,0B0h
        jne     MR_B8xx
        cmp     bl,10h
        je      MR_B010
        cmp     bl,11h
        je      MR_B011
        cmp     bl,12h
        je      MR_B012
        jmp     MR_mem2

MR_B8xx:
        cmp     bx,0B801h
        jne     MR_B8xx_2
        xor     ax,ax
        cmp     _pflag,00h
        jne     MR_B8xx_1
        mov     al,80h
MR_B8xx_1:
        pop     bp
        ret

MR_B8xx_2:
        mov     es,ax
        mov     al,byte ptr es:[bx]
        xor     ah,ah
        pop     bp
        ret

MR_B010:
        mov     ah,08h
        mov     bh,00h
        int     10h
        xor     ah,ah
        pop     bp
        ret

MR_B011:
        mov     ah,03h
        mov     bh,00h
        int     10h
        mov     al,dl
        xor     ah,ah
        pop     bp
        ret

MR_B012:
        mov     ah,03h
        mov     bh,00h
        int     10h
        mov     al,dh
        xor     ah,ah
        pop     bp
        ret

MR_Floppy:
        cmp     bl,04h
        jle     MR_Floppy1
        jmp     MR_mem2
MR_Floppy1:
        push    00h             ; dummy character, not needed by read
        push    bx              ; memory address of floppy controler
        push    00h             ; read command
        call    _FDC
        add     sp,6            ; discard parameters on stack
        pop     bp
        ret

_MRead  endp

; ************************************************
; ************  Atom memory Write  ***************
; ************************************************

        public  _MWrite
_MWrite proc    near
        ARG     address:word,char:byte
        push    bp
        mov     bp,sp
        mov     bx,[address]
        mov     ch,bh
        and     ch,0F0h
        cmp     ch,0A0h
        je      MW_mem1
        mov     ax,MGROUP
        ASSUME  cs:_TEXT,ds:DGROUP,es:MGROUP,ss:DGROUP
        cmp     ch,0B0h
        jne     MW_mem0
        jmp     MW_Bxxx
MW_mem0:
        cmp     bh,0Ah
        jne     MW_mem2
        jmp     MW_Floppy
MW_mem1:
        and     bx,0FFFh
        add     bh,[mx_rom]
        mov     ax,RGROUP
        ASSUME  cs:_TEXT,ds:DGROUP,es:RGROUP,ss:DGROUP
        mov     es,ax
        mov     al,[char]
        mov     byte ptr es:[bx],al
        pop     bp
        ret
MW_mem2:
        mov     es,ax
;        cmp     cx,0C000h
;        jl      MW_mem2c
;        mov     ch,bh
;        mov     cl,4
;        shr     ch,cl
;        and     ch,03h
;        mov     cl,1
;MW_mem2a:
;        dec     ch
;        jz      MW_mem2b
;        shl     cl,1
;        jmp     MW_mem2a
;MW_mem2b:
;        test    lockrom,cl
;        jnz     MW_mem4
;MW_mem2c:
        mov     al,[char]
        mov     byte ptr es:[bx],al
MW_mem3:
        cmp     bh,[VideoTo]            ; and Max Address
        jl      MW_mem5
        pop     bp
        ret
MW_mem5:
        cmp     bh,80h                  ; test for address between 0x8000
        jge     MW_mem6
        pop     bp
        ret
MW_mem6:
        or      [_CrtOutput],0000h      ; test for Atom Video mode
        jne     MW_mem4
        mov     dx,bx
        jmp     word ptr [VideoGo]      ; jump to atom video routine
MW_mem4:
        pop     bp
        ret

MW_B000:
        mov     es,ax
        mov     al,[char]
        mov     ah,byte ptr es:[bx]
        mov     byte ptr es:[bx],al
        and     al,0F0h                         ; get video mode byte
        and     ah,0F0h
        cmp     al,ah                           ; test is changed
        je      MW_B000_1
        mov     cl,4
        shr     al,cl                           ; calculate offset
        mov     bl,al
        xor     bh,bh
        mov     [_VideoMode],bx                 ; save video mode
        mov     cl,VideoMem[bx]                 ; get video memory range
        mov     [VideoTo],cl                    ; and set it for next display
        shl     bx,1
        mov     cx,VideoTab[bx]                 ; get function address
        mov     [VideoGo],cx                    ; and set it for next display
        or      [_CrtOutput],0000h              ; test for Atom Crt
        jne     MW_B000_1
        call    _grafix;                        ; initialize crt
MW_B000_1:
        pop     bp
        ret

MW_BFFF:
        mov     al,[char]
        mov     byte ptr es:[bx],al
        and     al,07h                  ; get rom number
        mov     ah,al
        mov     cl,4
        shl     al,cl                   ; and make it base address
        mov     [mx_rom],al             ; save it for later use
        test    [_CrtOutput],1          ; test for Atom Video mode
        je      MW_mem4                 ; if so, then skip rom number display
        mov     bx,0B800h               ; PC screen area
        mov     es,bx
        mov     bx,159
        mov     byte ptr es:[bx],70h    ; inverse attribute
        dec     bx
        or      ah,30h                  ; make char ascii
        mov     es:[bx],ah              ; and display it
MW_BFFF_1:
        pop     bp
        ret

MW_Bxxx:
        cmp     bh,0B8h
        je      MW_B8xx
        cmp     bx,0BFFFh
        je      MW_BFFF
        cmp     bx,0B000h
        je      MW_B000
        cmp     bx,0B002h
        je      MW_B002
        cmp     bx,0B003h
        jne     MW_Bxxx_1
MW_B003:
        mov     es,ax
        mov     al,[char]
        mov     byte ptr es:[bx],al
        test    al,01h
        jz      MW_B003_1
        mov     ax,34DDh
        mov     dx,12h
        mov     bx,2400                 ; 2400 Hz frequentie
        div     bx                      ; calc. value for timeq
        out     42h,al
        mov     al,ah
        out     42h,al
        in      al,61h
        or      al,03h
        out     61h,al
        pop     bp
        ret
MW_B003_1:
        in      al,61h
        and     al,0BCh
        out     61h,al
        pop     bp
        ret

MW_B002:
        mov     es,ax
        mov     al,[char]
        and     byte ptr es:[bx],0F0h           ; preserve repeat key bit
        and     al,0Fh
        or      byte ptr es:[bx],al
        pop     bp
        ret
MW_Bxxx_1:
        cmp     bx,0BFFDh
        je      MW_BFFD
        cmp     bx,0BFFEh
        je      MW_BFFE
        mov     cx,bx
        and     cx,0FFF0h
        cmp     cx,0B010h
        je      MW_B010
        mov     es,ax
        mov     al,[char]
        mov     byte ptr es:[bx],al
        pop     bp
        ret

MW_B8xx:
        cmp     bl,01h
        je      MW_B801
        mov     es,ax
        mov     al,[char]
        cmp     bl,0Ch                          ; enable printer  (0xB80C)
        jne     MW_B8xx_1
        test    _pflag,01h                      ; Test if printer available
        jne     MW_B8xx_1
        mov     al,00h                          ; if not then don't enable
MW_B8xx_1:
        mov     byte ptr es:[bx],al
        pop     bp
        ret

MW_BFFD:
        mov     es,ax
        mov     al,[char]       ; 0 = atomcrt, 1 = pc-crt
        mov     byte ptr es:[bx],al
        mov     lockrom,al
        pop     bp
        ret

MW_BFFE:
        mov     al,[char]       ; 0 = atomcrt, 1 = pc-crt
        xor     ah,ah
        push    ax              ; Character to select screen mode
        call    _SwitchCrt      ; call 'C' function
        pop     bp              ; discard parameters on stack
        pop     bp
        ret

MW_B801:                                        ; (0xB801)
        push    word ptr DGROUP:_printer+2      ; Print character in al
	push	word ptr DGROUP:_printer
        mov     al,[char]
        xor     ah,ah
        push    byte ptr ax
        call    near ptr _fputc                 ; "C" print function
	add	sp,6
        pop     bp
        ret

MW_B010:
        cmp     bl,10h
        je      MW_B010a
        jmp     MW_B011
MW_B010a:
        mov     al,[char]
        cmp     al,7Fh                  ; BackSpace
        jne     MW_B010_1
        mov     al,08h
        mov     ah,0Eh
        mov     bh,00h
        int     10h
        mov     al,20h
        mov     ah,0Eh
        mov     bl,[attrib]
        int     10h
        mov     al,08h
        mov     ah,0Eh
        int     10h
        pop     bp
        ret

MW_B010_1:
        cmp     al,09h                  ; Forward 1 position
        jne     MW_B010_2
        mov     ah,03h
        mov     bh,00h
        int     10h
        cmp     dl,79
        jge     MW_B010_1a
        inc     dl
        mov     ah,02h
        mov     bh,00h
        int     10h
        pop     bp
        ret
MW_B010_1a:
        cmp     dh,24
        jge     MW_B010_1c
        inc     dh
        mov     dl,00h
        mov     ah,02h
        mov     bh,00h
        int     10h
MW_B010_1c:
        pop     bp
        ret

MW_B010_2:
        cmp     al,0Bh                  ; Up 1 line
        jne     MW_B010_3
        mov     ah,03h
        mov     bh,00h
        int     10h
        or      dh,dh
        je      MW_B010_1c
        dec     dh
        mov     ah,02h
        mov     bh,00h
        int     10h
        pop     bp
        ret

MW_B010_3:
        cmp     al,0Ch                  ; Clear screen
        jne     MW_B010_4
        mov     ax,0600h
        mov     bh,[attrib]
        mov     cx,0000h
        mov     dx,184Fh
        int     10h
        jmp     MW_B010_4a

MW_B010_4:
        cmp     al,1Eh                  ; Cursor home
        jne     MW_B010_5
MW_B010_4a:
        mov     ah,02h
        mov     bh,00h
        mov     dx,0000h
        int     10h
        pop     bp
        ret

MW_B010_5:
        mov     ah,0Eh                  ; Display character
        int     10h
        pop     bp
        ret

MW_B011:
        cmp     bl,11h                  ; go to Position
        jne     MW_B012
        mov     al,[char]
        cmp     al,80                   ; must be position 0 - 79
        jge     MW_B011_1
        mov     ah,03h
        mov     bh,00h
        int     10h                     ; get current position
        mov     dl,al
        mov     ah,02h
        mov     bh,00h
        int     10h                     ; go to new position
MW_B011_1:
        pop     bp
        ret

MW_B012:
        cmp     bl,12h                  ; go to Line
        jne     MW_B013
        mov     al,[char]
        cmp     al,25                   ; must be line 0 - 24
        jge     MW_B012_1
        mov     ah,03h
        mov     bh,00h
        int     10h                     ; get current line
        mov     dh,al
        mov     ah,02h
        mov     bh,00h
        int     10h                     ; go to new line
MW_B012_1:
        pop     bp
        ret

MW_B013:
        mov     es,ax                   ; set colour (attribute)
        mov     al,[char]
        mov     byte ptr es:[bx],al
        mov     [attrib],al
        pop     bp
        ret

MW_Floppy:
        cmp     bl,04h
        jg      MW_B013
MW_Floppy1:
        mov     al,[char]
        xor     ah,ah
        push    ax              ; Character to write to floppy
        push    bx              ; memory address of floppy controler
        push    01h             ; write command
        call    _FDC
        add     sp,6            ; discard parameters on stack
        pop     bp
        ret

_MWrite endp

; ************************************************
; ************  Atom 0xB00X Write  ***************
; ************************************************

        public  _MWB00T
_MWB00T proc    near
        ARG     address:word,char:byte
        push    bp
        mov     bp,sp
        mov     bx,[address]
        cmp     bx,0B001h
        je      MWB00T_1
        cmp     bx,0B002h
        je      MWB00T_1
        jmp     MWB00T_e
MWB00T_1:
        mov     ax,MGROUP
        ASSUME  cs:_TEXT,ds:DGROUP,es:MGROUP,ss:DGROUP
        mov     es,ax
        mov     al,[char]
        mov     byte ptr es:[bx],al
MWB00T_e:
        pop     bp
        ret
_MWB00T endp

        end
