XXX00000000000C HLT :IS_BOOT ? IS_WAIT ? CR(0, ACC()) : FH(8) : (CR(CR(0) & 0xF0), FH(0xB), FL(0x5)) // Halting
XXX00011111110C NOP :$IB==$IB // No operation
0000000XXX0XXX_ PREFIX R#X/P#X :0 // Prefix for R#X!/P#X!
X1000011101XXXE PUSH+ U#X :HEAP(U#X()) // Push pointer into stack
X1000011111XXXE POP+ U#X :U#X(HEAP()) // Pop pointer from stack
XXXXXX11111110C NOP #Z :#Z // Hollow operation through #Z ticks
XXX10010101XXXA ALU#X IB :$1=ALU#X(DROP(FH()),$IB),ACC($1),FL($1.hi()) // ALU#X! with retained and immediate
XXXXXX10101XXXA ALU#X Z#Z,IB :$1=ALU#X(Z#Z(),$IB),Z#Z($1),FL($1.hi()) // ALU#X! with Z#Z! and byte
XXX1000XXX1XXXA ALU#X Z#Y :$1=ALU#X(DROP(#Y),REG(#Y)),REG(#Y,$1),FL($1.hi()) // ALU#X! with Z#Y! and retained
XXXXXX0XXX1XXXA ALU#X Z#Z,R#Y :$1=ALU#X(Z#Z(),R#Y()),Z#Z($1),FL($1.hi()) // ALU#X! with Z#Z! and R#Y!
000XXX0XXX0XXXC HLT #Z :IS_BOOT && IS_WAIT ? FH()==(#Z+8) ? ACC(PORT(ACC())) : FH()>=8 ? PORT(ACC(),REG(#Z)) : ACC(CR(#Z)) : FH(#Z+8) // Hold #Z index number
X1000011001XXXD INC+ Q#X :Q#X(Q#X()+1) // Increment Q#X!
X1000011011XXXD DEC+ Q#X :Q#X(Q#X()-1) // Decrement Q#X!
XXX00011001111A CMC :FL(FL() ^ 2) // Complement carry flag
XXXXXX11001110D ADC BX,P#Z :$1=BX()+P#Z()+(_CF?1:0),$2=($1>>15)&2,FL((FL()& 0xD)|$2), BX($1) // Addition register pair with carry
X10XXX11001XXXD ADD Q#X,P#Z :$1=Q#X()+P#Z()+(_CF?0:0),$2=($1>>15)&2,FL((FL()& 0xD)|$2), Q#X($1) // Addition register pair
XXXXXX11011110D SBB BX,P#Z :$1=BX()-P#Z()-(_CF?1:0),$2=($1>>15)&2,FL((FL()& 0xD)|$2), BX($1) // Subtraction register pair with borrow
X10XXX11011XXXD SUB Q#X,P#Z :$1=Q#X()-P#Z()-(_CF?0:0),$2=($1>>15)&2,FL((FL()& 0xD)|$2), Q#X($1) // Subtraction register pair
XXX00011001010A XCHG :$1=ACC(); for($2=0,$0=0;$0<8;++$0,$1>>=1) $2=($2<<1)+($1&1); ACC($2)>0 // Exchange retained bits by mirror
XXXXXX11001010A XCHG P#Z :$1=DST(),DST(P#Z()),P#Z($1) // Exchange P#Z! with retained pair
XXXXXX11001111A XCHG R#Z :$1=ACC(),ACC(R#Z()),R#Z($1) // Exchange R#Z! with retained register
XXX100110X1XXXA ALU#W :$1=ACC(ALU#W(ACC())),FL($1.hi()) // ALU#W! with retained
XXXXXX110X1XXXA ALU#W Z#Z :$1=Z#Z(ALU#W(Z#Z())),FL($1.hi()) // ALU#W! with Z#Z!
01110000000XXXD PUSH+ T#X+[T#Y] :HEAP(T#X()+DW(T#Y())) // Correct effective address in stack
0111000XXX0XXXD PUSH+ T#X+T#Y :HEAP(T#X()+T#Y()) // Push effective address into stack
1111000XXX0000D PUSH+ [T#X]-T#Y :HEAP(HEAP()-T#Y()) // Correct effective address in stack
1111000XXX0XXXD PUSH+ T#X-T#Y :HEAP(T#X()-T#Y()) // Push effective address into stack
XXXXXX00000000C HLT R#Z :/*IS_BOOT && */IS_WAIT ? FH() == #Z ? ACC(CTX(ACC())) : $IR ? CTX(ACC(),R#Z()) : CR(FH(),R#Z()) : FH(#Z) // Hold R#Z!/P#Z! as retained
XXX0000XXX0XXXF MOV R#X,R#Y :R#X(R#Y()) // Move R#Y! data into R#X!
XXX00010100XXXF MOV R#X,IB :R#X($IB) // Move immediate data into R#X!
XXX00010110000B JCND#X $+IB :CND#X?IP(IP()+$IV):0 // Relative branching if CND#X!
XXX00010110001E BIAS $+IB :HEAP($IP+$IV) // Push instruction based relative address
XXX00010110XXXB CCND#X $+IB :CND#X?HEAP(IP())+IP(IP()+$IV):0 // Relative call if CND#X!
XXX00011000XXXA INC+ R#X :$1=ADD(R#X(),1),R#X($1),FL($1.hi()) // Increment R#X!
XXX00011010XXXA DEC+ R#X :$1=SUB(R#X(),1),R#X($1),FL($1.hi()) // Decrement R#X!
X00XXX1111XXXXB INT #T :HEAP($IP)+IP(JP(#T<10?0:1))>0 // Programm interruption indexed by #T
XXX10011101110F XCHG [SP] :$1=DST(),DST(DW($2=SP())), DW($2, $1) // Exchange retained pair with stack heap
XXXXXX11101110F XCHG P#Z,[SP] :$1=P#Z(),P#Z(DW(SP())), DW(SP(), $1) // Exchange pair P#Z with stack heap
001XXX0XXX0XXXF XCHG P#Z,P#Y :$1=P#Z(),P#Z(P#Y()),P#Y($1) // Exchange P#Z! and P#Y!
010XXX0XXX0XXXF XCHG R#Z,R#Y :$1=R#Z(),R#Z(R#Y()),R#Y($1) // Exchange R#Z! and R#Y!
011XXX0XXX0XXXD LEA P#Z,T#X+T#Y :P#Z(T#X()+T#Y()) // Load T#X!+T#Y! effective address into P#Z
111XXX0XXX0XXXD LEA P#Z,T#X-T#Y :P#Z(T#X()-T#Y()) // Load T#X!-T#Y! effective address into P#Z
XXXXXX10100000E POP+ [P#Z+IB] :DW(P#Z()+$IV,HEAP()) // Pop data into memory indexed by P#Z
XXXXXX10100XXXF MOV R#X,[P#Z+IB] :trace.is_port=IP_BP; trace.is_context=IP_SP; R#X(DB(P#Z()+$IV)) // Move memory data by P#Z pointer into R#X
XXXXXX10110000E PUSH+ [P#Z+IB] :HEAP(DW(P#Z()+$IV)) // Push data from memory indexed by P#Z
XXXXXX10110XXXF MOV [P#Z+IB],R#X :trace.is_port=IP_BP; trace.is_context=IP_SP; DB(P#Z()+$IV,R#X()) // Move R#X register data into memory by P#Z
XXX10011101111E PUSH :HEAP(DST()) // Push retained pair
XXXXXX11101111E PUSH+ S#Z :HEAP(S#Z()) // Push service S#Z register pair to stack
XXX10011111111E POP :DST(HEAP()) // Pop retained pair
XXXXXX11111111E POP+ S#Z :S#Z(HEAP()) // Pop service S#Z register pair from stack
XXXXXX11101010E PUSH+ R#Z :DUP(#Z) // Dup R#Z register history
XXXXXX11101011C SKIP [R#Z] :FH(R#Z()|8),FL((FL() & 0x02) | 0x05) // Exclude next operations by R#Z bits
XXXXXX11101100C SKIP R#Z :FH(#Z), FL((FL() & 0x02) | 0x05) // Exclude next operations by R#Z counter
XXXXXX11101101C SKIP #Z :FH(#Z | 8), FL((FL() & 0x02) | 0x05) // Exclude next operations by #Z times
XXXXXX11111010E POP+ R#Z :DROP(#Z) // Drop R#Z register history
XXXXXX11111011C LOOP [R#Z] :FH(R#Z()|8),FL((FL() & 0x02) | 0x09) // Forcing next operation by R#Z bits
XXXXXX11111100C LOOP R#Z :FH(#Z), FL((FL() & 0x02) | 0x09) // Forcing next operation by R#Z counter
XXXXXX11111101C LOOP #Z :FH(#Z | 8), FL((FL() & 0x02) | 0x09) // Forcing next operation by #Z times
XXXXXX100XXXXXE PUSH+ #VIB :HEAP(0x#V00 + $IB) // Push immediate data into stack
0XX10010111XXXX --- IB :return 0 // Reserved extended code
XXX10010111010E LEA +IB :DST(DST()+$IB) // Load retained effective address
X1010010111XXXF MOV [U#X],IB :DB(U#X(),$IB) // Load immediate data into memory by U#X
XXXXXX10111000B JMP $+#UIB :$IW==-2?(FL((FL() & 0x02) | 0x0D),trace.expression=""):IP(IP()+$IW) // Unonditional relative branching
XXXXXX10111001B CALL $+#UIB :$IW==-2?0:HEAP(IP(IP()+$IW)) // Unconditional relative call
XXXXXX10111XXXB JCND#X $+#UIB :CND#X?IP(IP()+$IW):0 // Branching if CND#X!
XXXXXXXXXXXXXXX --- :return 0 // Reserved code
// Helpers
ALU08 ROL ROL Roll Overflow Left
ALU09 RCL RCL Roll Cyclic Left
ALU0A XCHG
ALU0F NEG 0
ALU18 ROR ROR Roll Overflow Right
ALU19 RCR RCR Roll Cyclic Right
ALU1A RAR RAR Roll Arithmetic Right
ALU1F NOT NOT Bitwise NOT
ALU0 ADC ADC Addition with carry
ALU1 SBB SBB Subtract with borrow
ALU2 ADD ADD Addition
ALU3 SUB SUB Subtract
ALU4 AND AND Bitwise AND/conjunct
ALU5 OR OR Bitwise OR/disjunct
ALU6 XOR XOR Bitwise eXclusive OR
ALU7 CMP CMP Comparation
// Register descriptions
// Pointers
P0 IP IP IP
P1 BP BP BP
P2 SI SI SI
P3 DI DI DI
P4 SP SP SP
P5 BX BX DX
P6 CX CX CX
P7 DX DX DX
// Quad
Q3 BX BX BX
Q4 CX CX CX
Q5 DX DX DX
Q6 SP SP SP
// Regular
R0 [BX] _BX_ [BX]
R1 BH BH BH
R2 CH CH CH
R3 DH DH DH
R4 AL AL AL
R5 BL BL BL
R6 CL CL CL
R7 DL DL DL
// Special
S0 IP IP IP
S1 BP BP BP
S2 SI SI SI
S3 DI DI DI
S4 [SP] _SP_ [SP]
S5 EX Extend Ex
S6 SX SX Sx
S7 TX Timers Tx
// Tabular
T0 SP SP SP
T1 BP BP BP
T2 SI SI SI
T3 DI DI DI
T4 AL _AL_ AL
T5 BX BX BX
T6 CX CX CX
T7 DX DX DX
// Unical
U2 AX AX AX
U3 BX BX BX
U4 CX CX CX
U5 DX DX DX
Z0 AL AL AL
Z1 BH BH BH
Z2 CH CH CH
Z3 DH DH DH
Z4 AL AL AL
Z5 BL BL BL
Z6 CL CL CL
Z7 DL DL DL
_ZF ZF !!(FL() & 1)
_CF CF !!(FL() & 2)
_PF PF !!(FL() & 4)
_SF SF !!(FL() & 8)
// Conditional
CND0 PE !!(FL() & 4) Parity is Even
CND1 PO !(FL() & 4) Parity is Odd
CND2 S !!(FL() & 8) result is Signed
CND3 NS !(FL() & 8) result is Not Signed
CND4 C !!(FL() & 2) result with Carry
CND5 NC !(FL() & 2) result with No Carry
CND6 Z !!(FL() & 1) result is Equal
CND7 NZ !(FL() & 1) result is Not Equal
IS_BOOT IS_BOOT (CR() == 0)
IS_WAIT IS_WAIT ($IE == 3)
IP_BP IP_BP (BP().hi()==IP().hi() && ((#Z==1)||(#Z==4)))
IP_SP IP_SP (SP().hi()==IP().hi() && (#Z==4))
// Aliases
WAIT!0 @B8 FE F0 Express Function #0
WAIT!1 @B8 FE F1 Express Function #1
WAIT!2 @B8 FE F2 Express Function #2
WAIT!3 @B8 FE F3 Express Function #3
WAIT!4 @B8 FE F4 Express Function #4
WAIT!5 @B8 FE F5 Express Function #5
WAIT!6 @B8 FE F6 Express Function #6
WAIT!7 @B8 FE F7 Express Function #7
WAIT!8 @B8 FE F8 Express Function #8
WAIT!9 @B8 FE F9 Express Function #9
CALL![SP] @EE Call subroutine
WAIT! @B8 FE Waitable mode
HLT 0 @00
HLT BP @11 00
HLT SI @22 00
HLT DI @33 00
HLT [SP] @44 00
HLT BX @55 00
HLT CX @66 00
HLT DX @77 00
CLC! @BD 01 CF Clear CARRY FLAG
STC! @BC 01 CF Store CARRY FLAG
RPE! @B0 FF Return by EVEN PARITY
RPO! @B1 FF Return by ODD PARITY
RS! @BA FF Return by Positive
RNS! @BB FF Return by Negative
RC! @BC FF Return by CARRY
RNC! @BD FF Return by not CARRY
RZ! @BE FF Return by ZERO
RNZ! @BF FF Return by not ZERO
RET! @FF Return from subroutine
MOV!BX,CX @21 65 Load %Y register pair to %X
MOV!BX,DX @31 75 Load %Y register pair to %X
MOV!CX,BX @12 56 Load %Y register pair to %X
MOV!CX,DX @31 76 Load %Y register pair to %X
MOV!DX,BX @13 57 Load %Y register pair to %X
MOV!DX,CX @23 67 Load %Y register pair to %X
MOV!BP,SI @22 EF 11 FF Load %Y register pair to %X
MOV!BP,DI @33 EF 11 FF Load %Y register pair to %X
MOV!BP,BX @EB 11 FF Load %Y register pair to %X
MOV!BP,CX @EC 11 FF Load %Y register pair to %X
MOV!BP,DX @ED 11 FF Load %Y register pair to %X
MOV!SI,BP @11 EF 22 FF Load %Y register pair to %X
MOV!SI,DI @33 EF 22 FF Load %Y register pair to %X
MOV!SI,BX @EB 22 FF Load %Y register pair to %X
MOV!SI,CX @EC 22 FF Load %Y register pair to %X
MOV!SI,DX @ED 22 FF Load %Y register pair to %X
MOV!DI,BP @11 EF 33 FF Load %Y register pair to %X
MOV!DI,SI @22 EF 33 FF Load %Y register pair to %X
MOV!DI,BX @EB 33 FF Load %Y register pair to %X
MOV!DI,CX @EC 33 FF Load %Y register pair to %X
MOV!DI,DX @ED 33 FF Load %Y register pair to %X
MOV!BX,BP @11 EF FB Load %Y register pair to %X
MOV!BX,SI @22 EF FB Load %Y register pair to %X
MOV!BX,DI @33 EF FB Load %Y register pair to %X
MOV!CX,BP @11 EF FC Load %Y register pair to %X
MOV!CX,SI @22 EF FC Load %Y register pair to %X
MOV!CX,DI @33 EF FC Load %Y register pair to %X
MOV!DX,BP @11 EF FD Load %Y register pair to %X
MOV!DX,SI @22 EF FD Load %Y register pair to %X
MOV!DX,DI @33 EF FD Load %Y register pair to %X
MOV [0],BH @00 B8 FE 11 00 Set control register #%X by %Y
MOV [0],CH @00 B8 FE 22 00 Set control register #%X by %Y
MOV [0],DH @00 B8 FE 33 00 Set control register #%X by %Y
MOV [0],AL @00 B8 FE 44 00 Set control register #%X by %Y
MOV [0],BL @00 B8 FE 55 00 Set control register #%X by %Y
MOV [0],CL @00 B8 FE 66 00 Set control register #%X by %Y
MOV [0],DL @00 B8 FE 77 00 Set control register #%X by %Y
MOV [1],BH @11 11 B8 FE 11 00 Set control register #%X by %Y
MOV [1],CH @11 11 B8 FE 22 00 Set control register #%X by %Y
MOV [1],DH @11 11 B8 FE 33 00 Set control register #%X by %Y
MOV [1],AL @11 11 B8 FE 44 00 Set control register #%X by %Y
MOV [1],BL @11 11 B8 FE 55 00 Set control register #%X by %Y
MOV [1],CL @11 11 B8 FE 66 00 Set control register #%X by %Y
MOV [1],DL @11 11 B8 FE 77 00 Set control register #%X by %Y
MOV [2],BH @22 22 B8 FE 11 00 Set control register #%X by %Y
MOV [2],CH @22 22 B8 FE 22 00 Set control register #%X by %Y
MOV [2],DH @22 22 B8 FE 33 00 Set control register #%X by %Y
MOV [2],AL @22 22 B8 FE 44 00 Set control register #%X by %Y
MOV [2],BL @22 22 B8 FE 55 00 Set control register #%X by %Y
MOV [2],CL @22 22 B8 FE 66 00 Set control register #%X by %Y
MOV [2],DL @22 22 B8 FE 77 00 Set control register #%X by %Y
MOV [3],BH @33 33 B8 FE 11 00 Set control register #%X by %Y
MOV [3],CH @33 33 B8 FE 22 00 Set control register #%X by %Y
MOV [3],DH @33 33 B8 FE 33 00 Set control register #%X by %Y
MOV [3],AL @33 33 B8 FE 44 00 Set control register #%X by %Y
MOV [3],BL @33 33 B8 FE 55 00 Set control register #%X by %Y
MOV [3],CL @33 33 B8 FE 66 00 Set control register #%X by %Y
MOV [3],DL @33 33 B8 FE 77 00 Set control register #%X by %Y
MOV [4],BH @44 44 B8 FE 11 00 Set control register #%X by %Y
MOV [4],CH @44 44 B8 FE 22 00 Set control register #%X by %Y
MOV [4],DH @44 44 B8 FE 33 00 Set control register #%X by %Y
MOV [4],AL @44 44 B8 FE 44 00 Set control register #%X by %Y
MOV [4],BL @44 44 B8 FE 55 00 Set control register #%X by %Y
MOV [4],CL @44 44 B8 FE 66 00 Set control register #%X by %Y
MOV [4],DL @44 44 B8 FE 77 00 Set control register #%X by %Y
MOV [5],BH @55 55 B8 FE 11 00 Set control register #%X by %Y
MOV [5],CH @55 55 B8 FE 22 00 Set control register #%X by %Y
MOV [5],DH @55 55 B8 FE 33 00 Set control register #%X by %Y
MOV [5],AL @55 55 B8 FE 44 00 Set control register #%X by %Y
MOV [5],BL @55 55 B8 FE 55 00 Set control register #%X by %Y
MOV [5],CL @55 55 B8 FE 66 00 Set control register #%X by %Y
MOV [5],DL @55 55 B8 FE 77 00 Set control register #%X by %Y
MOV [6],BH @66 66 B8 FE 11 00 Set control register #%X by %Y
MOV [6],CH @66 66 B8 FE 22 00 Set control register #%X by %Y
MOV [6],DH @66 66 B8 FE 33 00 Set control register #%X by %Y
MOV [6],AL @66 66 B8 FE 44 00 Set control register #%X by %Y
MOV [6],BL @66 66 B8 FE 55 00 Set control register #%X by %Y
MOV [6],CL @66 66 B8 FE 66 00 Set control register #%X by %Y
MOV [6],DL @66 66 B8 FE 77 00 Set control register #%X by %Y
MOV [7],BH @77 77 B8 FE 11 00 Set control register #%X by %Y
MOV [7],CH @77 77 B8 FE 22 00 Set control register #%X by %Y
MOV [7],DH @77 77 B8 FE 33 00 Set control register #%X by %Y
MOV [7],AL @77 77 B8 FE 44 00 Set control register #%X by %Y
MOV [7],BL @77 77 B8 FE 55 00 Set control register #%X by %Y
MOV [7],CL @77 77 B8 FE 66 00 Set control register #%X by %Y
MOV [7],DL @77 77 B8 FE 77 00 Set control register #%X by %Y
MOV BH,[0] @11 00 B8 FE 00 Get control register #%Y to %X
MOV CH,[0] @22 00 B8 FE 00 Get control register #%Y to %X
MOV DH,[0] @33 00 B8 FE 00 Get control register #%Y to %X
MOV AL,[0] @44 00 B8 FE 00 Get control register #%Y to %X
MOV BL,[0] @55 00 B8 FE 00 Get control register #%Y to %X
MOV CL,[0] @66 00 B8 FE 00 Get control register #%Y to %X
MOV DL,[0] @77 00 B8 FE 00 Get control register #%Y to %X
MOV BH,[1] @11 00 B8 FE 11 11 Get control register #%Y to %X
MOV CH,[1] @22 00 B8 FE 11 11 Get control register #%Y to %X
MOV DH,[1] @33 00 B8 FE 11 11 Get control register #%Y to %X
MOV AL,[1] @44 00 B8 FE 11 11 Get control register #%Y to %X
MOV BL,[1] @55 00 B8 FE 11 11 Get control register #%Y to %X
MOV CL,[1] @66 00 B8 FE 11 11 Get control register #%Y to %X
MOV DL,[1] @77 00 B8 FE 11 11 Get control register #%Y to %X
MOV BH,[2] @11 00 B8 FE 22 22 Get control register #%Y to %X
MOV CH,[2] @22 00 B8 FE 22 22 Get control register #%Y to %X
MOV DH,[2] @33 00 B8 FE 22 22 Get control register #%Y to %X
MOV AL,[2] @44 00 B8 FE 22 22 Get control register #%Y to %X
MOV BL,[2] @55 00 B8 FE 22 22 Get control register #%Y to %X
MOV CL,[2] @66 00 B8 FE 22 22 Get control register #%Y to %X
MOV DL,[2] @77 00 B8 FE 22 22 Get control register #%Y to %X
MOV BH,[3] @11 00 B8 FE 33 33 Get control register #%Y to %X
MOV CH,[3] @22 00 B8 FE 33 33 Get control register #%Y to %X
MOV DH,[3] @33 00 B8 FE 33 33 Get control register #%Y to %X
MOV AL,[3] @44 00 B8 FE 33 33 Get control register #%Y to %X
MOV BL,[3] @55 00 B8 FE 33 33 Get control register #%Y to %X
MOV CL,[3] @66 00 B8 FE 33 33 Get control register #%Y to %X
MOV DL,[3] @77 00 B8 FE 33 33 Get control register #%Y to %X
MOV BH,[4] @11 00 B8 FE 44 44 Get control register #%Y to %X
MOV CH,[4] @22 00 B8 FE 44 44 Get control register #%Y to %X
MOV DH,[4] @33 00 B8 FE 44 44 Get control register #%Y to %X
MOV AL,[4] @44 00 B8 FE 44 44 Get control register #%Y to %X
MOV BL,[4] @55 00 B8 FE 44 44 Get control register #%Y to %X
MOV CL,[4] @66 00 B8 FE 44 44 Get control register #%Y to %X
MOV DL,[4] @77 00 B8 FE 44 44 Get control register #%Y to %X
MOV BH,[5] @11 00 B8 FE 55 55 Get control register #%Y to %X
MOV CH,[5] @22 00 B8 FE 55 55 Get control register #%Y to %X
MOV DH,[5] @33 00 B8 FE 55 55 Get control register #%Y to %X
MOV AL,[5] @44 00 B8 FE 55 55 Get control register #%Y to %X
MOV BL,[5] @55 00 B8 FE 55 55 Get control register #%Y to %X
MOV CL,[5] @66 00 B8 FE 55 55 Get control register #%Y to %X
MOV DL,[5] @77 00 B8 FE 55 55 Get control register #%Y to %X
MOV BH,[6] @11 00 B8 FE 66 66 Get control register #%Y to %X
MOV CH,[6] @22 00 B8 FE 66 66 Get control register #%Y to %X
MOV DH,[6] @33 00 B8 FE 66 66 Get control register #%Y to %X
MOV AL,[6] @44 00 B8 FE 66 66 Get control register #%Y to %X
MOV BL,[6] @55 00 B8 FE 66 66 Get control register #%Y to %X
MOV CL,[6] @66 00 B8 FE 66 66 Get control register #%Y to %X
MOV DL,[6] @77 00 B8 FE 66 66 Get control register #%Y to %X
MOV BH,[7] @11 00 B8 FE 77 77 Get control register #%Y to %X
MOV CH,[7] @22 00 B8 FE 77 77 Get control register #%Y to %X
MOV DH,[7] @33 00 B8 FE 77 77 Get control register #%Y to %X
MOV AL,[7] @44 00 B8 FE 77 77 Get control register #%Y to %X
MOV BL,[7] @55 00 B8 FE 77 77 Get control register #%Y to %X
MOV CL,[7] @66 00 B8 FE 77 77 Get control register #%Y to %X
MOV DL,[7] @77 00 B8 FE 77 77 Get control register #%Y to %X
MOV BH,[BH] @11 00 B8 FE 11 00 Read context cell [%X] to %X
MOV CH,[CH] @22 00 B8 FE 22 00 Read context cell [%X] to %X
MOV DH,[DH] @33 00 B8 FE 33 00 Read context cell [%X] to %X
MOV AL,[AL] @44 00 B8 FE 44 00 Read context cell [%X] to %X
MOV BL,[BL] @55 00 B8 FE 55 00 Read context cell [%X] to %X
MOV CL,[CL] @66 00 B8 FE 66 00 Read context cell [%X] to %X
MOV DL,[DL] @77 00 B8 FE 77 00 Read context cell [%X] to %X
MOV [BH],CH @11 00 B8 FE 22 00 Write %Y to context cell [%X]
MOV [BH],DH @11 00 B8 FE 33 00 Write %Y to context cell [%X]
MOV [BH],AL @11 00 B8 FE 44 00 Write %Y to context cell [%X]
MOV [BH],BL @11 00 B8 FE 55 00 Write %Y to context cell [%X]
MOV [BH],CL @11 00 B8 FE 66 00 Write %Y to context cell [%X]
MOV [BH],DL @11 00 B8 FE 77 00 Write %Y to context cell [%X]
MOV [CH],BH @22 00 B8 FE 11 00 Write %Y to context cell [%X]
MOV [CH],DH @22 00 B8 FE 33 00 Write %Y to context cell [%X]
MOV [CH],AL @22 00 B8 FE 44 00 Write %Y to context cell [%X]
MOV [CH],BL @22 00 B8 FE 55 00 Write %Y to context cell [%X]
MOV [CH],CL @22 00 B8 FE 66 00 Write %Y to context cell [%X]
MOV [CH],DL @22 00 B8 FE 77 00 Write %Y to context cell [%X]
MOV [DH],BH @33 00 B8 FE 11 00 Write %Y to context cell [%X]
MOV [DH],CH @33 00 B8 FE 22 00 Write %Y to context cell [%X]
MOV [DH],AL @33 00 B8 FE 44 00 Write %Y to context cell [%X]
MOV [DH],BL @33 00 B8 FE 55 00 Write %Y to context cell [%X]
MOV [DH],CL @33 00 B8 FE 66 00 Write %Y to context cell [%X]
MOV [DH],DL @33 00 B8 FE 77 00 Write %Y to context cell [%X]
MOV [AL],BH @44 00 B8 FE 11 00 Write %Y to context cell [%X]
MOV [AL],CH @44 00 B8 FE 22 00 Write %Y to context cell [%X]
MOV [AL],DH @44 00 B8 FE 33 00 Write %Y to context cell [%X]
MOV [AL],BL @44 00 B8 FE 55 00 Write %Y to context cell [%X]
MOV [AL],CL @44 00 B8 FE 66 00 Write %Y to context cell [%X]
MOV [AL],DL @44 00 B8 FE 77 00 Write %Y to context cell [%X]
MOV [BL],BH @55 00 B8 FE 11 00 Write %Y to context cell [%X]
MOV [BL],CH @55 00 B8 FE 22 00 Write %Y to context cell [%X]
MOV [BL],DH @55 00 B8 FE 33 00 Write %Y to context cell [%X]
MOV [BL],AL @55 00 B8 FE 44 00 Write %Y to context cell [%X]
MOV [BL],CL @55 00 B8 FE 66 00 Write %Y to context cell [%X]
MOV [BL],DL @55 00 B8 FE 77 00 Write %Y to context cell [%X]
MOV [CL],BH @66 00 B8 FE 11 00 Write %Y to context cell [%X]
MOV [CL],CH @66 00 B8 FE 22 00 Write %Y to context cell [%X]
MOV [CL],DH @66 00 B8 FE 33 00 Write %Y to context cell [%X]
MOV [CL],AL @66 00 B8 FE 44 00 Write %Y to context cell [%X]
MOV [CL],BL @66 00 B8 FE 55 00 Write %Y to context cell [%X]
MOV [CL],DL @66 00 B8 FE 77 00 Write %Y to context cell [%X]
MOV [DL],BH @77 00 B8 FE 11 00 Write %Y to context cell [%X]
MOV [DL],CH @77 00 B8 FE 22 00 Write %Y to context cell [%X]
MOV [DL],DH @77 00 B8 FE 33 00 Write %Y to context cell [%X]
MOV [DL],AL @77 00 B8 FE 44 00 Write %Y to context cell [%X]
MOV [DL],BL @77 00 B8 FE 55 00 Write %Y to context cell [%X]
MOV [DL],CL @77 00 B8 FE 66 00 Write %Y to context cell [%X]
IN BH @11 11 B8 FE 11 11 Input to %X from port %X
IN CH @22 22 B8 FE 22 22 Input to %X from port %X
IN DH @33 33 B8 FE 33 33 Input to %X from port %X
IN AL @44 44 B8 FE 44 44 Input to %X from port %X
IN BL @55 55 B8 FE 55 55 Input to %X from port %X
IN CL @66 66 B8 FE 66 66 Input to %X from port %X
IN DL @77 77 B8 FE 77 77 Input to %X from port %X
OUT BH,CH @11 11 B8 FE 22 22 Output %Y to port %X
OUT BH,DH @11 11 B8 FE 33 33 Output %Y to port %X
OUT BH,AL @11 11 B8 FE 44 44 Output %Y to port %X
OUT BH,BL @11 11 B8 FE 55 55 Output %Y to port %X
OUT BH,CL @11 11 B8 FE 66 66 Output %Y to port %X
OUT BH,DL @11 11 B8 FE 77 77 Output %Y to port %X
OUT CH,BH @22 22 B8 FE 11 11 Output %Y to port %X
OUT CH,DH @22 22 B8 FE 33 33 Output %Y to port %X
OUT CH,AL @22 22 B8 FE 44 44 Output %Y to port %X
OUT CH,BL @22 22 B8 FE 55 55 Output %Y to port %X
OUT CH,CL @22 22 B8 FE 66 66 Output %Y to port %X
OUT CH,DL @22 22 B8 FE 77 77 Output %Y to port %X
OUT DH,BH @33 33 B8 FE 11 11 Output %Y to port %X
OUT DH,CH @33 33 B8 FE 22 22 Output %Y to port %X
OUT DH,AL @33 33 B8 FE 44 44 Output %Y to port %X
OUT DH,BL @33 33 B8 FE 55 55 Output %Y to port %X
OUT DH,CL @33 33 B8 FE 66 66 Output %Y to port %X
OUT DH,DL @33 33 B8 FE 77 77 Output %Y to port %X
OUT AL,BH @44 44 B8 FE 11 11 Output %Y to port %X
OUT AL,CH @44 44 B8 FE 22 22 Output %Y to port %X
OUT AL,DH @44 44 B8 FE 33 33 Output %Y to port %X
OUT AL,BL @44 44 B8 FE 55 55 Output %Y to port %X
OUT AL,CL @44 44 B8 FE 66 66 Output %Y to port %X
OUT AL,DL @44 44 B8 FE 77 77 Output %Y to port %X
OUT BL,BH @55 55 B8 FE 11 11 Output %Y to port %X
OUT BL,CH @55 55 B8 FE 22 22 Output %Y to port %X
OUT BL,DH @55 55 B8 FE 33 33 Output %Y to port %X
OUT BL,AL @55 55 B8 FE 44 44 Output %Y to port %X
OUT BL,CL @55 55 B8 FE 66 66 Output %Y to port %X
OUT BL,DL @55 55 B8 FE 77 77 Output %Y to port %X
OUT CL,BH @66 66 B8 FE 11 11 Output %Y to port %X
OUT CL,CH @66 66 B8 FE 22 22 Output %Y to port %X
OUT CL,DH @66 66 B8 FE 33 33 Output %Y to port %X
OUT CL,AL @66 66 B8 FE 44 44 Output %Y to port %X
OUT CL,BL @66 66 B8 FE 55 55 Output %Y to port %X
OUT CL,DL @66 66 B8 FE 77 77 Output %Y to port %X
OUT DL,BH @77 77 B8 FE 11 11 Output %Y to port %X
OUT DL,CH @77 77 B8 FE 22 22 Output %Y to port %X
OUT DL,DH @77 77 B8 FE 33 33 Output %Y to port %X
OUT DL,AL @77 77 B8 FE 44 44 Output %Y to port %X
OUT DL,BL @77 77 B8 FE 55 55 Output %Y to port %X
OUT DL,CL @77 77 B8 FE 66 66 Output %Y to port %X
ASCx0000 FF FF FF FF FF FF FF FF C7 C7 C7 C7 FF FF FF FF
ASCx0010 F8 F8 F8 F8 FF FF FF FF C0 C0 C0 C0 FF FF FF FF
ASCx0020 FF FF FF FF F8 F8 F8 F8 C7 C7 C7 C7 F8 F8 F8 F8
ASCx0030 F8 F8 F8 F8 F8 F8 F8 F8 C0 C0 C0 C0 F8 F8 F8 F8
ASCx0040 FF FF FF FF FF FF FF FF F3 F3 C0 D2 F3 F3 ED DE
ASCx0050 FF FF FF FF FF FF FF FF F3 E1 C0 F3 F3 F3 F3 F3
ASCx0060 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
ASCx0070 F7 F3 D1 C0 C0 D1 F3 F7 F3 F3 F3 F3 F3 C0 E1 F3
ASCx0080 FF FF FF FF C7 C7 C7 C7 C7 C7 C7 C7 C7 C7 C7 C7
ASCx0090 F8 F8 F8 F8 C7 C7 C7 C7 C0 C0 C0 C0 C7 C7 C7 C7
ASCx00A0 FF FF FF FF C0 C0 C0 C0 C7 C7 C7 C7 C0 C0 C0 C0
ASCx00B0 F8 F8 F8 F8 C0 C0 C0 C0 C0 C0 C0 C0 C0 C0 C0 C0
ASCx00C0 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
ASCx00D0 FF FF FF FF FF FF FF FF F3 F3 F3 F3 F3 F3 F3 F3
ASCx00E0 FF FF FF C0 C0 FF FF FF FB F3 E2 C0 C0 E2 F3 FB
ASCx00F0 C7 DF DF D8 C2 FA FA FA FF FF FF FF FF FF FF FF
ASCx0100 FF FF FF FF FF FF FF FF FB FB FB FB FB FF FB FF
ASCx0110 F5 F5 F5 FF FF FF FF FF F5 F5 E0 F5 E0 F5 F5 FF
ASCx0120 FB F0 EB F1 FA E1 FB FF E7 E6 FD FB F7 EC FC FF
ASCx0130 FB F5 F5 F3 EA ED F2 FF F9 F9 FD FB FF FF FF FF
ASCx0140 FD FB F7 F7 F7 FB FD FF F7 FB FD FD FD FB F7 FF
ASCx0150 FF FB EA F1 EA FB FF FF FF FB FB E0 FB FB FF FF
ASCx0160 FF FF FF F3 F3 FB F7 FF FF FF FF E0 FF FF FF FF
ASCx0170 FF FF FF FF FF F3 F3 FF FF FE FD FB F7 EF FF FF
ASCx0180 F1 EE EC EA E6 EE F1 FF FB F3 FB FB FB FB F1 FF
ASCx0190 F1 EE FE F9 F7 EF E0 FF E0 FE FD F9 FE EE F1 FF
ASCx01A0 FD F9 F5 ED E0 FD FD FF E0 EF E1 FE FE EE F1 FF
ASCx01B0 F8 F7 EF E1 EE EE F1 FF E0 FE FD FB F7 F7 F7 FF
ASCx01C0 F1 EE EE F1 EE EE F1 FF F1 EE EE F0 FE FD E3 FF
ASCx01D0 FF F3 F3 FF FF F3 F3 FF F3 F3 FF F3 F3 FB F7 FF
ASCx01E0 FD FB F7 EF F7 FB FD FF FF FF E0 FF E0 FF FF FF
ASCx01F0 F7 FB FD FE FD FB F7 FF F1 EE FE FD FB FF FB FF
ASCx0200 F1 EE EC EA E8 EF F1 FF FB F5 EE EE E0 EE EE FF
ASCx0210 E1 EE EE E1 EE EE E1 FF F1 EE EF EF EF EE F1 FF
ASCx0220 E1 F6 F6 F6 F6 F6 E1 FF E0 EF EF E1 EF EF E0 FF
ASCx0230 E0 EF EF E1 EF EF EF FF F1 EE EF EF EC EE F0 FF
ASCx0240 EE EE EE E0 EE EE EE FF F1 FB FB FB FB FB F1 FF
ASCx0250 FE FE FE FE EE EE F1 FF EE ED EB E7 EB ED EE FF
ASCx0260 EF EF EF EF EF EE E0 FF EE E4 EA EA EE EE EE FF
ASCx0270 EE EE E6 EA EC EE EE FF F1 EE EE EE EE EE F1 FF
ASCx0280 E1 EE EE E1 EF EF EF FF F1 EE EE EE EA ED F2 FF
ASCx0290 E1 EE EE E1 EB ED EE FF F1 EE EF F1 FE EE F1 FF
ASCx02A0 E0 FB FB FB FB FB FB FF EE EE EE EE EE EE F1 FF
ASCx02B0 EE EE EE F5 F5 FB FB FF EE EE EE EA EA EA F5 FF
ASCx02C0 EE EE F5 FB F5 EE EE FF EE EE F5 FB FB FB FB FF
ASCx02D0 E0 FE FD F1 F7 EF E0 FF F1 F7 F7 F7 F7 F7 F1 FF
ASCx02E0 FF EF F7 FB FD FE FF FF F1 FD FD FD FD FD F1 FF
ASCx02F0 F1 EE FF FF FF FF FF FF FF FF FF FF FF FF E0 FF
ASCx0300 ED EA EA E2 EA EA ED FF FB F5 EE EE E0 EE EE FF
ASCx0310 E0 EF EF E1 EE EE E1 FF ED ED ED ED ED E0 FE FF
ASCx0320 F9 F5 F5 F5 F5 E0 EE FF E0 EF EF E1 EF EF E0 FF
ASCx0330 FB E0 EA EA E0 FB FB FF E0 EE EF EF EF EF EF FF
ASCx0340 EE EE F5 FB F5 EE EE FF EE EE EC EA E6 EE EE FF
ASCx0350 EA EE EC EA E6 EE EE FF EE ED EB E7 EB ED EE FF
ASCx0360 F8 F6 F6 F6 F6 F6 F6 FF EE E4 EA EA EE EE EE FF
ASCx0370 EE EE EE E0 EE EE EE FF F1 EE EE EE EE EE F1 FF
ASCx0380 E0 EE EE EE EE EE EE FF F0 EE EE F0 FA F6 EE FF
ASCx0390 E1 EE EE E1 EF EF EF FF F1 EE EF EF EF EE F1 FF
ASCx03A0 E0 FB FB FB FB FB FB FF EE EE EE F5 FB F7 EF FF
ASCx03B0 EE EA EA F1 EA EA EE FF E1 EE EE E1 EE EE E1 FF
ASCx03C0 EF EF EF E1 EE EE E1 FF EE EE EE E6 EA EA E6 FF
ASCx03D0 F1 EE EE F9 FE EE F1 FF EE EA EA EA EA EA E0 FF
ASCx03E0 F1 EE FE F8 FE EE F1 FF EA EA EA EA EA E0 FE FF
ASCx03F0 EE EE EE E0 FE FE FE FF C0 C0 C0 C0 C0 C0 C0 FF
ASCx0400 FF FF FF FF FF FF FF FF C7 C7 C7 C7 FF FF FF FF
ASCx0410 F8 F8 F8 F8 FF FF FF FF C0 C0 C0 C0 FF FF FF FF
ASCx0420 FF FF FF FF F8 F8 F8 F8 C7 C7 C7 C7 F8 F8 F8 F8
ASCx0430 F8 F8 F8 F8 F8 F8 F8 F8 C0 C0 C0 C0 F8 F8 F8 F8
ASCx0440 FF FF FF FF FF FF FF FF F3 F3 C0 D2 F3 F3 ED DE
ASCx0450 FF FF FF FF FF FF FF FF F3 E1 C0 F3 F3 F3 F3 F3
ASCx0460 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
ASCx0470 F7 F3 D1 C0 C0 D1 F3 F7 F3 F3 F3 F3 F3 C0 E1 F3
ASCx0480 FF FF FF FF C7 C7 C7 C7 C7 C7 C7 C7 C7 C7 C7 C7
ASCx0490 F8 F8 F8 F8 C7 C7 C7 C7 C0 C0 C0 C0 C7 C7 C7 C7
ASCx04A0 FF FF FF FF C0 C0 C0 C0 C7 C7 C7 C7 C0 C0 C0 C0
ASCx04B0 F8 F8 F8 F8 C0 C0 C0 C0 C0 C0 C0 C0 C0 C0 C0 C0
ASCx04C0 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
ASCx04D0 FF FF FF FF FF FF FF FF F3 F3 F3 F3 F3 F3 F3 F3
ASCx04E0 FF FF FF C0 C0 FF FF FF FB F3 E2 C0 C0 E2 F3 FB
ASCx04F0 C7 DF DF D8 C2 FA FA FA FF FF FF FF FF FF FF FF
ASCx0500 FF FF FF FF FF FF FF FF FB FB FB FB FB FF FB FF
ASCx0510 F5 F5 F5 FF FF FF FF FF F5 F5 E0 F5 E0 F5 F5 FF
ASCx0520 FB F0 EB F1 FA E1 FB FF E7 E6 FD FB F7 EC FC FF
ASCx0530 FB F5 F5 F3 EA ED F2 FF F9 F9 FD FB FF FF FF FF
ASCx0540 FD FB F7 F7 F7 FB FD FF F7 FB FD FD FD FB F7 FF
ASCx0550 FF FB EA F1 EA FB FF FF FF FB FB E0 FB FB FF FF
ASCx0560 FF FF FF F3 F3 FB F7 FF FF FF FF E0 FF FF FF FF
ASCx0570 FF FF FF FF FF F3 F3 FF FF FE FD FB F7 EF FF FF
ASCx0580 F1 EE EC EA E6 EE F1 FF FB F3 FB FB FB FB F1 FF
ASCx0590 F1 EE FE F9 F7 EF E0 FF E0 FE FD F9 FE EE F1 FF
ASCx05A0 FD F9 F5 ED E0 FD FD FF E0 EF E1 FE FE EE F1 FF
ASCx05B0 F8 F7 EF E1 EE EE F1 FF E0 FE FD FB F7 F7 F7 FF
ASCx05C0 F1 EE EE F1 EE EE F1 FF F1 EE EE F0 FE FD E3 FF
ASCx05D0 FF F3 F3 FF FF F3 F3 FF F3 F3 FF F3 F3 FB F7 FF
ASCx05E0 FD FB F7 EF F7 FB FD FF FF FF E0 FF E0 FF FF FF
ASCx05F0 F7 FB FD FE FD FB F7 FF F1 EE FE FD FB FF FB FF
ASCx0600 EF F7 FB FF FF FF FF FF FF FF F1 ED ED ED F2 FF
ASCx0610 F7 F7 F1 F6 F6 F6 F1 FF FF FF F8 F7 F7 F7 F8 FF
ASCx0620 FE FE F8 F6 F6 F6 F8 FF FF FF F9 F6 F1 F7 F8 FF
ASCx0630 F9 F6 F7 E3 F7 F7 F7 FF FF FF F8 F6 F8 FE F1 FF
ASCx0640 F7 F7 F1 F6 F6 F6 F6 FF FD FF F9 FD FD FD F8 FF
ASCx0650 FE FF FE FE FE F6 F9 FF F7 F7 F6 F5 F3 F5 F6 FF
ASCx0660 F9 FD FD FD FD FD F8 FF FF FF E5 EA EA EA EA FF
ASCx0670 FF FF F1 F6 F6 F6 F6 FF FF FF F9 F6 F6 F6 F9 FF
ASCx0680 FF FF F1 F6 F6 F1 F7 FF FF FF F8 F6 F6 F8 FE FF
ASCx0690 FF FF F1 F6 F7 F7 F7 FF FF FF F8 F7 F9 FE F1 FF
ASCx06A0 F7 F7 E3 F7 F7 F6 F9 FF FF FF EE EE EE EE F1 FF
ASCx06B0 FF FF EE EE EE F5 FB FF FF FF EE EE EA EA F5 FF
ASCx06C0 FF FF EE F5 FD F5 EE FF FF FF F6 F6 F8 FE F1 FF
ASCx06D0 FF FF F0 FE F9 F7 F0 FF FE FD FD FB FD FD FE FF
ASCx06E0 F7 F7 F7 FF F7 F7 F7 FF EF F7 F7 FB F7 F7 EE FF
ASCx06F0 FF FF F7 F3 F0 FC FE FF F7 F3 E1 C0 E1 F3 FB FF
ASCx0700 FF FF ED EA E2 EA ED FF FF FF F1 FE F8 F6 F9 FF
ASCx0710 FF FF F8 F7 F1 F6 F1 FF FF FF ED ED ED ED E0 FE
ASCx0720 FF FF F9 F6 F8 FE F0 FF FF FF F9 F6 F1 F7 F8 FF
ASCx0730 FF FF FB F1 EA F1 FB FB FF FF F0 F7 F7 F7 F7 FF
ASCx0740 FF FF F6 F9 F9 F6 F6 FF FF FF F6 F6 F4 F2 F6 FF
ASCx0750 F9 FF F6 F6 F4 F2 F6 FF FF FF F6 F5 F3 F5 F6 FF
ASCx0760 FF FF FC FA F6 F6 F6 FF FF FF EE E4 EA EA EE FF
ASCx0770 FF FF F6 F6 F0 F6 F6 FF FF FF F9 F6 F6 F6 F9 FF
ASCx0780 FF FF F0 F6 F6 F6 F6 FF FF FF F8 F6 F8 FA F6 FF
ASCx0790 FF FF F1 F6 F1 F7 F7 F7 FF FF F8 F7 F7 F7 F8 FF
ASCx07A0 FF FF E0 FB FB FB FB FF FF FF F6 F6 F8 FE F1 FF
ASCx07B0 FF FF EA EA F1 EA EA FF FF FF F1 F6 F1 F6 F1 FF
ASCx07C0 FF FF F7 F7 F1 F6 F1 FF FF FF EE EE E6 EA E6 FF
ASCx07D0 FF FF F9 F6 FD FE F1 FF FF FF EA EA EA EA E0 FF
ASCx07E0 FF FF F1 FE F8 FE F1 FF FF FF D5 D5 D5 D5 C0 FE
ASCx07F0 FF FF F6 F6 F0 FE FE FF FF E7 E7 81 81 E7 E7 FF
ORG 0x0000
Xonix:
RET
ORG 0x0000
Tetris:
RET
DEBUG 0x00
ORG 0x0000
Zeroed: PUSH 0x0015
POP BX
MOV CL,0x09
LOOP CL
ADD BX,BX
MOV AL,0x01
LOOP 7
RCL AL
SKIP 3
DEC AL
DEC AL
DEC AL
DEC AL
NOP
ADD BX,BX
MOV AL,0x80
MOV CL,0x03
HLT CL
STR
MOV AL,0x81
MOV CL,0x03
HLT CL
STB
MOV AL,0x82
MOV CL,0x03
HLT CL
SKIP
INC AL
INC AL
INC AL
INC AL
MOV AL,0x83
MOV CL,0x03
HLT CL
SKIB
INC AL
INC AL
INC AL
INC AL
MOV AL,0x84
MOV CL,0x03
HLT CL
REP
INC AL
MOV AL,0x85
MOV CL,0x03
HLT CL
REB
INC AL
;;;;;;;;;;;;;;;;;
ORG 0xE000
INT_XX: XCHG BX,[SP]
PUSH AX
MOV AL,[BX]
LOOP 4
RCR AL
JS .basic
CMP AL,[BX]
JNZ .basic
MOV AL,[BX+1]
SUB AL,0xF0
JC .other
CMP AL,0x0A
JNC .other
MOV AL,[BX]
INC BX
SKIP [AL]
NOP
JMP .memory
JMP .string
JMP .audio
JMP .data
JMP .unic
JMP .file
JMP .window
.basic: MOV AL,[BX]
SUB AL,0xF0
JC .other
CMP AL,0x0A
JNC .other
SKIP AL
JMP .x0
JMP .x1
JMP .x2
JMP .x3
JMP .x4
JMP .x5
JMP .x6
JMP .x7
JMP .x8
JMP .x9
.memory:NOP 1
.string:NOP 2
.audio: NOP 3
.data: NOP 4
.unic: NOP 5
.file: NOP 6
BIAS .exit
RET
.other: NOP
JMP .other
.window:MOV AL,[BX]
INC BX
AND AL,0x0F
SKIP AL
JMP .exit
JMP .putc
JMP .putxt
JMP .getc
JMP .exit
JMP .puthx
JMP .exit
JMP .exit
JMP .exit
JMP .exit
.putc: POP AX
XCHG BX,[SP]
PUSH BIOS.PutChr
RET
.putxt: HLT BX
PUSH BIOS.PutMsg
XCHG IP,[SP]
POP AX
XCHG BX,[SP]
RET
.getc: POP AX
XCHG BX,[SP]
PUSH BIOS.GetChar
RET
.puthx: POP AX
XCHG BX,[SP]
PUSH BIOS.PutHex
RET
.exit: NOP
JMP .exit
INTS: XCHG BX,[SP]
PUSH DX
PUSH AX
MOV DL,[BX]
AND DL,DL
JZ .halt
INC BX
MOV DH,DL
LOOP 4
RCR DH
CMP DL,DH
JNZ .lo
AND DH,0x0F
CMP DH,0x08
JNC .lo
MOV DL,[BX]
INC BX
.lo: CMP DL,0xFA
JNC .hard
SUB DL,0xF0
JC .hard
HLT DH
CALL .switch
DW .basic
DW .memory
DW .string
DW .audio
DW .data
DW .unic
DW .file
DW .window
.basic: NOP
.memory:NOP 1
.string:NOP 2
.audio: NOP 3
.data: NOP 4
.unic: NOP 5
.file: NOP 6
BASE .exit
RET
; 77+F0:
; 77+F1:
; 77+F2:AL=IsChar()
; 77+F3:AL=GetChr()
; 77+F4:
; 77+F5:PutHex(AL)
; 77+F6:
; 77+F7:
; 77+F8:PutMsg(BX)
; 77+F9:PutChr(CL)
.window:SKIP [DL]
JMP .exit
JMP ..putc
JMP ..putxt
JMP ..getc
JMP .exit
JMP .exit
JMP .exit
JMP .exit
..putc: POP AX,DX ; 77 F1
XCHG BX,[SP]
PUSH BIOS.PutChr
RET
..putxt:POP AX,DX ; 77 F2
HLT BX
PUSH BIOS.PutMsg
XCHG IP,[SP]
XCHG BX,[SP]
RET
..getc: POP AX,DX ; 77 F3
XCHG BX,[SP]
PUSH BIOS.GetChar
RET
.exit: POP AX,DX
XCHG BX,[SP]
RET
.hard: POP AX,DX
XCHG BX,[SP]
RET
.halt: POP AX,DX
INT 72
DB "\r\nHALT AT \0"
HLT BX
PUSH BIOS.PutPtr
XCHG IP,[SP]
PUSH BIOS.Prompt
RET
.switch:XCHG BX,[SP]
XCHG AL
ADD AL,AL
LEA BX,BX+AL
XCHG AL
PUSH [BX+0x00]
POP BX
XCHG BX,[SP]
RET
;;;;;;;;;;;;;;;;;;;;;;;
ORG 0x1000
;;;;;;;;;;;;;;;;;;;;;;;
ORG 0x0100
USER: ; USER API BY INT 0-9
RET
DEBUG 0x1
ORG 0xF7FF
NOP
;;;;;;;;;;;;;;;
ORG 0xF000
TIMER: MOV BH,0x77
MOV BL,0x1E
XCHG SP,BX
.x_____:MOV BL,0x30
._x____:MOV BH,0x30
.__x___:MOV CL,0x30
.___x__:MOV CH,0x30
.____x_:MOV DL,0x30
._____x:MOV DH,0x30
MOV AL,0xFF
.______:PUSH DX,CX
PUSH BX
POP [SP]
POP [SP]
POP [SP]
DEC AL
JNZ .______
MOV AL,0x39
INC DH
CMP AL,DH
JNC .______
INC DL
CMP AL,DL
JNC ._____x
INC CH
CMP AL,CH
JNC .____x_
INC CL
CMP AL,CL
JNC .___x__
INC BH
CMP AL,BH
JNC .__x___
INC BL
CMP AL,BL
JNC ._x____
JMP .x_____
;;;;;;;;;;;;;;;
ORG 0xF600
SPEEDO: SKIP 5
MOV AL,CL
XOR AL,[BX]
MOV [BX],AL
DEC BX
CMP DH,BH
MOV DH,0x76
MOV DL,0xD4
XCHG SP,DX
.x___: MOV CL,0x30
._x__: MOV CH,0x30
.__x_: MOV BL,0x30
.___x: MOV BH,0x30
.____: XOR AL,AL
MOV DH,AL
MOV DL,AL
ADD DX,SP
PUSH BX,CX
MOV BH,0x7F
MOV BL,0xF3
MOV CL,0x7F
.loop: XOR AL,AL
;CMC
HLT 7
WAIT
NOP 5
CMP BH,DH
JNZ .loop
POP CX,BX
MOV AL,0x39
INC BH
CMP AL,BH
JNC .____
INC BL
CMP AL,BL
JNC .___x
INC CH
CMP AL,CH
JNC .__x_
INC CL
CMP AL,CL
JNC ._x__
JMP .x___
;;;;;;;;;;;;;;;;;
ORG 0xF700
SPEEDY: MOV DH,0x76
MOV DL,0xD4
XCHG SP,DX
.x___: MOV CL,0x30
._x__: MOV CH,0x30
.__x_: MOV BL,0x30
.___x: MOV BH,0x30
.____: XOR AL,AL
MOV DH,AL
MOV DL,AL
ADD DX,SP
PUSH BX,CX
MOV BH,0x7F
MOV BL,0xF3
.loop: MOV AL,[BX]
XOR AL,0x7F
MOV [BX],AL
DEC BX
CMP BL,DL
JNC .loop
CMP BH,DH
JNZ .loop
POP CX,BX
MOV AL,0x39
INC BH
CMP AL,BH
JNC .____
INC BL
CMP AL,BL
JNC .___x
INC CH
CMP AL,CH
JNC .__x_
INC CL
CMP AL,CL
JNC ._x__
JMP .x___
;;;;;;;;;;;;;;;;;
ORG 0xF300
Help:
.List: DB "\n[A]BAC - CALCULATOR\r"
DB "\n[B]OOT - DOS-BOOTER\r"
DB "\n[C]OPY - COPY MEMORY\r"
DB "\n[D]UMP - DUMP OF MEMORY\r"
DB "\n[E]DIT - EDIT DUMP\r"
DB "\n[F]IND - FIND IN MEMORY\r"
DB "\n[G]OTO - GOTO ADDRESS\r"
DB "\n[I]DLE - STREAM ECHO\r"
DB "\n[J]OIN - JOIN\r"
DB "\n[K]EEP - KEEP\r"
DB "\n[L]IST - FILE LIST\r"
DB "\n[M]OVE - MOVE MEMORY DATA\r"
DB "\n[N]OTE - NOTE\r"
DB "\n[O]PEN - OPEN\r"
DB "\n[Q]UIT - REBOOT\r"
DB "\n[R]EAD - READ\r"
DB "\n[S]AVE - SAVE\r"
DB "\n[T]EXT - TEXT\r"
DB "\n[U]NIT - DEVICES LIST\r"
DB "\n[V]ANE - CPU FANS OUT\r"
DB "\n[W]AVE - WAVE\r"
DB "\n[X]TRA - EXTRA\r"
DB "\n[Y]AMP - Y-AMPLITUDE\r"
DB "\n[Z]ERO - CLEAR MEMORY\0"
ORG 0xF800
BIOS: MOV BH,0x76
MOV BL,0xCE
XCHG SP,BX
PUSH 0x7600
POP BP
PUSH 0xE000
POP BX
INT 72
DB "\_X80-BIOS V0.1\0"
.prompt:
PUSH BX
MOV BH,0x76
MOV BL,0xCE
XCHG SP,BX
PUSH 0x7600
POP BP
;
INT 72
DB "\r\n/>\0"
..cmd: INT 73
CMP AL,0x5B
JNC ..cmd
MOV CL,AL
SUB AL,0x41
JC ..cmd
HLT CL
INT 71
PUSH .words
POP BX
ADD AL,AL
ADD AL,AL
MOV DL,AL
XOR DH,DH
LEA BX,DX+BX
PUSH [BX+2]
PUSH [BX+0]
POP BX
MOV CL,0x03
..loop: MOV AL,BH
ROR AL
ROR AL
AND AL,0x1F
ADD AL,0x40
HLT AL
INT 71
LOOP 5
ADD BX,BX
DEC CL
JNZ ..loop
POP DI
HLT AL
MOV AL,0x20
INT 71
PUSH ..hexas
POP SI
XOR CH,CH
MOV CL,0x01
..hexa: PUSH [SI+0x00]
POP BX
MOV AL,CH
AND AL,CL
ADD AL,0xFF
PUSH .GetHex
XCHG IP,[SP]
SBB DL,DL
CMP AL,0x0D
JZ ..next
CMP AL,0x1B
JZ .prompt
CMP AL,0x7F
JNZ ..next
NOT CH
OR CH,CL
NOT CH
RAR CL
AND CL,CL
;JZ .prompt
;CMP CL,0x01
JZ ..hexa
MOV AL,CH
AND AL,CH
JZ ..clr
MOV AL,0x08
HLT AL
INT 72
DB "\< \<\0";>
CMP CL,0x01
JZ ..hexa
..clr: XCHG SI,BX
DEC BX
DEC BX
XCHG SI,BX
JNZ ..hexa
..next: HLT AL
INT 71
ADD DL,DL
JNC ..next1
PUSH BX
POP [SI+0x00]
XCHG SI,BX
INC BX
INC BX
XCHG SI,BX
OR CH,CL
..next1:ADD CL,CL
CMP AL,0x0D
JNZ ..hexa
..exec: PUSH ..hexas
POP SI
PUSH [SI+0x04]
PUSH [SI+0x02]
PUSH [SI+0x00]
MOV AL,CH
ADD AL,CL
ADD AL,CL
POP BX,DX
POP CX
PUSH DI
XCHG IP,[SP]
XOR AL,AL
JZ .prompt
NOP 7
SBB DL,DL
CMP AL,0x7F
XOR AL,AL
JZ .prompt
INT 71
PUSH 0x76D0
PUSH 0x78FF
POP DX,BX
PUSH .HexDmp
XCHG IP,[SP]
PUSH .hello
POP BX
PUSH .PutMsg
HLT BX
XCHG IP,[SP]
PUSH .PutPtr
XCHG IP,[SP]
; MOV DL,0x08
; MOV DH,0x06
; INT 71
; INT 9S
; HLT 3
..hexas:DW 0x0000
DW 0x0000
DW 0x0000
DW 0x0000
DW 0x0000
DW 0x0000
DW 0x0000
DW 0x0000
.loopy: PUSH .PutChr
PUSH .GetChar
XCHG IP,[SP]
HLT AL
XCHG IP,[SP]
CMP AL,0x60
;JZ .stop
CMP AL,0x0D
JNZ .loopy
INT 72
DW 0x0808
DW 0x0808
DB 0x08
DB ":\0"
PUSH TX
POP BX
PUSH .PutPtr
XCHG IP,[SP]
JMP .loopy
.stop: PUSH? BIOS.API.fn
XCHG IP,[SP]
HLT
HLT
NOP 5
.hello: DB "\h\^\^BIOS\r\n/>\0"
.words: DW 0x0823,..none ;ABAC
DW 0x3DF4,..none ;BOOT
DW 0x3E19,..none ;COPY
DW 0x55B0,.HexDmp ;DUMP
DW 0x1134,..none ;EDIT
DW 0x25C4,..none ;FIND
DW 0x3E8F,..Goto ;GOTO
DW 0x1590,..Help ;HELP
DW 0x1185,..Idle ;IDLE
DW 0x3D2E,..none ;JOIN
DW 0x14B0,..none ;KEEP
DW 0x2674,..List ;LIST
DW 0x3EC5,..none ;MOVE
DW 0x3E85,..none ;NOTE
DW 0x40AE,..none ;OPEN
DW 0x3039,..none ;PLAY
DW 0x5534,0xF800 ;QUIT
DW 0x1424,..none ;READ
DW 0x06C5,..none ;SAVE
DW 0x1714,..none ;TEXT
DW 0x3934,..none ;UNIT
DW 0x05C5,..none ;VANE
DW 0x06C5,..none ;WAVE
DW 0x5241,..xtra ;XTRA
DW 0x06F0,..pan ;YAwP
DW 0x164F,..Zero ;ZERO
..pan: SKIP 5
MOV DL,AL
MOV AL,[BX]
MOV [BX],DL
ADD BX,CX
CMC
WAIT
INT 50
MOV BH,0x7F
MOV BL,0XF3
MOV CH,0xFF
MOV CL,0xB2
...loop:PUSH BX
MOV DH,0x4E
...rows:PUSH DX,BX
MOV DH,0x1E
HLT DH
WAIT
INT 0
POP BX,DX
DEC BX
DEC DH
JNZ ...rows
POP BX
JMP ...loop
;;;;;;;;;;;;;;;;;;;;;;;;;
..Edit: INT 72
DB "\r\n"
..Goto: PUSH BX
RET
..Help: PUSH Help.List
POP BX
HLT BX
PUSH BIOS.PutMsg
RET
..none: INT 72
DB "\n!!! RESERVED DIRECTIVE\0"
RET
..xtra: XCHG SP,BX
LOOP DL
PUSH EX
XCHG SP,BX
RET
..List: PUSH .FileIn
RET
..Zero:
..Idle: INT 73
CMP AL,0x1B
RZ
HLT AL
INT 71
JNZ ..Idle
.GetHex:PUSH CX
SBB CH,CH
JC ..addr
..inkey:INT 73
CMP AL,0x08
JZ ..back
CMP AL,0x20
JZ ..addr
CMP AL,0x30
JC ..exit
CMP AL,0x7F
JZ ..clear
CMP AL,0x47
JNC ..exit
CMP AL,0x3A
JC ..nibble
CMP AL,0x41
JC ..exit
SUB AL,0x07
..nibble:AND AL,0x0F
LOOP 4
ADD BX,BX
OR BL,AL
..addr: AND CH,CH
JZ ..ptr
INT 72
DB "\<\<\<\<\0";>
..ptr: HLT BX
PUSH .PutPtr
XCHG IP,[SP]
OR CH,0xFF
JNZ ..inkey
..exit: ADD CH,CH
POP CX
RET
..clear:ADD CH,CH
POP CX
RNC
INT 72
DB "\< \<\< \<\< \<\< \<\0";>
AND AL,AL
RET
..back: HLT BH
XCHG
HLT BL
XCHG
XCHG BL,BH
LOOP 4
ADD BX,BX
XCHG BL,BH
HLT BH
XCHG
HLT BL
XCHG
AND BL,BL
JMP ..addr
;;;;;;;;;;;;;;;;;;
.MulBxD:
;;;;;;;;;;;;;;;;;;
.TestBX:CMP BL,DL
RNZ
CMP BH,DH
RET
.HexDmp:PUSH BX,AX
..addr: HLT BX
CALL .PutPtr
AND BL,0xF0
..loop: MOV AL,0x20
HLT AL
CALL .PutChr
MOV AL,[BX]
CALL .PutHex
CALL .TestBX
JZ ..end
INC BX
MOV AL,BL
AND AL,0x0F
JNZ ..loop
MOV AL,0x0D
CALL .PutChr
MOV AL,0x0A
CALL .PutChr
JZ ..addr
..end: POP AX,BX
RET
.PutMsg:PUSH BX,AX
PUSH
POP BX
HLT AL
..loop: MOV AL,[BX]
INC BX
AND AL,AL
CNZ .PutChr
JNZ ..loop
POP AX
XCHG BX,[SP]
POP
RET
.PutPtr:PUSH BX,AX
PUSH
POP BX
HLT AL
PUSH .PutHex
PUSH [SP+0x00]
MOV AL,BH
XCHG IP,[SP]
MOV AL,BL
XCHG IP,[SP]
POP AX,BX
RET
.PutHex:PUSH AX
PUSH .PutChr.reada
XCHG AL
PUSH AX
LOOP 4
RAR AL
CALL ..nibble
POP AX
..nibble:AND AL,0x0F
CMP AL,0x0A
JC ..number
ADD AL,0x07
..number:ADD AL,0x30
HLT AL
.PutChr:PUSH AX,BX
PUSH CX,DX
PUSH BP
XCHG CL
PUSH [BP+0x64]
POP BP
MOV CH,[BP+0x0]
AND CH,CH
CALL ..main
PUSH BX
POP [BP+0x4]
PUSH [BP+0x8]
POP DX
ADD BX,DX
PUSH [BP+0xC];3
POP DX;1
DEC AL;1
DEC DX;1
XCHG BX,DX ;2
MOV AL,DL ;2
..exit: MOV [BX],AL ;1
DEC BX ;1
MOV [BX],DH ;1
..leave:MOV AL,CH
..ready:MOV [BP+0x0],AL
POP BP
POP DX,CX
POP BX
..reada:POP AX
RET
..main: PUSH [BP+0x4]
POP BX
PUSH [BP+0x6]
POP DX
JNZ ..ansi
MOV AL,CL
CMP AL,0x1B
JNZ ..out
MOV [BP+0xFF],CH
DEC CH
RET
..left: DEC BL
RNS
MOV BL,DL
DEC BL
..up: DEC BH
RNS
MOV BH,DH
DEC BH
RET
..right:INC BL
CMP BL,DL
RC
XOR BL,BL
..down: INC BH
CMP BH,DH
RC
XOR BH,BH
RET
..clrscr:XOR CL,CL
MOV BH,CL
MOV BL,CL
...loop:CALL ..put
JNZ ...loop
DEC DL
..home: XOR BH,BH
..return:MOV AL,0x20
..set_x:SUB AL,0x20
...loop:MOV BL,AL
SUB AL,DL
JNC ...loop
XOR CH,CH
RET
..quit: JZ ..exit
..out: CMP AL,0x0A
JZ ..scroll
CMP AL,0x0D
JZ ..return
CMP AL,0x08
JZ ..left
CMP AL,0x18
JZ ..right
CMP AL,0x19
JZ ..up
CMP AL,0x1A
JZ ..down
CMP AL,0x0C
JZ ..home
PUSH [BP+0x12]
RET
;..clear:JZ ..clrscr
..put: PUSH BX
PUSH CX
PUSH [BP+0xE]
XCHG IP,[SP]
POP CX
MOV AL,[BP+0x3]
ADD AL,CL
MOV [BX],AL
POP BX
INC BL
..tab: CMP BL,DL
RC
XOR BL,BL
..scroll:INC BH
CMP BH,DH
RC
MOV BH,DH
DEC BH
PUSH BX
XOR BL,BL
PUSH BX
PUSH [BP+0xE]
XCHG IP,[SP]
XCHG BX,[SP]
INC BH
PUSH [BP+0xE]
XCHG IP,[SP]
POP CX
SUB CX,BX
SKIP 5
...rows:ADD BX,CX
MOV DL,AL
MOV AL,[BX]
MOV [BX],DL
CMC
HLT 2
WAIT
INT 50
; DEC DH
; JNZ ...rows
HLT DH
;CMC
...cols:PUSH DX
PUSH BX
MOV AL,[BP+0x3]
CMC
WAIT
INT 0
POP BX
POP DX
INC BX
DEC DL
JNZ ...cols
POP BX
MOV CH,DL
RET
..ansi: MOV AL,CL
CMP CH,0xF3
JNC ..code
DEC CH
CMP CH,0xF0
JZ ..set_x
JNC ..set_y
INC CH
PUSH [BP+0xE]
RET
..code: MOV AL,CL
CMP AL,0x3A
JNC ..set_y.call
SUB AL,0x30
JC ..set_y.call
MOV CL,AL
POP AX
MOV BL,CH
XOR BH,BH
ADD BX,BP
MOV AL,[BX]
ADD AL,AL
ADD AL,AL
ADD AL,[BX]
ADD AL,AL
ADD AL,CL
XOR DH,DH
JZ ..quit
..outstd:PUSH ..clrscr
CMP CL,0x1F
RZ
CMP CL,0x09
JZ ...tab
POP [SP+0]
PUSH ..put
RET
...std: MOV CH,0xF2
CMP AL,0x59
RZ
XOR CH,CH
RET
...tab: POP [SP+0x00]
OR BL,0x07
INC BL
JNZ ..tab
..set_y:SUB AL,0x20
...loop:MOV BH,AL
SUB AL,DH
JNC ...loop
RET
...call:PUSH [BP+0x10]
XCHG IP,[SP]
PUSH [BP+0x4]
POP BX
RET
..mul78:PUSH [BP+0x8]
POP CX
ADD BX,CX
MOV AL,BL
MOV BL,BH
XOR BH,BH
ADD BX,BX
MOV CH,BH
MOV CL,BL
ADD BX,BX
ADD BX,BX
ADD BX,CX
ADD BX,BX
ADD BX,BX
ADD BX,BX
SUB BX,CX
XOR CH,CH
MOV CL,AL
ADD BX,CX
PUSH [BP+0xC]
POP CX
ADD BX,CX
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DL = Port Index[7F:PortIn]
; AL = Data
; DBG 0x01
; BRK 0x01
.PortIO:PUSH DX
CMP DL,0x80
SBB DH,DH
ADD DL,0x81
JZ ..input
XCHG SP,DX
DEC SP
JNS ..lower
INC SP
MOV [SP+127],AL
JS ..ready
..lower:MOV [SP+128],AL
JNS ..ready
..input:CMP AL,0x80
SBB DH,DH
ADD AL,0x81
MOV DL,AL
XCHG SP,DX
JZ ..ready
JS ..higher
DEC SP
MOV AL,[SP+128]
JNS ..ready
..higher:MOV AL,[SP+127]
..ready:XCHG SP,DX
POP DX
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CX - Register Index
; DX - Register Data
.CPU_In:PUSH CX
PUSH BX
XOR BH,BH
MOV BL,BH
DEC BX
XCHG SP,BX
.loop: POP DX
DEC CX
MOV AL,CL
OR AL,CH
JNZ .loop
XCHG SP,BX
POP BX
POP CX
RET
;;;;;;;;;;;;;;;;;;;;;;
.PortIn:PUSH BX
BIAS ..input
POP BX
MOV BL,AL
XCHG BP,BX
..input:MOV AL,[BP+0]
XCHG BP,BX
POP BX
RET
;;;;;;;;;;;;;;;;;;;;;;
.WaitOut:PUSH BX,CX;DL = Data
XCHG CL
BIAS ..input
POP BX
MOV BL,AL
XCHG BP,BX
SUB AL,AL
HLT CL
WAIT
..input:MOV [BP+0],DL
ADD CL,0xFF
XCHG BP,BX
POP CX,BX
RET
.WordOut:
;;;;;;;;;;;;;;;;;;;;;;
.OutByte:PUSH DX,AX;XH = Time, XL = Port, AL = Byte
PUSH
POP DX
CALL ..next
POP AX,DX
RET
..next: PUSH AX
LOOP 4
RCR AL
CALL ..loop
POP AX
..loop: AND AL,0x0F
ADD AL,0xC0
.Output:PUSH DX,BX;XH = Time, XL = Port, AL = Data
PUSH
POP DX
BIAS ..loop
POP BX
MOV BL,DL
XCHG BP,BX
SUB DL,DL
HLT DH
WAIT
..loop: MOV [BP+0],AL
ADD DH,0xFF
XCHG BP,BX
POP BX,DX
RET
;;;;;;;;;;;;;;;;;;;;;;
.FileIn:INT 72
DB "\r\nFILE LIST - \0"
MOV DL,0xFD
MOV DH,0x02
HLT DX
MOV AL,0x00
CALL .OutByte
MOV AL,0x00
CALL .OutByte
MOV AL,0xD3
CALL .Output
CALL .WaitIn
..loop: PUSH AX
INT 72
DB "\r\n#\0"
HLT AL
PUSH BIOS.PutHex
XCHG IP,[SP]
INT 72
DB " - \0"
MOV AL,0xFD
MOV CL,0x02
MOV DL,0x00
HLT CL
CALL .WaitOut
CALL .WaitOut
CALL .WaitOut
MOV DL,[SP+0]
AND DL,0x0F
OR DL,0xC0
CALL .WaitOut
MOV DL,0xD1
CALL .WaitOut
..print:CALL .WaitIn
HLT AL
INT 71
JC ..print
HLT
;;;;;;;;;;;;;;;;;;;;;;
.WaitIn:PUSH BX,CX
XCHG CL
BIAS ..input
POP BX
MOV BL,AL
XCHG BP,BX
SUB AL,AL
HLT CL
WAIT
..input:MOV AL,[BP+0]
ADD CL,0xFF
XCHG BP,BX
POP CX,BX
RET
;;;;;;;;;;;;;;;;;;;;;;
.GetChar:XOR AL,AL
..loop: CALL .Inkey
JNC ..loop
PUSH AX
PUSH CX
MOV CL,0x50
MOV CH,0xF0;01;0xF0
XOR AL,AL
CZ .beep
POP CX
POP AX
RET
.Inkey: PUSH DX
MOV DL,0x7F
MOV AL,0xFD
MOV DH,0x80
HLT DH
PUSH BIOS.WaitIn
XCHG IP,[SP]
POP DX
RET
.beep: PUSH DX
MOV DL,0x0A
MOV AL,CL
PUSH .PortIO
XCHG IP,[SP]
MOV AL,CH
LOOP AL
NOP
PUSH .PortIO
XCHG IP,[SP]
POP DX
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ORG 0xFF00
KERNEL: JMP .errors ;0#PUSHed AX
JMP .events ;1#PUSHed AX
JMP .memory ;2#PUSHed AX
JMP .tasks ;3#PUSHed AX
JMP .device ;4#PUSHed AX
JMP .quest ;5#PUSHed AX
JMP .break ;6#PUSHed AX
JMP .start ;7#
.errors:NOP
.events:NOP 1
.memory:NOP 2
.tasks: NOP 3
.quest: NOP 5
.break: NOP 6
.start: ; Init task #1
MOV CL,0xE6
IN CL
MOV DL,0xA5
OUT CL,DL
MOV BH,0xD0
MOV BL,0x00
XCHG SP,BX
PUSH 0xF800
POP BX
MOV BH,0xD0
MOV BL,0x00
PUSH BX
POP SI
XOR DH,DH
MOV DL,0x01
..loop: PUSH SI
LOOP 4
LEA SI,DX+SI
MOV BL,[SI+0]
MOV BH,[SI+1]
MOV CL,[SI+2]
MOV CH,[SI+3]
MOV AL,CL
OR AL,CH
MOV AL,DL
INC DX
POP SI
CNZ .context.init
JNZ ..loop
DEC DL
XCHG SI,BX
INC BX,BX
INC BX,BX
..jumps:PUSH DX,BX
XOR DH,DH
...run: DEC DL
JZ ...all
INC BX,BX
MOV AL,[BX]
MOV [6],AL
INC BX
MOV AL,[BX]
MOV [7],AL
INC BX
INC DH
...next:MOV AL,DH
LOOP 4
ADD AL,AL
ADD AL,DH
MOV [0],AL
JMP .errors ;0#PUSHed AX
JMP .events ;1#PUSHed AX
JMP .memory ;2#PUSHed AX
JMP ...run ;3#PUSHed AX
JMP .device ;4#PUSHed AX
JMP! .quest ;5#PUSHed AX
JMP! .break ;6#PUSHed AX
JMP! .start ;7#
...all: POP BX,DX
JMP ..jumps
.device:XOR AL,AL
MOV [0],AL
POP AL
IN AL
PUSH AL
MOV CL,0x80
MOV CH,0xFF
MOV [CL],CH
JMP .start.jumps.next
.context: ; Context trigger
..init: ; Context init (BX=IP,CX=Ticks,AL=Index)
PUSH AX
LOOP 4
ADD AL,AL
MOV [0],AL
MOV AL,0xF0
HLT AL
WAIT
HLT BL
ADD AL,0x08
WAIT
HLT BH
PUSH 0xE000
POP BX
MOV AL,0xF7
HLT AL
WAIT
HLT BL
ADD AL,0x08
WAIT
HLT BH
POP AX
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ORG 0x7650
DW 0x0000 ; Value .Sequency
DW 0x0000 ; Page .Blank
DW 0x0000 ; PosY .PosX
DW 0x1E48;0x1E4E; 0x1940 ; Rows .Columns
DW 0x0000;0x0308 ; FromY .FromX
DW 0x05F0 ; Bell .Tone
DW 0x76D0
DW BIOS.PutChr.mul78
DW BIOS.PutChr.OutStd.std
DW BIOS.PutChr.OutStd
DW 0x7650
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ORG 0xD000
PROCESS:DW 0x0000,0x0000 ;#0
DW 0xF800,0xFFFF ;#1
DW 0xF000,0x0001 ;#2
DW 0x0000,0x0000
Intuitive clear mnemonic to quick memorize
|Codes|Key|Elementary description_________
00 :Nil-Null of instruction queue / HLT
xA..xB:A/B-Add / Subtract
xC..xD:C/D-Conjunction / Disjunction
xE : E -Exclusive bitwise OR
A0..A7: A -Access to bytes
A8..AF:A/A-Access to ALU
B0..B7: B -Branches to nearest substitutes
B8..BF:B/F-Branches to near labels by flag
C0..C7: C -Increment
CA :RAL-Concatenate Access roll
CF :C/F-Carry Flag complement
D0..D7: D -Decrement
DA :RAR-Descended Access roll
DF :D/F-Data Formation by NOT
EE :E/E-Exchange
F0..F9:F/x-Functions of BIOS-API
FE :F/E-Fiction Execute / NOP
FF :F/F-Finalize the Function / RET
+EC/ED:Exclude operations by Counter/Data
+FC/FD:Forcing operation by Counter/Data
+EF :E/F-Enter register Feature
+FF :F/F-Flush register Feature
Simplest protection from errors in code:
Examples|Macros
CF BC FD|CLC ; Clear the Carry Flag
CF BD FD|STC ; Store the Carry Flag
BE FF |RZ ; Return by Zero Flag
BF FF |RNZ ; Return by no Zero Flag