// Microcode v0.1

// fetch = "CODE; IR <- MEM(PC); PC++"

// HALT 
op($00)
	0, *, CODE; IR <- MEM(PC)
endop

// NOP 
op($01)   
	0, *, fetch
endop

// MOV A, X 
op($02)
	0, *, A <- X; fetch
endop

// MOV A, Y 
op($03)
	0, *, A <- Y; fetch
endop

// MOV A, SP 
op($04)
	0, *, A <- SP
	1, *, fetch
endop

// MOV A, DP
op($05)
	0, *, A <- DP; 
	1, *, fetch
endop

// MOV X, A
op($06) 
	0, *, X <- A; fetch
endop

// MOV X, Y
op($07)
	0, *, X <- Y; fetch
endop

// MOV Y, A
op($08) 
	0, *, Y <- A; fetch
endop

// MOV Y, X
op($09)
	0, *, Y <- X; fetch
endop

// MOV SP, A 
op($0A) 
	0, *, SP <- A; fetch
endop

// MOV SP, DP
op($0B)
	0, *, SP <- DP;
	1, *, fetch
endop

// MOV DP, A 
op($0C) 
	0, *, DP <- A; fetch
endop

// MOV DP, SP 
op($0D) 
	0, *, DP <- SP;
	1, *, fetch
endop

// MOV A, MSW 
op($0E) 
	0, *, A <- MSW; fetch
endop

// MOV MSW, A 
op($0F) 
	0, *, MSW <- A; fetch
endop

// PUSH A 
op($10) 
	0, *, MEM(SP) <- HI(A); SP++
	1, *, MEM(SP) <- LO(A); SP++
	2, *, fetch
endop

// PUSH X 
op($11) 
	0, *, MEM(SP) <- HI(X); SP++
	1, *, MEM(SP) <- LO(X); SP++
	2, *, fetch
endop

// PUSH Y 
op($12) 
	0, *, MEM(SP) <- HI(Y); SP++
	1, *, MEM(SP) <- LO(Y); SP++
	2, *, fetch
endop

// PUSH SP 
op($13)
	0, *, MEM(SP) <- HI(SP); SP++
	1, *, MEM(SP) <- LO(SP); SP++
	2, *, fetch
endop

// PUSH DP 
op($14) 
	0, *, MDR <- DP;
	1, *, MEM(SP) <- HI(MDR); SP++
	2, *, MEM(SP) <- LO(MDR); SP++	
	3, *, fetch
endop

// PUSH PC 
op($15) 
	0, *, MDR <- PC;
	1, *, MEM(SP) <- HI(MDR); SP++
	2, *, MEM(SP) <- LO(MDR); SP++
	3, *, fetch
endop

// POP A 
op($16)
	0, *, SP--
	1, *, LO(A) <- MEM(SP); SP--
	2, *, HI(A) <- MEM(SP)
	3, *, fetch
endop

// POP X 
op($17) 
	0, *, SP--
	1, *, LO(MDR) <- MEM(SP); SP--
	2, *, HI(MDR) <- MEM(SP);
	3, *, X <- MDR; fetch
endop

// POP Y 
op($18) 
	0, *, SP--
	1, *, LO(MDR) <- MEM(SP); SP--
	2, *, HI(MDR) <- MEM(SP);
	3, *, Y <- MDR; fetch
endop

// POP SP 
op($19) 
	0, *, SP--
	1, *, LO(MDR) <- MEM(SP); SP--
	2, *, HI(MDR) <- MEM(SP);
	3, *, SP <- MDR; fetch
endop

// POP DP 
op($1A) 
	0, *, SP--
	1, *, LO(MDR) <- MEM(SP); SP--
	2, *, HI(MDR) <- MEM(SP);
	3, *, DP <- MDR; fetch
endop

// POP PC
op($1B)
	0, *, SP--
	1, *, LO(MDR) <- MEM(SP); SP--
	2, *, HI(MDR) <- MEM(SP);
	3, *, PC <- MDR; fetch
endop

// JMP #i16 
op($1C) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, PC <- MDR + PC
	3, *, fetch
endop

// CALL #i16 
op($1D)
	0, *, HI(MAR) <- MEM(PC); CODE; PC++
	1, *, LO(MAR) <- MEM(PC); CODE; PC++
	2, *, MDR <- PC
	3, *, MEM(SP) <- HI(MDR); SP++
	4, *, MEM(SP) <- LO(MDR); SP++	
	5, *, PC <- MDR + MAR
	6, *, fetch
endop

// RET 
op($1E) 
	0, *, LO(MDR) <- MEM(SP); SP--
	1, *, HI(MDR) <- MEM(SP); SP--
	2, *, PC <- MDR
	3, *, fetch
