        .286
        .MODEL compact

        EXTRN   _FDC: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

f6502   record S:1, V:1, X:1, B:1, D:1, I:1, Z:1, C:1

        .DATA

XPC     dw      0FFF3h
XA      db      0
XX      db      0
XY      db      0
XSP     dw      01FFh
XP      db      00000100b


TEMP    dw        3 dup (0)

        include 6502pc.inc

        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

        public _X6502
_X6502  proc near
        pusha
        mov     dx,0FFF3h
        call    _MReadx
        mov     byte ptr [XPC],al
        mov     dx,0FFF4h
        call    _MReadx
        mov     byte ptr [XPC+1],al
        call    fetch
        popa
        ret

fetch:
        mov     dx,[XPC]
        call    _MReadx
        inc     [XPC]
        shl     ax,1
        shl     ax,1
        inc     ax
        mov     bx,ax
        mov     ax,word ptr ds:X6502I[bx]
        jmp     ax

_MReadx:
        push    dx
        call    _MRead
        pop     dx
        ret

_MWritex:
        push    dx
        push    ax
        call    _MWrite
        pop     bx
        pop     dx
        ret

I_XXX:                                          ;  0x??, "Illegal Instruction",
        jmp     fetch

I_BRK:                                          ;  0x00, "BRK",
        or      [XP],MASK B
        inc     [XPC]
        mov     al,byte ptr [XPC+1]
        mov     dx,[XSP]
        dec     [XSP]
        call    _MWritex
        mov     al,byte ptr [XPC]
        mov     dx,[XSP]
        dec     [XSP]
        call    _MWritex
        mov     al,[XP]
        mov     dx,[XSP]
        dec     [XSP]
        call    _MWritex
        mov     dx,0FFFEh
        call    _Mreadx
        mov     byte ptr [XPC],al
        mov     dx,0FFFFh
        call    _Mreadx
        mov     byte ptr [XPC+1],al
        jmp     fetch

I_ORA0:                                         ;  0x01, "ORA (#%02X,X)",
        jmp     fetch
I_ORA1:                                         ;  0x05, "ORA #%02X",
        jmp     fetch
I_ASL1:                                         ;  0x06, "ASL #%02X",
        jmp     fetch
I_PHP:                                          ;  0x08, "PHP",
        jmp     fetch
I_ORA2:                                         ;  0x09, "ORA @#%02X",
        jmp     fetch
I_ASL2:                                         ;  0x0A, "ASL A",
        jmp     fetch
I_ORA3:                                         ;  0x0D, "ORA #%04X",
        jmp     fetch
I_ASL3:                                         ;  0x0E, "ASL #%04X",
        jmp     fetch
I_BPL:                                          ;  0x10, "BPL #%02X",
        jmp     fetch
I_ORA4:                                         ;  0x11, "ORA (#%02X),Y",
        jmp     fetch
I_ORA5:                                         ;  0x15, "ORA #%02X,X",
        jmp     fetch
I_ASL5:                                         ;  0x16, "ASL #%02X,X",
        jmp     fetch
I_CLC:                                          ;  0x18, "CLC",
        jmp     fetch
I_ORA6:                                         ;  0x19, "ORA #%04X,Y",
        jmp     fetch
I_ORA7:                                         ;  0x1D, "ORA #%04X,X",
        jmp     fetch
I_ASL7:                                         ;  0x1E, "ASL #%04X,X",
        jmp     fetch
I_JSR:                                          ;  0x20, "JSR #%04X",
        jmp     fetch
I_AND0:                                         ;  0x21, "AND (#%02X,X)",
        jmp     fetch
I_BIT0:                                         ;  0x24, "BIT #%02X",
        jmp     fetch
I_AND1:                                         ;  0x25, "AND #%02X",
        jmp     fetch
I_ROL1:                                         ;  0x26, "ROL #%02X",
        jmp     fetch
I_PLP:                                          ;  0x28, "PLP",
        jmp     fetch
I_AND2:                                         ;  0x29, "AND @#%02X",
        jmp     fetch
I_ROL2:                                         ;  0x2A, "ROL A",
        jmp     fetch
I_BIT1:                                         ;  0x2C, "BIT #%04X",
        jmp     fetch
I_AND3:                                         ;  0x2D, "AND #%04X",
        jmp     fetch
I_ROL3:                                         ;  0x2E, "ROL #%04X",
        jmp     fetch
I_BMI:                                          ;  0x30, "BMI #%02X",
        jmp     fetch
I_AND4:                                         ;  0x31, "AND (#%02X),Y",
        jmp     fetch
I_AND5:                                         ;  0x35, "AND #%02X,X",
        jmp     fetch
I_ROL5:                                         ;  0x36, "ROL #%02X,X",
        jmp     fetch
I_SEC:                                          ;  0x38, "SEC",
        jmp     fetch
I_AND6:                                         ;  0x39, "AND #%04X,Y",
        jmp     fetch
I_AND7:                                         ;  0x3D, "AND #%04X,X",
        jmp     fetch
I_ROL7:                                         ;  0x3E, "ROL #%04X,X",
        jmp     fetch
I_RTI:                                          ;  0x40, "RTI",
        jmp     fetch
I_EOR0:                                         ;  0x41, "EOR (#%02X,X)",
        jmp     fetch
I_EOR1:                                         ;  0x45, "EOR #%02X",
        jmp     fetch
I_LSR1:                                         ;  0x46, "LSR #%02X",
        jmp     fetch
I_PHA:                                          ;  0x48, "PHA",
        jmp     fetch
I_EOR2:                                         ;  0x49, "EOR @#%02X",
        jmp     fetch
I_LSR2:                                         ;  0x4A, "LSR A",
        jmp     fetch
I_JMP0:                                         ;  0x4C, "JMP #%04X",
        jmp     fetch
I_EOR3:                                         ;  0x4D, "EOR #%04X",
        jmp     fetch
I_LSR3:                                         ;  0x4E, "LSR #%04X",
        jmp     fetch
I_BVC:                                          ;  0x50, "BVC #%02X",
        jmp     fetch
I_EOR4:                                         ;  0x51, "EOR (#%02X),Y",
        jmp     fetch
I_EOR5:                                         ;  0x55, "EOR #%02X,X",
        jmp     fetch
I_LSR5:                                         ;  0x56, "LSR #%02X,X",
        jmp     fetch
I_CLI:                                          ;  0x58, "CLI",
        jmp     fetch
I_EOR6:                                         ;  0x59, "EOR #%04X,Y",
        jmp     fetch
I_EOR7:                                         ;  0x5D, "EOR #%04X,X",
        jmp     fetch
I_LSR7:                                         ;  0x5E, "LSR #%04X,X",
        jmp     fetch
I_RTS:                                          ;  0x60, "RTS",
        jmp     fetch
I_ADC0:                                         ;  0x61, "ADC (#%02X,X)",
        jmp     fetch
I_ADC1:                                         ;  0x65, "ADC #%02X",
        jmp     fetch
I_ROR1:                                         ;  0x66, "ROR #%02X",
        jmp     fetch
I_PLA:                                          ;  0x68, "PLA",
        jmp     fetch
I_ADC2:                                         ;  0x69, "ADC @#%02X",
        jmp     fetch
I_ROR2:                                         ;  0x6A, "ROR A",
        jmp     fetch
I_JMP1:                                         ;  0x6C, "JMP (#%04X)",
        jmp     fetch
I_ADC3:                                         ;  0x6D, "ADC #%04X",
        jmp     fetch
I_ROR3:                                         ;  0x6E, "ROR #%04X",
        jmp     fetch
I_BVS:                                          ;  0x70, "BVS #%02X",
        jmp     fetch
I_ADC4:                                         ;  0x71, "ADC (#%02X),Y",
        jmp     fetch
I_ADC5:                                         ;  0x75, "ADC #%02X,X",
        jmp     fetch
I_ROR5:                                         ;  0x76, "ROR #%02X,X",
        jmp     fetch
I_SEI:                                          ;  0x78, "SEI",
        jmp     fetch