endop

// IRET op($1F) endop
// SYSCALL op($20) endop

// LD A, #i16 
op($21) 
	0, *, HI(A) <- MEM(PC); CODE; PC++
	1, *, LO(A) <- MEM(PC); CODE; PC++
	2, *, fetch
endop

// LD A, #i8 
op($22) 
	0, *, A <- MEM(PC); CODE; PC++ // sign extended
	1, *, fetch
endop

// LD A, (SP) 
op($23) 
	0, *, MAR <- SP;
	1, *, HI(A) <- MEM(MAR); MAR++
	2, *, LO(A) <- MEM(MAR)
	3, *, fetch
endop

// LD A, (SP:#i8) 
op($24)
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(A) <- MEM(MAR); MAR++
	3, *, LO(A) <- MEM(MAR);
	4, *, fetch
endop

// LD A, (SP:#i16) 
op($25) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(A) <- MEM(MAR); MAR++
	4, *, LO(A) <- MEM(MAR);
	5, *, fetch
endop

// LD A, (DP:#i16) 
op($26)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(A) <- MEM(MAR); MAR++
	4, *, LO(A) <- MEM(MAR);
	5, *, fetch
endop

// LD A, (A:#i16) 
op($27) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- A + MDR
	3, *, HI(A) <- MEM(MAR); MAR++
	4, *, LO(A) <- MEM(MAR);
	5, *, fetch
endop

// LD A, (X:#i16) 
op($28) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- X + MDR
	3, *, HI(A) <- MEM(MAR); MAR++
	4, *, LO(A) <- MEM(MAR);
	5, *, fetch
endop

// LD A, (Y:#i16) 
op($29) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- Y + MDR
	3, *, HI(A) <- MEM(MAR); MAR++
	4, *, LO(A) <- MEM(MAR);
	5, *, fetch
endop

// LD X, #i16 
op($2A) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, X <- MDR; fetch
endop

// LD X, #i8 
op($2B) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, X <- MDR; fetch
endop

// LD X, (SP) 
op($2C)
	0, *, MAR <- SP;
	1, *, HI(MDR) <- MEM(MAR); MAR++
	2, *, LO(MDR) <- MEM(MAR)
	3, *, X <- MDR; fetch
endop

// LD X, (SP:#i8) 
op($2D) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR); MAR++
	3, *, LO(MDR) <- MEM(MAR);
	4, *, X <- MDR; fetch	
endop

// LD X, (SP:#i16) 
op($2E) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, X <- MDR; fetch	
endop

// LD X, (DP:#i16) 
op($2F)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, X <- MDR; fetch	
endop

// LD X, (A:#i16) 
op($30) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- A + MDR
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, X <- MDR; fetch	
endop

// LD X, (X:#i16) 
op($31)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- X + MDR
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, X <- MDR; fetch	
endop

// LD X, (Y:#i16) 
op($32)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- Y + MDR
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, X <- MDR; fetch	
endop

// LD Y, #i16 
op($33) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, Y <- MDR; fetch
endop

// LD Y, #i8 
op($34) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, Y <- MDR; fetch	
endop

// LD Y, (SP) 
op($35) 
	0, *, MAR <- SP;
	1, *, HI(MDR) <- MEM(MAR); MAR++
	2, *, LO(MDR) <- MEM(MAR)
	3, *, Y <- MDR; fetch
endop

// LD Y, (SP:#i8) 
op($36)
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR); MAR++
	3, *, LO(MDR) <- MEM(MAR);
	4, *, Y <- MDR; fetch
endop

// LD Y, (SP:#i16) 
op($37) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, Y <- MDR; fetch
endop

// LD Y, (DP:#i16) 
op($38) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, Y <- MDR; fetch
endop

// LD Y, (A:#i16) 
op($39) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- A + MDR
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, Y <- MDR; fetch
endop

// LD Y, (X:#i16) 
op($3A) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- X + MDR
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, Y <- MDR; fetch
endop

// LD Y, (Y:#i16) 
op($3B) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- Y + MDR
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR);
	5, *, Y <- MDR; fetch
endop

// LD AH, #i8 
op($3C) 
	0, *, HI(A) <- MEM(PC); CODE; PC++
	1, *, fetch
endop

// LD AL, #i8 
op($3D) 
	0, *, LO(A) <- MEM(PC); CODE; PC++
	1, *, fetch
endop

// LD AH, (SP:#i8) 
op($3E)
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(A) <- MEM(MAR)
	3, *, fetch
endop

// LD AL, (SP:#i8) 
op($3F) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, LO(A) <- MEM(MAR)
	3, *, fetch
endop

// LD AH, (SP:#i16) 
op($40) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- MDR + SP
	3, *, HI(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AL, (SP:#i16) 
op($41) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- MDR + SP
	3, *, LO(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AH, (DP:#i16) 
op($42) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- MDR + DP
	3, *, HI(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AL, (DP:#i16) 
op($43) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- MDR + DP
	3, *, LO(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AH, (A:#i16) 
op($44) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- A + MDR
	3, *, HI(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AL, (A:#i16) 
op($45) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- A + MDR
	3, *, LO(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AH, (X:#i16) 
op($46)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- X + MDR
	3, *, HI(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AL, (X:#i16) 
op($47) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- X + MDR
	3, *, LO(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AH, (Y:#i16) 
op($48)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- Y + MDR
	3, *, HI(A) <- MEM(MAR)
	4, *, fetch
endop

// LD AL, (Y:#i16) 
op($49)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, HI(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- Y + MDR
	3, *, LO(A) <- MEM(MAR)
	4, *, fetch
endop

// ST (SP), A 
op($4A)
	0, *, MAR <- SP
	1, *, MEM(MAR) <- HI(A); MAR++
	2, *, MEM(MAR) <- LO(A);
	3, *, fetch
endop

// ST (SP:#i8), A 
op($4B) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, MEM(MAR) <- HI(A); MAR++
	3, *, MEM(MAR) <- LO(A)
	4, *, fetch
endop

// ST (SP:#i16), A 
op($4C) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, MEM(MAR) <- HI(A); MAR++
	4, *, MEM(MAR) <- LO(A)
	5, *, fetch
endop

// ST (DP:#i16), A 
op($4D) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, MEM(MAR) <- HI(A); MAR++
	4, *, MEM(MAR) <- LO(A)
	5, *, fetch
endop

// ST (A:#i16), A 
op($4E)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- A + MDR
	3, *, MEM(MAR) <- HI(A); MAR++
	4, *, MEM(MAR) <- LO(A)
	5, *, fetch
endop

// ST (X:#i16), A 
op($4F)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- X + MDR
	3, *, MEM(MAR) <- HI(A); MAR++
	4, *, MEM(MAR) <- LO(A)
	5, *, fetch
endop

// ST (Y:#i16), A 
op($50) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- Y + MDR
	3, *, MEM(MAR) <- HI(A); MAR++
	4, *, MEM(MAR) <- LO(A)
	5, *, fetch
endop

// ST (SP), X 
op($51)
	0, *, MAR <- SP
	1, *, MEM(MAR) <- HI(X); MAR++
	2, *, MEM(MAR) <- LO(X);
	3, *, fetch
endop

// ST (SP:#i8), X 
op($52) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, MEM(MAR) <- HI(X); MAR++
	3, *, MEM(MAR) <- LO(X)
	4, *, fetch
endop

// ST (SP:#i16), X 
op($53) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, MEM(MAR) <- HI(X); MAR++
	4, *, MEM(MAR) <- LO(X)
	5, *, fetch
endop

// ST (DP:#i16), X 
op($54) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, MEM(MAR) <- HI(X); MAR++
	4, *, MEM(MAR) <- LO(X)
	5, *, fetch
endop

// ST (A:#i16), X 
op($55) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- A + MDR
	3, *, MEM(MAR) <- HI(X); MAR++
	4, *, MEM(MAR) <- LO(X)
	5, *, fetch
endop

// ST (X:#i16), X 
op($56) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- X + MDR
	3, *, MEM(MAR) <- HI(X); MAR++
	4, *, MEM(MAR) <- LO(X)
	5, *, fetch
endop

// ST (Y:#i16), X 
op($57) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- Y + MDR
	3, *, MEM(MAR) <- HI(X); MAR++
	4, *, MEM(MAR) <- LO(X)
	5, *, fetch
endop

// ST (SP), Y 
op($58) 
	0, *, MAR <- SP
	1, *, MEM(MAR) <- HI(Y); MAR++
	2, *, MEM(MAR) <- LO(Y);
	3, *, fetch
endop

// ST (SP:#i8), Y 
op($59)
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, MEM(MAR) <- HI(Y); MAR++
	3, *, MEM(MAR) <- LO(Y)
	4, *, fetch
endop

// ST (SP:#i16), Y 
op($5A) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, MEM(MAR) <- HI(Y); MAR++
	4, *, MEM(MAR) <- LO(Y)
	5, *, fetch
endop

// ST (DP:#i16), Y 
op($5B) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, MEM(MAR) <- HI(Y); MAR++
	4, *, MEM(MAR) <- LO(Y)
	5, *, fetch
endop

// ST (A:#i16), Y 
op($5C) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- A + MDR
	3, *, MEM(MAR) <- HI(Y); MAR++
	4, *, MEM(MAR) <- LO(Y)
	5, *, fetch
endop

// ST (X:#i16), Y 
op($5D) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- X + MDR
	3, *, MEM(MAR) <- HI(Y); MAR++
	4, *, MEM(MAR) <- LO(Y)
	5, *, fetch
endop

// ST (Y:#i16), Y 
op($5E) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- Y + MDR
	3, *, MEM(MAR) <- HI(Y); MAR++
	4, *, MEM(MAR) <- LO(Y)
	5, *, fetch
endop

// ST (SP), AH 
op($5F) 
	0, *, MEM(SP) <- HI(A)
	1, *, fetch
endop

// ST (SP), AL 
op($60) 
	0, *, MEM(SP) <- LO(A)
	1, *, fetch
endop

// ST (SP:#i8), AH 
op($61) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, MEM(MAR) <- HI(A)
	3, *, fetch
endop

// ST (SP:#i8), AL 
op($62) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, MEM(MAR) <- LO(A)
	3, *, fetch
endop

// ST (SP:#i16), AH 
op($63) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, MEM(MAR) <- HI(A)
	4, *, fetch
endop

// ST (SP:#i16), AL 
op($64) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, MEM(MAR) <- LO(A)
	4, *, fetch
endop

// ST (DP:#i16), AH 
op($65) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, MEM(MAR) <- HI(A)
	4, *, fetch
endop

// ST (DP:#i16), AL 
op($66) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, MEM(MAR) <- LO(A)
	4, *, fetch
endop

// ST, (A:#i16), AH 
op($67)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- A + MDR
	3, *, MEM(MAR) <- HI(A)
	4, *, fetch
endop

// ST (A:#i16), AL 
op($68)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- A + MDR
	3, *, MEM(MAR) <- LO(A)
	4, *, fetch
endop

// ST (X:#i16), AH 
op($69) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- X + MDR
	3, *, MEM(MAR) <- HI(A)
	4, *, fetch
endop

// ST (X:#i16), AL 
op($6A) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- X + MDR
	3, *, MEM(MAR) <- LO(A)
	4, *, fetch
endop

// ST (Y:#i16), AH 
op($6B)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- Y + MDR
	3, *, MEM(MAR) <- HI(A)
	4, *, fetch
endop

// ST (Y:#i16), AL 
op($6C)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- Y + MDR
	3, *, MEM(MAR) <- LO(A)
	4, *, fetch
endop

// ADD A, #i8 
op($6D) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// ADD A, #i16 
op($6E) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// ADD A, X 
op($6F)
	0, *, MDR <- X
	1, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// ADD A, Y 
op($70)
	0, *, MDR <- Y
	1, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// ADD A, (SP) 
op($71)
	0, *, MAR <- SP
	1, *, HI(MDR) <- MEM(MAR); MAR++
	2, *, LO(MDR) <- MEM(MAR); MAR++	
	3, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// ADD A, (SP:#i8) 
op($72) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR); MAR++
	3, *, LO(MDR) <- MEM(MAR)
	4, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// ADD A, (SP:#i16) 
op($73) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR)
	5, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// ADD A, (DP:#i16) 
op($74) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR)
	5, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// ADD AH, (SP) 
op($75) 
	0, *, MDR <- MDR ^ MDR
	1, *, HI(MDR) <- MEM(SP)
	2, *, HI(A) <- A + MDR; SETFLAGS_HIBYTE; fetch 
endop

// ADD AH, (SP:#i8) 
op($76) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, MDR <- MDR ^ MDR
	3, *, HI(MDR) <- MEM(MAR)
	4, *, HI(A) <- A + MDR; SETFLAGS_HIBYTE; fetch
endop

// ADD AH, (SP:#i16) 
op($77)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, MDR <- MDR ^ MDR
	4, *, HI(MDR) <- MEM(MAR)
	5, *, HI(A) <- A + MDR; SETFLAGS_HIBYTE; fetch
endop

// ADD AH, (DP:#i16) 
op($78)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, MDR <- MDR ^ MDR
	4, *, HI(MDR) <- MEM(MAR)
	5, *, HI(A) <- A + MDR; SETFLAGS_HIBYTE; fetch
endop

// ADD AL, (SP) 
op($79)
	0, *, LO(MDR) <- MEM(SP)
	1, *, LO(A) <- A + MDR; SETFLAGS_LOBYTE; fetch 
endop

// ADD AL, (SP:#i8) 
op($7A) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, LO(MDR) <- MEM(MAR)
	3, *, LO(A) <- A + MDR; SETFLAGS_LOBYTE; fetch
endop

// ADD AL, (SP:#i16) 
op($7B) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(A) <- A + MDR; SETFLAGS_LOBYTE; fetch
endop

// ADD AL, (DP:#i16) 
op($7C) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(A) <- A + MDR; SETFLAGS_LOBYTE; fetch
endop

// SUB A, #i8 
op($7D) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, A <- A - MDR; SETFLAGS_WORD; fetch
endop

// SUB A, #i16 
op($7E) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, A <- A - MDR; SETFLAGS_WORD; fetch
endop

// SUB A, X 
op($7F) 
	0, *, MDR <- X
	1, *, A <- A - MDR; SETFLAGS_WORD; fetch
endop

// SUB A, Y 
op($80) 
	0, *, MDR <- Y
	1, *, A <- A - MDR; SETFLAGS_WORD; fetch
endop

// SUB A, (SP) 
op($81) 
	0, *, MAR <- SP
	1, *, HI(MDR) <- MEM(MAR); MAR++
	2, *, LO(MDR) <- MEM(MAR); MAR++	
	3, *, A <- A - MDR; SETFLAGS_WORD; fetch
endop

// SUB A, (SP:#i8) 
op($82) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR); MAR++
	3, *, LO(MDR) <- MEM(MAR)
	4, *, A <- A - MDR; SETFLAGS_WORD; fetch
endop

// SUB A, (SP:#i16) 
op($83) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR)
	5, *, A <- A - MDR; SETFLAGS_WORD; fetch
endop

// SUB A, (DP:#i16) 
op($84) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR)
	5, *, A <- A - MDR; SETFLAGS_WORD; fetch
endop

// SUB AH, (SP) 
op($85) 
	0, *, MDR <- MDR ^ MDR
	1, *, HI(MDR) <- MEM(SP)
	2, *, HI(A) <- A - MDR; SETFLAGS_HIBYTE; fetch 
endop

// SUB AH, (SP:#i8) 
op($86) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, MDR <- MDR ^ MDR
	3, *, HI(MDR) <- MEM(MAR)
	4, *, HI(A) <- A - MDR; SETFLAGS_HIBYTE; fetch
endop

// SUB AH, (SP:#i16) 
op($87) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, MDR <- MDR ^ MDR
	4, *, HI(MDR) <- MEM(MAR)
	5, *, HI(A) <- A - MDR; SETFLAGS_HIBYTE; fetch
endop

// SUB AH, (DP:#i16) 
op($88) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, MDR <- MDR ^ MDR
	4, *, HI(MDR) <- MEM(MAR)
	5, *, HI(A) <- A - MDR; SETFLAGS_HIBYTE; fetch
endop

// SUB AL, (SP) 
op($89) 
	0, *, LO(MDR) <- MEM(SP)
	1, *, LO(A) <- A - MDR; SETFLAGS_LOBYTE; fetch
endop

// SUB AL, (SP:#i8) 
op($8A) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, LO(MDR) <- MEM(MAR)
	3, *, LO(A) <- A - MDR; SETFLAGS_LOBYTE; fetch
endop

// SUB AL, (SP:#i16) 
op($8B) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(A) <- A - MDR; SETFLAGS_LOBYTE; fetch
endop

// SUB AL, (DP:#i16) 
op($8C) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(A) <- A - MDR; SETFLAGS_LOBYTE; fetch
endop

// AND A, #i16 
op($8D) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, A <- A & MDR; SETFLAGS_WORD; fetch
endop

// AND A, X 
op($8E) 
	0, *, MDR <- X
	1, *, A <- A & MDR; SETFLAGS_WORD; fetch
endop

// AND A, Y 
op($8F) 
	0, *, MDR <- Y
	1, *, A <- A & MDR; SETFLAGS_WORD; fetch
endop

// AND A, (SP) 
op($90) 
	0, *, MAR <- SP
	1, *, HI(MDR) <- MEM(MAR); MAR++
	2, *, LO(MDR) <- MEM(MAR)
	3, *, A <- A & MDR; SETFLAGS_WORD; fetch
endop

// AND A, (SP:#i8) 
op($91) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR); MAR++
	3, *, LO(MDR) <- MEM(MAR); MAR++
	4, *, A <- A & MDR; SETFLAGS_WORD; fetch
endop

// AND A, (SP:#i16) 
op($92) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR); MAR++
	5, *, A <- A & MDR; SETFLAGS_WORD; fetch
endop

// AND A, (DP:#i16) 
op($93) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR); MAR++
	5, *, A <- A & MDR; SETFLAGS_WORD; fetch
endop

// AND AH, (SP) 
op($94) 
	0, *, HI(MDR) <- MEM(SP)
	1, *, HI(A) <- A & MDR; SETFLAGS_HIBYTE; fetch
endop

// AND AH, (SP:#i8) 
op($95) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR)
	3, *, HI(A) <- A & MDR; SETFLAGS_HIBYTE; fetch
endop

// AND AH, (SP:#i16) 
op($96) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR)
	4, *, HI(A) <- A & MDR; SETFLAGS_HIBYTE; fetch
endop

// AND AH, (DP:#i16) 
op($97) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR)
	4, *, HI(A) <- A & MDR; SETFLAGS_HIBYTE; fetch
endop

// AND AL, (SP) 
op($98) 
	0, *, LO(MDR) <- MEM(SP)
	1, *, LO(A) <- A & MDR; SETFLAGS_LOBYTE; fetch
endop

// AND AL, (SP:#i8) 
op($99) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, LO(MDR) <- MEM(MAR)
	3, *, LO(A) <- A & MDR; SETFLAGS_LOBYTE; fetch
endop

// AND AL, (SP:#i16) 
op($9A) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- MDR + SP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(A) <- A & MDR; SETFLAGS_LOBYTE; fetch
endop

// AND AL, (DP:#i16) 
op($9B)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- MDR + DP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(A) <- A & MDR; SETFLAGS_LOBYTE; fetch
endop

// OR A, #i16 
op($9C) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, A <- A | MDR; SETFLAGS_WORD; fetch
endop

// OR A, X 
op($9D) 
	0, *, MDR <- X
	1, *, A <- A | MDR; SETFLAGS_WORD; fetch
endop

// OR A, Y 
op($9E)
	0, *, MDR <- Y
	1, *, A <- A | MDR; SETFLAGS_WORD; fetch
endop

// OR A, (SP) 
op($9F) 
	0, *, MAR <- SP
	1, *, HI(MDR) <- MEM(MAR); MAR++
	2, *, LO(MDR) <- MEM(MAR)
	3, *, A <- A | MDR; SETFLAGS_WORD; fetch
endop

// OR A, (SP:#i8) 
op($A0) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR); MAR++
	3, *, LO(MDR) <- MEM(MAR); MAR++
	4, *, A <- A | MDR; SETFLAGS_WORD; fetch
endop

// OR A, (SP:#i16) 
op($A1) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR); MAR++
	5, *, A <- A | MDR; SETFLAGS_WORD; fetch
endop

// OR A, (DP:#i16) 
op($A2) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR); MAR++
	5, *, A <- A | MDR; SETFLAGS_WORD; fetch
endop

// OR AH, (SP) 
op($A3) 
	0, *, HI(MDR) <- MEM(SP)
	1, *, HI(A) <- A | MDR; SETFLAGS_HIBYTE; fetch
endop

// OR AH, (SP:#i8) 
op($A4) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR)
	3, *, HI(A) <- A | MDR; SETFLAGS_HIBYTE; fetch
endop

// OR AH, (SP:#i16) 
op($A5) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR)
	4, *, HI(A) <- A | MDR; SETFLAGS_HIBYTE; fetch