I_ADC6:                                         ;  0x79, "ADC #%04X,Y",
        jmp     fetch
I_ADC7:                                         ;  0x7D, "ADC #%04X,X",
        jmp     fetch
I_ROR7:                                         ;  0x7E, "ROR #%04X,X",
        jmp     fetch
I_STA0:                                         ;  0x81, "STA (#%02X,X)",
        jmp     fetch
I_STY0:                                         ;  0x84, "STY #%02X",
        jmp     fetch
I_STA1:                                         ;  0x85, "STA #%02X",
        jmp     fetch
I_STX0:                                         ;  0x86, "STX #%02X",
        jmp     fetch
I_DEY:                                          ;  0x88, "DEY",
        dec     [XY]
        jmp     fetch
I_TXA:                                          ;  0x8A, "TXA",
        jmp     fetch
I_STY1:                                         ;  0x8C, "STY #%04X",
        jmp     fetch
I_STA3:                                         ;  0x8D, "STA #%04X",
        jmp     fetch
I_STX1:                                         ;  0x8E, "STX #%04X",
        jmp     fetch
I_BCC:                                          ;  0x90, "BCC #%02X",
        jmp     fetch
I_STA4:                                         ;  0x91, "STA (#%02X),Y",
        jmp     fetch
I_STY2:                                         ;  0x94, "STY #%02X,X",
        jmp     fetch
I_STA5:                                         ;  0x95, "STA #%02X,X",
        jmp     fetch
I_STX2:                                         ;  0x96, "STX #%02X,Y",
        jmp     fetch
I_TYA:                                          ;  0x98, "TYA",
        jmp     fetch
I_STA6:                                         ;  0x99, "STA #%04X,Y",
        jmp     fetch
I_TXS:                                          ;  0x9A, "TXS",
        jmp     fetch
I_STA7:                                         ;  0x9D, "STA #%04X,X",
        jmp     fetch
I_LDY0:                                         ;  0xA0, "LDY @#%02X",
        jmp     fetch
I_LDA0:                                         ;  0xA1, "LDA (#%02X,X)",
        jmp     fetch
I_LDX0:                                         ;  0xA2, "LDX @#%02X",
        jmp     fetch
I_LDY1:                                         ;  0xA4, "LDY #%02X",
        jmp     fetch
I_LDA1:                                         ;  0xA5, "LDA #%02X",
        jmp     fetch
I_LDX1:                                         ;  0xA6, "LDX #%02X",
        jmp     fetch
I_TAY:                                          ;  0xA8, "TAY",
        jmp     fetch
I_LDA2:                                         ;  0xA9, "LDA @#%02X",
        jmp     fetch
I_TAX:                                          ;  0xAA, "TAX",
        jmp     fetch
I_LDY3:                                         ;  0xAC, "LDY #%04X",
        jmp     fetch
I_LDA3:                                         ;  0xAD, "LDA #%04X",
        jmp     fetch
I_LDX3:                                         ;  0xAE, "LDX #%04X",
        jmp     fetch
I_BCS:                                          ;  0xB0, "BCS #%02X",
        jmp     fetch
I_LDA4:                                         ;  0xB1, "LDA (#%02X),Y",
        jmp     fetch
I_LDY5:                                         ;  0xB4, "LDY #%02X,X",
        jmp     fetch
I_LDA5:                                         ;  0xB5, "LDA #%02X,X",
        jmp     fetch
I_LDX5:                                         ;  0xB6, "LDX #%02X,Y",
        jmp     fetch
I_CLV:                                          ;  0xB8, "CLV",
        jmp     fetch
I_LDA6:                                         ;  0xB9, "LDA #%04X,Y",
        jmp     fetch
I_TSX:                                          ;  0xBA, "TSX",
        jmp     fetch
I_LDY7:                                         ;  0xBC, "LDY #%04X,X",
        jmp     fetch
I_LDA7:                                         ;  0xBD, "LDA #%04X,X",
        jmp     fetch
I_LDX7:                                         ;  0xBE, "LDX #%04X,Y",
        jmp     fetch