endop

// OR AH, (DP:#i16) 
op($A6) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR)
	4, *, HI(A) <- A | MDR; SETFLAGS_HIBYTE; fetch
endop

// OR AL, (SP) 
op($A7) 
	0, *, LO(MDR) <- MEM(SP)
	1, *, LO(A) <- A | MDR; SETFLAGS_LOBYTE; fetch
endop

// OR AL, (SP:#i8) 
op($A8) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, LO(MDR) <- MEM(MAR)
	3, *, LO(A) <- A | MDR; SETFLAGS_LOBYTE; fetch
endop

// OR AL, (SP:#i16) 
op($A9) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- MDR + SP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(A) <- A | MDR; SETFLAGS_LOBYTE; fetch
endop

// OR AL, (DP:#i16) 
op($AA) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++	
	2, *, MAR <- MDR + DP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(A) <- A | MDR; SETFLAGS_LOBYTE; fetch
endop

// XOR A, #i16 
op($AB) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, A <- A ^ MDR; SETFLAGS_WORD; fetch
endop

// XOR A, A 
op($AC) 
	0, *, MDR <- A
	1, *, A <- A ^ MDR; SETFLAGS_WORD; fetch
endop

// XOR A, X 
op($AD) 
	0, *, MDR <- X
	1, *, A <- A ^ MDR; SETFLAGS_WORD; fetch
endop

// XOR A, Y 
op($AE) 
	0, *, MDR <- Y
	1, *, A <- A ^ MDR; SETFLAGS_WORD; fetch
endop

// XOR X, X 
op($AF) 
	0, *, MDR <- X
	1, *, X <- X ^ MDR; SETFLAGS_WORD; fetch
endop

// XOR Y, Y 
op($B0) 
	0, *, MDR <- Y
	1, *, Y <- Y ^ MDR; SETFLAGS_WORD; fetch
endop

// SHL A 
op($B1) 
	0, *, MDR <- A
	1, *, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// SHL X 
op($B2)
	0, *, MDR <- X
	1, *, X <- X + MDR; SETFLAGS_WORD; fetch
endop

// SHL Y 
op($B3) 
	0, *, MDR <- Y
	1, *, Y <- Y + MDR; SETFLAGS_WORD; fetch
endop

// SHR A 
op($B4) 
	0, *, A <- A; SHR;
	1, *, A <- A; SETFLAGS_WORD; fetch
endop

// SHR X 
op($B5) 
	0, *, X <- X; SHR; 
	1, *, X <- X; SETFLAGS_WORD; fetch
endop

// SHR Y 
op($B6) 
	0, *, Y <- Y; SHR; 
	1, *, Y <- Y; SETFLAGS_WORD; fetch