I_CPY0:                                         ;  0xC0, "CPY @#%02X",
        jmp     fetch
I_CMP0:                                         ;  0xC1, "CMP (#%02X,X)",
        jmp     fetch
I_CPY1:                                         ;  0xC4, "CPY #%02X",
        jmp     fetch
I_CMP1:                                         ;  0xC5, "CMP #%02X",
        jmp     fetch
I_DEC0:                                         ;  0xC6, "DEC #%02X",
        jmp     fetch
I_INY:                                          ;  0xC8, "INY",
        inc     [XY]
        jmp     fetch
I_CMP2:                                         ;  0xC9, "CMP @#%02X",
        jmp     fetch
I_DEX:                                          ;  0xCA, "DEX",
        dec     [XX]
        jmp     fetch
I_CPY3:                                         ;  0xCC, "CPY #%04X",
        jmp     fetch
I_CMP3:                                         ;  0xCD, "CMP #%04X",
        jmp     fetch
I_DEC1:                                         ;  0xCE, "DEC #%04X",
        jmp     fetch
I_BNE:                                          ;  0xD0, "BNE #%02X",
        jmp     fetch
I_CMP4:                                         ;  0xD1, "CMP (#%02X),Y",
        jmp     fetch
I_CMP5:                                         ;  0xD5, "CMP #%02X,X",
        jmp     fetch
I_DEC2:                                         ;  0xD6, "DEC #%02X,X",
        jmp     fetch
I_CLD:                                          ;  0xD8, "CLD",
        jmp     fetch
I_CMP6:                                         ;  0xD9, "CMP #%04X,Y",
        jmp     fetch
I_CMP7:                                         ;  0xDD, "CMP #%04X,X",
        jmp     fetch
I_DEC3:                                         ;  0xDE, "DEC #%04X,X",
        jmp     fetch
I_CPX0:                                         ;  0xE0, "CPX @#%02X",
        jmp     fetch
I_SBC0:                                         ;  0xE1, "SBC (#%02X,X)",
        jmp     fetch
I_CPX1:                                         ;  0xE4, "CPX #%02X",
        jmp     fetch
I_SBC1:                                         ;  0xE5, "SBC #%02X",
        jmp     fetch
I_INC0:                                         ;  0xE6, "INC #%02X",
        jmp     fetch
I_INX:                                          ;  0xE8, "INX",
        inc     [XX]
        jmp     fetch
I_SBC2:                                         ;  0xE9, "SBC @#%02X",
        jmp     fetch
I_NOP:                                          ;  0xEA, "NOP",
        jmp     fetch
I_CPX3:                                         ;  0xEC, "CPX #%04X",
        jmp     fetch
I_SBC3:                                         ;  0xED, "SBC #%04X",
        jmp     fetch
I_INC1:                                         ;  0xEE, "INC #%04X",
        jmp     fetch
I_BEQ:                                          ;  0xF0, "BEQ #%02X",
        jmp     fetch
I_SBC4:                                         ;  0xF1, "SBC (#%02X),Y",
        jmp     fetch
I_SBC5:                                         ;  0xF5, "SBC #%02X,X",
        jmp     fetch
I_INC2:                                         ;  0xF6, "INC #%02X,X",
        jmp     fetch
I_SED:                                          ;  0xF8, "SED",
        jmp     fetch
I_SBC6:                                         ;  0xF9, "SBC #%04X,Y",
        jmp     fetch
I_SBC7:                                         ;  0xFD, "SBC #%04X,X",
        jmp     fetch
I_INC3:                                         ;  0xFE, "INC #%04X,X",
        jmp     fetch

_X6502  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
        .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
        mov     al,[char]
        mov     byte ptr es:[bx],al
MW_mem3:
        cmp     bh,80h                  ; test for address between 0x8000
        jl      MW_mem4
        cmp     bh,[VideoTo]            ; and Max Address
        jge     MW_mem4
        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
        je      MW_B003_1
        mov     ax,34DDh
        mov     dx,12h
        mov     bx,2400
        div     bx
        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:
        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_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


        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


        end