endop

// SHL AH 
op($B7) 
	0, *, MDR <- MDR ^ MDR
	1, *, HI(MDR) <- A + A; SETFLAGS_HIBYTE
	2, *, HI(A) <- MDR; fetch
endop

// SHL AL 
op($B8) 
	0, *, LO(MDR) <- A + A; SETFLAGS_LOBYTE
	1, *, LO(A) <- MDR; fetch
endop

// SHR AH
op($B9) 
	0, *, HI(MDR) <- A; SHR; SETFLAGS_HIBYTE
	1, *, HI(A) <- MDR; fetch
endop

// SHR AL 
op($BA)
	0, *, LO(MDR) <- A; SHR; SETFLAGS_LOBYTE
	1, *, LO(A) <- MDR; fetch
endop

// ADC A, X 
op($BB) 
	0, *, MDR <- X
	1, C, A <- A + MDR + 1; SETFLAGS_WORD; fetch
	1, !C, A <- A + MDR; SETFLAGS_WORD; fetch 
endop

// ADC A, Y 
op($BC)
	0, *, MDR <- Y
	1, C, A <- A + MDR + 1; SETFLAGS_WORD; fetch
	1, !C, A <- A + MDR; SETFLAGS_WORD; fetch
endop

// SBC A, X 
op($BD) 
	0, *, MDR <- X
	1, C, A <- A - MDR; SETFLAGS_WORD; fetch
	1, !C, A <- A - MDR - 1; SETFLAGS_WORD; fetch
endop

// SBC A, Y 
op($BE) 
	0, *, MDR <- Y
	1, C, A <- A - MDR; SETFLAGS_WORD; fetch
	1, !C, A <- A - MDR - 1; SETFLAGS_WORD; fetch
endop

// ADD SP, #i8 
op($BF) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, SP <- MDR + SP; 
	2, *, fetch
endop

// ADD DP, #i8 
op($C0) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, DP <- MDR + DP; 
	2, *, fetch
endop

// ADD X, #i8 
op($C1) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, X <- X + MDR; fetch
endop

// ADD Y, #i8 
op($C2) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, Y <- Y + MDR; fetch
endop

//  op($C3) endop
//  op($C4) endop

// CMP A, #i8 
op($C5) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MDR <- A - MDR; SETFLAGS_WORD; fetch
endop

// CMP A, #i16 
op($C6) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MDR <- A - MDR; SETFLAGS_WORD; fetch
endop

// CMP A, X 
op($C7) 
	0, *, MDR <- X
	1, *, MDR <- A - MDR; SETFLAGS_WORD; fetch
endop

// CMP A, Y 
op($C8) 
	0, *, MDR <- Y
	1, *, MDR <- A - MDR; SETFLAGS_WORD; fetch
endop

// CMP A, (SP) 
op($C9) 
	0, *, MAR <- SP
	1, *, HI(MDR) <- MEM(MAR); MAR++
	2, *, LO(MDR) <- MEM(MAR); MAR++	
	3, *, MDR <- A - MDR; SETFLAGS_WORD; fetch
endop

// CMP A, (SP:#i8) 
op($CA) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, HI(MDR) <- MEM(MAR); MAR++
	3, *, LO(MDR) <- MEM(MAR)
	4, *, MDR <- A - MDR; SETFLAGS_WORD; fetch
endop

// CMP A, (SP:#i16) 
op($CB) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR)
	5, *, MDR <- A - MDR; SETFLAGS_WORD; fetch
endop

// CMP A, (DP:#i16) 
op($CC) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, HI(MDR) <- MEM(MAR); MAR++
	4, *, LO(MDR) <- MEM(MAR)
	5, *, MDR <- A - MDR; SETFLAGS_WORD; fetch
endop

// CMP AH, (SP) 
op($CD) 
	0, *, MDR <- MDR ^ MDR
	1, *, HI(MDR) <- MEM(SP)
	2, *, HI(MDR) <- A - MDR; SETFLAGS_HIBYTE; fetch 
endop

// CMP AH, (SP:#i8) 
op($CE) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, MDR <- MDR ^ MDR
	3, *, HI(MDR) <- MEM(MAR)
	4, *, HI(MDR) <- A - MDR; SETFLAGS_HIBYTE; fetch
endop

// CMP AH, (SP:#i16) 
op($CF) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, MDR <- MDR ^ MDR
	4, *, HI(MDR) <- MEM(MAR)
	5, *, HI(MDR) <- A - MDR; SETFLAGS_HIBYTE; fetch
endop

// CMP AH, (DP:#i16) 
op($D0) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, MDR <- MDR ^ MDR
	4, *, HI(MDR) <- MEM(MAR)
	5, *, HI(MDR) <- A - MDR; SETFLAGS_HIBYTE; fetch
endop

// CMP AL, (SP) 
op($D1) 
	0, *, LO(MDR) <- MEM(SP)
	1, *, LO(MDR) <- A - MDR; SETFLAGS_LOBYTE; fetch
endop

// CMP AL, (SP:#i8) 
op($D2) 
	0, *, MDR <- MEM(PC); CODE; PC++
	1, *, MAR <- MDR + SP
	2, *, LO(MDR) <- MEM(MAR)
	3, *, LO(MDR) <- A - MDR; SETFLAGS_LOBYTE; fetch
endop

// CMP AL, (SP:#i16) 
op($D3)
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + SP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(MDR) <- A - MDR; SETFLAGS_LOBYTE; fetch
endop

// CMP AL, (DP:#i16) 
op($D4) 
	0, *, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, MAR <- MDR + DP
	3, *, LO(MDR) <- MEM(MAR)
	4, *, LO(MDR) <- A - MDR; SETFLAGS_LOBYTE; fetch
endop

// JE #i16 
op($D5) 
	0, !Z, fetch
	0, Z, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, PC <- MDR + PC
	3, *, fetch
endop

// JL #i16 
op($D6) 
	0, !N, fetch
	0, N, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, PC <- MDR + PC
	3, *, fetch	
endop

// JLE #i16 
op($D7) 
	0, !N!Z, fetch
	0, N!Z, HI(MDR) <- MEM(PC); CODE; PC++
	0, Z!N, HI(MDR) <- MEM(PC); CODE; PC++
	0, Z N, HI(MDR) <- MEM(PC); CODE; PC++	
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, PC <- MDR + PC
	3, *, fetch	
endop

// JG #i16 
op($D8) 
	0, Z N, fetch
	0, N!Z, fetch
	0, Z!N, fetch
	0, !N!Z, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, PC <- MDR + PC
	3, *, fetch
endop

// JGE #i16 
op($D9) 
	0, N, fetch
	0, !N, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, PC <- MDR + PC
	3, *, fetch
endop

// JZ #i16 
op($DA) 
	0, !Z, fetch
	0, Z, HI(MDR) <- MEM(PC); CODE; PC++
	1, *, LO(MDR) <- MEM(PC); CODE; PC++
	2, *, PC <- MDR + PC
	3, *, fetch
endop

//  op($DB) endop
//  op($DC) endop
//  op($DD) endop
//  op($DE) endop
//  op($DF) endop
//  op($E0) endop
//  op($E1) endop
//  op($E2) endop
//  op($E3) endop
//  op($E4) endop
//  op($E5) endop
//  op($E6) endop
//  op($E7) endop
//  op($E8) endop
//  op($E9) endop
//  op($EA) endop
//  op($EB) endop
//  op($EC) endop
//  op($ED) endop
//  op($EE) endop
//  op($EF) endop
//  op($F0) endop
//  op($F1) endop
//  op($F2) endop
//  op($F3) endop
//  op($F4) endop
//  op($F5) endop
//  op($F6) endop
//  op($F7) endop
//  op($F8) endop
//  op($F9) endop
//  op($FA) endop
//  op($FB) endop
//  op($FC) endop
//  op($FD) endop
//  op($FE) endop
//  op($FF) endop

// fault0 op($100) endop
// fault1 op($101) endop
// fault2 op($102) endop
// fault3 op($103) endop
// fault4 op($104) endop
// fault5 op($105) endop
// fault6 op($106) endop
// fault7 op($107) endop

// irq0 op($108) endop
// irq1 op($109) endop
// irq2 op($10A) endop
// irq3 op($10B) endop
// irq4 op($10C) endop
// irq5 op($10D) endop
// irq6 op($10E) endop
// irq7 op($10F) endop