// ORG $0000
// FCC "g GCE 1982"
// FCB $80
// FDB music3
// FCB $F8, $50 ; h,w of raster image
// FCB $20, $C0 ; y,x of raster image
// FCC "ARMOR ATTACK"
// FCB $80
// FCB $00
case 0x001F: mon("L001F LDX #$C880 ; 001F: 8E C8 80 \n");
X = 0xc880;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDD #$0280 ; 0022: CC 02 80 \n");
A = (UINT8)((0x0280) >> 8);
B = (UINT8)((0x0280) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" JSR Clear_x_d ; 0025: BD F5 48 \n");
memory[--S] = 0x0028 & 0xff; memory[--S] = 0x0028 >> 8;
PC = 0xf548;
JUMP;
case 0x0028: mon("L0028 LDD #$0203 ; 0028: CC 02 03 \n");
A = (UINT8)((0x0203) >> 8);
B = (UINT8)((0x0203) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" JSR Select_Game ; 002B: BD F7 A9 \n");
memory[--S] = 0x002e & 0xff; memory[--S] = 0x002e >> 8;
PC = 0xf7a9;
JUMP;
case 0x002E: mon("L002E JSR DP_to_C8 ; 002E: BD F1 AF \n");
memory[--S] = 0x0031 & 0xff; memory[--S] = 0x0031 >> 8;
PC = 0xf1af;
JUMP;
case 0x0031: mon("L0031 LDA #$FF ; 0031: 86 FF \n");
A = (UINT8)(SINT8)0xff;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$29 ; 0033: 97 29 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x29] = A;
mon(" LDB #$BB ; 0035: C6 BB \n");
B = (UINT8)(SINT8)0xbb;
// N = B;
// Z = B;
// V = 0;
mon(" LDA <$7A ; 0037: 96 7A \n");
A = (UINT8)memory_DP[0x7a];
// N = A;
// Z = A;
// V = 0;
mon(" CMPA #$01 ; 0039: 81 01 \n");
res = A - (SINT8)0x01;
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ (SINT8)0x01) & (A ^ (UINT8)res);
mon(" BEQ $45 ; 003B: 27 08 \n");
if (!Z) {
PC = 0x0045;
JUMP;
}
mon(" LDB #$88 ; 003D: C6 88 \n");
B = (UINT8)(SINT8)0x88;
// N = B;
// Z = B;
// V = 0;
mon(" CMPA #$02 ; 003F: 81 02 \n");
res = A - (SINT8)0x02;
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ (SINT8)0x02) & (A ^ (UINT8)res);
mon(" BEQ $45 ; 0041: 27 02 \n");
if (!Z) {
PC = 0x0045;
JUMP;
}
mon(" INC <$29 ; 0043: 0C 29 \n");
res = (UINT8)(memory_DP[0x29] + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0x29]);
memory_DP[0x29] = res;
case 0x0045: mon("L0045 STB <$F0 ; 0045: D7 F0 \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xf0] = B;
mon(" CLR <$20 ; 0047: 0F 20 \n");
memory_DP[0x20] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" CLR <$22 ; 0049: 0F 22 \n");
memory_DP[0x22] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LDD #$7F7F ; 004B: CC 7F 7F \n");
A = (UINT8)((0x7f7f) >> 8);
B = (UINT8)((0x7f7f) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD <$C9 ; 004E: DD C9 \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xc9] = A;
memory_DP[0xc9 + 1] = B;
case 0x0050: mon("L0050 LDA <$79 ; 0050: 96 79 \n");
A = (UINT8)memory_DP[0x79];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$C8 ; 0052: 97 C8 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xc8] = A;
mon(" CLR <$87 ; 0054: 0F 87 \n");
memory_DP[0x87] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LDA #$10 ; 0056: 86 10 \n");
A = (UINT8)(SINT8)0x10;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$1A ; 0058: 97 1A \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x1a] = A;
mon(" LDD #$FA38 ; 005A: CC FA 38 \n");
A = (UINT8)((0xfa38) >> 8);
B = (UINT8)((0xfa38) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD <$2A ; 005D: DD 2A \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x2a] = A;
memory_DP[0x2a + 1] = B;
mon(" LDX #$C8DE ; 005F: 8E C8 DE \n");
X = 0xc8de;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDU #$0D3F ; 0062: CE 0D 3F \n");
U = 0x0d3f;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDA #$07 ; 0065: 86 07 \n");
A = (UINT8)(SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
mon(" JSR $0CF6 ; 0067: BD 0C F6 \n");
memory[--S] = 0x006a & 0xff; memory[--S] = 0x006a >> 8;
PC = 0x0cf6;
JUMP;
case 0x006A: mon("L006A LDX #$CA88 ; 006A: 8E CA 88 \n");
X = 0xca88;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDD #$7888 ; 006D: CC 78 88 \n");
A = (UINT8)((0x7888) >> 8);
B = (UINT8)((0x7888) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD ,X++ ; 0070: ED 81 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[X] = A;
memory[X + 1] = B;
X = X + 2;
mon(" JSR Clear_Score ; 0072: BD F8 4F \n");
memory[--S] = 0x0075 & 0xff; memory[--S] = 0x0075 >> 8;
PC = 0xf84f;
JUMP;
case 0x0075: mon("L0075 LEAX $07,X ; 0075: 30 07 \n");
X = (X + 0x0007);
// Z = X;
mon(" LDD #$7838 ; 0077: CC 78 38 \n");
A = (UINT8)((0x7838) >> 8);
B = (UINT8)((0x7838) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD ,X++ ; 007A: ED 81 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[X] = A;
memory[X + 1] = B;
X = X + 2;
mon(" JSR Clear_Score ; 007C: BD F8 4F \n");
memory[--S] = 0x007f & 0xff; memory[--S] = 0x007f >> 8;
PC = 0xf84f;
JUMP;
case 0x007F: mon("L007F JSR Init_Music_Buf ; 007F: BD F5 33 \n");
memory[--S] = 0x0082 & 0xff; memory[--S] = 0x0082 >> 8;
PC = 0xf533;
JUMP;
case 0x0082: mon("L0082 LDA #$FF ; 0082: 86 FF \n");
A = (UINT8)(SINT8)0xff;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$71 ; 0084: 97 71 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x71] = A;
mon(" STA <$8A ; 0086: 97 8A \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x8a] = A;
mon(" STA <$E9 ; 0088: 97 E9 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xe9] = A;
mon(" STA <$ED ; 008A: 97 ED \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xed] = A;
mon(" STA <$91 ; 008C: 97 91 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x91] = A;
mon(" LDX #$0FEE ; 008E: 8E 0F EE \n");
X = 0x0fee;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDU #$CA9A ; 0091: CE CA 9A \n");
U = 0xca9a;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDB #$02 ; 0094: C6 02 \n");
B = (UINT8)(SINT8)0x02;
// N = B;
// Z = B;
// V = 0;
mon(" JSR $0CAC ; 0096: BD 0C AC \n");
memory[--S] = 0x0099 & 0xff; memory[--S] = 0x0099 >> 8;
PC = 0x0cac;
JUMP;
case 0x0099: mon("L0099 LDA <$E1 ; 0099: 96 E1 \n");
A = (UINT8)memory_DP[0xe1];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$2E ; 009B: 97 2E \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x2e] = A;
mon(" LDA <$E0 ; 009D: 96 E0 \n");
A = (UINT8)memory_DP[0xe0];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$2F ; 009F: 97 2F \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x2f] = A;
mon(" LDA <$DE ; 00A1: 96 DE \n");
A = (UINT8)memory_DP[0xde];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$30 ; 00A3: 97 30 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x30] = A;
mon(" JSR $084B ; 00A5: BD 08 4B \n");
memory[--S] = 0x00a8 & 0xff; memory[--S] = 0x00a8 >> 8;
PC = 0x084b;
JUMP;
case 0x00A8: mon("L00A8 JSR $0CD4 ; 00A8: BD 0C D4 \n");
memory[--S] = 0x00ab & 0xff; memory[--S] = 0x00ab >> 8;
PC = 0x0cd4;
JUMP;
case 0x00AB: mon("L00AB CLR <$94 ; 00AB: 0F 94 \n");
memory_DP[0x94] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LDX #$C9C0 ; 00AD: 8E C9 C0 \n");
X = 0xc9c0;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDD #$0807 ; 00B0: CC 08 07 \n");
A = (UINT8)((0x0807) >> 8);
B = (UINT8)((0x0807) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" JSR $0CDA ; 00B3: BD 0C DA \n");
memory[--S] = 0x00b6 & 0xff; memory[--S] = 0x00b6 >> 8;
PC = 0x0cda;
JUMP;
case 0x00B6: mon("L00B6 CLR <$67 ; 00B6: 0F 67 \n");
memory_DP[0x67] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LDA <$E2 ; 00B8: 96 E2 \n");
A = (UINT8)memory_DP[0xe2];
// N = A;
Z = A;
// V = 0;
mon(" BNE $DD ; 00BA: 26 21 \n");
if (Z) {
PC = 0x00dd;
JUMP;
}
mon(" LDX #$CA8A ; 00BC: 8E CA 8A \n");
X = 0xca8a;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LEAU $09,X ; 00BF: 33 09 \n");
U = (X + 0x0009);
mon(" JSR Compare_Score ; 00C1: BD F8 C7 \n");
memory[--S] = 0x00c4 & 0xff; memory[--S] = 0x00c4 >> 8;
PC = 0xf8c7;
JUMP;
case 0x00C4: mon("L00C4 CMPA #$02 ; 00C4: 81 02 \n");
res = A - (SINT8)0x02;
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ (SINT8)0x02) & (A ^ (UINT8)res);
mon(" BNE $CA ; 00C6: 26 02 \n");
if (Z) {
PC = 0x00ca;
JUMP;
}
mon(" LEAX ,U ; 00C8: 30 C4 \n");
X = U;
// Z = X;
case 0x00CA: mon("L00CA LDU #Vec_High_Score ; 00CA: CE CB EB \n");
U = 0xcbeb;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" JSR New_High_Score ; 00CD: BD F8 D8 \n");
memory[--S] = 0x00d0 & 0xff; memory[--S] = 0x00d0 >> 8;
PC = 0xf8d8;
JUMP;
case 0x00D0: mon("L00D0 CLR <$ED ; 00D0: 0F ED \n");
memory_DP[0xed] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" LDD #$0BFF ; 00D2: CC 0B FF \n");
A = (UINT8)((0x0bff) >> 8);
B = (UINT8)((0x0bff) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD <$32 ; 00D5: DD 32 \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x32] = A;
memory_DP[0x32 + 1] = B;
mon(" LDA <$C8 ; 00D7: 96 C8 \n");
A = (UINT8)memory_DP[0xc8];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$E9 ; 00D9: 97 E9 \n");
Z = A;
N = A;
V = 0;
memory_DP[0xe9] = A;
mon(" BRA $011B ; 00DB: 20 3E \n");
PC = 0x011b;
JUMP;
case 0x00DD: mon("L00DD LDA <$C7 ; 00DD: 96 C7 \n");
A = (UINT8)memory_DP[0xc7];
// N = A;
Z = A;
// V = 0;
mon(" BNE $EF ; 00DF: 26 0E \n");
if (Z) {
PC = 0x00ef;
JUMP;
}
mon(" LDA <$2E ; 00E1: 96 2E \n");
A = (UINT8)memory_DP[0x2e];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $99 ; 00E3: 27 B4 \n");
if (!Z) {
PC = 0x0099;
JUMP;
}
mon(" LDA <$C8 ; 00E5: 96 C8 \n");
A = (UINT8)memory_DP[0xc8];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$E9 ; 00E7: 97 E9 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xe9] = A;
mon(" DEC <$2E ; 00E9: 0A 2E \n");
res = (UINT8)(memory_DP[0x2e] - 1);
// N = res;
Z = res;
// V = memory_DP[0x2e] & ~res;
memory_DP[0x2e] = res;
mon(" BNE $011B ; 00EB: 26 2E \n");
if (Z) {
PC = 0x011b;
JUMP;
}
mon(" COM <$E9 ; 00ED: 03 E9 \n");
memory_DP[0xe9] = memory_DP[0xe9] ^ 0xff;
// Z = memory_DP[0xe9];
// N = memory_DP[0xe9];
// V = 0;
// C = 256;
case 0x00EF: mon("L00EF LDB <$C7 ; 00EF: D6 C7 \n");
B = (UINT8)memory_DP[0xc7];
// N = B;
Z = B;
// V = 0;
mon(" BEQ $A8 ; 00F1: 27 B5 \n");
if (!Z) {
PC = 0x00a8;
JUMP;
}
mon(" LDA <$8A ; 00F3: 96 8A \n");
A = (UINT8)memory_DP[0x8a];
N = A;
// Z = A;
// V = 0;
mon(" BPL $010F ; 00F5: 2A 18 \n");
if ((SINT8)N >= 0) {
PC = 0x010f;
JUMP;
}
mon(" NEGA ; 00F7: 40 \n");
// V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
mon(" STA <$8A ; 00F8: 97 8A \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x8a] = A;
mon(" ANDA #$03 ; 00FA: 84 03 \n");
A = A & (SINT8)0x03;
// Z = A;
// N = A;
// V = 0;
mon(" CMPA #$01 ; 00FC: 81 01 \n");
res = A - (SINT8)0x01;
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ (SINT8)0x01) & (A ^ (UINT8)res);
mon(" BNE $010F ; 00FE: 26 0F \n");
if (Z) {
PC = 0x010f;
JUMP;
}
mon(" LDB <$87 ; 0100: D6 87 \n");
B = (UINT8)memory_DP[0x87];
// N = B;
// Z = B;
// V = 0;
mon(" LDU #$0CFF ; 0102: CE 0C FF \n");
U = 0x0cff;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LEAU B,U ; 0105: 33 C5 \n");
U = (U + (SINT8)B);
mon(" LDX #$C880 ; 0107: 8E C8 80 \n");
X = 0xc880;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDA #$08 ; 010A: 86 08 \n");
A = (UINT8)(SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
mon(" JSR $0CF6 ; 010C: BD 0C F6 \n");
memory[--S] = 0x010f & 0xff; memory[--S] = 0x010f >> 8;
PC = 0x0cf6;
JUMP;
case 0x010F: mon("L010F JSR $0A59 ; 010F: BD 0A 59 \n");
memory[--S] = 0x0112 & 0xff; memory[--S] = 0x0112 >> 8;
PC = 0x0a59;
JUMP;
case 0x0112: mon("L0112 JSR $08BA ; 0112: BD 08 BA \n");
memory[--S] = 0x0115 & 0xff; memory[--S] = 0x0115 >> 8;
PC = 0x08ba;
JUMP;
case 0x0115: mon("L0115 JSR $039D ; 0115: BD 03 9D \n");
memory[--S] = 0x0118 & 0xff; memory[--S] = 0x0118 >> 8;
PC = 0x039d;
JUMP;
case 0x0118: mon("L0118 JSR $06C6 ; 0118: BD 06 C6 \n");
memory[--S] = 0x011b & 0xff; memory[--S] = 0x011b >> 8;
PC = 0x06c6;
JUMP;
case 0x011B: mon("L011B INC <$EE ; 011B: 0C EE \n");
res = (UINT8)(memory_DP[0xee] + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0xee]);
memory_DP[0xee] = res;
mon(" JSR $0BD3 ; 011D: BD 0B D3 \n");
memory[--S] = 0x0120 & 0xff; memory[--S] = 0x0120 >> 8;
PC = 0x0bd3;
JUMP;
case 0x0120: mon("L0120 JSR $0185 ; 0120: BD 01 85 \n");
memory[--S] = 0x0123 & 0xff; memory[--S] = 0x0123 >> 8;
PC = 0x0185;
JUMP;
case 0x0123: mon("L0123 LDA <$ED ; 0123: 96 ED \n");
A = (UINT8)memory_DP[0xed];
N = A;
// Z = A;
// V = 0;
mon(" BMI $EF ; 0125: 2B C8 \n");
if ((SINT8)N < 0) {
PC = 0x00ef;
JUMP;
}
mon(" LDB <$0F ; 0127: D6 0F \n");
B = (UINT8)memory_DP[0x0f];
N = B;
Z = B;
V = 0;
mon(" LBNE $50 ; 0129: 10 26 FF 23 \n");
if (Z) {
PC = 0x0050;
JUMP;
}
mon(" DEC <$33 ; 012D: 0A 33 \n");
res = (UINT8)(memory_DP[0x33] - 1);
// N = res;
Z = res;
// V = memory_DP[0x33] & ~res;
memory_DP[0x33] = res;
mon(" BNE $011B ; 012F: 26 EA \n");
if (Z) {
PC = 0x011b;
JUMP;
}
mon(" DEC <$32 ; 0131: 0A 32 \n");
res = (UINT8)(memory_DP[0x32] - 1);
// N = res;
Z = res;
// V = memory_DP[0x32] & ~res;
memory_DP[0x32] = res;
mon(" BNE $011B ; 0133: 26 E6 \n");
if (Z) {
PC = 0x011b;
JUMP;
}
mon(" LDD #$06FF ; 0135: CC 06 FF \n");
A = (UINT8)((0x06ff) >> 8);
B = (UINT8)((0x06ff) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD <$32 ; 0138: DD 32 \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x32] = A;
memory_DP[0x32 + 1] = B;
case 0x013A: mon("L013A JSR Wait_Recal ; 013A: BD F1 92 \n");
memory[--S] = 0x013d & 0xff; memory[--S] = 0x013d >> 8;
PC = 0xf192;
JUMP;
case 0x013D: mon("L013D JSR Read_Btns ; 013D: BD F1 BA \n");
memory[--S] = 0x0140 & 0xff; memory[--S] = 0x0140 >> 8;
PC = 0xf1ba;
JUMP;
case 0x0140: mon("L0140 JSR DP_to_C8 ; 0140: BD F1 AF \n");
memory[--S] = 0x0143 & 0xff; memory[--S] = 0x0143 >> 8;
PC = 0xf1af;
JUMP;
case 0x0143: mon("L0143 LDX <$32 ; 0143: 9E 32 \n");
X = ((memory_DP[0x32]<<8)|memory_DP[0x32 + 1]);
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LEAX -1,X ; 0145: 30 1F \n");
X = (X + 0xffff);
// Z = X;
mon(" STX <$32 ; 0147: 9F 32 \n");
Z = X;
// N = (X) >> 8;
// V = 0;
memory_DP[0x32] = (UINT8)((X) >> 8);
memory_DP[(UINT16)(0x32 + 1)] = (X) & 0xff;
mon(" BEQ $0150 ; 0149: 27 05 \n");
if (!Z) {
PC = 0x0150;
JUMP;
}
mon(" LDA Vec_Btn_State ; 014B: B6 C8 0F \n");
A = (UINT8)memory[0xc80f];
N = A;
Z = A;
V = 0;
mon(" BEQ $013A ; 014E: 27 EA \n");
if (!Z) {
PC = 0x013a;
JUMP;
}
case 0x0150: mon("L0150 JMP Cold_Start ; 0150: 7E F0 00 \n");
PC = 0xf000;
JUMP;
case 0x0153: mon("L0153 STA <$04 ; 0153: 97 04 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x04] = A;
mon(" LDD ,U++ ; 0155: EC C1 \n");
A = memory[U];
B = memory[(UINT16)((U)+1)];
// Z = A|B;
// N = A;
// V = 0;
U = U + 2;
mon(" JSR Moveto_d ; 0157: BD F3 12 \n");
memory[--S] = 0x015a & 0xff; memory[--S] = 0x015a >> 8;
PC = 0xf312;
JUMP;
case 0x015A: mon("L015A LDA #$3F ; 015A: 86 3F \n");
A = (UINT8)(SINT8)0x3f;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$04 ; 015C: 97 04 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x04] = A;
mon(" LDA $03,S ; 015E: A6 63 \n");
A = (UINT8)memory[(UINT16)(S + 0x0003)];
// N = A;
// Z = A;
// V = 0;
mon(" STA Vec_Misc_Count ; 0160: B7 C8 23 \n");
// Z = A;
// N = A;
// V = 0;
memory[0xc823] = A;
mon(" JSR Draw_Pat_VL ; 0163: BD F4 37 \n");
memory[--S] = 0x0166 & 0xff; memory[--S] = 0x0166 >> 8;
PC = 0xf437;
JUMP;
case 0x0166: mon("L0166 DEC $02,S ; 0166: 6A 62 \n");
res = (UINT8)(memory[(UINT16)(S + 0x0002)] - 1);
N = res;
Z = res;
V = memory[(UINT16)(S + 0x0002)] & ~res;
memory[(UINT16)(S + 0x0002)] = res;
mon(" RTS ; 0168: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0169: mon("L0169 LDD ,U++ ; 0169: EC C1 \n");
A = memory[U];
B = memory[(UINT16)((U)+1)];
// Z = A|B;
// N = A;
// V = 0;
U = U + 2;
mon(" PSHS X,B,A ; 016B: 34 16 \n");
memory[--S] = X & 0xff; memory[--S] = X >> 8;
memory[--S] = B;
memory[--S] = A;
case 0x016D: mon("L016D LDX $02,S ; 016D: AE 62 \n");
X = ((memory[(UINT16)(S + 0x0002)]<<8)|memory[(UINT16)(((UINT16)(S + 0x0002))+1)]);
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDA $C8CA ; 016F: B6 C8 CA \n");
A = (UINT8)memory[0xc8ca];
N = A;
Z = A;
V = 0;
mon(" BSR $0153 ; 0172: 8D DF \n");
memory[--S] = 0x0174 & 0xff; memory[--S] = 0x0174 >> 8;
PC = 0x0153;
JUMP;
case 0x0174: mon("L0174 BNE $016D ; 0174: 26 F7 \n");
if (Z) {
PC = 0x016d;
JUMP;
}
mon(" PULS A,B,X,PC ; 0176: 35 96 \n"); // ;(PUL? PC=RTS)
A = memory[S++];
B = memory[S++];
X = memory[S++]<<8;
X |= memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0178: mon("L0178 LDD ,U++ ; 0178: EC C1 \n");
A = memory[U];
B = memory[(UINT16)((U)+1)];
// Z = A|B;
// N = A;
// V = 0;
U = U + 2;
mon(" PSHS B,A ; 017A: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
case 0x017C: mon("L017C LDA $C8C9 ; 017C: B6 C8 C9 \n");
A = (UINT8)memory[0xc8c9];
N = A;
Z = A;
V = 0;
mon(" BSR $0153 ; 017F: 8D D2 \n");
memory[--S] = 0x0181 & 0xff; memory[--S] = 0x0181 >> 8;
PC = 0x0153;
JUMP;
case 0x0181: mon("L0181 BNE $017C ; 0181: 26 F9 \n");
if (Z) {
PC = 0x017c;
JUMP;
}
mon(" PULS A,B,PC ; 0183: 35 86 \n"); // ;(PUL? PC=RTS)
A = memory[S++];
B = memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0185: mon("L0185 INC <$24 ; 0185: 0C 24 \n");
res = (UINT8)(memory_DP[0x24] + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0x24]);
memory_DP[0x24] = res;
mon(" JSR Wait_Recal ; 0187: BD F1 92 \n");
memory[--S] = 0x018a & 0xff; memory[--S] = 0x018a >> 8;
PC = 0xf192;
JUMP;
case 0x018A: mon("L018A JSR Do_Sound ; 018A: BD F2 89 \n");
memory[--S] = 0x018d & 0xff; memory[--S] = 0x018d >> 8;
PC = 0xf289;
JUMP;
case 0x018D: mon("L018D JSR Intensity_5F ; 018D: BD F2 A5 \n");
memory[--S] = 0x0190 & 0xff; memory[--S] = 0x0190 >> 8;
PC = 0xf2a5;
JUMP;
case 0x0190: mon("L0190 LDX #$0E18 ; 0190: 8E 0E 18 \n");
X = 0x0e18;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDU #$0EA4 ; 0193: CE 0E A4 \n");
U = 0x0ea4;
Z = U;
N = (U) >> 8;
V = 0;
mon(" BSR $0178 ; 0196: 8D E0 \n");
memory[--S] = 0x0198 & 0xff; memory[--S] = 0x0198 >> 8;
PC = 0x0178;
JUMP;
case 0x0198: mon("L0198 LDX #$0E60 ; 0198: 8E 0E 60 \n");
X = 0x0e60;
Z = X;
N = (X) >> 8;
V = 0;
mon(" BSR $0169 ; 019B: 8D CC \n");
memory[--S] = 0x019d & 0xff; memory[--S] = 0x019d >> 8;
PC = 0x0169;
JUMP;
case 0x019D: mon("L019D LEAX $0C,X ; 019D: 30 0C \n");
X = (X + 0x000c);
Z = X;
mon(" BSR $0169 ; 019F: 8D C8 \n");
memory[--S] = 0x01a1 & 0xff; memory[--S] = 0x01a1 >> 8;
PC = 0x0169;
JUMP;
case 0x01A1: mon("L01A1 LEAX $08,X ; 01A1: 30 08 \n");
X = (X + 0x0008);
Z = X;
mon(" BSR $0178 ; 01A3: 8D D3 \n");
memory[--S] = 0x01a5 & 0xff; memory[--S] = 0x01a5 >> 8;
PC = 0x0178;
JUMP;
case 0x01A5: mon("L01A5 CLR Vec_0Ref_Enable ; 01A5: 7F C8 24 \n");
memory[0xc824] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LEAS -10,S ; 01A8: 32 76 \n");
S = (S + 0xfff6);
mon(" LDU #$C900 ; 01AA: CE C9 00 \n");
U = 0xc900;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDD #$038F ; 01AD: CC 03 8F \n");
A = (UINT8)((0x038f) >> 8);
B = (UINT8)((0x038f) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD ,S ; 01B0: ED E4 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[S] = A;
memory[S + 1] = B;
mon(" LDD #$0275 ; 01B2: CC 02 75 \n");
A = (UINT8)((0x0275) >> 8);
B = (UINT8)((0x0275) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD $02,S ; 01B5: ED 62 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0002)] = A;
memory[(UINT16)(S + 0x0002) + 1] = B;
mon(" LDA $C881 ; 01B7: B6 C8 81 \n");
A = (UINT8)memory[0xc881];
// N = A;
// Z = A;
// V = 0;
mon(" LDB #$40 ; 01BA: C6 40 \n");
B = (UINT8)(SINT8)0x40;
// N = B;
// Z = B;
// V = 0;
mon(" JSR $0381 ; 01BC: BD 03 81 \n");
memory[--S] = 0x01bf & 0xff; memory[--S] = 0x01bf >> 8;
PC = 0x0381;
JUMP;
case 0x01BF: mon("L01BF LDU #$CA00 ; 01BF: CE CA 00 \n");
U = 0xca00;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDD #$02E6 ; 01C2: CC 02 E6 \n");
A = (UINT8)((0x02e6) >> 8);
B = (UINT8)((0x02e6) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD $02,S ; 01C5: ED 62 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0002)] = A;
memory[(UINT16)(S + 0x0002) + 1] = B;
mon(" LDA $C8C8 ; 01C7: B6 C8 C8 \n");
A = (UINT8)memory[0xc8c8];
// N = A;
// Z = A;
// V = 0;
mon(" LDB #$27 ; 01CA: C6 27 \n");
B = (UINT8)(SINT8)0x27;
// N = B;
// Z = B;
// V = 0;
mon(" JSR $0381 ; 01CC: BD 03 81 \n");
memory[--S] = 0x01cf & 0xff; memory[--S] = 0x01cf >> 8;
PC = 0x0381;
JUMP;
case 0x01CF: mon("L01CF LDU #$C9C0 ; 01CF: CE C9 C0 \n");
U = 0xc9c0;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDD #$02B2 ; 01D2: CC 02 B2 \n");
A = (UINT8)((0x02b2) >> 8);
B = (UINT8)((0x02b2) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD $02,S ; 01D5: ED 62 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0002)] = A;
memory[(UINT16)(S + 0x0002) + 1] = B;
mon(" LDY #$CA56 ; 01D7: 10 8E CA 56 \n");
Y = 0xca56;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
mon(" LDD #$0807 ; 01DB: CC 08 07 \n");
A = (UINT8)((0x0807) >> 8);
B = (UINT8)((0x0807) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" JSR $0381 ; 01DE: BD 03 81 \n");
memory[--S] = 0x01e1 & 0xff; memory[--S] = 0x01e1 >> 8;
PC = 0x0381;
JUMP;
case 0x01E1: mon("L01E1 LDU #$C894 ; 01E1: CE C8 94 \n");
U = 0xc894;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDD #$0308 ; 01E4: CC 03 08 \n");
A = (UINT8)((0x0308) >> 8);
B = (UINT8)((0x0308) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD $02,S ; 01E7: ED 62 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0002)] = A;
memory[(UINT16)(S + 0x0002) + 1] = B;
mon(" LDA #$01 ; 01E9: 86 01 \n");
A = (UINT8)(SINT8)0x01;
// N = A;
// Z = A;
// V = 0;
mon(" JSR $0381 ; 01EB: BD 03 81 \n");
memory[--S] = 0x01ee & 0xff; memory[--S] = 0x01ee >> 8;
PC = 0x0381;
JUMP;
case 0x01EE: mon("L01EE LDD #$0CA3 ; 01EE: CC 0C A3 \n");
A = (UINT8)((0x0ca3) >> 8);
B = (UINT8)((0x0ca3) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD ,S ; 01F1: ED E4 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[S] = A;
memory[S + 1] = B;
mon(" LDX #$CA8A ; 01F3: 8E CA 8A \n");
X = 0xca8a;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDU #$C8E5 ; 01F6: CE C8 E5 \n");
U = 0xc8e5;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDA $C8C8 ; 01F9: B6 C8 C8 \n");
A = (UINT8)memory[0xc8c8];
// N = A;
// Z = A;
// V = 0;
mon(" JSR $0381 ; 01FC: BD 03 81 \n");
memory[--S] = 0x01ff & 0xff; memory[--S] = 0x01ff >> 8;
PC = 0x0381;
JUMP;
case 0x01FF: mon("L01FF LDD #$7E7F ; 01FF: CC 7E 7F \n");
A = (UINT8)((0x7e7f) >> 8);
B = (UINT8)((0x7e7f) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STB <$04 ; 0202: D7 04 \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0x04] = B;
mon(" JSR Intensity_a ; 0204: BD F2 AB \n");
memory[--S] = 0x0207 & 0xff; memory[--S] = 0x0207 >> 8;
PC = 0xf2ab;
JUMP;
case 0x0207: mon("L0207 LDA $C8E9 ; 0207: B6 C8 E9 \n");
A = (UINT8)memory[0xc8e9];
N = A;
// Z = A;
// V = 0;
mon(" BMI $021A ; 020A: 2B 0E \n");
if ((SINT8)N < 0) {
PC = 0x021a;
JUMP;
}
mon(" LDA $C8C8 ; 020C: B6 C8 C8 \n");
A = (UINT8)memory[0xc8c8];
// N = A;
// Z = A;
// V = 0;
mon(" LDX #Print_Str_yx ; 020F: 8E F3 78 \n");
X = 0xf378;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" STX ,S ; 0212: AF E4 \n");
// Z = X;
// N = (X) >> 8;
// V = 0;
memory[S] = (UINT8)((X) >> 8);
memory[(UINT16)(S + 1)] = (X) & 0xff;
mon(" LDU #$CA88 ; 0214: CE CA 88 \n");
U = 0xca88;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" JSR $0381 ; 0217: BD 03 81 \n");
memory[--S] = 0x021a & 0xff; memory[--S] = 0x021a >> 8;
PC = 0x0381;
JUMP;
case 0x021A: mon("L021A LEAS $0A,S ; 021A: 32 6A \n");
S = (S + 0x000a);
mon(" LDA $C8E9 ; 021C: B6 C8 E9 \n");
A = (UINT8)memory[0xc8e9];
N = A;
// Z = A;
// V = 0;
mon(" BMI $0237 ; 021F: 2B 16 \n");
if ((SINT8)N < 0) {
PC = 0x0237;
JUMP;
}
mon(" LDX #$78EF ; 0221: 8E 78 EF \n");
X = 0x78ef;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDB $C8E2 ; 0224: F6 C8 E2 \n");
B = (UINT8)memory[0xc8e2];
// N = B;
// Z = B;
// V = 0;
mon(" LDA #$60 ; 0227: 86 60 \n");
A = (UINT8)(SINT8)0x60;
// N = A;
// Z = A;
// V = 0;
mon(" JSR Print_Ships ; 0229: BD F3 93 \n");
memory[--S] = 0x022c & 0xff; memory[--S] = 0x022c >> 8;
PC = 0xf393;
JUMP;
case 0x022C: mon("L022C LDA $C8ED ; 022C: B6 C8 ED \n");
A = (UINT8)memory[0xc8ed];
// N = A;
Z = A;
// V = 0;
mon(" BNE $0237 ; 022F: 26 06 \n");
if (Z) {
PC = 0x0237;
JUMP;
}
mon(" LDU #$0FF4 ; 0231: CE 0F F4 \n");
U = 0x0ff4;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" JSR Print_Str_yx ; 0234: BD F3 78 \n");
memory[--S] = 0x0237 & 0xff; memory[--S] = 0x0237 >> 8;
PC = 0xf378;
JUMP;
case 0x0237: mon("L0237 LDA $C8F0 ; 0237: B6 C8 F0 \n");
A = (UINT8)memory[0xc8f0];
// N = A;
// Z = A;
// V = 0;
mon(" JSR Read_Btns_Mask ; 023A: BD F1 B4 \n");
memory[--S] = 0x023d & 0xff; memory[--S] = 0x023d >> 8;
PC = 0xf1b4;
JUMP;
case 0x023D: mon("L023D JSR Joy_Digital ; 023D: BD F1 F8 \n");
memory[--S] = 0x0240 & 0xff; memory[--S] = 0x0240 >> 8;
PC = 0xf1f8;
JUMP;
case 0x0240: mon("L0240 LDA $C8C8 ; 0240: B6 C8 C8 \n");
A = (UINT8)memory[0xc8c8];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $026F ; 0243: 27 2A \n");
if (!Z) {
PC = 0x026f;
JUMP;
}
mon(" LDX #$CA4E ; 0245: 8E CA 4E \n");
X = 0xca4e;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDU #Vec_Button_1_1 ; 0248: CE C8 12 \n");
U = 0xc812;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDY #Vec_Joy_1_X ; 024B: 10 8E C8 1B \n");
Y = 0xc81b;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
case 0x024F: mon("L024F PSHS X,A ; 024F: 34 12 \n");
memory[--S] = X & 0xff; memory[--S] = X >> 8;
memory[--S] = A;
mon(" LDD ,U++ ; 0251: EC C1 \n");
A = memory[U];
B = memory[(UINT16)((U)+1)];
// Z = A|B;
// N = A;
// V = 0;
U = U + 2;
mon(" STD ,X+ ; 0253: ED 80 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[X] = A;
memory[X + 1] = B;
X = X + 1;
mon(" LDD ,U++ ; 0255: EC C1 \n");
A = memory[U];
B = memory[(UINT16)((U)+1)];
// Z = A|B;
// N = A;
// V = 0;
U = U + 2;
mon(" STD $01,X ; 0257: ED 01 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0001)] = A;
memory[(UINT16)(X + 0x0001) + 1] = B;
mon(" CLRB ; 0259: 5F \n");
B = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" LDA ,Y++ ; 025A: A6 A1 \n");
A = (UINT8)memory[Y];
// N = A;
Z = A;
// V = 0;
Y = Y + 2;
mon(" BEQ $0268 ; 025C: 27 0A \n");
if (!Z) {
PC = 0x0268;
JUMP;
}
mon(" ROLA ; 025E: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" ROLB ; 025F: 59 \n");
res = ((B) << 1) + (C != 0 ?1:0);
// C = res & 0x100;
Z = (UINT8)res;
// N = res;
// V = res ^ (B);
B = (UINT8)res;
mon(" BEQ $0264 ; 0260: 27 02 \n");
if (!Z) {
PC = 0x0264;
JUMP;
}
mon(" COMA ; 0262: 43 \n");
A = A ^ 0xff;
// Z = A;
// N = A;
// V = 0;
// C = 256;
mon(" NEGB ; 0263: 50 \n");
// V = (UINT8)(-B) & (B);
C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
case 0x0264: mon("L0264 ORA B,X ; 0264: AA 85 \n");
A = A | memory[(UINT16)(X + (SINT8)B)];
// Z = A;
// N = A;
// V = 0;
mon(" STA B,X ; 0266: A7 85 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + (SINT8)B)] = A;
case 0x0268: mon("L0268 PULS A,X ; 0268: 35 12 \n");
A = memory[S++];
X = memory[S++]<<8;
X |= memory[S++];
mon(" LEAX $04,X ; 026A: 30 04 \n");
X = (X + 0x0004);
// Z = X;
mon(" DECA ; 026C: 4A \n");
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
mon(" BNE $024F ; 026D: 26 E0 \n");
if (Z) {
PC = 0x024f;
JUMP;
}
case 0x026F: mon("L026F JSR Reset0Ref ; 026F: BD F3 54 \n");
memory[--S] = 0x0272 & 0xff; memory[--S] = 0x0272 >> 8;
PC = 0xf354;
JUMP;
case 0x0272: mon("L0272 JMP DP_to_C8 ; 0272: 7E F1 AF \n");
PC = 0xf1af;
JUMP;
// FCB $30 ; 0275: '0' 30 4E LEAX 14,U
// FCB $4E ; 0276: 'N' 4E Invalid
// FCB $BD ; 0277: ' ' BD F3 0C JSR $F30C
// FCB $F3 ; 0278: ' ' F3 0C 30 ADDD $0C30
// FCB $0C ; 0279: ' ' 0C 30 INC <$30
// FCB $30 ; 027A: '0' 30 03 LEAX 3,X
// FCB $03 ; 027B: ' ' 03 C6 COM <$C6
// FCB $C6 ; 027C: ' ' C6 30 LDB #$30
// FCB $30 ; 027D: '0' 30 BD F4 0E LEAX [$F40E,PC]
// FCB $BD ; 027E: ' ' BD F4 0E JSR $F40E
// FCB $F4 ; 027F: ' ' F4 0E 30 ANDB $0E30
// FCB $0E ; 0280: ' ' 0E 30 JMP <$30
// FCB $30 ; 0281: '0' 30 C8 26 LEAX $26,U
// FCB $C8 ; 0282: ' ' C8 26 EORB #$26
// FCB $26 ; 0283: '&' 26 C6 BNE $024B
// FCB $C6 ; 0284: ' ' C6 20 LDB #$20
// FCB $20 ; 0285: ' ' 20 BD BRA $0244
// FCB $BD ; 0286: ' ' BD F4 0E JSR $F40E
// FCB $F4 ; 0287: ' ' F4 0E A6 ANDB $0EA6
// FCB $0E ; 0288: ' ' 0E A6 JMP <$A6
// FCB $A6 ; 0289: ' ' A6 C4 LDA ,U
// FCB $C4 ; 028A: ' ' C4 2A ANDB #$2A
// FCB $2A ; 028B: '*' 2A 22 BPL $02AF
// FCB $22 ; 028C: '"' 22 BD BHI $024B
// FCB $BD ; 028D: ' ' BD F3 54 JSR $F354
// FCB $F3 ; 028E: ' ' F3 54 BD ADDD $54BD
// FCB $54 ; 028F: 'T' 54 LSRB
// FCB $BD ; 0290: ' ' BD F2 A9 JSR $F2A9
// FCB $F2 ; 0291: ' ' F2 A9 30 SBCB $A930
// FCB $A9 ; 0292: ' ' A9 30 ADCA -16,Y
// FCB $30 ; 0293: '0' 30 4E LEAX 14,U
// FCB $4E ; 0294: 'N' 4E Invalid
// FCB $BD ; 0295: ' ' BD F3 0C JSR $F30C
// FCB $F3 ; 0296: ' ' F3 0C AE ADDD $0CAE
// FCB $0C ; 0297: ' ' 0C AE INC <$AE
// FCB $AE ; 0298: ' ' AE 4A LDX 10,U
// FCB $4A ; 0299: 'J' 4A DECA
// FCB $E6 ; 029A: ' ' E6 4D LDB 13,U
// FCB $4D ; 029B: 'M' 4D TSTA
// FCB $86 ; 029C: ' ' 86 06 LDA #$06
// FCB $06 ; 029D: ' ' 06 3D ROR <$3D
// FCB $3D ; 029E: '=' 3D MUL
// FCB $3A ; 029F: ':' 3A ABX
// FCB $E6 ; 02A0: ' ' E6 4C LDB 12,U
// FCB $4C ; 02A1: 'L' 4C INCA
// FCB $BD ; 02A2: ' ' BD F3 0E JSR $F30E
// FCB $F3 ; 02A3: ' ' F3 0E 86 ADDD $0E86
// FCB $0E ; 02A4: ' ' 0E 86 JMP <$86
// FCB $86 ; 02A5: ' ' 86 01 LDA #$01
// FCB $01 ; 02A6: ' ' 01 Invalid
// FCB $E6 ; 02A7: ' ' E6 4C LDB 12,U
// FCB $4C ; 02A8: 'L' 4C INCA
// FCB $BD ; 02A9: ' ' BD F3 D8 JSR $F3D8
// FCB $F3 ; 02AA: ' ' F3 D8 BD ADDD $D8BD
// FCB $D8 ; 02AB: ' ' D8 BD EORB <$BD
// FCB $BD ; 02AC: ' ' BD F2 A5 JSR $F2A5
// FCB $F2 ; 02AD: ' ' F2 A5 7E SBCB $A57E
// FCB $A5 ; 02AE: ' ' A5 7E BITA -2,S
// FCB $7E ; 02AF: '~' 7E F3 54 JMP $F354
// FCB $F3 ; 02B0: ' ' F3 54 30 ADDD $5430
// FCB $54 ; 02B1: 'T' 54 LSRB
// FCB $30 ; 02B2: '0' 30 41 LEAX 1,U
// FCB $41 ; 02B3: 'A' 41 Invalid
// FCB $BD ; 02B4: ' ' BD F3 0C JSR $F30C
// FCB $F3 ; 02B5: ' ' F3 0C E6 ADDD $0CE6
// FCB $0C ; 02B6: ' ' 0C E6 INC <$E6
// FCB $E6 ; 02B7: ' ' E6 C4 LDB ,U
// FCB $C4 ; 02B8: ' ' C4 2B ANDB #$2B
// FCB $2B ; 02B9: '+' 2B 12 BMI $02CD
// FCB $12 ; 02BA: ' ' 12 NOP
// FCB $EC ; 02BB: ' ' EC 43 LDD 3,U
// FCB $43 ; 02BC: 'C' 43 COMA
// FCB $B7 ; 02BD: ' ' B7 C8 28 STA $C828
// FCB $C8 ; 02BE: ' ' C8 28 EORB #$28
// FCB $28 ; 02BF: '(' 28 D7 BVC $0298
// FCB $D7 ; 02C0: ' ' D7 04 STB <$04
// FCB $04 ; 02C1: ' ' 04 86 LSR <$86
// FCB $86 ; 02C2: ' ' 86 03 LDA #$03
// FCB $03 ; 02C3: ' ' 03 B7 COM <$B7
// FCB $B7 ; 02C4: ' ' B7 C8 23 STA $C823
// FCB $C8 ; 02C5: ' ' C8 23 EORB #$23
// FCB $23 ; 02C6: '#' 23 AE BLS $0276
// FCB $AE ; 02C7: ' ' AE 45 LDX 5,U
// FCB $45 ; 02C8: 'E' 45 Invalid
// FCB $BD ; 02C9: ' ' BD F2 D5 JSR $F2D5
// FCB $F2 ; 02CA: ' ' F2 D5 39 SBCB $D539
// FCB $D5 ; 02CB: ' ' D5 39 BITB <$39
// FCB $39 ; 02CC: '9' 39 RTS
// FCB $5C ; 02CD: '\' 5C INCB
// FCB $2B ; 02CE: '+' 2B 0A BMI $02DA
// FCB $0A ; 02CF: ' ' 0A 86 DEC <$86
// FCB $86 ; 02D0: ' ' 86 08 LDA #$08
// FCB $08 ; 02D1: ' ' 08 B7 ASL <$B7
// FCB $B7 ; 02D2: ' ' B7 C8 28 STA $C828
// FCB $C8 ; 02D3: ' ' C8 28 EORB #$28
// FCB $28 ; 02D4: '(' 28 BD BVC $0293
// FCB $BD ; 02D5: ' ' BD F2 C5 JSR $F2C5
// FCB $F2 ; 02D6: ' ' F2 C5 20 SBCB $C520
// FCB $C5 ; 02D7: ' ' C5 20 BITB #$20
// FCB $20 ; 02D8: ' ' 20 08 BRA $02E2
// FCB $08 ; 02D9: ' ' 08 CC ASL <$CC
// FCB $CC ; 02DA: ' ' CC 04 28 LDD #$0428
// FCB $04 ; 02DB: ' ' 04 28 LSR <$28
// FCB $28 ; 02DC: '(' 28 30 BVC $030E
// FCB $30 ; 02DD: '0' 30 A4 LEAX ,Y
// FCB $A4 ; 02DE: ' ' A4 BD F3 D8 ANDA [$F3D8,PC]
// FCB $BD ; 02DF: ' ' BD F3 D8 JSR $F3D8
// FCB $F3 ; 02E0: ' ' F3 D8 BD ADDD $D8BD
// FCB $D8 ; 02E1: ' ' D8 BD EORB <$BD
// FCB $BD ; 02E2: ' ' BD F3 54 JSR $F354
// FCB $F3 ; 02E3: ' ' F3 54 39 ADDD $5439
// FCB $54 ; 02E4: 'T' 54 LSRB
// FCB $39 ; 02E5: '9' 39 RTS
// FCB $30 ; 02E6: '0' 30 46 LEAX 6,U
// FCB $46 ; 02E7: 'F' 46 RORA
// FCB $BD ; 02E8: ' ' BD F2 F2 JSR $F2F2
// FCB $F2 ; 02E9: ' ' F2 F2 A6 SBCB $F2A6
// FCB $F2 ; 02EA: ' ' F2 A6 C4 SBCB $A6C4
// FCB $A6 ; 02EB: ' ' A6 C4 LDA ,U
// FCB $C4 ; 02EC: ' ' C4 2A ANDB #$2A
// FCB $2A ; 02ED: '*' 2A 12 BPL $0301
// FCB $12 ; 02EE: ' ' 12 NOP
// FCB $E6 ; 02EF: ' ' E6 43 LDB 3,U
// FCB $43 ; 02F0: 'C' 43 COMA
// FCB $D7 ; 02F1: ' ' D7 04 STB <$04
// FCB $04 ; 02F2: ' ' 04 8E LSR <$8E
// FCB $8E ; 02F3: ' ' 8E CA 9A LDX #$CA9A
// FCB $CA ; 02F4: ' ' CA 9A ORB #$9A
// FCB $9A ; 02F5: ' ' 9A 86 ORA <$86
// FCB $86 ; 02F6: ' ' 86 0B LDA #$0B
// FCB $0B ; 02F7: ' ' 0B Invalid
// FCB $B7 ; 02F8: ' ' B7 C8 23 STA $C823
// FCB $C8 ; 02F9: ' ' C8 23 EORB #$23
// FCB $23 ; 02FA: '#' 23 BD BLS $02B9
// FCB $BD ; 02FB: ' ' BD F3 DA JSR $F3DA
// FCB $F3 ; 02FC: ' ' F3 DA 7E ADDD $DA7E
// FCB $DA ; 02FD: ' ' DA 7E ORB <$7E
// FCB $7E ; 02FE: '~' 7E F3 54 JMP $F354
// FCB $F3 ; 02FF: ' ' F3 54 30 ADDD $5430
// FCB $54 ; 0300: 'T' 54 LSRB
// FCB $30 ; 0301: '0' 30 4B LEAX 11,U
// FCB $4B ; 0302: 'K' 4B Invalid
// FCB $C6 ; 0303: ' ' C6 28 LDB #$28
// FCB $28 ; 0304: '(' 28 7E BVC $0384
// FCB $7E ; 0305: '~' 7E 0C 9D JMP $0C9D
// FCB $0C ; 0306: ' ' 0C 9D INC <$9D
// FCB $9D ; 0307: ' ' 9D 30 JSR <$30
// FCB $30 ; 0308: '0' 30 49 LEAX 9,U
// FCB $49 ; 0309: 'I' 49 ROLA
// FCB $EC ; 030A: ' ' EC 84 LDD ,X
// FCB $84 ; 030B: ' ' 84 AB ANDA #$AB
// FCB $AB ; 030C: ' ' AB 02 ADDA 2,X
// FCB $02 ; 030D: ' ' 02 Invalid
// FCB $29 ; 030E: ')' 29 04 BVS $0314
// FCB $04 ; 030F: ' ' 04 EB LSR <$EB
// FCB $EB ; 0310: ' ' EB 03 ADDB 3,X
// FCB $03 ; 0311: ' ' 03 28 COM <$28
// FCB $28 ; 0312: '(' 28 01 BVC $0315
// FCB $01 ; 0313: ' ' 01 Invalid
// FCB $39 ; 0314: '9' 39 RTS
// FCB $BD ; 0315: ' ' BD F3 0C JSR $F30C
// FCB $F3 ; 0316: ' ' F3 0C BD ADDD $0CBD
// FCB $0C ; 0317: ' ' 0C BD INC <$BD
// FCB $BD ; 0318: ' ' BD F3 0C JSR $F30C
// FCB $F3 ; 0319: ' ' F3 0C 8E ADDD $0C8E
// FCB $0C ; 031A: ' ' 0C 8E INC <$8E
// FCB $8E ; 031B: ' ' 8E C8 A7 LDX #$C8A7
// FCB $C8 ; 031C: ' ' C8 A7 EORB #$A7
// FCB $A7 ; 031D: ' ' A7 A6 STA A,Y
// FCB $A6 ; 031E: ' ' A6 C4 LDA ,U
// FCB $C4 ; 031F: ' ' C4 2B ANDB #$2B
// FCB $2B ; 0320: '+' 2B 14 BMI $0336
// FCB $14 ; 0321: ' ' 14 Invalid
// FCB $C6 ; 0322: ' ' C6 20 LDB #$20
// FCB $20 ; 0323: ' ' 20 BD BRA $02E2
// FCB $BD ; 0324: ' ' BD F4 0E JSR $F40E
// FCB $F4 ; 0325: ' ' F4 0E C6 ANDB $0EC6
// FCB $0E ; 0326: ' ' 0E C6 JMP <$C6
// FCB $C6 ; 0327: ' ' C6 20 LDB #$20
// FCB $20 ; 0328: ' ' 20 D7 BRA $0301
// FCB $D7 ; 0329: ' ' D7 04 STB <$04
// FCB $04 ; 032A: ' ' 04 8E LSR <$8E
// FCB $8E ; 032B: ' ' 8E CA 9A LDX #$CA9A
// FCB $CA ; 032C: ' ' CA 9A ORB #$9A
// FCB $9A ; 032D: ' ' 9A E6 ORA <$E6
// FCB $E6 ; 032E: ' ' E6 45 LDB 5,U
// FCB $45 ; 032F: 'E' 45 Invalid
// FCB $86 ; 0330: ' ' 86 18 LDA #$18
// FCB $18 ; 0331: ' ' 18 Invalid
// FCB $3D ; 0332: '=' 3D MUL
// FCB $3A ; 0333: ':' 3A ABX
// FCB $20 ; 0334: ' ' 20 C0 BRA $02F6
// FCB $C0 ; 0335: ' ' C0 31 SUBB #$31
// FCB $31 ; 0336: '1' 31 5E LEAY -2,U
// FCB $5E ; 0337: '^' 5E Invalid
// FCB $CE ; 0338: ' ' CE CB 00 LDU #$CB00
// FCB $CB ; 0339: ' ' CB 00 ADDB #$00
// FCB $00 ; 033A: ' ' 00 A6 NEG <$A6
// FCB $A6 ; 033B: ' ' A6 A4 LDA ,Y
// FCB $A4 ; 033C: ' ' A4 1E ANDA -2,X
// FCB $1E ; 033D: ' ' 1E 31 EXG U,X
// FCB $31 ; 033E: '1' 31 BD F2 AB LEAY [$F2AB,PC]
// FCB $BD ; 033F: ' ' BD F2 AB JSR $F2AB
// FCB $F2 ; 0340: ' ' F2 AB E6 SBCB $ABE6
// FCB $AB ; 0341: ' ' AB E6 ADDA A,S
// FCB $E6 ; 0342: ' ' E6 21 LDB 1,Y
// FCB $21 ; 0343: '!' 21 58 BRN $039D
// FCB $58 ; 0344: 'X' 58 ASLB
// FCB $BD ; 0345: ' ' BD F3 0E JSR $F30E
// FCB $F3 ; 0346: ' ' F3 0E 1E ADDD $0E1E
// FCB $0E ; 0347: ' ' 0E 1E JMP <$1E
// FCB $1E ; 0348: ' ' 1E 13 EXG X,U
// FCB $13 ; 0349: ' ' 13 SYNC
// FCB $C6 ; 034A: ' ' C6 20 LDB #$20
// FCB $20 ; 034B: ' ' 20 BD BRA $030A
// FCB $BD ; 034C: ' ' BD F4 0E JSR $F40E
// FCB $F4 ; 034D: ' ' F4 0E E6 ANDB $0EE6
// FCB $0E ; 034E: ' ' 0E E6 JMP <$E6
// FCB $E6 ; 034F: ' ' E6 21 LDB 1,Y
// FCB $21 ; 0350: '!' 21 1E BRN $0370
// FCB $1E ; 0351: ' ' 1E 31 EXG U,X
// FCB $31 ; 0352: '1' 31 BD F3 0E LEAY [$F30E,PC]
// FCB $BD ; 0353: ' ' BD F3 0E JSR $F30E
// FCB $F3 ; 0354: ' ' F3 0E 1E ADDD $0E1E
// FCB $0E ; 0355: ' ' 0E 1E JMP <$1E
// FCB $1E ; 0356: ' ' 1E 13 EXG X,U
// FCB $13 ; 0357: ' ' 13 SYNC
// FCB $E6 ; 0358: ' ' E6 80 LDB ,X+
// FCB $80 ; 0359: ' ' 80 BD SUBA #$BD
// FCB $BD ; 035A: ' ' BD F4 0E JSR $F40E
// FCB $F4 ; 035B: ' ' F4 0E 8E ANDB $0E8E
// FCB $0E ; 035C: ' ' 0E 8E JMP <$8E
// FCB $8E ; 035D: ' ' 8E CA 9A LDX #$CA9A
// FCB $CA ; 035E: ' ' CA 9A ORB #$9A
// FCB $9A ; 035F: ' ' 9A E6 ORA <$E6
// FCB $E6 ; 0360: ' ' E6 27 LDB 7,Y
// FCB $27 ; 0361: ''' 27 86 BEQ $02E9
// FCB $86 ; 0362: ' ' 86 18 LDA #$18
// FCB $18 ; 0363: ' ' 18 Invalid
// FCB $3D ; 0364: '=' 3D MUL
// FCB $3A ; 0365: ':' 3A ABX
// FCB $C6 ; 0366: ' ' C6 04 LDB #$04
// FCB $04 ; 0367: ' ' 04 E7 LSR <$E7
// FCB $E7 ; 0368: ' ' E7 7B STB -5,S
// FCB $7B ; 0369: '{' 7B Invalid
// FCB $E6 ; 036A: ' ' E6 21 LDB 1,Y
// FCB $21 ; 036B: '!' 21 D7 BRN $0344
// FCB $D7 ; 036C: ' ' D7 04 STB <$04
// FCB $04 ; 036D: ' ' 04 EC LSR <$EC
// FCB $EC ; 036E: ' ' EC C1 LDD ,U++
// FCB $C1 ; 036F: ' ' C1 BD CMPB #$BD
// FCB $BD ; 0370: ' ' BD F3 12 JSR $F312
// FCB $F3 ; 0371: ' ' F3 12 C6 ADDD $12C6
// FCB $12 ; 0372: ' ' 12 NOP
// FCB $C6 ; 0373: ' ' C6 20 LDB #$20
// FCB $20 ; 0374: ' ' 20 86 BRA $02FC
// FCB $86 ; 0375: ' ' 86 02 LDA #$02
// FCB $02 ; 0376: ' ' 02 Invalid
// FCB $BD ; 0377: ' ' BD F3 D8 JSR $F3D8
// FCB $F3 ; 0378: ' ' F3 D8 6A ADDD $D86A
// FCB $D8 ; 0379: ' ' D8 6A EORB <$6A
// FCB $6A ; 037A: 'j' 6A 7B DEC -5,S
// FCB $7B ; 037B: '{' 7B Invalid
// FCB $26 ; 037C: '&' 26 EC BNE $036A
// FCB $EC ; 037D: ' ' EC 7E LDD -2,S
// FCB $7E ; 037E: '~' 7E F3 54 JMP $F354
// FCB $F3 ; 037F: ' ' F3 54 34 ADDD $5434
// FCB $54 ; 0380: 'T' 54 LSRB
case 0x0381: mon("L0381 PSHS B,A ; 0381: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
mon(" TSTA ; 0383: 4D \n");
Z = A;
// N = A;
// V = 0;
mon(" BEQ $038D ; 0384: 27 07 \n");
if (!Z) {
PC = 0x038d;
JUMP;
}
case 0x0386: mon("L0386 JSR [$04,S] ; 0386: AD F8 04 \n");
memory[--S] = 0x0389 & 0xff; memory[--S] = 0x0389 >> 8;
PC = ((memory[(UINT16)(S + (SINT8)0x04)]<<8)|memory[(UINT16)(S + (SINT8)0x04 + 1)]);
JUMP;
case 0x0389: mon("L0389 DEC ,S ; 0389: 6A E4 \n");
res = (UINT8)(memory[S] - 1);
N = res;
Z = res;
V = memory[S] & ~res;
memory[S] = res;
mon(" BNE $0386 ; 038B: 26 F9 \n");
if (Z) {
PC = 0x0386;
JUMP;
}
case 0x038D: mon("L038D PULS A,B,PC ; 038D: 35 86 \n"); // ;(PUL? PC=RTS)
A = memory[S++];
B = memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
// FCB $A6 ; 038F: ' ' A6 C4 LDA ,U
// FCB $C4 ; 0390: ' ' C4 27 ANDB #$27
// FCB $27 ; 0391: ''' 27 03 BEQ $0396
// FCB $03 ; 0392: ' ' 03 AD COM <$AD
// FCB $AD ; 0393: ' ' AD F8 08 JSR [$08,S]
// FCB $F8 ; 0394: ' ' F8 08 E6 EORB $08E6
// FCB $08 ; 0395: ' ' 08 E6 ASL <$E6
// FCB $E6 ; 0396: ' ' E6 63 LDB 3,S
// FCB $63 ; 0397: 'c' 63 33 COM -13,Y
// FCB $33 ; 0398: '3' 33 C5 LEAU B,U
// FCB $C5 ; 0399: ' ' C5 31 BITB #$31
// FCB $31 ; 039A: '1' 31 2A LEAY 10,Y
// FCB $2A ; 039B: '*' 2A 39 BPL $03D6
// FCB $39 ; 039C: '9' 39 RTS
case 0x039D: mon("L039D LDA #$FC ; 039D: 86 FC \n");
A = (UINT8)(SINT8)0xfc;
// N = A;
// Z = A;
// V = 0;
mon(" ANDA <$67 ; 039F: 94 67 \n");
A = A & memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
mon(" STA <$67 ; 03A1: 97 67 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
mon(" LDA <$2F ; 03A3: 96 2F \n");
A = (UINT8)memory_DP[0x2f];
N = A;
Z = A;
V = 0;
mon(" LBEQ $0448 ; 03A5: 10 27 00 9F \n");
if (!Z) {
PC = 0x0448;
JUMP;
}
mon(" DEC <$2F ; 03A9: 0A 2F \n");
res = (UINT8)(memory_DP[0x2f] - 1);
// N = res;
Z = res;
// V = memory_DP[0x2f] & ~res;
memory_DP[0x2f] = res;
mon(" BNE $03E9 ; 03AB: 26 3C \n");
if (Z) {
PC = 0x03e9;
JUMP;
}
mon(" COM <$8A ; 03AD: 03 8A \n");
memory_DP[0x8a] = memory_DP[0x8a] ^ 0xff;
// Z = memory_DP[0x8a];
// N = memory_DP[0x8a];
// V = 0;
// C = 256;
mon(" LDX #$CB00 ; 03AF: 8E CB 00 \n");
X = 0xcb00;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDU #$0E6C ; 03B2: CE 0E 6C \n");
U = 0x0e6c;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDA #$04 ; 03B5: 86 04 \n");
A = (UINT8)(SINT8)0x04;
// N = A;
// Z = A;
// V = 0;
mon(" PSHS A ; 03B7: 34 02 \n");
memory[--S] = A;
case 0x03B9: mon("L03B9 LDD #$0408 ; 03B9: CC 04 08 \n");
A = (UINT8)((0x0408) >> 8);
B = (UINT8)((0x0408) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" JSR $0CE1 ; 03BC: BD 0C E1 \n");
memory[--S] = 0x03bf & 0xff; memory[--S] = 0x03bf >> 8;
PC = 0x0ce1;
JUMP;
case 0x03BF: mon("L03BF DEC ,S ; 03BF: 6A E4 \n");
res = (UINT8)(memory[S] - 1);
// N = res;
Z = res;
// V = memory[S] & ~res;
memory[S] = res;
mon(" BNE $03B9 ; 03C1: 26 F6 \n");
if (Z) {
PC = 0x03b9;
JUMP;
}
mon(" PULS A ; 03C3: 35 02 \n");
A = memory[S++];
mon(" LDA <$80 ; 03C5: 96 80 \n");
A = (UINT8)memory_DP[0x80];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$88 ; 03C7: 97 88 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x88] = A;
mon(" CMPA #$01 ; 03C9: 81 01 \n");
res = A - (SINT8)0x01;
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ (SINT8)0x01) & (A ^ (UINT8)res);
mon(" BNE $03D2 ; 03CB: 26 05 \n");
if (Z) {
PC = 0x03d2;
JUMP;
}
mon(" LDD #$01FD ; 03CD: CC 01 FD \n");
A = (UINT8)((0x01fd) >> 8);
B = (UINT8)((0x01fd) & 0xff);
Z = A|B;
N = A;
V = 0;
mon(" BRA $03D5 ; 03D0: 20 03 \n");
PC = 0x03d5;
JUMP;
case 0x03D2: mon("L03D2 LDD #$02FE ; 03D2: CC 02 FE \n");
A = (UINT8)((0x02fe) >> 8);
B = (UINT8)((0x02fe) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
case 0x03D5: mon("L03D5 STD <$EB ; 03D5: DD EB \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xeb] = A;
memory_DP[0xeb + 1] = B;
mon(" JSR $0CD4 ; 03D7: BD 0C D4 \n");
memory[--S] = 0x03da & 0xff; memory[--S] = 0x03da >> 8;
PC = 0x0cd4;
JUMP;
case 0x03DA: mon("L03DA LDA <$82 ; 03DA: 96 82 \n");
A = (UINT8)memory_DP[0x82];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$89 ; 03DC: 97 89 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x89] = A;
mon(" LDX #$C900 ; 03DE: 8E C9 00 \n");
X = 0xc900;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDB <$81 ; 03E1: D6 81 \n");
B = (UINT8)memory_DP[0x81];
// N = B;
// Z = B;
// V = 0;
mon(" STB <$8B ; 03E3: D7 8B \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0x8b] = B;
case 0x03E5: mon("L03E5 STB <$CD ; 03E5: D7 CD \n");
Z = B;
N = B;
V = 0;
memory_DP[0xcd] = B;
mon(" BNE $03EA ; 03E7: 26 01 \n");
if (Z) {
PC = 0x03ea;
JUMP;
}
case 0x03E9: mon("L03E9 RTS ; 03E9: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x03EA: mon("L03EA LDA #$09 ; 03EA: 86 09 \n");
A = (UINT8)(SINT8)0x09;
// N = A;
// Z = A;
// V = 0;
mon(" MUL ; 03EC: 3D \n");
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" LDU #$0D7C ; 03ED: CE 0D 7C \n");
U = 0x0d7c;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LEAU B,U ; 03F0: 33 C5 \n");
U = (U + (SINT8)B);
mon(" INCA ; 03F2: 4C \n");
res = (UINT8)(A + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
mon(" STA ,X+ ; 03F3: A7 80 \n");
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
X = X + 1;
mon(" LDA #$08 ; 03F5: 86 08 \n");
A = (UINT8)(SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
case 0x03F7: mon("L03F7 CLR ,X+ ; 03F7: 6F 80 \n");
memory[X] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
X = X + 1;
mon(" DECA ; 03F9: 4A \n");
res = (UINT8)(A - 1);
// N = res;
Z = res;
// V = A & ~res;
A = res;
mon(" BNE $03F7 ; 03FA: 26 FB \n");
if (Z) {
PC = 0x03f7;
JUMP;
}
mon(" JSR Random_3 ; 03FC: BD F5 11 \n");
memory[--S] = 0x03ff & 0xff; memory[--S] = 0x03ff >> 8;
PC = 0xf511;
JUMP;
case 0x03FF: mon("L03FF ANDA #$03 ; 03FF: 84 03 \n");
A = A & (SINT8)0x03;
// Z = A;
// N = A;
// V = 0;
mon(" STA ,X+ ; 0401: A7 80 \n");
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
X = X + 1;
mon(" LDA #$09 ; 0403: 86 09 \n");
A = (UINT8)(SINT8)0x09;
// N = A;
// Z = A;
// V = 0;
mon(" JSR $0CF6 ; 0405: BD 0C F6 \n");
memory[--S] = 0x0408 & 0xff; memory[--S] = 0x0408 >> 8;
PC = 0x0cf6;
JUMP;
case 0x0408: mon("L0408 LEAU -2,X ; 0408: 33 1E \n");
U = (X + 0xfffe);
mon(" LDA ,U ; 040A: A6 C4 \n");
A = (UINT8)memory[U];
// N = A;
Z = A;
// V = 0;
mon(" BNE $0410 ; 040C: 26 02 \n");
if (Z) {
PC = 0x0410;
JUMP;
}
mon(" LDA ,-U ; 040E: A6 C2 \n");
U = U - 1;
A = (UINT8)memory[U];
// N = A;
// Z = A;
// V = 0;
case 0x0410: mon("L0410 LDB <$88 ; 0410: D6 88 \n");
B = (UINT8)memory_DP[0x88];
// N = B;
// Z = B;
// V = 0;
mon(" MUL ; 0412: 3D \n");
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" NEGB ; 0413: 50 \n");
// V = (UINT8)(-B) & (B);
// C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
mon(" STB ,U ; 0414: E7 C4 \n");
// Z = B;
// N = B;
// V = 0;
memory[U] = B;
mon(" LDB -10,X ; 0416: E6 16 \n");
B = (UINT8)memory[(UINT16)(X + 0xfff6)];
// N = B;
Z = B;
// V = 0;
mon(" BEQ $0427 ; 0418: 27 0D \n");
if (!Z) {
PC = 0x0427;
JUMP;
}
mon(" LEAU -5,X ; 041A: 33 1B \n");
U = (X + 0xfffb);
mon(" COMA ; 041C: 43 \n");
A = A ^ 0xff;
// Z = A;
// N = A;
// V = 0;
// C = 256;
case 0x041D: mon("L041D NEGA ; 041D: 40 \n");
// V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
mon(" LEAU A,U ; 041E: 33 C6 \n");
U = (U + (SINT8)A);
mon(" NEG ,U ; 0420: 60 C4 \n");
// V = (UINT8)(-memory[U]) & (memory[U]);
// C = (-memory[U]) & 0x100;
memory[U] = (UINT8)(-memory[U]);
// Z = memory[U];
// N = memory[U];
mon(" NEG $02,U ; 0422: 60 42 \n");
// V = (UINT8)(-memory[(UINT16)(U + 0x0002)]) & (memory[(UINT16)(U + 0x0002)]);
// C = (-memory[(UINT16)(U + 0x0002)]) & 0x100;
memory[(UINT16)(U + 0x0002)] = (UINT8)(-memory[(UINT16)(U + 0x0002)]);
// Z = memory[(UINT16)(U + 0x0002)];
// N = memory[(UINT16)(U + 0x0002)];
mon(" DECB ; 0424: 5A \n");
res = (UINT8)(B - 1);
// N = res;
Z = res;
// V = B & ~res;
B = res;
mon(" BNE $041D ; 0425: 26 F6 \n");
if (Z) {
PC = 0x041d;
JUMP;
}
case 0x0427: mon("L0427 CLRA ; 0427: 4F \n");
A = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" TFR D,Y ; 0428: 1F 02 \n");
Y = ((A << 8) | B);
mon(" LDD -5,X ; 042A: EC 1B \n");
A = memory[(UINT16)(X + 0xfffb)];
B = memory[(UINT16)(((UINT16)(X + 0xfffb))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" JSR $0C80 ; 042C: BD 0C 80 \n");
memory[--S] = 0x042f & 0xff; memory[--S] = 0x042f >> 8;
PC = 0x0c80;
JUMP;
case 0x042F: mon("L042F STA -13,X ; 042F: A7 13 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfff3)] = A;
mon(" LDA -1,X ; 0431: A6 1F \n");
A = (UINT8)memory[(UINT16)(X + 0xffff)];
// N = A;
// Z = A;
// V = 0;
mon(" LEAU ,X ; 0433: 33 84 \n");
U = X;
mon(" LDX #$0EC8 ; 0435: 8E 0E C8 \n");
X = 0x0ec8;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" JSR Rot_VL_Mode_a ; 0438: BD F6 1F \n");
memory[--S] = 0x043b & 0xff; memory[--S] = 0x043b >> 8;
PC = 0xf61f;
JUMP;
case 0x043B: mon("L043B LDA -$20,U ; 043B: A6 C8 E0 \n");
A = (UINT8)memory[(UINT16)(U + (SINT8)0xe0)];
// N = A;
// Z = A;
// V = 0;
mon(" JSR Rot_VL_Mode_a ; 043E: BD F6 1F \n");
memory[--S] = 0x0441 & 0xff; memory[--S] = 0x0441 >> 8;
PC = 0xf61f;
JUMP;
case 0x0441: mon("L0441 LEAX $01,U ; 0441: 30 41 \n");
X = (U + 0x0001);
// Z = X;
mon(" LDB <$CD ; 0443: D6 CD \n");
B = (UINT8)memory_DP[0xcd];
// N = B;
// Z = B;
// V = 0;
mon(" DECB ; 0445: 5A \n");
res = (UINT8)(B - 1);
N = res;
Z = res;
V = B & ~res;
B = res;
mon(" BRA $03E5 ; 0446: 20 9D \n");
PC = 0x03e5;
JUMP;
case 0x0448: mon("L0448 LDA <$8B ; 0448: 96 8B \n");
A = (UINT8)memory_DP[0x8b];
// N = A;
Z = A;
// V = 0;
mon(" BNE $0451 ; 044A: 26 05 \n");
if (Z) {
PC = 0x0451;
JUMP;
}
mon(" LDA <$E0 ; 044C: 96 E0 \n");
A = (UINT8)memory_DP[0xe0];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$2F ; 044E: 97 2F \n");
Z = A;
N = A;
V = 0;
memory_DP[0x2f] = A;
mon(" RTS ; 0450: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0451: mon("L0451 LDB $C900 ; 0451: F6 C9 00 \n");
B = (UINT8)memory[0xc900];
N = B;
Z = B;
V = 0;
mon(" BGT $0464 ; 0454: 2E 0E \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0464;
JUMP;
}
mon(" LDB $C940 ; 0456: F6 C9 40 \n");
B = (UINT8)memory[0xc940];
N = B;
Z = B;
V = 0;
mon(" BGT $0464 ; 0459: 2E 09 \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0464;
JUMP;
}
mon(" LDB $C980 ; 045B: F6 C9 80 \n");
B = (UINT8)memory[0xc980];
N = B;
Z = B;
V = 0;
mon(" BGT $0464 ; 045E: 2E 04 \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0464;
JUMP;
}
mon(" LDA #$FC ; 0460: 86 FC \n");
A = (UINT8)(SINT8)0xfc;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$EC ; 0462: 97 EC \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xec] = A;
case 0x0464: mon("L0464 LDA <$67 ; 0464: 96 67 \n");
A = (UINT8)memory_DP[0x67];
// N = A;
// Z = A;
// V = 0;
mon(" ORA <$EB ; 0466: 9A EB \n");
A = A | memory_DP[0xeb];
// Z = A;
// N = A;
// V = 0;
mon(" ANDA <$EC ; 0468: 94 EC \n");
A = A & memory_DP[0xec];
// Z = A;
// N = A;
// V = 0;
mon(" STA <$67 ; 046A: 97 67 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
mon(" LDX #$C8C8 ; 046C: 8E C8 C8 \n");
X = 0xc8c8;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDB <$8E ; 046F: D6 8E \n");
B = (UINT8)memory_DP[0x8e];
// N = B;
// Z = B;
// V = 0;
case 0x0471: mon("L0471 INCB ; 0471: 5C \n");
res = (UINT8)(B + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
mon(" ANDB #$03 ; 0472: C4 03 \n");
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
mon(" STB <$8E ; 0474: D7 8E \n");
Z = B;
// N = B;
// V = 0;
memory_DP[0x8e] = B;
mon(" BEQ $0471 ; 0476: 27 F9 \n");
if (!Z) {
PC = 0x0471;
JUMP;
}
mon(" LDA #$40 ; 0478: 86 40 \n");
A = (UINT8)(SINT8)0x40;
// N = A;
// Z = A;
// V = 0;
mon(" MUL ; 047A: 3D \n");
res = (UINT16)(A * B);
// Z = res;
C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" ABX ; 047B: 3A \n");
X = X + B;
mon(" LDA -8,X ; 047C: A6 18 \n");
A = (UINT8)memory[(UINT16)(X + 0xfff8)];
N = A;
Z = A;
// V = 0;
mon(" BEQ $048B ; 047E: 27 0B \n");
if (!Z) {
PC = 0x048b;
JUMP;
}
mon(" BMI $04A5 ; 0480: 2B 23 \n");
if ((SINT8)N < 0) {
PC = 0x04a5;
JUMP;
}
mon(" LDB -7,X ; 0482: E6 19 \n");
B = (UINT8)memory[(UINT16)(X + 0xfff9)];
// N = B;
Z = B;
// V = 0;
mon(" BNE $048C ; 0484: 26 06 \n");
if (Z) {
PC = 0x048c;
JUMP;
}
mon(" TSTA ; 0486: 4D \n");
Z = A;
N = A;
V = 0;
mon(" LBNE $0552 ; 0487: 10 26 00 C7 \n");
if (Z) {
PC = 0x0552;
JUMP;
}
case 0x048B: mon("L048B RTS ; 048B: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x048C: mon("L048C LDA #$80 ; 048C: 86 80 \n");
A = (UINT8)(SINT8)0x80;
// N = A;
// Z = A;
// V = 0;
mon(" STA -8,X ; 048E: A7 18 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfff8)] = A;
mon(" LDU #$CB00 ; 0490: CE CB 00 \n");
U = 0xcb00;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" STU $02,X ; 0493: EF 02 \n");
// Z = U;
// N = (U) >> 8;
// V = 0;
memory[(UINT16)(X + 0x0002)] = (UINT8)((U) >> 8);
memory[(UINT16)((X + 0x0002) + 1)] = (U) & 0xff;
mon(" LDB #$10 ; 0495: C6 10 \n");
B = (UINT8)(SINT8)0x10;
// N = B;
// Z = B;
// V = 0;
mon(" LDA $0A,X ; 0497: A6 0A \n");
A = (UINT8)memory[(UINT16)(X + 0x000a)];
// N = A;
// Z = A;
// V = 0;
mon(" STB $04,X ; 0499: E7 04 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0004)] = B;
mon(" CLR $05,X ; 049B: 6F 05 \n");
memory[(UINT16)(X + 0x0005)] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" LEAU $0B,X ; 049D: 33 0B \n");
U = (X + 0x000b);
mon(" LDX #$0EF4 ; 049F: 8E 0E F4 \n");
X = 0x0ef4;
Z = X;
N = (X) >> 8;
V = 0;
mon(" JMP Rot_VL_Mode_a ; 04A2: 7E F6 1F \n");
PC = 0xf61f;
JUMP;
case 0x04A5: mon("L04A5 INC -8,X ; 04A5: 6C 18 \n");
res = (UINT8)(memory[(UINT16)(X + 0xfff8)] + 1);
Z = res;
// N = res;
// V = res & ~(memory[(UINT16)(X + 0xfff8)]);
memory[(UINT16)(X + 0xfff8)] = res;
mon(" BNE $04B2 ; 04A7: 26 09 \n");
if (Z) {
PC = 0x04b2;
JUMP;
}
mon(" CLR -7,X ; 04A9: 6F 19 \n");
memory[(UINT16)(X + 0xfff9)] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" DEC <$8B ; 04AB: 0A 8B \n");
res = (UINT8)(memory_DP[0x8b] - 1);
// N = res;
Z = res;
// V = memory_DP[0x8b] & ~res;
memory_DP[0x8b] = res;
mon(" BNE $04B1 ; 04AD: 26 02 \n");
if (Z) {
PC = 0x04b1;
JUMP;
}
mon(" CLR <$EB ; 04AF: 0F EB \n");
memory_DP[0xeb] = 0;
V = 0;
Z = 0;
N = 0;
C = 0;
case 0x04B1: mon("L04B1 RTS ; 04B1: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x04B2: mon("L04B2 CMPA #$F8 ; 04B2: 81 F8 \n");
res = A - (SINT8)0xf8;
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ (SINT8)0xf8) & (A ^ (UINT8)res);
mon(" BLT $04BC ; 04B4: 2D 06 \n");
if ((SINT8)(N^V) < 0) {
PC = 0x04bc;
JUMP;
}
mon(" LDA #$02 ; 04B6: 86 02 \n");
A = (UINT8)(SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
mon(" ADDA $04,X ; 04B8: AB 04 \n");
res = A + memory[(UINT16)(X + 0x0004)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = A ^ memory[(UINT16)(X + 0x0004)] ^ (UINT8)res ^ C;
// V = A ^ memory[(UINT16)(X + 0x0004)] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" STA $04,X ; 04BA: A7 04 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0004)] = A;
case 0x04BC: mon("L04BC JSR $0709 ; 04BC: BD 07 09 \n");
memory[--S] = 0x04bf & 0xff; memory[--S] = 0x04bf >> 8;
PC = 0x0709;
JUMP;
case 0x04BF: mon("L04BF LDB -7,X ; 04BF: E6 19 \n");
B = (UINT8)memory[(UINT16)(X + 0xfff9)];
// N = B;
// Z = B;
// V = 0;
mon(" DECB ; 04C1: 5A \n");
res = (UINT8)(B - 1);
// N = res;
Z = res;
// V = B & ~res;
B = res;
mon(" BEQ $04CF ; 04C2: 27 0B \n");
if (!Z) {
PC = 0x04cf;
JUMP;
}
mon(" LDU #$0F07 ; 04C4: CE 0F 07 \n");
U = 0x0f07;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LEAX $1E,X ; 04C7: 30 88 1E \n");
X = (X + (SINT8)0x1e);
// Z = X;
mon(" LDA #$19 ; 04CA: 86 19 \n");
A = (UINT8)(SINT8)0x19;
N = A;
Z = A;
V = 0;
mon(" JMP $0CF6 ; 04CC: 7E 0C F6 \n");
PC = 0x0cf6;
JUMP;
case 0x04CF: mon("L04CF DEC -6,X ; 04CF: 6A 1A \n");
res = (UINT8)(memory[(UINT16)(X + 0xfffa)] - 1);
N = res;
Z = res;
V = memory[(UINT16)(X + 0xfffa)] & ~res;
memory[(UINT16)(X + 0xfffa)] = res;
mon(" BGT $0501 ; 04D1: 2E 2E \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0501;
JUMP;
}
mon(" LDU #$C9DC ; 04D3: CE C9 DC \n");
U = 0xc9dc;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDB <$8E ; 04D6: D6 8E \n");
B = (UINT8)memory_DP[0x8e];
// N = B;
// Z = B;
// V = 0;
mon(" LDA #$07 ; 04D8: 86 07 \n");
A = (UINT8)(SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
mon(" MUL ; 04DA: 3D \n");
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" LEAU B,U ; 04DB: 33 C5 \n");
U = (U + (SINT8)B);
mon(" LDB ,U ; 04DD: E6 C4 \n");
B = (UINT8)memory[U];
// N = B;
Z = B;
// V = 0;
mon(" BNE $0501 ; 04DF: 26 20 \n");
if (Z) {
PC = 0x0501;
JUMP;
}
mon(" LDD $06,X ; 04E1: EC 06 \n");
A = memory[(UINT16)(X + 0x0006)];
B = memory[(UINT16)(((UINT16)(X + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" STD $01,U ; 04E3: ED 41 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0001)] = A;
memory[(UINT16)(U + 0x0001) + 1] = B;
mon(" LDB -2,X ; 04E5: E6 1E \n");
B = (UINT8)memory[(UINT16)(X + 0xfffe)];
// N = B;
// Z = B;
// V = 0;
mon(" LDA <$86 ; 04E7: 96 86 \n");
A = (UINT8)memory_DP[0x86];
// N = A;
// Z = A;
// V = 0;
mon(" STA -6,X ; 04E9: A7 1A \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfffa)] = A;
case 0x04EB: mon("L04EB LDA #$07 ; 04EB: 86 07 \n");
A = (UINT8)(SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
mon(" JSR Rise_Run_X ; 04ED: BD F5 FF \n");
memory[--S] = 0x04f0 & 0xff; memory[--S] = 0x04f0 >> 8;
PC = 0xf5ff;
JUMP;
case 0x04F0: mon("L04F0 STD $03,U ; 04F0: ED 43 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0003)] = A;
memory[(UINT16)(U + 0x0003) + 1] = B;
mon(" ASRA ; 04F2: 47 \n");
// C = A & 1;
A = (UINT8)((SINT8)A >> 1);
// Z = A;
// N = A;
mon(" ASRB ; 04F3: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" STD $05,U ; 04F4: ED 45 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0005)] = A;
memory[(UINT16)(U + 0x0005) + 1] = B;
mon(" LDD $03,U ; 04F6: EC 43 \n");
A = memory[(UINT16)(U + 0x0003)];
B = memory[(UINT16)(((UINT16)(U + 0x0003))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" SUBA $05,U ; 04F8: A0 45 \n");
res = A - memory[(UINT16)(U + 0x0005)];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((A) ^ memory[(UINT16)(U + 0x0005)]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" SUBB $06,U ; 04FA: E0 46 \n");
res = B - memory[(UINT16)(U + 0x0006)];
C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((B) ^ memory[(UINT16)(U + 0x0006)]) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
mon(" STD $03,U ; 04FC: ED 43 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0003)] = A;
memory[(UINT16)(U + 0x0003) + 1] = B;
mon(" DEC ,U ; 04FE: 6A C4 \n");
res = (UINT8)(memory[U] - 1);
N = res;
Z = res;
V = memory[U] & ~res;
memory[U] = res;
case 0x0500: mon("L0500 RTS ; 0500: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0501: mon("L0501 LDA #$7F ; 0501: 86 7F \n");
A = (UINT8)(SINT8)0x7f;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$D0 ; 0503: 97 D0 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xd0] = A;
mon(" LDU #$CA06 ; 0505: CE CA 06 \n");
U = 0xca06;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDA -6,U ; 0508: A6 5A \n");
A = (UINT8)memory[(UINT16)(U + 0xfffa)];
N = A;
Z = A;
V = 0;
mon(" BLE $0517 ; 050A: 2F 0B \n");
if (((SINT8)(N^V) < 0) || (!Z)) {
PC = 0x0517;
JUMP;
}
mon(" LDD $06,X ; 050C: EC 06 \n");
A = memory[(UINT16)(X + 0x0006)];
B = memory[(UINT16)(((UINT16)(X + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" JSR $0C76 ; 050E: BD 0C 76 \n");
memory[--S] = 0x0511 & 0xff; memory[--S] = 0x0511 >> 8;
PC = 0x0c76;
JUMP;
case 0x0511: mon("L0511 CMPB #$04 ; 0511: C1 04 \n");
res = B - (SINT8)0x04;
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = (B ^ (SINT8)0x04) & (B ^ (UINT8)res);
mon(" BLT $0549 ; 0513: 2D 34 \n");
if ((SINT8)(N^V) < 0) {
PC = 0x0549;
JUMP;
}
mon(" STD <$CF ; 0515: DD CF \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcf] = A;
memory_DP[0xcf + 1] = B;
case 0x0517: mon("L0517 LDA <$C8 ; 0517: 96 C8 \n");
A = (UINT8)memory_DP[0xc8];
// N = A;
// Z = A;
// V = 0;
mon(" DECA ; 0519: 4A \n");
res = (UINT8)(A - 1);
// N = res;
Z = res;
// V = A & ~res;
A = res;
mon(" BEQ $0530 ; 051A: 27 14 \n");
if (!Z) {
PC = 0x0530;
JUMP;
}
mon(" LEAU $27,U ; 051C: 33 C8 27 \n");
U = (U + (SINT8)0x27);
mon(" LDA -6,U ; 051F: A6 5A \n");
A = (UINT8)memory[(UINT16)(U + 0xfffa)];
N = A;
// Z = A;
V = 0;
mon(" BLT $0530 ; 0521: 2D 0D \n");
if ((SINT8)(N^V) < 0) {
PC = 0x0530;
JUMP;
}
mon(" LDD $06,X ; 0523: EC 06 \n");
A = memory[(UINT16)(X + 0x0006)];
B = memory[(UINT16)(((UINT16)(X + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" JSR $0C76 ; 0525: BD 0C 76 \n");
memory[--S] = 0x0528 & 0xff; memory[--S] = 0x0528 >> 8;
PC = 0x0c76;
JUMP;
case 0x0528: mon("L0528 CMPB #$04 ; 0528: C1 04 \n");
res = B - (SINT8)0x04;
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = (B ^ (SINT8)0x04) & (B ^ (UINT8)res);
mon(" BLT $0549 ; 052A: 2D 1D \n");
if ((SINT8)(N^V) < 0) {
PC = 0x0549;
JUMP;
}
mon(" CMPB <$D0 ; 052C: D1 D0 \n");
res = B - memory_DP[0xd0];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = (B ^ memory_DP[0xd0]) & (B ^ (UINT8)res);
mon(" BLT $0532 ; 052E: 2D 02 \n");
if ((SINT8)(N^V) < 0) {
PC = 0x0532;
JUMP;
}
case 0x0530: mon("L0530 LDA <$CF ; 0530: 96 CF \n");
A = (UINT8)memory_DP[0xcf];
// N = A;
// Z = A;
// V = 0;
case 0x0532: mon("L0532 ANDA <$84 ; 0532: 94 84 \n");
A = A & memory_DP[0x84];
// Z = A;
// N = A;
// V = 0;
mon(" CMPA -2,X ; 0534: A1 1E \n");
res = A - memory[(UINT16)(X + 0xfffe)];
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ memory[(UINT16)(X + 0xfffe)]) & (A ^ (UINT8)res);
mon(" BEQ $0500 ; 0536: 27 C8 \n");
if (!Z) {
PC = 0x0500;
JUMP;
}
mon(" LDB <$EE ; 0538: D6 EE \n");
B = (UINT8)memory_DP[0xee];
// N = B;
// Z = B;
// V = 0;
mon(" BITB #$01 ; 053A: C5 01 \n");
res = B & (SINT8)0x01;
Z = res;
// N = res;
// V = 0;
mon(" BEQ $0500 ; 053C: 27 C2 \n");
if (!Z) {
PC = 0x0500;
JUMP;
}
mon(" STA -2,X ; 053E: A7 1E \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfffe)] = A;
mon(" LEAU $1E,X ; 0540: 33 88 1E \n");
U = (X + (SINT8)0x1e);
mon(" LDX #$0EDB ; 0543: 8E 0E DB \n");
X = 0x0edb;
Z = X;
N = (X) >> 8;
V = 0;
mon(" JMP Rot_VL_Mode_a ; 0546: 7E F6 1F \n");
PC = 0xf61f;
JUMP;
case 0x0549: mon("L0549 LDA #$02 ; 0549: 86 02 \n");
A = (UINT8)(SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
mon(" STA -7,X ; 054B: A7 19 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfff9)] = A;
mon(" LDA #$80 ; 054D: 86 80 \n");
A = (UINT8)(SINT8)0x80;
// N = A;
// Z = A;
// V = 0;
mon(" STA -6,U ; 054F: A7 5A \n");
Z = A;
N = A;
V = 0;
memory[(UINT16)(U + 0xfffa)] = A;
mon(" RTS ; 0551: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0552: mon("L0552 LDA ,X ; 0552: A6 84 \n");
A = (UINT8)memory[X];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $0568 ; 0554: 27 12 \n");
if (!Z) {
PC = 0x0568;
JUMP;
}
mon(" SUBA <$89 ; 0556: 90 89 \n");
res = A - memory_DP[0x89];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((A) ^ memory_DP[0x89]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" STA ,X ; 0558: A7 84 \n");
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
mon(" LDA $0A,X ; 055A: A6 0A \n");
A = (UINT8)memory[(UINT16)(X + 0x000a)];
// N = A;
// Z = A;
// V = 0;
mon(" ADDA -3,X ; 055C: AB 1D \n");
res = A + memory[(UINT16)(X + 0xfffd)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = A ^ memory[(UINT16)(X + 0xfffd)] ^ (UINT8)res ^ C;
// V = A ^ memory[(UINT16)(X + 0xfffd)] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" STA $0A,X ; 055E: A7 0A \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x000a)] = A;
mon(" LEAU $0B,X ; 0560: 33 0B \n");
U = (X + 0x000b);
mon(" LDX #$0EC8 ; 0562: 8E 0E C8 \n");
X = 0x0ec8;
Z = X;
N = (X) >> 8;
V = 0;
mon(" JMP Rot_VL_Mode_a ; 0565: 7E F6 1F \n");
PC = 0xf61f;
JUMP;
case 0x0568: mon("L0568 LDY #$0DA0 ; 0568: 10 8E 0D A0 \n");
Y = 0x0da0;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
mon(" LDA $05,X ; 056C: A6 05 \n");
A = (UINT8)memory[(UINT16)(X + 0x0005)];
N = A;
Z = A;
V = 0;
mon(" LBEQ $0600 ; 056E: 10 27 00 8E \n");
if (!Z) {
PC = 0x0600;
JUMP;
}
mon(" LEAU $40,X ; 0572: 33 88 40 \n");
U = (X + (SINT8)0x40);
mon(" CMPU #$C9C8 ; 0575: 11 83 C9 C8 \n");
res = (U) - (0xc9c8);
// C = res & 0x10000;
res = (UINT16)res;
Z = res;
// N = res >> 8;
// V = (((U) ^ (0xc9c8)) & ((U) ^ res)) >> 8;
mon(" BNE $057E ; 0579: 26 03 \n");
if (Z) {
PC = 0x057e;
JUMP;
}
mon(" LDU #$C908 ; 057B: CE C9 08 \n");
U = 0xc908;
// Z = U;
// N = (U) >> 8;
// V = 0;
case 0x057E: mon("L057E LDA -8,U ; 057E: A6 58 \n");
A = (UINT8)memory[(UINT16)(U + 0xfff8)];
N = A;
Z = A;
V = 0;
mon(" BLE $05DD ; 0580: 2F 5B \n");
if (((SINT8)(N^V) < 0) || (!Z)) {
PC = 0x05dd;
JUMP;
}
mon(" LDD $06,U ; 0582: EC 46 \n");
A = memory[(UINT16)(U + 0x0006)];
B = memory[(UINT16)(((UINT16)(U + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" SUBA $06,X ; 0584: A0 06 \n");
res = A - memory[(UINT16)(X + 0x0006)];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
V = ((A) ^ memory[(UINT16)(X + 0x0006)]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" BVS $05DD ; 0586: 29 55 \n");
if ((SINT8)V < 0) {
PC = 0x05dd;
JUMP;
}
mon(" SUBB $07,X ; 0588: E0 07 \n");
res = B - memory[(UINT16)(X + 0x0007)];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
V = ((B) ^ memory[(UINT16)(X + 0x0007)]) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
mon(" BVS $05DD ; 058A: 29 51 \n");
if ((SINT8)V < 0) {
PC = 0x05dd;
JUMP;
}
mon(" JSR Abs_a_b ; 058C: BD F5 84 \n");
memory[--S] = 0x058f & 0xff; memory[--S] = 0x058f >> 8;
PC = 0xf584;
JUMP;
case 0x058F: mon("L058F STD <$CB ; 058F: DD CB \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcb] = A;
memory_DP[0xcb + 1] = B;
mon(" TSTA ; 0591: 4D \n");
Z = A;
// N = A;
// V = 0;
mon(" BEQ $0597 ; 0592: 27 03 \n");
if (!Z) {
PC = 0x0597;
JUMP;
}
mon(" TSTB ; 0594: 5D \n");
Z = B;
// N = B;
// V = 0;
mon(" BNE $05DD ; 0595: 26 46 \n");
if (Z) {
PC = 0x05dd;
JUMP;
}
case 0x0597: mon("L0597 ADDA <$CC ; 0597: 9B CC \n");
res = A + memory_DP[0xcc];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ memory_DP[0xcc] ^ (UINT8)res ^ C;
// V = A ^ memory_DP[0xcc] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" CMPA #$0C ; 0599: 81 0C \n");
res = A - (SINT8)0x0c;
// C = res & 0x100;
Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ (SINT8)0x0c) & (A ^ (UINT8)res);
mon(" BGT $05DD ; 059B: 2E 40 \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x05dd;
JUMP;
}
mon(" LDA $03,X ; 059D: A6 03 \n");
A = (UINT8)memory[(UINT16)(X + 0x0003)];
// N = A;
// Z = A;
// V = 0;
mon(" CMPA $02,X ; 059F: A1 02 \n");
res = A - memory[(UINT16)(X + 0x0002)];
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ memory[(UINT16)(X + 0x0002)]) & (A ^ (UINT8)res);
mon(" BEQ $05DD ; 05A1: 27 3A \n");
if (!Z) {
PC = 0x05dd;
JUMP;
}
mon(" DECA ; 05A3: 4A \n");
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
mon(" LDB #$08 ; 05A4: C6 08 \n");
B = (UINT8)(SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
mon(" MUL ; 05A6: 3D \n");
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" LEAY $04,Y ; 05A7: 31 24 \n");
Y = (Y + 0x0004);
// Z = Y;
mon(" LEAY D,Y ; 05A9: 31 AB \n");
Y = (Y + (((UINT8)A<<8)|(UINT8)B));
// Z = Y;
mon(" LDB $04,X ; 05AB: E6 04 \n");
B = (UINT8)memory[(UINT16)(X + 0x0004)];
// N = B;
// Z = B;
// V = 0;
mon(" LDA B,Y ; 05AD: A6 A5 \n");
A = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
// N = A;
// Z = A;
// V = 0;
mon(" SUBA $05,X ; 05AF: A0 05 \n");
res = A - memory[(UINT16)(X + 0x0005)];
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = ((A) ^ memory[(UINT16)(X + 0x0005)]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" BEQ $05DD ; 05B1: 27 2A \n");
if (!Z) {
PC = 0x05dd;
JUMP;
}
mon(" STA $05,X ; 05B3: A7 05 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0005)] = A;
mon(" ADDB #$02 ; 05B5: CB 02 \n");
res = B + (SINT8)0x02;
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = B ^ (SINT8)0x02 ^ (UINT8)res ^ C;
// V = B ^ (SINT8)0x02 ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" ANDB #$03 ; 05B7: C4 03 \n");
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
mon(" STB $04,X ; 05B9: E7 04 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0004)] = B;
mon(" LEAY -4,Y ; 05BB: 31 3C \n");
Y = (Y + 0xfffc);
// Z = Y;
mon(" INCB ; 05BD: 5C \n");
res = (UINT8)(B + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
mon(" ANDB #$03 ; 05BE: C4 03 \n");
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
mon(" LDA B,Y ; 05C0: A6 A5 \n");
A = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
// N = A;
Z = A;
// V = 0;
mon(" BNE $05CF ; 05C2: 26 0B \n");
if (Z) {
PC = 0x05cf;
JUMP;
}
mon(" INCB ; 05C4: 5C \n");
res = (UINT8)(B + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
mon(" INCB ; 05C5: 5C \n");
res = (UINT8)(B + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
mon(" ANDB #$03 ; 05C6: C4 03 \n");
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
mon(" LDA B,Y ; 05C8: A6 A5 \n");
A = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
// N = A;
Z = A;
// V = 0;
mon(" BNE $05CF ; 05CA: 26 03 \n");
if (Z) {
PC = 0x05cf;
JUMP;
}
mon(" INCB ; 05CC: 5C \n");
res = (UINT8)(B + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
mon(" ANDB #$03 ; 05CD: C4 03 \n");
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
case 0x05CF: mon("L05CF STB -4,X ; 05CF: E7 1C \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0xfffc)] = B;
mon(" NEG $08,X ; 05D1: 60 08 \n");
// V = (UINT8)(-memory[(UINT16)(X + 0x0008)]) & (memory[(UINT16)(X + 0x0008)]);
// C = (-memory[(UINT16)(X + 0x0008)]) & 0x100;
memory[(UINT16)(X + 0x0008)] = (UINT8)(-memory[(UINT16)(X + 0x0008)]);
// Z = memory[(UINT16)(X + 0x0008)];
// N = memory[(UINT16)(X + 0x0008)];
mon(" NEG $09,X ; 05D3: 60 09 \n");
// V = (UINT8)(-memory[(UINT16)(X + 0x0009)]) & (memory[(UINT16)(X + 0x0009)]);
// C = (-memory[(UINT16)(X + 0x0009)]) & 0x100;
memory[(UINT16)(X + 0x0009)] = (UINT8)(-memory[(UINT16)(X + 0x0009)]);
// Z = memory[(UINT16)(X + 0x0009)];
// N = memory[(UINT16)(X + 0x0009)];
mon(" CLR -1,X ; 05D5: 6F 1F \n");
memory[(UINT16)(X + 0xffff)] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LDD $02,X ; 05D7: EC 02 \n");
A = memory[(UINT16)(X + 0x0002)];
B = memory[(UINT16)(((UINT16)(X + 0x0002))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" STA $03,X ; 05D9: A7 03 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0003)] = A;
mon(" STB $02,X ; 05DB: E7 02 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0002)] = B;
case 0x05DD: mon("L05DD LDA $05,X ; 05DD: A6 05 \n");
A = (UINT8)memory[(UINT16)(X + 0x0005)];
// N = A;
// Z = A;
// V = 0;
mon(" SUBA <$88 ; 05DF: 90 88 \n");
res = A - memory_DP[0x88];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
// V = ((A) ^ memory_DP[0x88]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" BPL $05F3 ; 05E1: 2A 10 \n");
if ((SINT8)N >= 0) {
PC = 0x05f3;
JUMP;
}
mon(" LEAY $09,X ; 05E3: 31 09 \n");
Y = (X + 0x0009);
// Z = Y;
mon(" LDB ,Y ; 05E5: E6 A4 \n");
B = (UINT8)memory[Y];
// N = B;
Z = B;
// V = 0;
mon(" BNE $05EB ; 05E7: 26 02 \n");
if (Z) {
PC = 0x05eb;
JUMP;
}
mon(" LDB ,-Y ; 05E9: E6 A2 \n");
Y = Y - 1;
B = (UINT8)memory[Y];
N = B;
// Z = B;
// V = 0;
case 0x05EB: mon("L05EB BPL $05EE ; 05EB: 2A 01 \n");
if ((SINT8)N >= 0) {
PC = 0x05ee;
JUMP;
}
mon(" NEGA ; 05ED: 40 \n");
// V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
case 0x05EE: mon("L05EE ADDA ,--Y ; 05EE: AB A3 \n");
Y = Y - 2;
res = A + memory[Y];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ memory[Y] ^ (UINT8)res ^ C;
// V = A ^ memory[Y] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" STA ,Y ; 05F0: A7 A4 \n");
// Z = A;
// N = A;
// V = 0;
memory[Y] = A;
mon(" CLRA ; 05F2: 4F \n");
A = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
case 0x05F3: mon("L05F3 STA $05,X ; 05F3: A7 05 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0005)] = A;
mon(" LDD $06,X ; 05F5: EC 06 \n");
A = memory[(UINT16)(X + 0x0006)];
B = memory[(UINT16)(((UINT16)(X + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" ADDA $08,X ; 05F7: AB 08 \n");
res = A + memory[(UINT16)(X + 0x0008)];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ memory[(UINT16)(X + 0x0008)] ^ (UINT8)res ^ C;
// V = A ^ memory[(UINT16)(X + 0x0008)] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" ADDB $09,X ; 05F9: EB 09 \n");
res = B + memory[(UINT16)(X + 0x0009)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ memory[(UINT16)(X + 0x0009)] ^ (UINT8)res ^ C;
// V = B ^ memory[(UINT16)(X + 0x0009)] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" STD $06,X ; 05FB: ED 06 \n");
Z = A | B;
N = A;
V = 0;
memory[(UINT16)(X + 0x0006)] = A;
memory[(UINT16)(X + 0x0006) + 1] = B;
mon(" JMP $04CF ; 05FD: 7E 04 CF \n");
PC = 0x04cf;
JUMP;
case 0x0600: mon("L0600 LDA -5,X ; 0600: A6 1B \n");
A = (UINT8)memory[(UINT16)(X + 0xfffb)];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $0618 ; 0602: 27 14 \n");
if (!Z) {
PC = 0x0618;
JUMP;
}
mon(" LDB #$08 ; 0604: C6 08 \n");
B = (UINT8)(SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
mon(" STB $05,X ; 0606: E7 05 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0005)] = B;
mon(" SUBA $01,X ; 0608: A0 01 \n");
res = A - memory[(UINT16)(X + 0x0001)];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((A) ^ memory[(UINT16)(X + 0x0001)]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" ANDA #$03 ; 060A: 84 03 \n");
A = A & (SINT8)0x03;
// Z = A;
// N = A;
// V = 0;
mon(" STA $01,X ; 060C: A7 01 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0001)] = A;
mon(" LDA -5,X ; 060E: A6 1B \n");
A = (UINT8)memory[(UINT16)(X + 0xfffb)];
// N = A;
// Z = A;
// V = 0;
mon(" ANDA #$02 ; 0610: 84 02 \n");
A = A & (SINT8)0x02;
// Z = A;
// N = A;
// V = 0;
mon(" ASRA ; 0612: 47 \n");
// C = A & 1;
A = (UINT8)((SINT8)A >> 1);
// Z = A;
// N = A;
mon(" STA $04,X ; 0613: A7 04 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0004)] = A;
mon(" CLR -5,X ; 0615: 6F 1B \n");
memory[(UINT16)(X + 0xfffb)] = 0;
V = 0;
Z = 0;
N = 0;
C = 0;
mon(" RTS ; 0617: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0618: mon("L0618 LDA $02,X ; 0618: A6 02 \n");
A = (UINT8)memory[(UINT16)(X + 0x0002)];
// N = A;
// Z = A;
// V = 0;
mon(" DECA ; 061A: 4A \n");
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
mon(" LDB #$08 ; 061B: C6 08 \n");
B = (UINT8)(SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
mon(" MUL ; 061D: 3D \n");
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" LEAY D,Y ; 061E: 31 AB \n");
Y = (Y + (((UINT8)A<<8)|(UINT8)B));
// Z = Y;
mon(" LDB -4,X ; 0620: E6 1C \n");
B = (UINT8)memory[(UINT16)(X + 0xfffc)];
N = B;
// Z = B;
// V = 0;
mon(" BMI $0628 ; 0622: 2B 04 \n");
if ((SINT8)N < 0) {
PC = 0x0628;
JUMP;
}
mon(" COM -4,X ; 0624: 63 1C \n");
memory[(UINT16)(X + 0xfffc)] = memory[(UINT16)(X + 0xfffc)] ^ 0xff;
Z = memory[(UINT16)(X + 0xfffc)];
N = memory[(UINT16)(X + 0xfffc)];
V = 0;
C = 256;
mon(" BSR $065F ; 0626: 8D 37 \n");
memory[--S] = 0x0628 & 0xff; memory[--S] = 0x0628 >> 8;
PC = 0x065f;
JUMP;
case 0x0628: mon("L0628 LDB -2,X ; 0628: E6 1E \n");
B = (UINT8)memory[(UINT16)(X + 0xfffe)];
// N = B;
// Z = B;
// V = 0;
mon(" LSRB ; 062A: 54 \n");
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
mon(" LSRB ; 062B: 54 \n");
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
mon(" LSRB ; 062C: 54 \n");
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
mon(" LSRB ; 062D: 54 \n");
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
mon(" CMPB $01,X ; 062E: E1 01 \n");
res = B - memory[(UINT16)(X + 0x0001)];
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (B ^ memory[(UINT16)(X + 0x0001)]) & (B ^ (UINT8)res);
mon(" BNE $0633 ; 0630: 26 01 \n");
if (Z) {
PC = 0x0633;
JUMP;
}
mon(" NEGB ; 0632: 50 \n");
// V = (UINT8)(-B) & (B);
// C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
case 0x0633: mon("L0633 ADDB $01,X ; 0633: EB 01 \n");
res = B + memory[(UINT16)(X + 0x0001)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ memory[(UINT16)(X + 0x0001)] ^ (UINT8)res ^ C;
// V = B ^ memory[(UINT16)(X + 0x0001)] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" CMPB #$04 ; 0635: C1 04 \n");
res = B - (SINT8)0x04;
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (B ^ (SINT8)0x04) & (B ^ (UINT8)res);
mon(" BNE $063B ; 0637: 26 02 \n");
if (Z) {
PC = 0x063b;
JUMP;
}
mon(" LDB #$02 ; 0639: C6 02 \n");
B = (UINT8)(SINT8)0x02;
// N = B;
// Z = B;
// V = 0;
case 0x063B: mon("L063B ANDB #$03 ; 063B: C4 03 \n");
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
mon(" TFR B,A ; 063D: 1F 98 \n");
A = B;
mon(" INCA ; 063F: 4C \n");
res = (UINT8)(A + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
mon(" PSHS B,A ; 0640: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
mon(" JSR Random ; 0642: BD F5 17 \n");
memory[--S] = 0x0645 & 0xff; memory[--S] = 0x0645 >> 8;
PC = 0xf517;
JUMP;
case 0x0645: mon("L0645 PULS A,B ; 0645: 35 06 \n");
A = memory[S++];
B = memory[S++];
mon(" BCC $064B ; 0647: 24 02 \n");
if (!C) {
PC = 0x064b;
JUMP;
}
mon(" EXG A,B ; 0649: 1E 89 \n");
val = A;
A = B;
B = val;
case 0x064B: mon("L064B STA <$CB ; 064B: 97 CB \n");
Z = A;
N = A;
V = 0;
memory_DP[0xcb] = A;
mon(" BSR $065F ; 064D: 8D 10 \n");
memory[--S] = 0x064f & 0xff; memory[--S] = 0x064f >> 8;
PC = 0x065f;
JUMP;
case 0x064F: mon("L064F LDB <$CB ; 064F: D6 CB \n");
B = (UINT8)memory_DP[0xcb];
N = B;
Z = B;
V = 0;
mon(" BSR $065F ; 0651: 8D 0C \n");
memory[--S] = 0x0653 & 0xff; memory[--S] = 0x0653 >> 8;
PC = 0x065f;
JUMP;
case 0x0653: mon("L0653 LDB $04,X ; 0653: E6 04 \n");
B = (UINT8)memory[(UINT16)(X + 0x0004)];
N = B;
Z = B;
V = 0;
mon(" BSR $065F ; 0655: 8D 08 \n");
memory[--S] = 0x0657 & 0xff; memory[--S] = 0x0657 >> 8;
PC = 0x065f;
JUMP;
case 0x0657: mon("L0657 LDB #$03 ; 0657: C6 03 \n");
B = (UINT8)(SINT8)0x03;
N = B;
Z = B;
V = 0;
case 0x0659: mon("L0659 BSR $065F ; 0659: 8D 04 \n");
memory[--S] = 0x065b & 0xff; memory[--S] = 0x065b >> 8;
PC = 0x065f;
JUMP;
case 0x065B: mon("L065B DECB ; 065B: 5A \n");
res = (UINT8)(B - 1);
N = res;
Z = res;
V = B & ~res;
B = res;
mon(" BPL $0659 ; 065C: 2A FB \n");
if ((SINT8)N >= 0) {
PC = 0x0659;
JUMP;
}
mon(" RTS ; 065E: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x065F: mon("L065F ANDB #$03 ; 065F: C4 03 \n");
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
mon(" LDA B,Y ; 0661: A6 A5 \n");
A = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $066D ; 0663: 27 08 \n");
if (!Z) {
PC = 0x066d;
JUMP;
}
mon(" CMPA $03,X ; 0665: A1 03 \n");
res = A - memory[(UINT16)(X + 0x0003)];
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ memory[(UINT16)(X + 0x0003)]) & (A ^ (UINT8)res);
mon(" BNE $066E ; 0667: 26 05 \n");
if (Z) {
PC = 0x066e;
JUMP;
}
mon(" TST -1,X ; 0669: 6D 1F \n");
Z = memory[(UINT16)(X + 0xffff)];
N = memory[(UINT16)(X + 0xffff)];
V = 0;
mon(" BEQ $0672 ; 066B: 27 05 \n");
if (!Z) {
PC = 0x0672;
JUMP;
}
case 0x066D: mon("L066D RTS ; 066D: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x066E: mon("L066E CLR -1,X ; 066E: 6F 1F \n");
memory[(UINT16)(X + 0xffff)] = 0;
V = 0;
Z = 0;
N = 0;
C = 0;
mon(" BRA $0674 ; 0670: 20 02 \n");
PC = 0x0674;
JUMP;
case 0x0672: mon("L0672 INC -1,X ; 0672: 6C 1F \n");
res = (UINT8)(memory[(UINT16)(X + 0xffff)] + 1);
// Z = res;
// N = res;
// V = res & ~(memory[(UINT16)(X + 0xffff)]);
memory[(UINT16)(X + 0xffff)] = res;
case 0x0674: mon("L0674 STD ,S++ ; 0674: ED E1 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[S] = A;
memory[S + 1] = B;
S = S + 2;
mon(" CMPA $02,X ; 0676: A1 02 \n");
res = A - memory[(UINT16)(X + 0x0002)];
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ memory[(UINT16)(X + 0x0002)]) & (A ^ (UINT8)res);
mon(" BNE $0683 ; 0678: 26 09 \n");
if (Z) {
PC = 0x0683;
JUMP;
}
mon(" RORB ; 067A: 56 \n");
res = ((UINT8)B) | ((C != 0) ? 0x100 : 0);
C = res & 1;
res = (UINT8)(res >> 1);
// Z = res;
// N = res;
B = res;
mon(" BCS $067F ; 067B: 25 02 \n");
if (C) {
PC = 0x067f;
JUMP;
}
mon(" ADDB #$02 ; 067D: CB 02 \n");
res = B + (SINT8)0x02;
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = B ^ (SINT8)0x02 ^ (UINT8)res ^ C;
// V = B ^ (SINT8)0x02 ^ (UINT8)res ^ C;
B = (UINT8)res;
case 0x067F: mon("L067F ADDB #$02 ; 067F: CB 02 \n");
res = B + (SINT8)0x02;
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ (SINT8)0x02 ^ (UINT8)res ^ C;
// V = B ^ (SINT8)0x02 ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" STB -5,X ; 0681: E7 1B \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0xfffb)] = B;
case 0x0683: mon("L0683 LDA $02,X ; 0683: A6 02 \n");
A = (UINT8)memory[(UINT16)(X + 0x0002)];
// N = A;
// Z = A;
// V = 0;
mon(" STA $03,X ; 0685: A7 03 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0003)] = A;
mon(" LDD -2,S ; 0687: EC 7E \n");
A = memory[(UINT16)(S + 0xfffe)];
B = memory[(UINT16)(((UINT16)(S + 0xfffe))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" STA $02,X ; 0689: A7 02 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0002)] = A;
mon(" LEAY B,Y ; 068B: 31 A5 \n");
Y = (Y + (SINT8)B);
// Z = Y;
mon(" LDA $04,Y ; 068D: A6 24 \n");
A = (UINT8)memory[(UINT16)(Y + 0x0004)];
// N = A;
// Z = A;
// V = 0;
mon(" STA $05,X ; 068F: A7 05 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0005)] = A;
mon(" TFR B,A ; 0691: 1F 98 \n");
A = B;
mon(" SUBB $04,X ; 0693: E0 04 \n");
res = B - memory[(UINT16)(X + 0x0004)];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((B) ^ memory[(UINT16)(X + 0x0004)]) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
mon(" ANDB #$03 ; 0695: C4 03 \n");
B = B & (SINT8)0x03;
Z = B;
// N = B;
// V = 0;
mon(" BEQ $06A5 ; 0697: 27 0C \n");
if (!Z) {
PC = 0x06a5;
JUMP;
}
mon(" STA $04,X ; 0699: A7 04 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0004)] = A;
mon(" CMPB #$02 ; 069B: C1 02 \n");
res = B - (SINT8)0x02;
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (B ^ (SINT8)0x02) & (B ^ (UINT8)res);
mon(" BNE $06A6 ; 069D: 26 07 \n");
if (Z) {
PC = 0x06a6;
JUMP;
}
mon(" LDD $08,X ; 069F: EC 08 \n");
A = memory[(UINT16)(X + 0x0008)];
B = memory[(UINT16)(((UINT16)(X + 0x0008))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" NEGA ; 06A1: 40 \n");
// V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
case 0x06A2: mon("L06A2 NEGB ; 06A2: 50 \n");
// V = (UINT8)(-B) & (B);
C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
case 0x06A3: mon("L06A3 STD $08,X ; 06A3: ED 08 \n");
Z = A | B;
N = A;
V = 0;
memory[(UINT16)(X + 0x0008)] = A;
memory[(UINT16)(X + 0x0008) + 1] = B;
case 0x06A5: mon("L06A5 RTS ; 06A5: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x06A6: mon("L06A6 LDA #$10 ; 06A6: 86 10 \n");
A = (UINT8)(SINT8)0x10;
// N = A;
// Z = A;
// V = 0;
mon(" STA ,X ; 06A8: A7 84 \n");
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
mon(" LDA $01,X ; 06AA: A6 01 \n");
A = (UINT8)memory[(UINT16)(X + 0x0001)];
// N = A;
// Z = A;
// V = 0;
mon(" RORA ; 06AC: 46 \n");
res = ((UINT8)A) | ((C != 0) ? 0x100 : 0);
C = res & 1;
res = (UINT8)(res >> 1);
// Z = res;
// N = res;
A = res;
mon(" BCC $06B3 ; 06AD: 24 04 \n");
if (!C) {
PC = 0x06b3;
JUMP;
}
mon(" ADDB #$02 ; 06AF: CB 02 \n");
res = B + (SINT8)0x02;
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ (SINT8)0x02 ^ (UINT8)res ^ C;
// V = B ^ (SINT8)0x02 ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" ANDB #$03 ; 06B1: C4 03 \n");
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
case 0x06B3: mon("L06B3 LDA <$89 ; 06B3: 96 89 \n");
A = (UINT8)memory_DP[0x89];
// N = A;
// Z = A;
// V = 0;
mon(" STA -3,X ; 06B5: A7 1D \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfffd)] = A;
mon(" LDA $09,X ; 06B7: A6 09 \n");
A = (UINT8)memory[(UINT16)(X + 0x0009)];
// N = A;
// Z = A;
// V = 0;
mon(" PSHS B ; 06B9: 34 04 \n");
memory[--S] = B;
mon(" LDB $08,X ; 06BB: E6 08 \n");
B = (UINT8)memory[(UINT16)(X + 0x0008)];
// N = B;
// Z = B;
// V = 0;
mon(" DEC ,S+ ; 06BD: 6A E0 \n");
res = (UINT8)(memory[S] - 1);
// N = res;
Z = res;
// V = memory[S] & ~res;
memory[S] = res;
S = S + 1;
mon(" BEQ $06A2 ; 06BF: 27 E1 \n");
if (!Z) {
PC = 0x06a2;
JUMP;
}
mon(" NEGA ; 06C1: 40 \n");
// V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
mon(" NEG -3,X ; 06C2: 60 1D \n");
V = (UINT8)(-memory[(UINT16)(X + 0xfffd)]) & (memory[(UINT16)(X + 0xfffd)]);
C = (-memory[(UINT16)(X + 0xfffd)]) & 0x100;
memory[(UINT16)(X + 0xfffd)] = (UINT8)(-memory[(UINT16)(X + 0xfffd)]);
Z = memory[(UINT16)(X + 0xfffd)];
N = memory[(UINT16)(X + 0xfffd)];
mon(" BRA $06A3 ; 06C4: 20 DD \n");
PC = 0x06a3;
JUMP;
case 0x06C6: mon("L06C6 LDX #$CA00 ; 06C6: 8E CA 00 \n");
X = 0xca00;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" CLRA ; 06C9: 4F \n");
A = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" STA <$DA ; 06CA: 97 DA \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xda] = A;
mon(" LDY #$CA4E ; 06CC: 10 8E CA 4E \n");
Y = 0xca4e;
Z = Y;
N = (Y) >> 8;
V = 0;
case 0x06D0: mon("L06D0 BSR $0711 ; 06D0: 8D 3F \n");
memory[--S] = 0x06d2 & 0xff; memory[--S] = 0x06d2 >> 8;
PC = 0x0711;
JUMP;
case 0x06D2: mon("L06D2 LDA #$02 ; 06D2: 86 02 \n");
A = (UINT8)(SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$DA ; 06D4: 97 DA \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xda] = A;
mon(" LEAY $04,Y ; 06D6: 31 24 \n");
Y = (Y + 0x0004);
// Z = Y;
mon(" LEAX $27,X ; 06D8: 30 88 27 \n");
X = (X + (SINT8)0x27);
// Z = X;
mon(" CMPX #$CA4E ; 06DB: 8C CA 4E \n");
res = (X) - (0xca4e);
C = res & 0x10000;
res = (UINT16)res;
Z = res;
N = res >> 8;
V = (((X) ^ (0xca4e)) & ((X) ^ res)) >> 8;
mon(" BNE $06D0 ; 06DE: 26 F0 \n");
if (Z) {
PC = 0x06d0;
JUMP;
}
mon(" RTS ; 06E0: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x06E1: mon("L06E1 LDB $03,X ; 06E1: E6 03 \n");
B = (UINT8)memory[(UINT16)(X + 0x0003)];
// N = B;
// Z = B;
// V = 0;
mon(" CMPA #$80 ; 06E3: 81 80 \n");
res = A - (SINT8)0x80;
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ (SINT8)0x80) & (A ^ (UINT8)res);
mon(" BNE $06EF ; 06E5: 26 08 \n");
if (Z) {
PC = 0x06ef;
JUMP;
}
mon(" LDB #$02 ; 06E7: C6 02 \n");
B = (UINT8)(SINT8)0x02;
// N = B;
// Z = B;
// V = 0;
mon(" STB $04,X ; 06E9: E7 04 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0004)] = B;
mon(" LDB #$01 ; 06EB: C6 01 \n");
B = (UINT8)(SINT8)0x01;
// N = B;
// Z = B;
// V = 0;
mon(" STB $03,X ; 06ED: E7 03 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0003)] = B;
case 0x06EF: mon("L06EF INCA ; 06EF: 4C \n");
res = (UINT8)(A + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
mon(" STA ,X ; 06F0: A7 84 \n");
Z = A;
// N = A;
// V = 0;
memory[X] = A;
mon(" BNE $06FB ; 06F2: 26 07 \n");
if (Z) {
PC = 0x06fb;
JUMP;
}
mon(" DEC <$C7 ; 06F4: 0A C7 \n");
res = (UINT8)(memory_DP[0xc7] - 1);
// N = res;
Z = res;
// V = memory_DP[0xc7] & ~res;
memory_DP[0xc7] = res;
mon(" BNE $06FA ; 06F6: 26 02 \n");
if (Z) {
PC = 0x06fa;
JUMP;
}
mon(" DEC <$E2 ; 06F8: 0A E2 \n");
res = (UINT8)(memory_DP[0xe2] - 1);
N = res;
Z = res;
V = memory_DP[0xe2] & ~res;
memory_DP[0xe2] = res;
case 0x06FA: mon("L06FA RTS ; 06FA: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x06FB: mon("L06FB CMPA #$C2 ; 06FB: 81 C2 \n");
res = A - (SINT8)0xc2;
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ (SINT8)0xc2) & (A ^ (UINT8)res);
mon(" BNE $0701 ; 06FD: 26 02 \n");
if (Z) {
PC = 0x0701;
JUMP;
}
mon(" NEG $04,X ; 06FF: 60 04 \n");
// V = (UINT8)(-memory[(UINT16)(X + 0x0004)]) & (memory[(UINT16)(X + 0x0004)]);
// C = (-memory[(UINT16)(X + 0x0004)]) & 0x100;
memory[(UINT16)(X + 0x0004)] = (UINT8)(-memory[(UINT16)(X + 0x0004)]);
// Z = memory[(UINT16)(X + 0x0004)];
// N = memory[(UINT16)(X + 0x0004)];
case 0x0701: mon("L0701 ASRA ; 0701: 47 \n");
C = A & 1;
A = (UINT8)((SINT8)A >> 1);
// Z = A;
// N = A;
mon(" BCS $06FA ; 0702: 25 F6 \n");
if (C) {
PC = 0x06fa;
JUMP;
}
mon(" ADDB $04,X ; 0704: EB 04 \n");
res = B + memory[(UINT16)(X + 0x0004)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ memory[(UINT16)(X + 0x0004)] ^ (UINT8)res ^ C;
// V = B ^ memory[(UINT16)(X + 0x0004)] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" STB $03,X ; 0706: E7 03 \n");
Z = B;
N = B;
V = 0;
memory[(UINT16)(X + 0x0003)] = B;
mon(" RTS ; 0708: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0709: mon("L0709 LDA $05,X ; 0709: A6 05 \n");
A = (UINT8)memory[(UINT16)(X + 0x0005)];
// N = A;
// Z = A;
// V = 0;
mon(" INCA ; 070B: 4C \n");
res = (UINT8)(A + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
mon(" ANDA #$03 ; 070C: 84 03 \n");
A = A & (SINT8)0x03;
// Z = A;
// N = A;
// V = 0;
mon(" STA $05,X ; 070E: A7 05 \n");
Z = A;
N = A;
V = 0;
memory[(UINT16)(X + 0x0005)] = A;
case 0x0710: mon("L0710 RTS ; 0710: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0711: mon("L0711 LDA ,X ; 0711: A6 84 \n");
A = (UINT8)memory[X];
N = A;
Z = A;
// V = 0;
mon(" BMI $06E1 ; 0713: 2B CC \n");
if ((SINT8)N < 0) {
PC = 0x06e1;
JUMP;
}
mon(" BEQ $0710 ; 0715: 27 F9 \n");
if (!Z) {
PC = 0x0710;
JUMP;
}
mon(" PSHS X ; 0717: 34 10 \n");
memory[--S] = X & 0xff; memory[--S] = X >> 8;
mon(" LDA $03,X ; 0719: A6 03 \n");
A = (UINT8)memory[(UINT16)(X + 0x0003)];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $0721 ; 071B: 27 04 \n");
if (!Z) {
PC = 0x0721;
JUMP;
}
mon(" DEC $03,X ; 071D: 6A 03 \n");
res = (UINT8)(memory[(UINT16)(X + 0x0003)] - 1);
// N = res;
Z = res;
// V = memory[(UINT16)(X + 0x0003)] & ~res;
memory[(UINT16)(X + 0x0003)] = res;
mon(" BNE $0771 ; 071F: 26 50 \n");
if (Z) {
PC = 0x0771;
JUMP;
}
case 0x0721: mon("L0721 LDA $03,Y ; 0721: A6 23 \n");
A = (UINT8)memory[(UINT16)(Y + 0x0003)];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $0771 ; 0723: 27 4C \n");
if (!Z) {
PC = 0x0771;
JUMP;
}
mon(" LDB <$DA ; 0725: D6 DA \n");
B = (UINT8)memory_DP[0xda];
// N = B;
// Z = B;
// V = 0;
mon(" LDU $01,X ; 0727: EE 01 \n");
U = ((memory[(UINT16)(X + 0x0001)]<<8)|memory[(UINT16)(((UINT16)(X + 0x0001))+1)]);
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDA ,U ; 0729: A6 C4 \n");
A = (UINT8)memory[U];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $0734 ; 072B: 27 07 \n");
if (!Z) {
PC = 0x0734;
JUMP;
}
mon(" INCB ; 072D: 5C \n");
res = (UINT8)(B + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
mon(" LEAU $07,U ; 072E: 33 47 \n");
U = (U + 0x0007);
mon(" LDA ,U ; 0730: A6 C4 \n");
A = (UINT8)memory[U];
// N = A;
Z = A;
// V = 0;
mon(" BNE $0771 ; 0732: 26 3D \n");
if (Z) {
PC = 0x0771;
JUMP;
}
case 0x0734: mon("L0734 STB <$CB ; 0734: D7 CB \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xcb] = B;
mon(" DEC ,U ; 0736: 6A C4 \n");
res = (UINT8)(memory[U] - 1);
// N = res;
// Z = res;
// V = memory[U] & ~res;
memory[U] = res;
mon(" LDA #$10 ; 0738: 86 10 \n");
A = (UINT8)(SINT8)0x10;
// N = A;
// Z = A;
// V = 0;
mon(" ORA <$67 ; 073A: 9A 67 \n");
A = A | memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
mon(" STA <$67 ; 073C: 97 67 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
mon(" LDA $06,X ; 073E: A6 06 \n");
A = (UINT8)memory[(UINT16)(X + 0x0006)];
// N = A;
// Z = A;
// V = 0;
mon(" LDB $08,X ; 0740: E6 08 \n");
B = (UINT8)memory[(UINT16)(X + 0x0008)];
// N = B;
// Z = B;
// V = 0;
mon(" STD $01,U ; 0742: ED 41 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0001)] = A;
memory[(UINT16)(U + 0x0001) + 1] = B;
mon(" LDB $0A,X ; 0744: E6 0A \n");
B = (UINT8)memory[(UINT16)(X + 0x000a)];
// N = B;
// Z = B;
// V = 0;
mon(" JSR $04EB ; 0746: BD 04 EB \n");
memory[--S] = 0x0749 & 0xff; memory[--S] = 0x0749 >> 8;
PC = 0x04eb;
JUMP;
case 0x0749: mon("L0749 LDA #$08 ; 0749: 86 08 \n");
A = (UINT8)(SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
mon(" STA $03,X ; 074B: A7 03 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0003)] = A;
mon(" LDB #$0A ; 074D: C6 0A \n");
B = (UINT8)(SINT8)0x0a;
// N = B;
// Z = B;
// V = 0;
mon(" LDA <$CB ; 074F: 96 CB \n");
A = (UINT8)memory_DP[0xcb];
// N = A;
// Z = A;
// V = 0;
mon(" MUL ; 0751: 3D \n");
res = (UINT16)(A * B);
// Z = res;
C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" LDU #$CA56 ; 0752: CE CA 56 \n");
U = 0xca56;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LEAU B,U ; 0755: 33 C5 \n");
U = (U + (SINT8)B);
mon(" LDA $0A,X ; 0757: A6 0A \n");
A = (UINT8)memory[(UINT16)(X + 0x000a)];
// N = A;
// Z = A;
// V = 0;
mon(" LDX #$0D7B ; 0759: 8E 0D 7B \n");
X = 0x0d7b;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDB #$04 ; 075C: C6 04 \n");
B = (UINT8)(SINT8)0x04;
// N = B;
// Z = B;
// V = 0;
mon(" JSR Rot_VL_ab ; 075E: BD F6 10 \n");
memory[--S] = 0x0761 & 0xff; memory[--S] = 0x0761 >> 8;
PC = 0xf610;
JUMP;
case 0x0761: mon("L0761 LDA <$EF ; 0761: 96 EF \n");
A = (UINT8)memory_DP[0xef];
N = A;
// Z = A;
// V = 0;
mon(" BMI $076F ; 0763: 2B 0A \n");
if ((SINT8)N < 0) {
PC = 0x076f;
JUMP;
}
mon(" LDA #$80 ; 0765: 86 80 \n");
A = (UINT8)(SINT8)0x80;
// N = A;
// Z = A;
// V = 0;
mon(" ORA <$67 ; 0767: 9A 67 \n");
A = A | memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
mon(" STA <$67 ; 0769: 97 67 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
mon(" LDA #$20 ; 076B: 86 20 \n");
A = (UINT8)(SINT8)0x20;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$EF ; 076D: 97 EF \n");
Z = A;
N = A;
V = 0;
memory_DP[0xef] = A;
case 0x076F: mon("L076F PULS X,PC ; 076F: 35 90 \n"); // ;(PUL? PC=RTS)
X = memory[S++]<<8;
X |= memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0771: mon("L0771 LDA $02,Y ; 0771: A6 22 \n");
A = (UINT8)memory[(UINT16)(Y + 0x0002)];
// N = A;
Z = A;
// V = 0;
mon(" BEQ $07CD ; 0773: 27 58 \n");
if (!Z) {
PC = 0x07cd;
JUMP;
}
mon(" LDB $04,X ; 0775: E6 04 \n");
B = (UINT8)memory[(UINT16)(X + 0x0004)];
// N = B;
// Z = B;
// V = 0;
mon(" SEX ; 0777: 1D \n");
// Z = B;
// N = B & 0x80;
A = ((B & 0x80) != 0) ? 0xff : 0;
mon(" ASLB ; 0778: 58 \n");
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
mon(" ROLA ; 0779: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
// C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" ASLB ; 077A: 58 \n");
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
mon(" ROLA ; 077B: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
// C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" ASLB ; 077C: 58 \n");
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
mon(" ROLA ; 077D: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
// C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" STD <$CB ; 077E: DD CB \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcb] = A;
memory_DP[0xcb + 1] = B;
mon(" ADDD $06,X ; 0780: E3 06 \n");
arg = (A << 8) | B;
res = arg + ((memory[(UINT16)(X + 0x0006)]<<8)|memory[(UINT16)(((UINT16)(X + 0x0006))+1)]);
// C = res & 0x10000;
res = (UINT16)res;
// Z = res;
// V = ((arg ^ res) & ((((memory[(UINT16)(X + 0x0006)]<<8)|memory[(UINT16)(((UINT16)(X + 0x0006))+1)])) ^ res)) >> 8;
// N = res >> 8;
A = (UINT8)(res >> 8);
B = (UINT8)(res & 0xff);
mon(" STD $06,X ; 0782: ED 06 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0006)] = A;
memory[(UINT16)(X + 0x0006) + 1] = B;
mon(" LDB $05,X ; 0784: E6 05 \n");
B = (UINT8)memory[(UINT16)(X + 0x0005)];
// N = B;
// Z = B;
// V = 0;
mon(" SEX ; 0786: 1D \n");
// Z = B;
// N = B & 0x80;
A = ((B & 0x80) != 0) ? 0xff : 0;
mon(" ASLB ; 0787: 58 \n");
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
mon(" ROLA ; 0788: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
// C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" ASLB ; 0789: 58 \n");
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
mon(" ROLA ; 078A: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
// C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" ASLB ; 078B: 58 \n");
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
mon(" ROLA ; 078C: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
// C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" STD <$CD ; 078D: DD CD \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcd] = A;
memory_DP[0xcd + 1] = B;
mon(" ADDD $08,X ; 078F: E3 08 \n");
arg = (A << 8) | B;
res = arg + ((memory[(UINT16)(X + 0x0008)]<<8)|memory[(UINT16)(((UINT16)(X + 0x0008))+1)]);
// C = res & 0x10000;
res = (UINT16)res;
// Z = res;
// V = ((arg ^ res) & ((((memory[(UINT16)(X + 0x0008)]<<8)|memory[(UINT16)(((UINT16)(X + 0x0008))+1)])) ^ res)) >> 8;
// N = res >> 8;
A = (UINT8)(res >> 8);
B = (UINT8)(res & 0xff);
mon(" STD $08,X ; 0791: ED 08 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0008)] = A;
memory[(UINT16)(X + 0x0008) + 1] = B;
mon(" CLRB ; 0793: 5F \n");
B = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LDA $06,X ; 0794: A6 06 \n");
A = (UINT8)memory[(UINT16)(X + 0x0006)];
N = A;
// Z = A;
// V = 0;
mon(" BPL $079A ; 0796: 2A 02 \n");
if ((SINT8)N >= 0) {
PC = 0x079a;
JUMP;
}
mon(" NEGA ; 0798: 40 \n");
// V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
mon(" INCB ; 0799: 5C \n");
res = (UINT8)(B + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
case 0x079A: mon("L079A STA <$DB ; 079A: 97 DB \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xdb] = A;
mon(" LDA $08,X ; 079C: A6 08 \n");
A = (UINT8)memory[(UINT16)(X + 0x0008)];
N = A;
// Z = A;
// V = 0;
mon(" BPL $07A3 ; 079E: 2A 03 \n");
if ((SINT8)N >= 0) {
PC = 0x07a3;
JUMP;
}
mon(" NEGA ; 07A0: 40 \n");
// V = (UINT8)(-A) & (A);
C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
mon(" ORB #$02 ; 07A1: CA 02 \n");
B = B | (SINT8)0x02;
// Z = B;
// N = B;
// V = 0;
case 0x07A3: mon("L07A3 STA <$DC ; 07A3: 97 DC \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xdc] = A;
mon(" PSHS B ; 07A5: 34 04 \n");
memory[--S] = B;
mon(" LDB <$DB ; 07A7: D6 DB \n");
B = (UINT8)memory_DP[0xdb];
// N = B;
// Z = B;
// V = 0;
mon(" LDU #$0F6A ; 07A9: CE 0F 6A \n");
U = 0x0f6a;
Z = U;
N = (U) >> 8;
V = 0;
mon(" BSR $081C ; 07AC: 8D 6E \n");
memory[--S] = 0x07ae & 0xff; memory[--S] = 0x07ae >> 8;
PC = 0x081c;
JUMP;
case 0x07AE: mon("L07AE BVC $07B2 ; 07AE: 28 02 \n");
if ((SINT8)V >= 0) {
PC = 0x07b2;
JUMP;
}
mon(" STB <$DB ; 07B0: D7 DB \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xdb] = B;
case 0x07B2: mon("L07B2 LDB <$DC ; 07B2: D6 DC \n");
B = (UINT8)memory_DP[0xdc];
// N = B;
// Z = B;
// V = 0;
mon(" LDU #$0F20 ; 07B4: CE 0F 20 \n");
U = 0x0f20;
Z = U;
N = (U) >> 8;
V = 0;
mon(" BSR $081C ; 07B7: 8D 63 \n");
memory[--S] = 0x07b9 & 0xff; memory[--S] = 0x07b9 >> 8;
PC = 0x081c;
JUMP;
case 0x07B9: mon("L07B9 BVC $07BD ; 07B9: 28 02 \n");
if ((SINT8)V >= 0) {
PC = 0x07bd;
JUMP;
}
mon(" STB <$DC ; 07BB: D7 DC \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xdc] = B;
case 0x07BD: mon("L07BD LDD <$DB ; 07BD: DC DB \n");
A = memory_DP[0xdb];
B = memory_DP[0xdb + 1];
// Z = A|B;
// N = A;
// V = 0;
mon(" ROR ,S ; 07BF: 66 E4 \n");
res = ((UINT8)memory[S]) | ((C != 0) ? 0x100 : 0);
C = res & 1;
res = (UINT8)(res >> 1);
// Z = res;
// N = res;
memory[S] = res;
mon(" BCC $07C4 ; 07C1: 24 01 \n");
if (!C) {
PC = 0x07c4;
JUMP;
}
mon(" NEGA ; 07C3: 40 \n");
// V = (UINT8)(-A) & (A);
C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
case 0x07C4: mon("L07C4 STA $06,X ; 07C4: A7 06 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0006)] = A;
mon(" ROR ,S+ ; 07C6: 66 E0 \n");
res = ((UINT8)memory[S]) | ((C != 0) ? 0x100 : 0);
C = res & 1;
res = (UINT8)(res >> 1);
// Z = res;
// N = res;
memory[S] = res;
S = S + 1;
mon(" BCC $07CB ; 07C8: 24 01 \n");
if (!C) {
PC = 0x07cb;
JUMP;
}
mon(" NEGB ; 07CA: 50 \n");
// V = (UINT8)(-B) & (B);
// C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
case 0x07CB: mon("L07CB STB $08,X ; 07CB: E7 08 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0008)] = B;
case 0x07CD: mon("L07CD CLRA ; 07CD: 4F \n");
A = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LDB ,Y ; 07CE: E6 A4 \n");
B = (UINT8)memory[Y];
// N = B;
Z = B;
// V = 0;
mon(" BEQ $07D3 ; 07D0: 27 01 \n");
if (!Z) {
PC = 0x07d3;
JUMP;
}
mon(" INCA ; 07D2: 4C \n");
res = (UINT8)(A + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
case 0x07D3: mon("L07D3 LDB $01,Y ; 07D3: E6 21 \n");
B = (UINT8)memory[(UINT16)(Y + 0x0001)];
// N = B;
Z = B;
// V = 0;
mon(" BEQ $07D8 ; 07D5: 27 01 \n");
if (!Z) {
PC = 0x07d8;
JUMP;
}
mon(" DECA ; 07D7: 4A \n");
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
case 0x07D8: mon("L07D8 TSTA ; 07D8: 4D \n");
Z = A;
// N = A;
// V = 0;
mon(" BEQ $07FA ; 07D9: 27 1F \n");
if (!Z) {
PC = 0x07fa;
JUMP;
}
mon(" ADDA $0A,X ; 07DB: AB 0A \n");
res = A + memory[(UINT16)(X + 0x000a)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = A ^ memory[(UINT16)(X + 0x000a)] ^ (UINT8)res ^ C;
// V = A ^ memory[(UINT16)(X + 0x000a)] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" ANDA #$3F ; 07DD: 84 3F \n");
A = A & (SINT8)0x3f;
// Z = A;
// N = A;
// V = 0;
mon(" STA $0A,X ; 07DF: A7 0A \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x000a)] = A;
mon(" TFR A,B ; 07E1: 1F 89 \n");
B = A;
mon(" LDA #$20 ; 07E3: 86 20 \n");
A = (UINT8)(SINT8)0x20;
// N = A;
// Z = A;
// V = 0;
mon(" JSR Rise_Run_X ; 07E5: BD F5 FF \n");
memory[--S] = 0x07e8 & 0xff; memory[--S] = 0x07e8 >> 8;
PC = 0xf5ff;
JUMP;
case 0x07E8: mon("L07E8 STD $04,X ; 07E8: ED 04 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0004)] = A;
memory[(UINT16)(X + 0x0004) + 1] = B;
mon(" LDA <$DA ; 07EA: 96 DA \n");
A = (UINT8)memory_DP[0xda];
// N = A;
// Z = A;
// V = 0;
mon(" LDB #$0E ; 07EC: C6 0E \n");
B = (UINT8)(SINT8)0x0e;
// N = B;
// Z = B;
// V = 0;
mon(" MUL ; 07EE: 3D \n");
res = (UINT16)(A * B);
// Z = res;
C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" LDA $0A,X ; 07EF: A6 0A \n");
A = (UINT8)memory[(UINT16)(X + 0x000a)];
// N = A;
// Z = A;
// V = 0;
mon(" LEAU $0B,X ; 07F1: 33 0B \n");
U = (X + 0x000b);
mon(" LDX #$0D46 ; 07F3: 8E 0D 46 \n");
X = 0x0d46;
Z = X;
N = (X) >> 8;
V = 0;
mon(" ABX ; 07F6: 3A \n");
X = X + B;
mon(" JSR Rot_VL_Mode_a ; 07F7: BD F6 1F \n");
memory[--S] = 0x07fa & 0xff; memory[--S] = 0x07fa >> 8;
PC = 0xf61f;
JUMP;
case 0x07FA: mon("L07FA PULS X,PC ; 07FA: 35 90 \n"); // ;(PUL? PC=RTS)
X = memory[S++]<<8;
X |= memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
// FCB $E6 ; 07FC: ' ' E6 13 LDB -13,X
// FCB $13 ; 07FD: ' ' 13 SYNC
// FCB $86 ; 07FE: ' ' 86 02 LDA #$02
// FCB $02 ; 07FF: ' ' 02 Invalid
// FCB $A7 ; 0800: ' ' A7 13 STA -13,X
// FCB $13 ; 0801: ' ' 13 SYNC
// FCB $30 ; 0802: '0' 30 C4 LEAX ,U
// FCB $C4 ; 0803: ' ' C4 C0 ANDB #$C0
// FCB $C0 ; 0804: ' ' C0 02 SUBB #$02
// FCB $02 ; 0805: ' ' 02 Invalid
// FCB $2B ; 0806: '+' 2B 06 BMI $080E
// FCB $06 ; 0807: ' ' 06 86 ROR <$86
// FCB $86 ; 0808: ' ' 86 80 LDA #$80
// FCB $80 ; 0809: ' ' 80 A7 SUBA #$A7
// FCB $A7 ; 080A: ' ' A7 84 STA ,X
// FCB $84 ; 080B: ' ' 84 35 ANDA #$35
// FCB $35 ; 080C: '5' 35 90 PULS PC,X
// FCB $90 ; 080D: ' ' 90 EC SUBA <$EC
// FCB $EC ; 080E: ' ' EC 06 LDD 6,X
// FCB $06 ; 080F: ' ' 06 93 ROR <$93
// FCB $93 ; 0810: ' ' 93 CB SUBD <$CB
// FCB $CB ; 0811: ' ' CB ED ADDB #$ED
// FCB $ED ; 0812: ' ' ED 06 STD 6,X
// FCB $06 ; 0813: ' ' 06 EC ROR <$EC
// FCB $EC ; 0814: ' ' EC 08 LDD 8,X
// FCB $08 ; 0815: ' ' 08 93 ASL <$93
// FCB $93 ; 0816: ' ' 93 CD SUBD <$CD
// FCB $CD ; 0817: ' ' CD Invalid
// FCB $ED ; 0818: ' ' ED 08 STD 8,X
// FCB $08 ; 0819: ' ' 08 20 ASL <$20
// FCB $20 ; 081A: ' ' 20 B1 BRA $07CD
// FCB $B1 ; 081B: ' ' B1 C0 0A CMPA $C00A
case 0x081C: mon("L081C SUBB #$0A ; 081C: C0 0A \n");
res = B - (SINT8)0x0a;
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
// V = ((B) ^ (SINT8)0x0a) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
mon(" BMI $084A ; 081E: 2B 2A \n");
if ((SINT8)N < 0) {
PC = 0x084a;
JUMP;
}
mon(" ANDB #$70 ; 0820: C4 70 \n");
B = B & (SINT8)0x70;
// Z = B;
// N = B;
// V = 0;
mon(" ASRB ; 0822: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" ASRB ; 0823: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" ASRB ; 0824: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" LDD B,U ; 0825: EC C5 \n");
A = memory[(UINT16)(U + (SINT8)B)];
B = memory[(UINT16)(((UINT16)(U + (SINT8)B))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" LEAU A,U ; 0827: 33 C6 \n");
U = (U + (SINT8)A);
mon(" STB <$DD ; 0829: D7 DD \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xdd] = B;
case 0x082B: mon("L082B LDD <$DB ; 082B: DC DB \n");
A = memory_DP[0xdb];
B = memory_DP[0xdb + 1];
// Z = A|B;
// N = A;
// V = 0;
mon(" SUBA ,U ; 082D: A0 C4 \n");
res = A - memory[U];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
// V = ((A) ^ memory[U]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" BMI $0842 ; 082F: 2B 11 \n");
if ((SINT8)N < 0) {
PC = 0x0842;
JUMP;
}
mon(" CMPA $01,U ; 0831: A1 41 \n");
res = A - memory[(UINT16)(U + 0x0001)];
// C = res & 0x100;
Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ memory[(UINT16)(U + 0x0001)]) & (A ^ (UINT8)res);
mon(" BGT $0842 ; 0833: 2E 0D \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0842;
JUMP;
}
mon(" SUBB $02,U ; 0835: E0 42 \n");
res = B - memory[(UINT16)(U + 0x0002)];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
// V = ((B) ^ memory[(UINT16)(U + 0x0002)]) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
mon(" BMI $0842 ; 0837: 2B 09 \n");
if ((SINT8)N < 0) {
PC = 0x0842;
JUMP;
}
mon(" CMPB $03,U ; 0839: E1 43 \n");
res = B - memory[(UINT16)(U + 0x0003)];
C = res & 0x100;
Z = (UINT8)res;
N = (UINT8)res;
V = (B ^ memory[(UINT16)(U + 0x0003)]) & (B ^ (UINT8)res);
mon(" BGT $0842 ; 083B: 2E 05 \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0842;
JUMP;
}
mon(" LDB $04,U ; 083D: E6 44 \n");
B = (UINT8)memory[(UINT16)(U + 0x0004)];
N = B;
Z = B;
// V = 0;
mon(" ORCC #$02 ; 083F: 1A 02 \n");
V = 1;
mon(" RTS ; 0841: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0842: mon("L0842 LEAU $05,U ; 0842: 33 45 \n");
U = (U + 0x0005);
mon(" DEC <$DD ; 0844: 0A DD \n");
res = (UINT8)(memory_DP[0xdd] - 1);
N = res;
Z = res;
// V = memory_DP[0xdd] & ~res;
memory_DP[0xdd] = res;
mon(" BNE $082B ; 0846: 26 E3 \n");
if (Z) {
PC = 0x082b;
JUMP;
}
mon(" ANDCC #$FD ; 0848: 1C FD \n");
V = 0;
case 0x084A: mon("L084A RTS ; 084A: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x084B: mon("L084B LDU #$CA00 ; 084B: CE CA 00 \n");
U = 0xca00;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDY #$C9C0 ; 084E: 10 8E C9 C0 \n");
Y = 0xc9c0;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
mon(" LDX #$0D46 ; 0852: 8E 0D 46 \n");
X = 0x0d46;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDA <$C8 ; 0855: 96 C8 \n");
A = (UINT8)memory_DP[0xc8];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$C7 ; 0857: 97 C7 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xc7] = A;
mon(" LDB #$20 ; 0859: C6 20 \n");
B = (UINT8)(SINT8)0x20;
// N = B;
// Z = B;
// V = 0;
case 0x085B: mon("L085B PSHS B,A ; 085B: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
mon(" STA ,U+ ; 085D: A7 C0 \n");
// Z = A;
// N = A;
// V = 0;
memory[U] = A;
U = U + 1;
mon(" STY ,U++ ; 085F: 10 AF C1 \n");
// Z = Y;
// N = (Y) >> 8;
// V = 0;
memory[U] = (UINT8)((Y) >> 8);
memory[(UINT16)(U + 1)] = (Y) & 0xff;
U = U + 2;
mon(" LDB #$08 ; 0862: C6 08 \n");
B = (UINT8)(SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
case 0x0864: mon("L0864 CLR ,U+ ; 0864: 6F C0 \n");
memory[U] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
U = U + 1;
mon(" DECB ; 0866: 5A \n");
res = (UINT8)(B - 1);
// N = res;
Z = res;
// V = B & ~res;
B = res;
mon(" BNE $0864 ; 0867: 26 FB \n");
if (Z) {
PC = 0x0864;
JUMP;
}
mon(" LDD ,S ; 0869: EC E4 \n");
A = memory[S];
B = memory[(UINT16)((S)+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" STD -6,U ; 086B: ED 5A \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0xfffa)] = A;
memory[(UINT16)(U + 0xfffa) + 1] = B;
mon(" JSR Rot_VL_Mode_a ; 086D: BD F6 1F \n");
memory[--S] = 0x0870 & 0xff; memory[--S] = 0x0870 >> 8;
PC = 0xf61f;
JUMP;
case 0x0870: mon("L0870 LEAY $0E,Y ; 0870: 31 2E \n");
Y = (Y + 0x000e);
// Z = Y;
mon(" PULS A,B ; 0872: 35 06 \n");
A = memory[S++];
B = memory[S++];
mon(" NEGB ; 0874: 50 \n");
// V = (UINT8)(-B) & (B);
C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
mon(" DECA ; 0875: 4A \n");
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
mon(" BNE $085B ; 0876: 26 E3 \n");
if (Z) {
PC = 0x085b;
JUMP;
}
mon(" RTS ; 0878: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0879: mon("L0879 NEGA ; 0879: 40 \n");
V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
mon(" BVC $088D ; 087A: 28 11 \n");
if ((SINT8)V >= 0) {
PC = 0x088d;
JUMP;
}
mon(" DECA ; 087C: 4A \n");
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
mon(" CLRB ; 087D: 5F \n");
B = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" STD <$92 ; 087E: DD 92 \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x92] = A;
memory_DP[0x92 + 1] = B;
mon(" ASR <$A3 ; 0880: 07 A3 \n");
// C = memory_DP[0xa3] & 1;
memory_DP[0xa3] = (UINT8)((SINT8)memory_DP[0xa3] >> 1);
// Z = memory_DP[0xa3];
// N = memory_DP[0xa3];
mon(" ASR <$A4 ; 0882: 07 A4 \n");
// C = memory_DP[0xa4] & 1;
memory_DP[0xa4] = (UINT8)((SINT8)memory_DP[0xa4] >> 1);
// Z = memory_DP[0xa4];
// N = memory_DP[0xa4];
mon(" DECB ; 0884: 5A \n");
res = (UINT8)(B - 1);
// N = res;
// Z = res;
// V = B & ~res;
B = res;
mon(" STB <$EF ; 0885: D7 EF \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xef] = B;
mon(" LDA #$80 ; 0887: 86 80 \n");
A = (UINT8)(SINT8)0x80;
// N = A;
// Z = A;
// V = 0;
mon(" ORA <$67 ; 0889: 9A 67 \n");
A = A | memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
mon(" STA <$67 ; 088B: 97 67 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
case 0x088D: mon("L088D INC <$94 ; 088D: 0C 94 \n");
res = (UINT8)(memory_DP[0x94] + 1);
Z = res;
// N = res;
// V = res & ~(memory_DP[0x94]);
memory_DP[0x94] = res;
mon(" BNE $089A ; 088F: 26 09 \n");
if (Z) {
PC = 0x089a;
JUMP;
}
mon(" CLR <$EF ; 0891: 0F EF \n");
memory_DP[0xef] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" LDA #$F7 ; 0893: 86 F7 \n");
A = (UINT8)(SINT8)0xf7;
// N = A;
// Z = A;
// V = 0;
mon(" ANDA <$67 ; 0895: 94 67 \n");
A = A & memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
mon(" STA <$67 ; 0897: 97 67 \n");
Z = A;
N = A;
V = 0;
memory_DP[0x67] = A;
mon(" RTS ; 0899: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x089A: mon("L089A RORA ; 089A: 46 \n");
res = ((UINT8)A) | ((C != 0) ? 0x100 : 0);
C = res & 1;
res = (UINT8)(res >> 1);
// Z = res;
// N = res;
A = res;
mon(" BCC $08B7 ; 089B: 24 1A \n");
if (!C) {
PC = 0x08b7;
JUMP;
}
mon(" INC <$A5 ; 089D: 0C A5 \n");
res = (UINT8)(memory_DP[0xa5] + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0xa5]);
memory_DP[0xa5] = res;
mon(" DEC <$A6 ; 089F: 0A A6 \n");
res = (UINT8)(memory_DP[0xa6] - 1);
// N = res;
// Z = res;
// V = memory_DP[0xa6] & ~res;
memory_DP[0xa6] = res;
mon(" RORA ; 08A1: 46 \n");
res = ((UINT8)A) | ((C != 0) ? 0x100 : 0);
C = res & 1;
res = (UINT8)(res >> 1);
// Z = res;
// N = res;
A = res;
mon(" BCC $08A8 ; 08A2: 24 04 \n");
if (!C) {
PC = 0x08a8;
JUMP;
}
mon(" DEC <$92 ; 08A4: 0A 92 \n");
res = (UINT8)(memory_DP[0x92] - 1);
// N = res;
// Z = res;
// V = memory_DP[0x92] & ~res;
memory_DP[0x92] = res;
mon(" INC <$93 ; 08A6: 0C 93 \n");
res = (UINT8)(memory_DP[0x93] + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0x93]);
memory_DP[0x93] = res;
case 0x08A8: mon("L08A8 LDA <$A6 ; 08A8: 96 A6 \n");
A = (UINT8)memory_DP[0xa6];
// N = A;
// Z = A;
// V = 0;
mon(" LEAU $0A,X ; 08AA: 33 0A \n");
U = (X + 0x000a);
mon(" LDX #$0FCE ; 08AC: 8E 0F CE \n");
X = 0x0fce;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" JSR Rot_VL_Mode_a ; 08AF: BD F6 1F \n");
memory[--S] = 0x08b2 & 0xff; memory[--S] = 0x08b2 >> 8;
PC = 0xf61f;
JUMP;
case 0x08B2: mon("L08B2 LDA <$A6 ; 08B2: 96 A6 \n");
A = (UINT8)memory_DP[0xa6];
N = A;
Z = A;
V = 0;
mon(" JSR Rot_VL_Mode_a ; 08B4: BD F6 1F \n");
memory[--S] = 0x08b7 & 0xff; memory[--S] = 0x08b7 >> 8;
PC = 0xf61f;
JUMP;
case 0x08B7: mon("L08B7 JMP $0965 ; 08B7: 7E 09 65 \n");
PC = 0x0965;
JUMP;
case 0x08BA: mon("L08BA LDX <$30 ; 08BA: 9E 30 \n");
X = ((memory_DP[0x30]<<8)|memory_DP[0x30 + 1]);
Z = X;
// N = (X) >> 8;
// V = 0;
mon(" BEQ $0911 ; 08BC: 27 53 \n");
if (!Z) {
PC = 0x0911;
JUMP;
}
mon(" LEAX -1,X ; 08BE: 30 1F \n");
X = (X + 0xffff);
// Z = X;
mon(" STX <$30 ; 08C0: 9F 30 \n");
Z = X;
// N = (X) >> 8;
// V = 0;
memory_DP[0x30] = (UINT8)((X) >> 8);
memory_DP[(UINT16)(0x30 + 1)] = (X) & 0xff;
mon(" BNE $0910 ; 08C2: 26 4C \n");
if (Z) {
PC = 0x0910;
JUMP;
}
mon(" LDA #$F7 ; 08C4: 86 F7 \n");
A = (UINT8)(SINT8)0xf7;
// N = A;
// Z = A;
// V = 0;
mon(" ANDA <$67 ; 08C6: 94 67 \n");
A = A & memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
mon(" STA <$67 ; 08C8: 97 67 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
mon(" COM <$8A ; 08CA: 03 8A \n");
memory_DP[0x8a] = memory_DP[0x8a] ^ 0xff;
// Z = memory_DP[0x8a];
// N = memory_DP[0x8a];
// V = 0;
// C = 256;
mon(" LDX #$C894 ; 08CC: 8E C8 94 \n");
X = 0xc894;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDB #$19 ; 08CF: C6 19 \n");
B = (UINT8)(SINT8)0x19;
// N = B;
// Z = B;
// V = 0;
mon(" JSR Clear_x_b ; 08D1: BD F5 3F \n");
memory[--S] = 0x08d4 & 0xff; memory[--S] = 0x08d4 >> 8;
PC = 0xf53f;
JUMP;
case 0x08D4: mon("L08D4 LDA #$00 ; 08D4: 86 00 \n");
A = (UINT8)(SINT8)0x00;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$71 ; 08D6: 97 71 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x71] = A;
mon(" LDA #$02 ; 08D8: 86 02 \n");
A = (UINT8)(SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$94 ; 08DA: 97 94 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x94] = A;
mon(" DECA ; 08DC: 4A \n");
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
mon(" STA <$95 ; 08DD: 97 95 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x95] = A;
mon(" LDD #$CA00 ; 08DF: CC CA 00 \n");
A = (UINT8)((0xca00) >> 8);
B = (UINT8)((0xca00) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD <$9B ; 08E2: DD 9B \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x9b] = A;
memory_DP[0x9b + 1] = B;
mon(" LDA <$83 ; 08E4: 96 83 \n");
A = (UINT8)memory_DP[0x83];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$96 ; 08E6: 97 96 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x96] = A;
mon(" LDA <$86 ; 08E8: 96 86 \n");
A = (UINT8)memory_DP[0x86];
// N = A;
// Z = A;
// V = 0;
mon(" STA <$9A ; 08EA: 97 9A \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x9a] = A;
mon(" LEAX $09,X ; 08EC: 30 09 \n");
X = (X + 0x0009);
// Z = X;
mon(" JSR Random ; 08EE: BD F5 17 \n");
memory[--S] = 0x08f1 & 0xff; memory[--S] = 0x08f1 >> 8;
PC = 0xf517;
JUMP;
case 0x08F1: mon("L08F1 CLRB ; 08F1: 5F \n");
B = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" ROLA ; 08F2: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" ROLB ; 08F3: 59 \n");
res = ((B) << 1) + (C != 0 ?1:0);
C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (B);
B = (UINT8)res;
mon(" LEAX B,X ; 08F4: 30 85 \n");
X = (X + (SINT8)B);
// Z = X;
mon(" STB <$CB ; 08F6: D7 CB \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xcb] = B;
mon(" LDB #$7F ; 08F8: C6 7F \n");
B = (UINT8)(SINT8)0x7f;
// N = B;
// Z = B;
// V = 0;
mon(" ROLA ; 08FA: 49 \n");
res = ((A) << 1) + (C != 0 ?1:0);
C = res & 0x100;
// Z = (UINT8)res;
// N = res;
// V = res ^ (A);
A = (UINT8)res;
mon(" BCC $08FE ; 08FB: 24 01 \n");
if (!C) {
PC = 0x08fe;
JUMP;
}
mon(" NEGB ; 08FD: 50 \n");
// V = (UINT8)(-B) & (B);
// C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
case 0x08FE: mon("L08FE STB ,X ; 08FE: E7 84 \n");
// Z = B;
// N = B;
// V = 0;
memory[X] = B;
mon(" ASRB ; 0900: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" ASRB ; 0901: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" STB $02,X ; 0902: E7 02 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0002)] = B;
mon(" LDA #$07 ; 0904: 86 07 \n");
A = (UINT8)(SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
mon(" SUBA <$CB ; 0906: 90 CB \n");
res = A - memory_DP[0xcb];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((A) ^ memory_DP[0xcb]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" SUBA <$CB ; 0908: 90 CB \n");
res = A - memory_DP[0xcb];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((A) ^ memory_DP[0xcb]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" LEAX A,X ; 090A: 30 86 \n");
X = (X + (SINT8)A);
// Z = X;
mon(" INC ,X ; 090C: 6C 84 \n");
res = (UINT8)(memory[X] + 1);
// Z = res;
// N = res;
// V = res & ~(memory[X]);
memory[X] = res;
mon(" COM <$98 ; 090E: 03 98 \n");
memory_DP[0x98] = memory_DP[0x98] ^ 0xff;
Z = memory_DP[0x98];
N = memory_DP[0x98];
V = 0;
C = 256;
case 0x0910: mon("L0910 RTS ; 0910: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0911: mon("L0911 LDX #$C894 ; 0911: 8E C8 94 \n");
X = 0xc894;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" JSR $0709 ; 0914: BD 07 09 \n");
memory[--S] = 0x0917 & 0xff; memory[--S] = 0x0917 >> 8;
PC = 0x0709;
JUMP;
case 0x0917: mon("L0917 LEAX $09,X ; 0917: 30 09 \n");
X = (X + 0x0009);
// Z = X;
mon(" LDA <$94 ; 0919: 96 94 \n");
A = (UINT8)memory_DP[0x94];
N = A;
Z = A;
V = 0;
mon(" LBMI $0879 ; 091B: 10 2B FF 5A \n");
if ((SINT8)N < 0) {
PC = 0x0879;
JUMP;
}
mon(" BNE $0928 ; 091F: 26 07 \n");
if (Z) {
PC = 0x0928;
JUMP;
}
mon(" STD <$8C ; 0921: DD 8C \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x8c] = A;
memory_DP[0x8c + 1] = B;
mon(" LDD <$DE ; 0923: DC DE \n");
A = memory_DP[0xde];
B = memory_DP[0xde + 1];
// Z = A|B;
// N = A;
// V = 0;
mon(" STD <$30 ; 0925: DD 30 \n");
Z = A | B;
N = A;
V = 0;
memory_DP[0x30] = A;
memory_DP[0x30 + 1] = B;
mon(" RTS ; 0927: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0928: mon("L0928 LDA #$08 ; 0928: 86 08 \n");
A = (UINT8)(SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
mon(" ORA <$67 ; 092A: 9A 67 \n");
A = A | memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
mon(" STA <$67 ; 092C: 97 67 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
mon(" LDB <$98 ; 092E: D6 98 \n");
B = (UINT8)memory_DP[0x98];
N = B;
// Z = B;
// V = 0;
mon(" BPL $0940 ; 0930: 2A 0E \n");
if ((SINT8)N >= 0) {
PC = 0x0940;
JUMP;
}
mon(" LEAU $0A,X ; 0932: 33 0A \n");
U = (X + 0x000a);
mon(" LDX #$0FAF ; 0934: 8E 0F AF \n");
X = 0x0faf;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDA <$A6 ; 0937: 96 A6 \n");
A = (UINT8)memory_DP[0xa6];
// N = A;
// Z = A;
// V = 0;
mon(" JSR Rot_VL_Mode_a ; 0939: BD F6 1F \n");
memory[--S] = 0x093c & 0xff; memory[--S] = 0x093c >> 8;
PC = 0xf61f;
JUMP;
case 0x093C: mon("L093C CLR <$98 ; 093C: 0F 98 \n");
memory_DP[0x98] = 0;
V = 0;
Z = 0;
N = 0;
C = 0;
mon(" BRA $0965 ; 093E: 20 25 \n");
PC = 0x0965;
JUMP;
case 0x0940: mon("L0940 LDD <$8C ; 0940: DC 8C \n");
A = memory_DP[0x8c];
B = memory_DP[0x8c + 1];
// Z = A|B;
// N = A;
// V = 0;
mon(" TFR D,Y ; 0942: 1F 02 \n");
Y = ((A << 8) | B);
mon(" JSR $0C66 ; 0944: BD 0C 66 \n");
memory[--S] = 0x0947 & 0xff; memory[--S] = 0x0947 >> 8;
PC = 0x0c66;
JUMP;
case 0x0947: mon("L0947 ANDA <$84 ; 0947: 94 84 \n");
A = A & memory_DP[0x84];
// Z = A;
// N = A;
// V = 0;
mon(" STD <$CD ; 0949: DD CD \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcd] = A;
memory_DP[0xcd + 1] = B;
mon(" LEAX $09,X ; 094B: 30 09 \n");
X = (X + 0x0009);
// Z = X;
mon(" CMPB #$08 ; 094D: C1 08 \n");
res = B - (SINT8)0x08;
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (B ^ (SINT8)0x08) & (B ^ (UINT8)res);
mon(" BLS $0959 ; 094F: 23 08 \n");
if ((!Z) || C) {
PC = 0x0959;
JUMP;
}
mon(" SUBA <$A6 ; 0951: 90 A6 \n");
res = A - memory_DP[0xa6];
C = res & 0x100;
Z = (UINT8)res;
N = (UINT8)res;
V = ((A) ^ memory_DP[0xa6]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" BEQ $0959 ; 0953: 27 04 \n");
if (!Z) {
PC = 0x0959;
JUMP;
}
mon(" BSR $0989 ; 0955: 8D 32 \n");
memory[--S] = 0x0957 & 0xff; memory[--S] = 0x0957 >> 8;
PC = 0x0989;
JUMP;
case 0x0957: mon("L0957 DEC <$98 ; 0957: 0A 98 \n");
res = (UINT8)(memory_DP[0x98] - 1);
// N = res;
// Z = res;
// V = memory_DP[0x98] & ~res;
memory_DP[0x98] = res;
case 0x0959: mon("L0959 LEAX -1,X ; 0959: 30 1F \n");
X = (X + 0xffff);
// Z = X;
mon(" LDA <$95 ; 095B: 96 95 \n");
A = (UINT8)memory_DP[0x95];
// N = A;
// Z = A;
// V = 0;
mon(" ANDA #$01 ; 095D: 84 01 \n");
A = A & (SINT8)0x01;
// Z = A;
// N = A;
// V = 0;
mon(" ASLA ; 095F: 48 \n");
res = A << 1;
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = A ^ res;
A = res;
mon(" LDU #$0A55 ; 0960: CE 0A 55 \n");
U = 0x0a55;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" JSR [A,U] ; 0963: AD D6 \n");
memory[--S] = 0x0965 & 0xff; memory[--S] = 0x0965 >> 8;
PC = ((memory[(UINT16)(U + (SINT8)A)]<<8)|memory[(UINT16)(U + (SINT8)A + 1)]);
JUMP;
case 0x0965: mon("L0965 LDD #$78FF ; 0965: CC 78 FF \n");
A = (UINT8)((0x78ff) >> 8);
B = (UINT8)((0x78ff) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" LEAX -6,X ; 0968: 30 1A \n");
X = (X + 0xfffa);
// Z = X;
mon(" CMPA ,X+ ; 096A: A1 80 \n");
res = A - memory[X];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ memory[X]) & (A ^ (UINT8)res);
X = X + 1;
mon(" BLT $097E ; 096C: 2D 10 \n");
if ((SINT8)(N^V) < 0) {
PC = 0x097e;
JUMP;
}
mon(" CMPA ,X+ ; 096E: A1 80 \n");
res = A - memory[X];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ memory[X]) & (A ^ (UINT8)res);
X = X + 1;
mon(" BLT $097E ; 0970: 2D 0C \n");
if ((SINT8)(N^V) < 0) {
PC = 0x097e;
JUMP;
}
mon(" NEGA ; 0972: 40 \n");
// V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
mon(" NEGB ; 0973: 50 \n");
// V = (UINT8)(-B) & (B);
// C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
mon(" LEAX -2,X ; 0974: 30 1E \n");
X = (X + 0xfffe);
// Z = X;
mon(" CMPA ,X+ ; 0976: A1 80 \n");
res = A - memory[X];
// C = res & 0x100;
Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ memory[X]) & (A ^ (UINT8)res);
X = X + 1;
mon(" BGT $097E ; 0978: 2E 04 \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x097e;
JUMP;
}
mon(" CMPA ,X+ ; 097A: A1 80 \n");
res = A - memory[X];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ memory[X]) & (A ^ (UINT8)res);
X = X + 1;
mon(" BLT $0980 ; 097C: 2D 02 \n");
if ((SINT8)(N^V) < 0) {
PC = 0x0980;
JUMP;
}
case 0x097E: mon("L097E STB $03,X ; 097E: E7 03 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0003)] = B;
case 0x0980: mon("L0980 LDD <$9F ; 0980: DC 9F \n");
A = memory_DP[0x9f];
B = memory_DP[0x9f + 1];
// Z = A|B;
// N = A;
// V = 0;
mon(" ADDA <$A3 ; 0982: 9B A3 \n");
res = A + memory_DP[0xa3];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ memory_DP[0xa3] ^ (UINT8)res ^ C;
// V = A ^ memory_DP[0xa3] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" ADDB <$A4 ; 0984: DB A4 \n");
res = B + memory_DP[0xa4];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ memory_DP[0xa4] ^ (UINT8)res ^ C;
// V = B ^ memory_DP[0xa4] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" STD <$9F ; 0986: DD 9F \n");
Z = A | B;
N = A;
V = 0;
memory_DP[0x9f] = A;
memory_DP[0x9f + 1] = B;
mon(" RTS ; 0988: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0989: mon("L0989 ANDA #$3F ; 0989: 84 3F \n");
A = A & (SINT8)0x3f;
// Z = A;
// N = A;
// V = 0;
mon(" LDB #$01 ; 098B: C6 01 \n");
B = (UINT8)(SINT8)0x01;
// N = B;
// Z = B;
// V = 0;
mon(" CMPA #$20 ; 098D: 81 20 \n");
res = A - (SINT8)0x20;
// C = res & 0x100;
Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ (SINT8)0x20) & (A ^ (UINT8)res);
mon(" BLE $0992 ; 098F: 2F 01 \n");
if (((SINT8)(N^V) < 0) || (!Z)) {
PC = 0x0992;
JUMP;
}
mon(" NEGB ; 0991: 50 \n");
// V = (UINT8)(-B) & (B);
// C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
case 0x0992: mon("L0992 STB <$CF ; 0992: D7 CF \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xcf] = B;
mon(" ADDB ,X ; 0994: EB 84 \n");
res = B + memory[X];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = B ^ memory[X] ^ (UINT8)res ^ C;
// V = B ^ memory[X] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" ANDB #$3F ; 0996: C4 3F \n");
B = B & (SINT8)0x3f;
// Z = B;
// N = B;
// V = 0;
mon(" CMPB <$CD ; 0998: D1 CD \n");
res = B - memory_DP[0xcd];
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (B ^ memory_DP[0xcd]) & (B ^ (UINT8)res);
mon(" BEQ $09A0 ; 099A: 27 04 \n");
if (!Z) {
PC = 0x09a0;
JUMP;
}
mon(" ADDB <$CF ; 099C: DB CF \n");
res = B + memory_DP[0xcf];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ memory_DP[0xcf] ^ (UINT8)res ^ C;
// V = B ^ memory_DP[0xcf] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" ANDB #$3F ; 099E: C4 3F \n");
B = B & (SINT8)0x3f;
// Z = B;
// N = B;
// V = 0;
case 0x09A0: mon("L09A0 STB ,X ; 09A0: E7 84 \n");
Z = B;
N = B;
V = 0;
memory[X] = B;
mon(" RTS ; 09A2: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
// FCB $96 ; 09A3: ' ' 96 96 LDA <$96
// FCB $96 ; 09A4: ' ' 96 4A LDA <$4A
// FCB $4A ; 09A5: 'J' 4A DECA
// FCB $26 ; 09A6: '&' 26 02 BNE $09AA
// FCB $02 ; 09A7: ' ' 02 Invalid
// FCB $8D ; 09A8: ' ' 8D 37 BSR $09E1
// FCB $37 ; 09A9: '7' 37 86 PULU PC,B,A
// FCB $86 ; 09AA: ' ' 86 02 LDA #$02
// FCB $02 ; 09AB: ' ' 02 Invalid
// FCB $97 ; 09AC: ' ' 97 71 STA <$71
// FCB $71 ; 09AD: 'q' 71 Invalid
// FCB $DC ; 09AE: ' ' DC 9D LDD <$9D
// FCB $9D ; 09AF: ' ' 9D BD JSR <$BD
// FCB $BD ; 09B0: ' ' BD 0C 80 JSR $0C80
// FCB $0C ; 09B1: ' ' 0C 80 INC <$80
// FCB $80 ; 09B2: ' ' 80 C1 SUBA #$C1
// FCB $C1 ; 09B3: ' ' C1 04 CMPB #$04
// FCB $04 ; 09B4: ' ' 04 2F LSR <$2F
// FCB $2F ; 09B5: '/' 2F 10 BLE $09C7
// FCB $10 ; 09B6: ' ' 10 1F Invalid
// FCB $1F ; 09B7: ' ' 1F 89 TFR A,B
// FCB $89 ; 09B8: ' ' 89 86 ADCA #$86
// FCB $86 ; 09B9: ' ' 86 01 LDA #$01
// FCB $01 ; 09BA: ' ' 01 Invalid
// FCB $BD ; 09BB: ' ' BD F5 FF JSR $F5FF
// FCB $F5 ; 09BC: ' ' F5 FF DD BITB $FFDD
// FCB $FF ; 09BD: ' ' FF DD A1 STU $DDA1
// FCB $DD ; 09BE: ' ' DD A1 STD <$A1
// FCB $A1 ; 09BF: ' ' A1 9B CMPA [D,X]
// FCB $9B ; 09C0: ' ' 9B 9D ADDA <$9D
// FCB $9D ; 09C1: ' ' 9D DB JSR <$DB
// FCB $DB ; 09C2: ' ' DB 9E ADDB <$9E
// FCB $9E ; 09C3: ' ' 9E DD LDX <$DD
// FCB $DD ; 09C4: ' ' DD 9D STD <$9D
// FCB $9D ; 09C5: ' ' 9D 39 JSR <$39
// FCB $39 ; 09C6: '9' 39 RTS
// FCB $96 ; 09C7: ' ' 96 96 LDA <$96
// FCB $96 ; 09C8: ' ' 96 26 LDA <$26
// FCB $26 ; 09C9: '&' 26 03 BNE $09CE
// FCB $03 ; 09CA: ' ' 03 97 COM <$97
// FCB $97 ; 09CB: ' ' 97 95 STA <$95
// FCB $95 ; 09CC: ' ' 95 39 BITA <$39
// FCB $39 ; 09CD: '9' 39 RTS
// FCB $0A ; 09CE: ' ' 0A 96 DEC <$96
// FCB $96 ; 09CF: ' ' 96 27 LDA <$27
// FCB $27 ; 09D0: ''' 27 0F BEQ $09E1
// FCB $0F ; 09D1: ' ' 0F BD CLR <$BD
// FCB $BD ; 09D2: ' ' BD F5 17 JSR $F517
// FCB $F5 ; 09D3: ' ' F5 17 9B BITB $179B
// FCB $17 ; 09D4: ' ' 17 9B 8C LBSR $A563
// FCB $9B ; 09D5: ' ' 9B 8C ADDA <$8C
// FCB $8C ; 09D6: ' ' 8C 97 8C CMPX #$978C
// FCB $97 ; 09D7: ' ' 97 8C STA <$8C
// FCB $8C ; 09D8: ' ' 8C 49 49 CMPX #$4949
// FCB $49 ; 09D9: 'I' 49 ROLA
// FCB $49 ; 09DA: 'I' 49 ROLA
// FCB $43 ; 09DB: 'C' 43 COMA
// FCB $9B ; 09DC: ' ' 9B 8D ADDA <$8D
// FCB $8D ; 09DD: ' ' 8D 97 BSR $0976
// FCB $97 ; 09DE: ' ' 97 8D STA <$8D
// FCB $8D ; 09DF: ' ' 8D 39 BSR $0A1A
// FCB $39 ; 09E0: '9' 39 RTS
// FCB $DE ; 09E1: ' ' DE 9B LDU <$9B
// FCB $9B ; 09E2: ' ' 9B A6 ADDA <$A6
// FCB $A6 ; 09E3: ' ' A6 C4 LDA ,U
// FCB $C4 ; 09E4: ' ' C4 2E ANDB #$2E
// FCB $2E ; 09E5: '.' 2E 0E BGT $09F5
// FCB $0E ; 09E6: ' ' 0E CE JMP <$CE
// FCB $CE ; 09E7: ' ' CE CA 27 LDU #$CA27
// FCB $CA ; 09E8: ' ' CA 27 ORB #$27
// FCB $27 ; 09E9: ''' 27 DF BEQ $09CA
// FCB $DF ; 09EA: ' ' DF 9B STU <$9B
// FCB $9B ; 09EB: ' ' 9B 86 ADDA <$86
// FCB $86 ; 09EC: ' ' 86 01 LDA #$01
// FCB $01 ; 09ED: ' ' 01 Invalid
// FCB $97 ; 09EE: ' ' 97 95 STA <$95
// FCB $95 ; 09EF: ' ' 95 0C BITA <$0C
// FCB $0C ; 09F0: ' ' 0C 96 INC <$96
// FCB $96 ; 09F1: ' ' 96 1A LDA <$1A
// FCB $1A ; 09F2: ' ' 1A 02 ORCC #$02
// FCB $02 ; 09F3: ' ' 02 Invalid
// FCB $39 ; 09F4: '9' 39 RTS
// FCB $A6 ; 09F5: ' ' A6 46 LDA 6,U
// FCB $46 ; 09F6: 'F' 46 RORA
// FCB $E6 ; 09F7: ' ' E6 48 LDB 8,U
// FCB $48 ; 09F8: 'H' 48 ASLA
// FCB $DD ; 09F9: ' ' DD 8C STD <$8C
// FCB $8C ; 09FA: ' ' 8C 1C FE CMPX #$1CFE
// FCB $1C ; 09FB: ' ' 1C FE ANDCC #$FE
// FCB $FE ; 09FC: ' ' FE 39 86 LDU $3986
// FCB $39 ; 09FD: '9' 39 RTS
// FCB $86 ; 09FE: ' ' 86 01 LDA #$01
// FCB $01 ; 09FF: ' ' 01 Invalid
// FCB $97 ; 0A00: ' ' 97 71 STA <$71
// FCB $71 ; 0A01: 'q' 71 Invalid
// FCB $BD ; 0A02: ' ' BD 09 E1 JSR $09E1
// FCB $09 ; 0A03: ' ' 09 E1 ROL <$E1
// FCB $E1 ; 0A04: ' ' E1 29 CMPB 9,Y
// FCB $29 ; 0A05: ')' 29 F6 BVS $09FD
// FCB $F6 ; 0A06: ' ' F6 DD 9D LDB $DD9D
// FCB $DD ; 0A07: ' ' DD 9D STD <$9D
// FCB $9D ; 0A08: ' ' 9D DC JSR <$DC
// FCB $DC ; 0A09: ' ' DC CD LDD <$CD
// FCB $CD ; 0A0A: ' ' CD Invalid
// FCB $90 ; 0A0B: ' ' 90 A5 SUBA <$A5
// FCB $A5 ; 0A0C: ' ' A5 27 BITA 7,Y
// FCB $27 ; 0A0D: ''' 27 17 BEQ $0A26
// FCB $17 ; 0A0E: ' ' 17 C1 10 LBSR $CB21
// FCB $C1 ; 0A0F: ' ' C1 10 CMPB #$10
// FCB $10 ; 0A10: ' ' 10 23 13 D6 LBLS $1DEA
// FCB $23 ; 0A11: '#' 23 13 BLS $0A26
// FCB $13 ; 0A12: ' ' 13 SYNC
// FCB $D6 ; 0A13: ' ' D6 97 LDB <$97
// FCB $97 ; 0A14: ' ' 97 5C STA <$5C
// FCB $5C ; 0A15: '\' 5C INCB
// FCB $D4 ; 0A16: ' ' D4 85 ANDB <$85
// FCB $85 ; 0A17: ' ' 85 D7 BITA #$D7
// FCB $D7 ; 0A18: ' ' D7 97 STB <$97
// FCB $97 ; 0A19: ' ' 97 26 STA <$26
// FCB $26 ; 0A1A: '&' 26 0A BNE $0A26
// FCB $0A ; 0A1B: ' ' 0A BD DEC <$BD
// FCB $BD ; 0A1C: ' ' BD 09 89 JSR $0989
// FCB $09 ; 0A1D: ' ' 09 89 ROL <$89
// FCB $89 ; 0A1E: ' ' 89 86 ADCA #$86
// FCB $86 ; 0A1F: ' ' 86 02 LDA #$02
// FCB $02 ; 0A20: ' ' 02 Invalid
// FCB $BD ; 0A21: ' ' BD F5 FF JSR $F5FF
// FCB $F5 ; 0A22: ' ' F5 FF DD BITB $FFDD
// FCB $FF ; 0A23: ' ' FF DD A3 STU $DDA3
// FCB $DD ; 0A24: ' ' DD A3 STD <$A3
// FCB $A3 ; 0A25: ' ' A3 0A SUBD 10,X
// FCB $0A ; 0A26: ' ' 0A 9A DEC <$9A
// FCB $9A ; 0A27: ' ' 9A 2E ORA <$2E
// FCB $2E ; 0A28: '.' 2E D3 BGT $09FD
// FCB $D3 ; 0A29: ' ' D3 CE ADDD <$CE
// FCB $CE ; 0A2A: ' ' CE C9 DC LDU #$C9DC
// FCB $C9 ; 0A2B: ' ' C9 DC ADCB #$DC
// FCB $DC ; 0A2C: ' ' DC A6 LDD <$A6
// FCB $A6 ; 0A2D: ' ' A6 C4 LDA ,U
// FCB $C4 ; 0A2E: ' ' C4 26 ANDB #$26
// FCB $26 ; 0A2F: '&' 26 CC BNE $09FD
// FCB $CC ; 0A30: ' ' CC DC 9D LDD #$DC9D
// FCB $DC ; 0A31: ' ' DC 9D LDD <$9D
// FCB $9D ; 0A32: ' ' 9D 9B JSR <$9B
// FCB $9B ; 0A33: ' ' 9B 9F ADDA <$9F
// FCB $9F ; 0A34: ' ' 9F 29 STX <$29
// FCB $29 ; 0A35: ')' 29 C6 BVS $09FD
// FCB $C6 ; 0A36: ' ' C6 DB LDB #$DB
// FCB $DB ; 0A37: ' ' DB A0 ADDB <$A0
// FCB $A0 ; 0A38: ' ' A0 29 SUBA 9,Y
// FCB $29 ; 0A39: ')' 29 C2 BVS $09FD
// FCB $C2 ; 0A3A: ' ' C2 ED SBCB #$ED
// FCB $ED ; 0A3B: ' ' ED 41 STD 1,U
// FCB $41 ; 0A3C: 'A' 41 Invalid
// FCB $96 ; 0A3D: ' ' 96 86 LDA <$86
// FCB $86 ; 0A3E: ' ' 86 97 LDA #$97
// FCB $97 ; 0A3F: ' ' 97 9A STA <$9A
// FCB $9A ; 0A40: ' ' 9A 6A ORA <$6A
// FCB $6A ; 0A41: 'j' 6A C4 DEC ,U
// FCB $C4 ; 0A42: ' ' C4 D6 ANDB #$D6
// FCB $D6 ; 0A43: ' ' D6 A6 LDB <$A6
// FCB $A6 ; 0A44: ' ' A6 BD 04 EB LDA [$04EB,PC]
// FCB $BD ; 0A45: ' ' BD 04 EB JSR $04EB
// FCB $04 ; 0A46: ' ' 04 EB LSR <$EB
// FCB $EB ; 0A47: ' ' EB 96 ADDB [A,X]
// FCB $96 ; 0A48: ' ' 96 A6 LDA <$A6
// FCB $A6 ; 0A49: ' ' A6 CE LDA ???
// FCB $CE ; 0A4A: ' ' CE CA 7E LDU #$CA7E
// FCB $CA ; 0A4B: ' ' CA 7E ORB #$7E
// FCB $7E ; 0A4C: '~' 7E 8E 0D JMP $8E0D
// FCB $8E ; 0A4D: ' ' 8E 0D 7B LDX #$0D7B
// FCB $0D ; 0A4E: ' ' 0D 7B TST <$7B
// FCB $7B ; 0A4F: '{' 7B Invalid
// FCB $C6 ; 0A50: ' ' C6 04 LDB #$04
// FCB $04 ; 0A51: ' ' 04 7E LSR <$7E
// FCB $7E ; 0A52: '~' 7E F6 10 JMP $F610
// FCB $F6 ; 0A53: ' ' F6 10 09 LDB $1009
// FCB $10 ; 0A54: ' ' 10 09 Invalid
// FCB $09 ; 0A55: ' ' 09 FE ROL <$FE
// FCB $FE ; 0A56: ' ' FE 09 A3 LDU $09A3
// FCB $09 ; 0A57: ' ' 09 A3 ROL <$A3
// FCB $A3 ; 0A58: ' ' A3 00 SUBD 0,X
case 0x0A59: mon("L0A59 NEG <$91 ; 0A59: 00 91 \n");
// V = (UINT8)(-memory_DP[0x91]) & (memory_DP[0x91]);
// C = (-memory_DP[0x91]) & 0x100;
memory_DP[0x91] = (UINT8)(-memory_DP[0x91]);
// Z = memory_DP[0x91];
// N = memory_DP[0x91];
mon(" LDY #$C8E3 ; 0A5B: 10 8E C8 E3 \n");
Y = 0xc8e3;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
mon(" CLR $02,Y ; 0A5F: 6F 22 \n");
memory[(UINT16)(Y + 0x0002)] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" CLR $03,Y ; 0A61: 6F 23 \n");
memory[(UINT16)(Y + 0x0003)] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
mon(" LDA #$02 ; 0A63: 86 02 \n");
A = (UINT8)(SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$DA ; 0A65: 97 DA \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xda] = A;
mon(" LDX #$C9C0 ; 0A67: 8E C9 C0 \n");
X = 0xc9c0;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDD #$0B6E ; 0A6A: CC 0B 6E \n");
A = (UINT8)((0x0b6e) >> 8);
B = (UINT8)((0x0b6e) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD <$CC ; 0A6D: DD CC \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcc] = A;
memory_DP[0xcc + 1] = B;
mon(" LDB #$08 ; 0A6F: C6 08 \n");
B = (UINT8)(SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
case 0x0A71: mon("L0A71 STB <$D2 ; 0A71: D7 D2 \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xd2] = B;
mon(" LDA ,X ; 0A73: A6 84 \n");
A = (UINT8)memory[X];
N = A;
Z = A;
// V = 0;
mon(" BMI $0AAD ; 0A75: 2B 36 \n");
if ((SINT8)N < 0) {
PC = 0x0aad;
JUMP;
}
mon(" BEQ $0A92 ; 0A77: 27 19 \n");
if (!Z) {
PC = 0x0a92;
JUMP;
}
mon(" LDU #$CB00 ; 0A79: CE CB 00 \n");
U = 0xcb00;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" DECA ; 0A7C: 4A \n");
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
mon(" STA ,X ; 0A7D: A7 84 \n");
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
mon(" ANDA #$03 ; 0A7F: 84 03 \n");
A = A & (SINT8)0x03;
Z = A;
// N = A;
// V = 0;
mon(" BNE $0A8B ; 0A81: 26 08 \n");
if (Z) {
PC = 0x0a8b;
JUMP;
}
mon(" LDB $04,X ; 0A83: E6 04 \n");
B = (UINT8)memory[(UINT16)(X + 0x0004)];
// N = B;
// Z = B;
// V = 0;
mon(" ADDB $04,X ; 0A85: EB 04 \n");
res = B + memory[(UINT16)(X + 0x0004)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ memory[(UINT16)(X + 0x0004)] ^ (UINT8)res ^ C;
// V = B ^ memory[(UINT16)(X + 0x0004)] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" STB $04,X ; 0A87: E7 04 \n");
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0004)] = B;
mon(" DEC $03,X ; 0A89: 6A 03 \n");
res = (UINT8)(memory[(UINT16)(X + 0x0003)] - 1);
// N = res;
// Z = res;
// V = memory[(UINT16)(X + 0x0003)] & ~res;
memory[(UINT16)(X + 0x0003)] = res;
case 0x0A8B: mon("L0A8B LDB #$08 ; 0A8B: C6 08 \n");
B = (UINT8)(SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
mon(" MUL ; 0A8D: 3D \n");
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
mon(" LEAU B,U ; 0A8E: 33 C5 \n");
U = (U + (SINT8)B);
mon(" STU $05,X ; 0A90: EF 05 \n");
// Z = U;
// N = (U) >> 8;
// V = 0;
memory[(UINT16)(X + 0x0005)] = (UINT8)((U) >> 8);
memory[(UINT16)((X + 0x0005) + 1)] = (U) & 0xff;
case 0x0A92: mon("L0A92 LEAX $07,X ; 0A92: 30 07 \n");
X = (X + 0x0007);
// Z = X;
mon(" LDB <$D2 ; 0A94: D6 D2 \n");
B = (UINT8)memory_DP[0xd2];
// N = B;
// Z = B;
// V = 0;
mon(" DECB ; 0A96: 5A \n");
res = (UINT8)(B - 1);
// N = res;
Z = res;
// V = B & ~res;
B = res;
mon(" BEQ $0AAC ; 0A97: 27 13 \n");
if (!Z) {
PC = 0x0aac;
JUMP;
}
mon(" CMPB #$06 ; 0A99: C1 06 \n");
res = B - (SINT8)0x06;
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (B ^ (SINT8)0x06) & (B ^ (UINT8)res);
mon(" BNE $0A9F ; 0A9B: 26 02 \n");
if (Z) {
PC = 0x0a9f;
JUMP;
}
mon(" INC <$DA ; 0A9D: 0C DA \n");
res = (UINT8)(memory_DP[0xda] + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0xda]);
memory_DP[0xda] = res;
case 0x0A9F: mon("L0A9F CMPB #$04 ; 0A9F: C1 04 \n");
res = B - (SINT8)0x04;
C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = (B ^ (SINT8)0x04) & (B ^ (UINT8)res);
mon(" BNE $0A71 ; 0AA1: 26 CE \n");
if (Z) {
PC = 0x0a71;
JUMP;
}
mon(" LDU #$0B2C ; 0AA3: CE 0B 2C \n");
U = 0x0b2c;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" STU <$CC ; 0AA6: DF CC \n");
// Z = U;
// N = (U) >> 8;
// V = 0;
memory_DP[0xcc] = (UINT8)((U) >> 8);
memory_DP[(UINT16)(0xcc + 1)] = (U) & 0xff;
mon(" INC <$DA ; 0AA8: 0C DA \n");
res = (UINT8)(memory_DP[0xda] + 1);
Z = res;
N = res;
V = res & ~(memory_DP[0xda]);
memory_DP[0xda] = res;
mon(" BRA $0A71 ; 0AAA: 20 C5 \n");
PC = 0x0a71;
JUMP;
case 0x0AAC: mon("L0AAC RTS ; 0AAC: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0AAD: mon("L0AAD LDA <$91 ; 0AAD: 96 91 \n");
A = (UINT8)memory_DP[0x91];
// N = A;
// Z = A;
// V = 0;
mon(" ADDA #$04 ; 0AAF: 8B 04 \n");
res = A + (SINT8)0x04;
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ (SINT8)0x04 ^ (UINT8)res ^ C;
// V = A ^ (SINT8)0x04 ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" LEAU A,X ; 0AB1: 33 86 \n");
U = (X + (SINT8)A);
mon(" LDD $01,X ; 0AB3: EC 01 \n");
A = memory[(UINT16)(X + 0x0001)];
B = memory[(UINT16)(((UINT16)(X + 0x0001))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" ADDA ,U ; 0AB5: AB C4 \n");
res = A + memory[U];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ memory[U] ^ (UINT8)res ^ C;
// V = A ^ memory[U] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" ADDB $01,U ; 0AB7: EB 41 \n");
res = B + memory[(UINT16)(U + 0x0001)];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = B ^ memory[(UINT16)(U + 0x0001)] ^ (UINT8)res ^ C;
// V = B ^ memory[(UINT16)(U + 0x0001)] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" STD $01,X ; 0AB9: ED 01 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0001)] = A;
memory[(UINT16)(X + 0x0001) + 1] = B;
mon(" JSR Abs_a_b ; 0ABB: BD F5 84 \n");
memory[--S] = 0x0abe & 0xff; memory[--S] = 0x0abe >> 8;
PC = 0xf584;
JUMP;
case 0x0ABE: mon("L0ABE STD <$DB ; 0ABE: DD DB \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xdb] = A;
memory_DP[0xdb + 1] = B;
mon(" CMPA #$78 ; 0AC0: 81 78 \n");
res = A - (SINT8)0x78;
C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = (A ^ (SINT8)0x78) & (A ^ (UINT8)res);
mon(" BCC $0B1B ; 0AC2: 24 57 \n");
if (!C) {
PC = 0x0b1b;
JUMP;
}
mon(" CMPB #$78 ; 0AC4: C1 78 \n");
res = B - (SINT8)0x78;
C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = (B ^ (SINT8)0x78) & (B ^ (UINT8)res);
mon(" BCC $0B1B ; 0AC6: 24 53 \n");
if (!C) {
PC = 0x0b1b;
JUMP;
}
mon(" LDU #$0F20 ; 0AC8: CE 0F 20 \n");
U = 0x0f20;
// Z = U;
// N = (U) >> 8;
V = 0;
mon(" JSR $081C ; 0ACB: BD 08 1C \n");
memory[--S] = 0x0ace & 0xff; memory[--S] = 0x0ace >> 8;
PC = 0x081c;
JUMP;
case 0x0ACE: mon("L0ACE BVS $0B1B ; 0ACE: 29 4B \n");
if ((SINT8)V < 0) {
PC = 0x0b1b;
JUMP;
}
mon(" LDB <$DB ; 0AD0: D6 DB \n");
B = (UINT8)memory_DP[0xdb];
// N = B;
// Z = B;
// V = 0;
mon(" LDU #$0F6A ; 0AD2: CE 0F 6A \n");
U = 0x0f6a;
// Z = U;
// N = (U) >> 8;
V = 0;
mon(" JSR $081C ; 0AD5: BD 08 1C \n");
memory[--S] = 0x0ad8 & 0xff; memory[--S] = 0x0ad8 >> 8;
PC = 0x081c;
JUMP;
case 0x0AD8: mon("L0AD8 BVS $0B1B ; 0AD8: 29 41 \n");
if ((SINT8)V < 0) {
PC = 0x0b1b;
JUMP;
}
mon(" LDU #$C900 ; 0ADA: CE C9 00 \n");
U = 0xc900;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDB <$81 ; 0ADD: D6 81 \n");
B = (UINT8)memory_DP[0x81];
// N = B;
// Z = B;
// V = 0;
case 0x0ADF: mon("L0ADF STB <$CB ; 0ADF: D7 CB \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0xcb] = B;
mon(" SUBB <$D2 ; 0AE1: D0 D2 \n");
res = B - memory_DP[0xd2];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((B) ^ memory_DP[0xd2]) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
mon(" ADDB #$03 ; 0AE3: CB 03 \n");
res = B + (SINT8)0x03;
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = B ^ (SINT8)0x03 ^ (UINT8)res ^ C;
// V = B ^ (SINT8)0x03 ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" SUBB <$81 ; 0AE5: D0 81 \n");
res = B - memory_DP[0x81];
// C = res & 0x100;
Z = (UINT8)res;
// N = (UINT8)res;
// V = ((B) ^ memory_DP[0x81]) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
mon(" BEQ $0B0B ; 0AE7: 27 22 \n");
if (!Z) {
PC = 0x0b0b;
JUMP;
}
mon(" LDD ,U ; 0AE9: EC C4 \n");
A = memory[U];
B = memory[(UINT16)((U)+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" TSTA ; 0AEB: 4D \n");
Z = A;
// N = A;
// V = 0;
mon(" BEQ $0B0B ; 0AEC: 27 1D \n");
if (!Z) {
PC = 0x0b0b;
JUMP;
}
mon(" CMPB #$02 ; 0AEE: C1 02 \n");
res = B - (SINT8)0x02;
C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = (B ^ (SINT8)0x02) & (B ^ (UINT8)res);
mon(" BGE $0B0B ; 0AF0: 2C 19 \n");
if ((SINT8)(N^V) >= 0) {
PC = 0x0b0b;
JUMP;
}
mon(" LDA #$05 ; 0AF2: 86 05 \n");
A = (UINT8)(SINT8)0x05;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$E8 ; 0AF4: 97 E8 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0xe8] = A;
mon(" LDD $0E,U ; 0AF6: EC 4E \n");
A = memory[(UINT16)(U + 0x000e)];
B = memory[(UINT16)(((UINT16)(U + 0x000e))+1)];
Z = A|B;
N = A;
V = 0;
mon(" BSR $0B52 ; 0AF8: 8D 58 \n");
memory[--S] = 0x0afa & 0xff; memory[--S] = 0x0afa >> 8;
PC = 0x0b52;
JUMP;
case 0x0AFA: mon("L0AFA BVC $0B0B ; 0AFA: 28 0F \n");
if ((SINT8)V >= 0) {
PC = 0x0b0b;
JUMP;
}
mon(" LDB $01,U ; 0AFC: E6 41 \n");
B = (UINT8)memory[(UINT16)(U + 0x0001)];
// N = B;
// Z = B;
// V = 0;
mon(" LDA B,Y ; 0AFE: A6 A5 \n");
A = (UINT8)memory[(UINT16)(Y + (SINT8)B)];
// N = A;
// Z = A;
// V = 0;
mon(" LDB <$DA ; 0B00: D6 DA \n");
B = (UINT8)memory_DP[0xda];
// N = B;
// Z = B;
// V = 0;
mon(" ADDA B,Y ; 0B02: AB A5 \n");
res = A + memory[(UINT16)(Y + (SINT8)B)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = A ^ memory[(UINT16)(Y + (SINT8)B)] ^ (UINT8)res ^ C;
// V = A ^ memory[(UINT16)(Y + (SINT8)B)] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" DAA ; 0B04: 19 \n");
res = A;
msn = res & 0xf0;
lsn = res & 0x0f;
res = res + (((lsn > 0x09) || (H & 0x10)) ? 0x06 : 0);
res = res + (((msn > 0x80) && (lsn > 0x09)) || ((msn > 0x90) || (C != 0)) ? 0x60 : 0);
C = C | (res & 0x100);
res = (UINT8)res;
A = res;
// N = res;
// Z = res;
// V = 0;
mon(" STA B,Y ; 0B05: A7 A5 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(Y + (SINT8)B)] = A;
mon(" INC $01,U ; 0B07: 6C 41 \n");
res = (UINT8)(memory[(UINT16)(U + 0x0001)] + 1);
Z = res;
N = res;
V = res & ~(memory[(UINT16)(U + 0x0001)]);
memory[(UINT16)(U + 0x0001)] = res;
mon(" BRA $0B1B ; 0B09: 20 10 \n");
PC = 0x0b1b;
JUMP;
case 0x0B0B: mon("L0B0B LEAU $40,U ; 0B0B: 33 C8 40 \n");
U = (U + (SINT8)0x40);
mon(" LDB <$CB ; 0B0E: D6 CB \n");
B = (UINT8)memory_DP[0xcb];
// N = B;
// Z = B;
// V = 0;
mon(" DECB ; 0B10: 5A \n");
res = (UINT8)(B - 1);
N = res;
Z = res;
V = B & ~res;
B = res;
mon(" BNE $0ADF ; 0B11: 26 CC \n");
if (Z) {
PC = 0x0adf;
JUMP;
}
mon(" JSR [$C8CC] ; 0B13: AD 9F C8 CC \n");
memory[--S] = 0x0b17 & 0xff; memory[--S] = 0x0b17 >> 8;
PC = ((memory[0xc8cc]<<8)|memory[(UINT16)((0xc8cc)+1)]);
JUMP;
case 0x0B17: mon("L0B17 LBVC $0A92 ; 0B17: 10 28 FF 77 \n");
if ((SINT8)V >= 0) {
PC = 0x0a92;
JUMP;
}
case 0x0B1B: mon("L0B1B LDA #$08 ; 0B1B: 86 08 \n");
A = (UINT8)(SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
mon(" STA ,X ; 0B1D: A7 84 \n");
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
mon(" LDD #$090A ; 0B1F: CC 09 0A \n");
A = (UINT8)((0x090a) >> 8);
B = (UINT8)((0x090a) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD $03,X ; 0B22: ED 03 \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0003)] = A;
memory[(UINT16)(X + 0x0003) + 1] = B;
mon(" LDD #$CB00 ; 0B24: CC CB 00 \n");
A = (UINT8)((0xcb00) >> 8);
B = (UINT8)((0xcb00) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
mon(" STD $05,X ; 0B27: ED 05 \n");
Z = A | B;
N = A;
V = 0;
memory[(UINT16)(X + 0x0005)] = A;
memory[(UINT16)(X + 0x0005) + 1] = B;
mon(" JMP $0A92 ; 0B29: 7E 0A 92 \n");
PC = 0x0a92;
JUMP;
// FCB $CE ; 0B2C: ' ' CE CA 00 LDU #$CA00
// FCB $CA ; 0B2D: ' ' CA 00 ORB #$00
// FCB $00 ; 0B2E: ' ' 00 A6 NEG <$A6
// FCB $A6 ; 0B2F: ' ' A6 C4 LDA ,U
// FCB $C4 ; 0B30: ' ' C4 2F ANDB #$2F
// FCB $2F ; 0B31: '/' 2F 13 BLE $0B46
// FCB $13 ; 0B32: ' ' 13 SYNC
// FCB $86 ; 0B33: ' ' 86 02 LDA #$02
// FCB $02 ; 0B34: ' ' 02 Invalid
// FCB $97 ; 0B35: ' ' 97 E8 STA <$E8
// FCB $E8 ; 0B36: ' ' E8 A6 EORB A,Y
// FCB $A6 ; 0B37: ' ' A6 46 LDA 6,U
// FCB $46 ; 0B38: 'F' 46 RORA
// FCB $E6 ; 0B39: ' ' E6 48 LDB 8,U
// FCB $48 ; 0B3A: 'H' 48 ASLA
// FCB $8D ; 0B3B: ' ' 8D 15 BSR $0B52
// FCB $15 ; 0B3C: ' ' 15 Invalid
// FCB $28 ; 0B3D: '(' 28 07 BVC $0B46
// FCB $07 ; 0B3E: ' ' 07 86 ASR <$86
// FCB $86 ; 0B3F: ' ' 86 80 LDA #$80
// FCB $80 ; 0B40: ' ' 80 A7 SUBA #$A7
// FCB $A7 ; 0B41: ' ' A7 C4 STA ,U
// FCB $C4 ; 0B42: ' ' C4 1A ANDB #$1A
// FCB $1A ; 0B43: ' ' 1A 02 ORCC #$02
// FCB $02 ; 0B44: ' ' 02 Invalid
// FCB $39 ; 0B45: '9' 39 RTS
// FCB $33 ; 0B46: '3' 33 C8 27 LEAU $27,U
// FCB $C8 ; 0B47: ' ' C8 27 EORB #$27
// FCB $27 ; 0B48: ''' 27 11 BEQ $0B5B
// FCB $11 ; 0B49: ' ' 11 83 CA 4E CMPU #$CA4E
// FCB $83 ; 0B4A: ' ' 83 CA 4E SUBD #$CA4E
// FCB $CA ; 0B4B: ' ' CA 4E ORB #$4E
// FCB $4E ; 0B4C: 'N' 4E Invalid
// FCB $26 ; 0B4D: '&' 26 E0 BNE $0B2F
// FCB $E0 ; 0B4E: ' ' E0 1C SUBB -4,X
// FCB $1C ; 0B4F: ' ' 1C FD ANDCC #$FD
// FCB $FD ; 0B50: ' ' FD 39 A0 STD $39A0
// FCB $39 ; 0B51: '9' 39 RTS
case 0x0B52: mon("L0B52 SUBA $01,X ; 0B52: A0 01 \n");
res = A - memory[(UINT16)(X + 0x0001)];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = ((A) ^ memory[(UINT16)(X + 0x0001)]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
mon(" BVS $0B6B ; 0B54: 29 15 \n");
if ((SINT8)V < 0) {
PC = 0x0b6b;
JUMP;
}
mon(" BPL $0B59 ; 0B56: 2A 01 \n");
if ((SINT8)N >= 0) {
PC = 0x0b59;
JUMP;
}
mon(" NEGA ; 0B58: 40 \n");
// V = (UINT8)(-A) & (A);
// C = (-A) & 0x100;
A = (UINT8)(-A);
// Z = A;
// N = A;
case 0x0B59: mon("L0B59 SUBB $02,X ; 0B59: E0 02 \n");
res = B - memory[(UINT16)(X + 0x0002)];
// C = res & 0x100;
// Z = (UINT8)res;
N = (UINT8)res;
V = ((B) ^ memory[(UINT16)(X + 0x0002)]) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
mon(" BVS $0B6B ; 0B5B: 29 0E \n");
if ((SINT8)V < 0) {
PC = 0x0b6b;
JUMP;
}
mon(" BPL $0B60 ; 0B5D: 2A 01 \n");
if ((SINT8)N >= 0) {
PC = 0x0b60;
JUMP;
}
mon(" NEGB ; 0B5F: 50 \n");
// V = (UINT8)(-B) & (B);
// C = (-B) & 0x100;
B = (UINT8)(-B);
// Z = B;
// N = B;
case 0x0B60: mon("L0B60 CMPA <$E8 ; 0B60: 91 E8 \n");
res = A - memory_DP[0xe8];
// C = res & 0x100;
Z = (UINT8)res;
N = (UINT8)res;
V = (A ^ memory_DP[0xe8]) & (A ^ (UINT8)res);
mon(" BGT $0B6B ; 0B62: 2E 07 \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0b6b;
JUMP;
}
mon(" CMPB <$E8 ; 0B64: D1 E8 \n");
res = B - memory_DP[0xe8];
C = res & 0x100;
Z = (UINT8)res;
N = (UINT8)res;
V = (B ^ memory_DP[0xe8]) & (B ^ (UINT8)res);
mon(" BGT $0B6B ; 0B66: 2E 03 \n");
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0b6b;
JUMP;
}
mon(" ORCC #$02 ; 0B68: 1A 02 \n");
V = 1;
mon(" RTS ; 0B6A: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0B6B: mon("L0B6B ANDCC #$FD ; 0B6B: 1C FD \n");
V = 0;
mon(" RTS ; 0B6D: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
// FCB $96 ; 0B6E: ' ' 96 94 LDA <$94
// FCB $94 ; 0B6F: ' ' 94 2F ANDA <$2F
// FCB $2F ; 0B70: '/' 2F 5B BLE $0BCD
// FCB $5B ; 0B71: '[' 5B Invalid
// FCB $DC ; 0B72: ' ' DC 9D LDD <$9D
// FCB $9D ; 0B73: ' ' 9D 9B JSR <$9B
// FCB $9B ; 0B74: ' ' 9B 9F ADDA <$9F
// FCB $9F ; 0B75: ' ' 9F 29 STX <$29
// FCB $29 ; 0B76: ')' 29 55 BVS $0BCD
// FCB $55 ; 0B77: 'U' 55 Invalid
// FCB $DB ; 0B78: ' ' DB A0 ADDB <$A0
// FCB $A0 ; 0B79: ' ' A0 29 SUBA 9,Y
// FCB $29 ; 0B7A: ')' 29 51 BVS $0BCD
// FCB $51 ; 0B7B: 'Q' 51 Invalid
// FCB $A0 ; 0B7C: ' ' A0 01 SUBA 1,X
// FCB $01 ; 0B7D: ' ' 01 Invalid
// FCB $29 ; 0B7E: ')' 29 4D BVS $0BCD
// FCB $4D ; 0B7F: 'M' 4D TSTA
// FCB $E0 ; 0B80: ' ' E0 02 SUBB 2,X
// FCB $02 ; 0B81: ' ' 02 Invalid
// FCB $29 ; 0B82: ')' 29 49 BVS $0BCD
// FCB $49 ; 0B83: 'I' 49 ROLA
// FCB $47 ; 0B84: 'G' 47 ASRA
// FCB $57 ; 0B85: 'W' 57 ASRB
// FCB $DD ; 0B86: ' ' DD CF STD <$CF
// FCB $CF ; 0B87: ' ' CF Invalid
// FCB $D6 ; 0B88: ' ' D6 A6 LDB <$A6
// FCB $A6 ; 0B89: ' ' A6 C0 LDA ,U+
// FCB $C0 ; 0B8A: ' ' C0 40 SUBB #$40
// FCB $40 ; 0B8B: '@' 40 NEGA
// FCB $C4 ; 0B8C: ' ' C4 3F ANDB #$3F
// FCB $3F ; 0B8D: '?' 3F SWI
// FCB $BD ; 0B8E: ' ' BD F6 01 JSR $F601
// FCB $F6 ; 0B8F: ' ' F6 01 DD LDB $01DD
// FCB $01 ; 0B90: ' ' 01 Invalid
// FCB $DD ; 0B91: ' ' DD CE STD <$CE
// FCB $CE ; 0B92: ' ' CE 96 D0 LDU #$96D0
// FCB $96 ; 0B93: ' ' 96 D0 LDA <$D0
// FCB $D0 ; 0B94: ' ' D0 D6 SUBB <$D6
// FCB $D6 ; 0B95: ' ' D6 36 LDB <$36
// FCB $36 ; 0B96: '6' 36 BD PSHU PC,Y,X,DP,B,CC
// FCB $BD ; 0B97: ' ' BD F5 FF JSR $F5FF
// FCB $F5 ; 0B98: ' ' F5 FF 9B BITB $FF9B
// FCB $FF ; 0B99: ' ' FF 9B CE STU $9BCE
// FCB $9B ; 0B9A: ' ' 9B CE ADDA <$CE
// FCB $CE ; 0B9B: ' ' CE 2A 01 LDU #$2A01
// FCB $2A ; 0B9C: '*' 2A 01 BPL $0B9F
// FCB $01 ; 0B9D: ' ' 01 Invalid
// FCB $40 ; 0B9E: '@' 40 NEGA
// FCB $DB ; 0B9F: ' ' DB CF ADDB <$CF
// FCB $CF ; 0BA0: ' ' CF Invalid
// FCB $2A ; 0BA1: '*' 2A 01 BPL $0BA4
// FCB $01 ; 0BA2: ' ' 01 Invalid
// FCB $50 ; 0BA3: 'P' 50 NEGB
// FCB $81 ; 0BA4: ' ' 81 02 CMPA #$02
// FCB $02 ; 0BA5: ' ' 02 Invalid
// FCB $2E ; 0BA6: '.' 2E 25 BGT $0BCD
// FCB $25 ; 0BA7: '%' 25 C1 BCS $0B6A
// FCB $C1 ; 0BA8: ' ' C1 04 CMPB #$04
// FCB $04 ; 0BA9: ' ' 04 2E LSR <$2E
// FCB $2E ; 0BAA: '.' 2E 21 BGT $0BCD
// FCB $21 ; 0BAB: '!' 21 86 BRN $0B33
// FCB $86 ; 0BAC: ' ' 86 80 LDA #$80
// FCB $80 ; 0BAD: ' ' 80 97 SUBA #$97
// FCB $97 ; 0BAE: ' ' 97 94 STA <$94
// FCB $94 ; 0BAF: ' ' 94 D6 ANDA <$D6
// FCB $D6 ; 0BB0: ' ' D6 DA LDB <$DA
// FCB $DA ; 0BB1: ' ' DA A6 ORB <$A6
// FCB $A6 ; 0BB2: ' ' A6 A5 LDA B,Y
// FCB $A5 ; 0BB3: ' ' A5 8B BITA D,X
// FCB $8B ; 0BB4: ' ' 8B 0A ADDA #$0A
// FCB $0A ; 0BB5: ' ' 0A 19 DEC <$19
// FCB $19 ; 0BB6: ' ' 19 DAA
// FCB $A7 ; 0BB7: ' ' A7 A5 STA B,Y
// FCB $A5 ; 0BB8: ' ' A5 E6 BITA A,S
// FCB $E6 ; 0BB9: ' ' E6 21 LDB 1,Y
// FCB $21 ; 0BBA: '!' 21 5C BRN $0C18
// FCB $5C ; 0BBB: '\' 5C INCB
// FCB $C1 ; 0BBC: ' ' C1 08 CMPB #$08
// FCB $08 ; 0BBD: ' ' 08 26 ASL <$26
// FCB $26 ; 0BBE: '&' 26 08 BNE $0BC8
// FCB $08 ; 0BBF: ' ' 08 0C ASL <$0C
// FCB $0C ; 0BC0: ' ' 0C E2 INC <$E2
// FCB $E2 ; 0BC1: ' ' E2 26 SBCB 6,Y
// FCB $26 ; 0BC2: '&' 26 02 BNE $0BC6
// FCB $02 ; 0BC3: ' ' 02 Invalid
// FCB $0A ; 0BC4: ' ' 0A E2 DEC <$E2
// FCB $E2 ; 0BC5: ' ' E2 C6 SBCB A,U
// FCB $C6 ; 0BC6: ' ' C6 02 LDB #$02
// FCB $02 ; 0BC7: ' ' 02 Invalid
// FCB $E7 ; 0BC8: ' ' E7 21 STB 1,Y
// FCB $21 ; 0BC9: '!' 21 1A BRN $0BE5
// FCB $1A ; 0BCA: ' ' 1A 02 ORCC #$02
// FCB $02 ; 0BCB: ' ' 02 Invalid
// FCB $39 ; 0BCC: '9' 39 RTS
// FCB $1C ; 0BCD: ' ' 1C FD ANDCC #$FD
// FCB $FD ; 0BCE: ' ' FD 39 7E STD $397E
// FCB $39 ; 0BCF: '9' 39 RTS
case 0x0BD0: mon("L0BD0 JMP Explosion_Snd ; 0BD0: 7E F9 2E \n");
PC = 0xf92e;
JUMP;
case 0x0BD3: mon("L0BD3 LDU #$0C5E ; 0BD3: CE 0C 5E \n");
U = 0x0c5e;
// Z = U;
// N = (U) >> 8;
// V = 0;
mon(" LDA <$EF ; 0BD6: 96 EF \n");
A = (UINT8)memory_DP[0xef];
N = A;
Z = A;
// V = 0;
mon(" BEQ $0BE5 ; 0BD8: 27 0B \n");
if (!Z) {
PC = 0x0be5;
JUMP;
}
mon(" BMI $0BD0 ; 0BDA: 2B F4 \n");
if ((SINT8)N < 0) {
PC = 0x0bd0;
JUMP;
}
mon(" DEC <$EF ; 0BDC: 0A EF \n");
res = (UINT8)(memory_DP[0xef] - 1);
N = res;
Z = res;
V = memory_DP[0xef] & ~res;
memory_DP[0xef] = res;
mon(" LEAU $04,U ; 0BDE: 33 44 \n");
U = (U + 0x0004);
mon(" JSR Explosion_Snd ; 0BE0: BD F9 2E \n");
memory[--S] = 0x0be3 & 0xff; memory[--S] = 0x0be3 >> 8;
PC = 0xf92e;
JUMP;
case 0x0BE3: mon("L0BE3 BRA $0C33 ; 0BE3: 20 4E \n");
PC = 0x0c33;
JUMP;
case 0x0BE5: mon("L0BE5 LDA #$0F ; 0BE5: 86 0F \n");
A = (UINT8)(SINT8)0x0f;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$44 ; 0BE7: 97 44 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x44] = A;
mon(" STA <$43 ; 0BE9: 97 43 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x43] = A;
mon(" STA <$42 ; 0BEB: 97 42 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x42] = A;
mon(" LDB <$45 ; 0BED: D6 45 \n");
B = (UINT8)memory_DP[0x45];
// N = B;
// Z = B;
// V = 0;
mon(" LDA <$67 ; 0BEF: 96 67 \n");
A = (UINT8)memory_DP[0x67];
// N = A;
// Z = A;
// V = 0;
mon(" ANDA #$03 ; 0BF1: 84 03 \n");
A = A & (SINT8)0x03;
Z = A;
// N = A;
// V = 0;
mon(" BEQ $0C2F ; 0BF3: 27 3A \n");
if (!Z) {
PC = 0x0c2f;
JUMP;
}
mon(" ANDB #$F9 ; 0BF5: C4 F9 \n");
B = B & (SINT8)0xf9;
// Z = B;
// N = B;
// V = 0;
mon(" ORB #$30 ; 0BF7: CA 30 \n");
B = B | (SINT8)0x30;
// Z = B;
// N = B;
// V = 0;
mon(" STB <$45 ; 0BF9: D7 45 \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0x45] = B;
mon(" ADDA <$76 ; 0BFB: 9B 76 \n");
res = A + memory_DP[0x76];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ memory_DP[0x76] ^ (UINT8)res ^ C;
// V = A ^ memory_DP[0x76] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" STA <$76 ; 0BFD: 97 76 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x76] = A;
mon(" BITA #$08 ; 0BFF: 85 08 \n");
res = A & (SINT8)0x08;
Z = res;
// N = res;
// V = 0;
mon(" BNE $0C07 ; 0C01: 26 04 \n");
if (Z) {
PC = 0x0c07;
JUMP;
}
mon(" ORB #$04 ; 0C03: CA 04 \n");
B = B | (SINT8)0x04;
// Z = B;
// N = B;
// V = 0;
mon(" STB <$45 ; 0C05: D7 45 \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0x45] = B;
case 0x0C07: mon("L0C07 BITA #$10 ; 0C07: 85 10 \n");
res = A & (SINT8)0x10;
Z = res;
// N = res;
// V = 0;
mon(" BNE $0C0D ; 0C09: 26 02 \n");
if (Z) {
PC = 0x0c0d;
JUMP;
}
mon(" EORA #$07 ; 0C0B: 88 07 \n");
A = A ^ (SINT8)0x07;
// Z = A;
// N = A;
// V = 0;
case 0x0C0D: mon("L0C0D ANDA #$07 ; 0C0D: 84 07 \n");
A = A & (SINT8)0x07;
// Z = A;
// N = A;
// V = 0;
mon(" ADDA #$10 ; 0C0F: 8B 10 \n");
res = A + (SINT8)0x10;
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
// V = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" STA <$48 ; 0C11: 97 48 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x48] = A;
mon(" CLR <$47 ; 0C13: 0F 47 \n");
memory_DP[0x47] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" LDA #$08 ; 0C15: 86 08 \n");
A = (UINT8)(SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$42 ; 0C17: 97 42 \n");
// Z = A;
// N = A;
// V = 0;
memory_DP[0x42] = A;
mon(" LDA <$67 ; 0C19: 96 67 \n");
A = (UINT8)memory_DP[0x67];
// N = A;
// Z = A;
// V = 0;
mon(" BITA #$01 ; 0C1B: 85 01 \n");
res = A & (SINT8)0x01;
Z = res;
// N = res;
// V = 0;
mon(" BEQ $0C24 ; 0C1D: 27 05 \n");
if (!Z) {
PC = 0x0c24;
JUMP;
}
mon(" LDD #$0FFF ; 0C1F: CC 0F FF \n");
A = (UINT8)((0x0fff) >> 8);
B = (UINT8)((0x0fff) & 0xff);
Z = A|B;
N = A;
V = 0;
mon(" BRA $0C27 ; 0C22: 20 03 \n");
PC = 0x0c27;
JUMP;
case 0x0C24: mon("L0C24 LDD #$0BFF ; 0C24: CC 0B FF \n");
A = (UINT8)((0x0bff) >> 8);
B = (UINT8)((0x0bff) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
case 0x0C27: mon("L0C27 STD <$49 ; 0C27: DD 49 \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x49] = A;
memory_DP[0x49 + 1] = B;
mon(" LDA #$0E ; 0C29: 86 0E \n");
A = (UINT8)(SINT8)0x0e;
// N = A;
// Z = A;
// V = 0;
mon(" STD <$43 ; 0C2B: DD 43 \n");
Z = A | B;
N = A;
V = 0;
memory_DP[0x43] = A;
memory_DP[0x43 + 1] = B;
mon(" BRA $0C33 ; 0C2D: 20 04 \n");
PC = 0x0c33;
JUMP;
case 0x0C2F: mon("L0C2F ORB #$36 ; 0C2F: CA 36 \n");
B = B | (SINT8)0x36;
// Z = B;
// N = B;
// V = 0;
mon(" STB <$45 ; 0C31: D7 45 \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0x45] = B;
case 0x0C33: mon("L0C33 LDB <$45 ; 0C33: D6 45 \n");
B = (UINT8)memory_DP[0x45];
// N = B;
// Z = B;
// V = 0;
mon(" LDA <$67 ; 0C35: 96 67 \n");
A = (UINT8)memory_DP[0x67];
// N = A;
// Z = A;
// V = 0;
mon(" BITA #$08 ; 0C37: 85 08 \n");
res = A & (SINT8)0x08;
Z = res;
// N = res;
// V = 0;
mon(" BEQ $0C59 ; 0C39: 27 1E \n");
if (!Z) {
PC = 0x0c59;
JUMP;
}
mon(" INC <$6A ; 0C3B: 0C 6A \n");
res = (UINT8)(memory_DP[0x6a] + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0x6a]);
memory_DP[0x6a] = res;
mon(" LDA <$6A ; 0C3D: 96 6A \n");
A = (UINT8)memory_DP[0x6a];
// N = A;
// Z = A;
// V = 0;
mon(" BITA #$02 ; 0C3F: 85 02 \n");
res = A & (SINT8)0x02;
Z = res;
// N = res;
// V = 0;
mon(" BEQ $0C59 ; 0C41: 27 16 \n");
if (!Z) {
PC = 0x0c59;
JUMP;
}
mon(" ANDB #$F7 ; 0C43: C4 F7 \n");
B = B & (SINT8)0xf7;
// Z = B;
// N = B;
// V = 0;
mon(" STB <$45 ; 0C45: D7 45 \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0x45] = B;
mon(" RORA ; 0C47: 46 \n");
res = ((UINT8)A) | ((C != 0) ? 0x100 : 0);
C = res & 1;
res = (UINT8)(res >> 1);
// Z = res;
// N = res;
A = res;
mon(" LDB #$20 ; 0C48: C6 20 \n");
B = (UINT8)(SINT8)0x20;
// N = B;
// Z = B;
// V = 0;
mon(" BCS $0C4D ; 0C4A: 25 01 \n");
if (C) {
PC = 0x0c4d;
JUMP;
}
mon(" LSRB ; 0C4C: 54 \n");
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
case 0x0C4D: mon("L0C4D CLRA ; 0C4D: 4F \n");
A = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" STD <$4B ; 0C4E: DD 4B \n");
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x4b] = A;
memory_DP[0x4b + 1] = B;
mon(" LDB #$03 ; 0C50: C6 03 \n");
B = (UINT8)(SINT8)0x03;
// N = B;
// Z = B;
// V = 0;
mon(" STB <$46 ; 0C52: D7 46 \n");
// Z = B;
// N = B;
// V = 0;
memory_DP[0x46] = B;
mon(" LDA #$0D ; 0C54: 86 0D \n");
A = (UINT8)(SINT8)0x0d;
// N = A;
// Z = A;
// V = 0;
mon(" STA <$44 ; 0C56: 97 44 \n");
Z = A;
N = A;
V = 0;
memory_DP[0x44] = A;
mon(" RTS ; 0C58: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0C59: mon("L0C59 ORB #$09 ; 0C59: CA 09 \n");
B = B | (SINT8)0x09;
// Z = B;
// N = B;
// V = 0;
mon(" STB <$45 ; 0C5B: D7 45 \n");
Z = B;
N = B;
V = 0;
memory_DP[0x45] = B;
mon(" RTS ; 0C5D: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
// FCB $3B ; 0C5E: ';' 3B RTI
// FCB $00 ; 0C5F: ' ' 00 00 NEG <$00
// FCB $00 ; 0C60: ' ' 00 01 NEG <$01
// FCB $01 ; 0C61: ' ' 01 Invalid
// FCB $36 ; 0C62: '6' 36 78 PSHU S,Y,X,DP
// FCB $78 ; 0C63: 'x' 78 00 04 ASL $0004
// FCB $00 ; 0C64: ' ' 00 04 NEG <$04
// FCB $04 ; 0C65: ' ' 04 EC LSR <$EC
case 0x0C66: mon("L0C66 LDD ,X ; 0C66: EC 84 \n");
A = memory[X];
B = memory[(UINT16)((X)+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" ASRA ; 0C68: 47 \n");
// C = A & 1;
A = (UINT8)((SINT8)A >> 1);
// Z = A;
// N = A;
mon(" ASRB ; 0C69: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" STD -2,S ; 0C6A: ED 7E \n");
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0xfffe)] = A;
memory[(UINT16)(S + 0xfffe) + 1] = B;
mon(" LDD $02,X ; 0C6C: EC 02 \n");
A = memory[(UINT16)(X + 0x0002)];
B = memory[(UINT16)(((UINT16)(X + 0x0002))+1)];
// Z = A|B;
// N = A;
// V = 0;
mon(" ASRA ; 0C6E: 47 \n");
// C = A & 1;
A = (UINT8)((SINT8)A >> 1);
// Z = A;
// N = A;
mon(" ASRB ; 0C6F: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" ADDA -2,S ; 0C70: AB 7E \n");
res = A + memory[(UINT16)(S + 0xfffe)];
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ memory[(UINT16)(S + 0xfffe)] ^ (UINT8)res ^ C;
// V = A ^ memory[(UINT16)(S + 0xfffe)] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" ADDB -1,S ; 0C72: EB 7F \n");
res = B + memory[(UINT16)(S + 0xffff)];
C = (res >> 1) & 0x80;
Z = (UINT8)res;
N = (UINT8)res;
H = B ^ memory[(UINT16)(S + 0xffff)] ^ (UINT8)res ^ C;
V = B ^ memory[(UINT16)(S + 0xffff)] ^ (UINT8)res ^ C;
B = (UINT8)res;
mon(" BRA $0C82 ; 0C74: 20 0C \n");
PC = 0x0c82;
JUMP;
case 0x0C76: mon("L0C76 PSHS B,A ; 0C76: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
mon(" LDA ,U ; 0C78: A6 C4 \n");
A = (UINT8)memory[U];
// N = A;
// Z = A;
// V = 0;
mon(" LDB $02,U ; 0C7A: E6 42 \n");
B = (UINT8)memory[(UINT16)(U + 0x0002)];
// N = B;
// Z = B;
// V = 0;
mon(" TFR D,Y ; 0C7C: 1F 02 \n");
Y = ((A << 8) | B);
mon(" PULS A,B ; 0C7E: 35 06 \n");
A = memory[S++];
B = memory[S++];
case 0x0C80: mon("L0C80 ASRA ; 0C80: 47 \n");
// C = A & 1;
A = (UINT8)((SINT8)A >> 1);
// Z = A;
// N = A;
mon(" ASRB ; 0C81: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
case 0x0C82: mon("L0C82 PSHS B,A ; 0C82: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
mon(" TFR Y,D ; 0C84: 1F 20 \n");
A = (UINT8)((Y) >> 8);
B = (UINT8)((Y) & 0xff);
mon(" ASRA ; 0C86: 47 \n");
// C = A & 1;
A = (UINT8)((SINT8)A >> 1);
// Z = A;
// N = A;
mon(" ASRB ; 0C87: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" SUBA ,S+ ; 0C88: A0 E0 \n");
res = A - memory[S];
// C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((A) ^ memory[S]) & ((A) ^ (UINT8)res);
A = (UINT8)(res);
S = S + 1;
mon(" SUBB ,S+ ; 0C8A: E0 E0 \n");
res = B - memory[S];
C = res & 0x100;
// Z = (UINT8)res;
// N = (UINT8)res;
// V = ((B) ^ memory[S]) & ((B) ^ (UINT8)res);
B = (UINT8)(res);
S = S + 1;
mon(" PSHS B,A ; 0C8C: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
mon(" JSR Rise_Run_Angle ; 0C8E: BD F5 93 \n");
memory[--S] = 0x0c91 & 0xff; memory[--S] = 0x0c91 >> 8;
PC = 0xf593;
JUMP;
case 0x0C91: mon("L0C91 PULS A,B ; 0C91: 35 06 \n");
A = memory[S++];
B = memory[S++];
mon(" JSR Abs_a_b ; 0C93: BD F5 84 \n");
memory[--S] = 0x0c96 & 0xff; memory[--S] = 0x0c96 >> 8;
PC = 0xf584;
JUMP;
case 0x0C96: mon("L0C96 PSHS A ; 0C96: 34 02 \n");
memory[--S] = A;
mon(" ORB ,S+ ; 0C98: EA E0 \n");
B = B | memory[S];
// Z = B;
// N = B;
// V = 0;
S = S + 1;
mon(" LDA <$36 ; 0C9A: 96 36 \n");
A = (UINT8)memory_DP[0x36];
N = A;
Z = A;
V = 0;
mon(" RTS ; 0C9C: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
// FCB $BD ; 0C9D: ' ' BD F4 0E JSR $F40E
// FCB $F4 ; 0C9E: ' ' F4 0E 7E ANDB $0E7E
// FCB $0E ; 0C9F: ' ' 0E 7E JMP <$7E
// FCB $7E ; 0CA0: '~' 7E F3 54 JMP $F354
// FCB $F3 ; 0CA1: ' ' F3 54 A6 ADDD $54A6
// FCB $54 ; 0CA2: 'T' 54 LSRB
// FCB $A6 ; 0CA3: ' ' A6 C0 LDA ,U+
// FCB $C0 ; 0CA4: ' ' C0 5F SUBB #$5F
// FCB $5F ; 0CA5: '_' 5F CLRB
// FCB $BD ; 0CA6: ' ' BD F8 7C JSR $F87C
// FCB $F8 ; 0CA7: ' ' F8 7C 30 EORB $7C30
// FCB $7C ; 0CA8: '|' 7C 30 09 INC $3009
// FCB $30 ; 0CA9: '0' 30 09 LEAX 9,X
// FCB $09 ; 0CAA: ' ' 09 39 ROL <$39
// FCB $39 ; 0CAB: '9' 39 RTS
case 0x0CAC: mon("L0CAC LEAY ,X ; 0CAC: 31 84 \n");
Y = X;
// Z = Y;
mon(" LDA #$04 ; 0CAE: 86 04 \n");
A = (UINT8)(SINT8)0x04;
// N = A;
// Z = A;
// V = 0;
mon(" PSHS B,A ; 0CB0: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
mon(" LDB #$04 ; 0CB2: C6 04 \n");
B = (UINT8)(SINT8)0x04;
// N = B;
// Z = B;
// V = 0;
mon(" PSHS B,A ; 0CB4: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
case 0x0CB6: mon("L0CB6 LDA $01,S ; 0CB6: A6 61 \n");
A = (UINT8)memory[(UINT16)(S + 0x0001)];
// N = A;
// Z = A;
// V = 0;
case 0x0CB8: mon("L0CB8 ADDA #$10 ; 0CB8: 8B 10 \n");
res = A + (SINT8)0x10;
// C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
// H = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
// V = A ^ (SINT8)0x10 ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" STA $01,S ; 0CBA: A7 61 \n");
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0001)] = A;
mon(" LDB $03,S ; 0CBC: E6 63 \n");
B = (UINT8)memory[(UINT16)(S + 0x0003)];
// N = B;
// Z = B;
// V = 0;
mon(" JSR Rot_VL_ab ; 0CBE: BD F6 10 \n");
memory[--S] = 0x0cc1 & 0xff; memory[--S] = 0x0cc1 >> 8;
PC = 0xf610;
JUMP;
case 0x0CC1: mon("L0CC1 LEAX ,Y ; 0CC1: 30 A4 \n");
X = Y;
// Z = X;
mon(" DEC ,S ; 0CC3: 6A E4 \n");
res = (UINT8)(memory[S] - 1);
// N = res;
Z = res;
// V = memory[S] & ~res;
memory[S] = res;
mon(" BNE $0CB6 ; 0CC5: 26 EF \n");
if (Z) {
PC = 0x0cb6;
JUMP;
}
mon(" LDA #$04 ; 0CC7: 86 04 \n");
A = (UINT8)(SINT8)0x04;
// N = A;
// Z = A;
// V = 0;
mon(" STA ,S ; 0CC9: A7 E4 \n");
// Z = A;
// N = A;
// V = 0;
memory[S] = A;
mon(" ADDA $01,S ; 0CCB: AB 61 \n");
res = A + memory[(UINT16)(S + 0x0001)];
C = (res >> 1) & 0x80;
// Z = (UINT8)res;
// N = (UINT8)res;
H = A ^ memory[(UINT16)(S + 0x0001)] ^ (UINT8)res ^ C;
// V = A ^ memory[(UINT16)(S + 0x0001)] ^ (UINT8)res ^ C;
A = (UINT8)res;
mon(" DEC $02,S ; 0CCD: 6A 62 \n");
res = (UINT8)(memory[(UINT16)(S + 0x0002)] - 1);
N = res;
Z = res;
V = memory[(UINT16)(S + 0x0002)] & ~res;
memory[(UINT16)(S + 0x0002)] = res;
mon(" BNE $0CB8 ; 0CCF: 26 E7 \n");
if (Z) {
PC = 0x0cb8;
JUMP;
}
mon(" LEAS $04,S ; 0CD1: 32 64 \n");
S = (S + 0x0004);
mon(" RTS ; 0CD3: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0CD4: mon("L0CD4 LDX #$C900 ; 0CD4: 8E C9 00 \n");
X = 0xc900;
// Z = X;
// N = (X) >> 8;
// V = 0;
mon(" LDD #$0340 ; 0CD7: CC 03 40 \n");
A = (UINT8)((0x0340) >> 8);
B = (UINT8)((0x0340) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
case 0x0CDA: mon("L0CDA CLR ,X ; 0CDA: 6F 84 \n");
memory[X] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
mon(" ABX ; 0CDC: 3A \n");
X = X + B;
mon(" DECA ; 0CDD: 4A \n");
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
mon(" BNE $0CDA ; 0CDE: 26 FA \n");
if (Z) {
PC = 0x0cda;
JUMP;
}
mon(" RTS ; 0CE0: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0CE1: mon("L0CE1 PSHS B,A ; 0CE1: 34 06 \n");
memory[--S] = B;
memory[--S] = A;
mon(" JSR Random ; 0CE3: BD F5 17 \n");
memory[--S] = 0x0ce6 & 0xff; memory[--S] = 0x0ce6 >> 8;
PC = 0xf517;
JUMP;
case 0x0CE6: mon("L0CE6 ANDA ,S+ ; 0CE6: A4 E0 \n");
A = A & memory[S];
// Z = A;
// N = A;
// V = 0;
S = S + 1;
mon(" LEAU A,U ; 0CE8: 33 C6 \n");
U = (U + (SINT8)A);
mon(" PULS A ; 0CEA: 35 02 \n");
A = memory[S++];
case 0x0CEC: mon("L0CEC LDB ,U+ ; 0CEC: E6 C0 \n");
B = (UINT8)memory[U];
// N = B;
// Z = B;
// V = 0;
U = U + 1;
mon(" ASRB ; 0CEE: 57 \n");
// C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" ASRB ; 0CEF: 57 \n");
C = B & 1;
B = (UINT8)((SINT8)B >> 1);
// Z = B;
// N = B;
mon(" STB ,X+ ; 0CF0: E7 80 \n");
// Z = B;
// N = B;
// V = 0;
memory[X] = B;
X = X + 1;
mon(" DECA ; 0CF2: 4A \n");
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
mon(" BNE $0CEC ; 0CF3: 26 F7 \n");
if (Z) {
PC = 0x0cec;
JUMP;
}
mon(" RTS ; 0CF5: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
case 0x0CF6: mon("L0CF6 LDB ,U+ ; 0CF6: E6 C0 \n");
B = (UINT8)memory[U];
// N = B;
// Z = B;
// V = 0;
U = U + 1;
mon(" STB ,X+ ; 0CF8: E7 80 \n");
// Z = B;
// N = B;
// V = 0;
memory[X] = B;
X = X + 1;
mon(" DECA ; 0CFA: 4A \n");
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
mon(" BNE $0CF6 ; 0CFB: 26 F9 \n");
if (Z) {
PC = 0x0cf6;
JUMP;
}
mon(" RTS ; 0CFD: 39 \n");
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
// FCB $12 ; 0CFE: ' ' 12 NOP
// FCB $01 ; 0CFF: ' ' 01 Invalid
// FCB $01 ; 0D00: ' ' 01 Invalid
// FCB $02 ; 0D01: ' ' 02 Invalid
// FCB $06 ; 0D02: ' ' 06 FC ROR <$FC
// FCB $FC ; 0D03: ' ' FC 03 20 LDD $0320
// FCB $03 ; 0D04: ' ' 03 20 COM <$20
// FCB $20 ; 0D05: ' ' 20 08 BRA $0D0F
// FCB $08 ; 0D06: ' ' 08 01 ASL <$01
// FCB $01 ; 0D07: ' ' 01 Invalid
// FCB $02 ; 0D08: ' ' 02 Invalid
// FCB $02 ; 0D09: ' ' 02 Invalid
// FCB $04 ; 0D0A: ' ' 04 FD LSR <$FD
// FCB $FD ; 0D0B: ' ' FD 01 20 STD $0120
// FCB $01 ; 0D0C: ' ' 01 Invalid
// FCB $20 ; 0D0D: ' ' 20 10 BRA $0D1F
// FCB $10 ; 0D0E: ' ' 10 01 Invalid
// FCB $01 ; 0D0F: ' ' 01 Invalid
// FCB $02 ; 0D10: ' ' 02 Invalid
// FCB $02 ; 0D11: ' ' 02 Invalid
// FCB $02 ; 0D12: ' ' 02 Invalid
// FCB $FD ; 0D13: ' ' FD 01 20 STD $0120
// FCB $01 ; 0D14: ' ' 01 Invalid
// FCB $20 ; 0D15: ' ' 20 18 BRA $0D2F
// FCB $18 ; 0D16: ' ' 18 Invalid
// FCB $01 ; 0D17: ' ' 01 Invalid
// FCB $03 ; 0D18: ' ' 03 02 COM <$02
// FCB $02 ; 0D19: ' ' 02 Invalid
// FCB $02 ; 0D1A: ' ' 02 Invalid
// FCB $FD ; 0D1B: ' ' FD 01 1C STD $011C
// FCB $01 ; 0D1C: ' ' 01 Invalid
// FCB $1C ; 0D1D: ' ' 1C 20 ANDCC #$20
// FCB $20 ; 0D1E: ' ' 20 01 BRA $0D21
// FCB $01 ; 0D1F: ' ' 01 Invalid
// FCB $03 ; 0D20: ' ' 03 02 COM <$02
// FCB $02 ; 0D21: ' ' 02 Invalid
// FCB $02 ; 0D22: ' ' 02 Invalid
// FCB $FE ; 0D23: ' ' FE 01 1C LDU $011C
// FCB $01 ; 0D24: ' ' 01 Invalid
// FCB $1C ; 0D25: ' ' 1C 28 ANDCC #$28
// FCB $28 ; 0D26: '(' 28 02 BVC $0D2A
// FCB $02 ; 0D27: ' ' 02 Invalid
// FCB $03 ; 0D28: ' ' 03 02 COM <$02
// FCB $02 ; 0D29: ' ' 02 Invalid
// FCB $01 ; 0D2A: ' ' 01 Invalid
// FCB $FE ; 0D2B: ' ' FE 01 1C LDU $011C
// FCB $01 ; 0D2C: ' ' 01 Invalid
// FCB $1C ; 0D2D: ' ' 1C 30 ANDCC #$30
// FCB $30 ; 0D2E: '0' 30 02 LEAX 2,X
// FCB $02 ; 0D2F: ' ' 02 Invalid
// FCB $03 ; 0D30: ' ' 03 02 COM <$02
// FCB $02 ; 0D31: ' ' 02 Invalid
// FCB $01 ; 0D32: ' ' 01 Invalid
// FCB $FF ; 0D33: ' ' FF 00 1C STU $001C
// FCB $00 ; 0D34: ' ' 00 1C NEG <$1C
// FCB $1C ; 0D35: ' ' 1C 38 ANDCC #$38
// FCB $38 ; 0D36: '8' 38 Invalid
// FCB $02 ; 0D37: ' ' 02 Invalid
// FCB $03 ; 0D38: ' ' 03 04 COM <$04
// FCB $04 ; 0D39: ' ' 04 01 LSR <$01
// FCB $01 ; 0D3A: ' ' 01 Invalid
// FCB $FF ; 0D3B: ' ' FF 00 14 STU $0014
// FCB $00 ; 0D3C: ' ' 00 14 NEG <$14
// FCB $14 ; 0D3D: ' ' 14 Invalid
// FCB $38 ; 0D3E: '8' 38 Invalid
// FCB $02 ; 0D3F: ' ' 02 Invalid
// FCB $00 ; 0D40: ' ' 00 30 NEG <$30
// FCB $30 ; 0D41: '0' 30 FF LEAX ???
// FCB $FF ; 0D42: ' ' FF 05 02 STU $0502
// FCB $05 ; 0D43: ' ' 05 Invalid
// FCB $02 ; 0D44: ' ' 02 Invalid
// FCB $03 ; 0D45: ' ' 03 00 COM <$00
// FCB $00 ; 0D46: ' ' 00 08 NEG <$08
// FCB $08 ; 0D47: ' ' 08 0C ASL <$0C
// FCB $0C ; 0D48: ' ' 0C FF INC <$FF
// FCB $FF ; 0D49: ' ' FF F0 00 STU $F000
// FCB $F0 ; 0D4A: ' ' F0 00 FF SUBB $00FF
// FCB $00 ; 0D4B: ' ' 00 FF NEG <$FF
// FCB $FF ; 0D4C: ' ' FF 00 E8 STU $00E8
// FCB $00 ; 0D4D: ' ' 00 E8 NEG <$E8
// FCB $E8 ; 0D4E: ' ' E8 FF EORB ???
// FCB $FF ; 0D4F: ' ' FF 10 00 STU $1000
// FCB $10 ; 0D50: ' ' 10 00 Invalid
// FCB $00 ; 0D51: ' ' 00 FF NEG <$FF
// FCB $FF ; 0D52: ' ' FF 00 18 STU $0018
// FCB $00 ; 0D53: ' ' 00 18 NEG <$18
// FCB $18 ; 0D54: ' ' 18 Invalid
// FCB $00 ; 0D55: ' ' 00 F4 NEG <$F4
// FCB $F4 ; 0D56: ' ' F4 00 FF ANDB $00FF
// FCB $00 ; 0D57: ' ' 00 FF NEG <$FF
// FCB $FF ; 0D58: ' ' FF FC F6 STU $FCF6
// FCB $FC ; 0D59: ' ' FC F6 FF LDD $F6FF
// FCB $F6 ; 0D5A: ' ' F6 FF 10 LDB $FF10
// FCB $FF ; 0D5B: ' ' FF 10 00 STU $1000
// FCB $10 ; 0D5C: ' ' 10 00 Invalid
// FCB $00 ; 0D5D: ' ' 00 FF NEG <$FF
// FCB $FF ; 0D5E: ' ' FF FC 0A STU $FC0A
// FCB $FC ; 0D5F: ' ' FC 0A 01 LDD $0A01
// FCB $0A ; 0D60: ' ' 0A 01 DEC <$01
// FCB $01 ; 0D61: ' ' 01 Invalid
// FCB $00 ; 0D62: ' ' 00 08 NEG <$08
// FCB $08 ; 0D63: ' ' 08 0C ASL <$0C
// FCB $0C ; 0D64: ' ' 0C FF INC <$FF
// FCB $FF ; 0D65: ' ' FF F0 00 STU $F000
// FCB $F0 ; 0D66: ' ' F0 00 FF SUBB $00FF
// FCB $00 ; 0D67: ' ' 00 FF NEG <$FF
// FCB $FF ; 0D68: ' ' FF 00 E8 STU $00E8
// FCB $00 ; 0D69: ' ' 00 E8 NEG <$E8
// FCB $E8 ; 0D6A: ' ' E8 FF EORB ???
// FCB $FF ; 0D6B: ' ' FF 10 00 STU $1000
// FCB $10 ; 0D6C: ' ' 10 00 Invalid
// FCB $00 ; 0D6D: ' ' 00 FF NEG <$FF
// FCB $FF ; 0D6E: ' ' FF 00 18 STU $0018
// FCB $00 ; 0D6F: ' ' 00 18 NEG <$18
// FCB $18 ; 0D70: ' ' 18 Invalid
// FCB $FF ; 0D71: ' ' FF F0 F6 STU $F0F6
// FCB $F0 ; 0D72: ' ' F0 F6 FF SUBB $F6FF
// FCB $F6 ; 0D73: ' ' F6 FF 10 LDB $FF10
// FCB $FF ; 0D74: ' ' FF 10 00 STU $1000
// FCB $10 ; 0D75: ' ' 10 00 Invalid
// FCB $00 ; 0D76: ' ' 00 FF NEG <$FF
// FCB $FF ; 0D77: ' ' FF F0 0A STU $F00A
// FCB $F0 ; 0D78: ' ' F0 0A 01 SUBB $0A01
// FCB $0A ; 0D79: ' ' 0A 01 DEC <$01
// FCB $01 ; 0D7A: ' ' 01 Invalid
// FCB $00 ; 0D7B: ' ' 00 1B NEG <$1B
// FCB $1B ; 0D7C: ' ' 1B Invalid
// FCB $00 ; 0D7D: ' ' 00 EE NEG <$EE
// FCB $EE ; 0D7E: ' ' EE 03 LDU 3,X
// FCB $03 ; 0D7F: ' ' 03 FD COM <$FD
// FCB $FD ; 0D80: ' ' FD FA 00 STD $FA00
// FCB $FA ; 0D81: ' ' FA 00 03 ORB $0003
// FCB $00 ; 0D82: ' ' 00 03 NEG <$03
// FCB $03 ; 0D83: ' ' 03 03 COM <$03
// FCB $03 ; 0D84: ' ' 03 0F COM <$0F
// FCB $0F ; 0D85: ' ' 0F 0F CLR <$0F
// FCB $0F ; 0D86: ' ' 0F 02 CLR <$02
// FCB $02 ; 0D87: ' ' 02 Invalid
// FCB $08 ; 0D88: ' ' 08 18 ASL <$18
// FCB $18 ; 0D89: ' ' 18 Invalid
// FCB $78 ; 0D8A: 'x' 78 00 01 ASL $0001
// FCB $00 ; 0D8B: ' ' 00 01 NEG <$01
// FCB $01 ; 0D8C: ' ' 01 Invalid
// FCB $30 ; 0D8D: '0' 30 0A LEAX 10,X
// FCB $0A ; 0D8E: ' ' 0A 0A DEC <$0A
// FCB $0A ; 0D8F: ' ' 0A 02 DEC <$02
// FCB $02 ; 0D90: ' ' 02 Invalid
// FCB $08 ; 0D91: ' ' 08 38 ASL <$38
// FCB $38 ; 0D92: '8' 38 Invalid
// FCB $78 ; 0D93: 'x' 78 00 01 ASL $0001
// FCB $00 ; 0D94: ' ' 00 01 NEG <$01
// FCB $01 ; 0D95: ' ' 01 Invalid
// FCB $30 ; 0D96: '0' 30 06 LEAX 6,X
// FCB $06 ; 0D97: ' ' 06 06 ROR <$06
// FCB $06 ; 0D98: ' ' 06 03 ROR <$03
// FCB $03 ; 0D99: ' ' 03 08 COM <$08
// FCB $08 ; 0D9A: ' ' 08 78 ASL <$78
// FCB $78 ; 0D9B: 'x' 78 38 01 ASL $3801
// FCB $38 ; 0D9C: '8' 38 Invalid
// FCB $01 ; 0D9D: ' ' 01 Invalid
// FCB $00 ; 0D9E: ' ' 00 00 NEG <$00
// FCB $00 ; 0D9F: ' ' 00 00 NEG <$00
// FCB $00 ; 0DA0: ' ' 00 02 NEG <$02
// FCB $02 ; 0DA1: ' ' 02 Invalid
// FCB $01 ; 0DA2: ' ' 01 Invalid
// FCB $01 ; 0DA3: ' ' 01 Invalid
// FCB $00 ; 0DA4: ' ' 00 20 NEG <$20
// FCB $20 ; 0DA5: ' ' 20 08 BRA $0DAF
// FCB $08 ; 0DA6: ' ' 08 08 ASL <$08
// FCB $08 ; 0DA7: ' ' 08 0B ASL <$0B
// FCB $0B ; 0DA8: ' ' 0B Invalid
// FCB $03 ; 0DA9: ' ' 03 02 COM <$02
// FCB $02 ; 0DAA: ' ' 02 Invalid
// FCB $01 ; 0DAB: ' ' 01 Invalid
// FCB $30 ; 0DAC: '0' 30 30 LEAX -16,Y
// FCB $30 ; 0DAD: '0' 30 08 LEAX 8,X
// FCB $08 ; 0DAE: ' ' 08 20 ASL <$20
// FCB $20 ; 0DAF: ' ' 20 04 BRA $0DB5
// FCB $04 ; 0DB0: ' ' 04 00 LSR <$00
// FCB $00 ; 0DB1: ' ' 00 03 NEG <$03
// FCB $03 ; 0DB2: ' ' 03 02 COM <$02
// FCB $02 ; 0DB3: ' ' 02 Invalid
// FCB $10 ; 0DB4: ' ' 10 00 Invalid
// FCB $00 ; 0DB5: ' ' 00 08 NEG <$08
// FCB $08 ; 0DB6: ' ' 08 30 ASL <$30
// FCB $30 ; 0DB7: '0' 30 00 LEAX 0,X
// FCB $00 ; 0DB8: ' ' 00 05 NEG <$05
// FCB $05 ; 0DB9: ' ' 05 Invalid
// FCB $03 ; 0DBA: ' ' 03 00 COM <$00
// FCB $00 ; 0DBB: ' ' 00 00 NEG <$00
// FCB $00 ; 0DBC: ' ' 00 18 NEG <$18
// FCB $18 ; 0DBD: ' ' 18 Invalid
// FCB $10 ; 0DBE: ' ' 10 00 Invalid
// FCB $00 ; 0DBF: ' ' 00 06 NEG <$06
// FCB $06 ; 0DC0: ' ' 06 00 ROR <$00
// FCB $00 ; 0DC1: ' ' 00 00 NEG <$00
// FCB $00 ; 0DC2: ' ' 00 04 NEG <$04
// FCB $04 ; 0DC3: ' ' 04 20 LSR <$20
// FCB $20 ; 0DC4: ' ' 20 00 BRA $0DC6
// FCB $00 ; 0DC5: ' ' 00 00 NEG <$00
// FCB $00 ; 0DC6: ' ' 00 18 NEG <$18
// FCB $18 ; 0DC7: ' ' 18 Invalid
// FCB $00 ; 0DC8: ' ' 00 00 NEG <$00
// FCB $00 ; 0DC9: ' ' 00 05 NEG <$05
// FCB $05 ; 0DCA: ' ' 05 Invalid
// FCB $07 ; 0DCB: ' ' 07 00 ASR <$00
// FCB $00 ; 0DCC: ' ' 00 00 NEG <$00
// FCB $00 ; 0DCD: ' ' 00 20 NEG <$20
// FCB $20 ; 0DCE: ' ' 20 18 BRA $0DE8
// FCB $18 ; 0DCF: ' ' 18 Invalid
// FCB $08 ; 0DD0: ' ' 08 06 ASL <$06
// FCB $06 ; 0DD1: ' ' 06 00 ROR <$00
// FCB $00 ; 0DD2: ' ' 00 0B NEG <$0B
// FCB $0B ; 0DD3: ' ' 0B Invalid
// FCB $20 ; 0DD4: ' ' 20 18 BRA $0DEE
// FCB $18 ; 0DD5: ' ' 18 Invalid
// FCB $00 ; 0DD6: ' ' 00 30 NEG <$30
// FCB $30 ; 0DD7: '0' 30 00 LEAX 0,X
// FCB $00 ; 0DD8: ' ' 00 00 NEG <$00
// FCB $00 ; 0DD9: ' ' 00 07 NEG <$07
// FCB $07 ; 0DDA: ' ' 07 09 ASR <$09
// FCB $09 ; 0DDB: ' ' 09 00 ROL <$00
// FCB $00 ; 0DDC: ' ' 00 00 NEG <$00
// FCB $00 ; 0DDD: ' ' 00 20 NEG <$20
// FCB $20 ; 0DDE: ' ' 20 20 BRA $0E00
// FCB $20 ; 0DDF: ' ' 20 0A BRA $0DEB
// FCB $0A ; 0DE0: ' ' 0A 08 DEC <$08
// FCB $08 ; 0DE1: ' ' 08 00 ASL <$00
// FCB $00 ; 0DE2: ' ' 00 0C NEG <$0C
// FCB $0C ; 0DE3: ' ' 0C 18 INC <$18
// FCB $18 ; 0DE4: ' ' 18 Invalid
// FCB $20 ; 0DE5: ' ' 20 00 BRA $0DE7
// FCB $00 ; 0DE6: ' ' 00 10 NEG <$10
// FCB $10 ; 0DE7: ' ' 10 00 Invalid
// FCB $00 ; 0DE8: ' ' 00 00 NEG <$00
// FCB $00 ; 0DE9: ' ' 00 09 NEG <$09
// FCB $09 ; 0DEA: ' ' 09 0F ROL <$0F
// FCB $0F ; 0DEB: ' ' 0F 00 CLR <$00
// FCB $00 ; 0DEC: ' ' 00 00 NEG <$00
// FCB $00 ; 0DED: ' ' 00 18 NEG <$18
// FCB $18 ; 0DEE: ' ' 18 Invalid
// FCB $20 ; 0DEF: ' ' 20 0C BRA $0DFD
// FCB $0C ; 0DF0: ' ' 0C 07 INC <$07
// FCB $07 ; 0DF1: ' ' 07 02 ASR <$02
// FCB $02 ; 0DF2: ' ' 02 Invalid
// FCB $00 ; 0DF3: ' ' 00 20 NEG <$20
// FCB $20 ; 0DF4: ' ' 20 30 BRA $0E26
// FCB $30 ; 0DF5: '0' 30 30 LEAX -16,Y
// FCB $30 ; 0DF6: '0' 30 00 LEAX 0,X
// FCB $00 ; 0DF7: ' ' 00 00 NEG <$00
// FCB $00 ; 0DF8: ' ' 00 09 NEG <$09
// FCB $09 ; 0DF9: ' ' 09 0B ROL <$0B
// FCB $0B ; 0DFA: ' ' 0B Invalid
// FCB $0D ; 0DFB: ' ' 0D 00 TST <$00
// FCB $00 ; 0DFC: ' ' 00 10 NEG <$10
// FCB $10 ; 0DFD: ' ' 10 20 Invalid
// FCB $20 ; 0DFE: ' ' 20 10 BRA $0E10
// FCB $10 ; 0DFF: ' ' 10 0F Invalid
// FCB $0F ; 0E00: ' ' 0F 0C CLR <$0C
// FCB $0C ; 0E01: ' ' 0C 00 INC <$00
// FCB $00 ; 0E02: ' ' 00 0E NEG <$0E
// FCB $0E ; 0E03: ' ' 0E 18 JMP <$18
// FCB $18 ; 0E04: ' ' 18 Invalid
// FCB $10 ; 0E05: ' ' 10 00 Invalid
// FCB $00 ; 0E06: ' ' 00 10 NEG <$10
// FCB $10 ; 0E07: ' ' 10 00 Invalid
// FCB $00 ; 0E08: ' ' 00 0D NEG <$0D
// FCB $0D ; 0E09: ' ' 0D 00 TST <$00
// FCB $00 ; 0E0A: ' ' 00 0E NEG <$0E
// FCB $0E ; 0E0B: ' ' 0E 00 JMP <$00
// FCB $00 ; 0E0C: ' ' 00 10 NEG <$10
// FCB $10 ; 0E0D: ' ' 10 00 Invalid
// FCB $00 ; 0E0E: ' ' 00 08 NEG <$08
// FCB $08 ; 0E0F: ' ' 08 00 ASL <$00
// FCB $00 ; 0E10: ' ' 00 0A NEG <$0A
// FCB $0A ; 0E11: ' ' 0A 0D DEC <$0D
// FCB $0D ; 0E12: ' ' 0D 00 TST <$00
// FCB $00 ; 0E13: ' ' 00 00 NEG <$00
// FCB $00 ; 0E14: ' ' 00 20 NEG <$20
// FCB $20 ; 0E15: ' ' 20 18 BRA $0E2F
// FCB $18 ; 0E16: ' ' 18 Invalid
// FCB $00 ; 0E17: ' ' 00 30 NEG <$30
// FCB $30 ; 0E18: '0' 30 00 LEAX 0,X
// FCB $00 ; 0E19: ' ' 00 00 NEG <$00
// FCB $00 ; 0E1A: ' ' 00 60 NEG <$60
// FCB $60 ; 0E1B: '`' 60 D0 NEG ???
// FCB $D0 ; 0E1C: ' ' D0 00 SUBB <$00
// FCB $00 ; 0E1D: ' ' 00 00 NEG <$00
// FCB $00 ; 0E1E: ' ' 00 40 NEG <$40
// FCB $40 ; 0E1F: '@' 40 NEGA
// FCB $C0 ; 0E20: ' ' C0 00 SUBB #$00
// FCB $00 ; 0E21: ' ' 00 00 NEG <$00
// FCB $00 ; 0E22: ' ' 00 30 NEG <$30
// FCB $30 ; 0E23: '0' 30 A0 LEAX ,Y+
// FCB $A0 ; 0E24: ' ' A0 00 SUBA 0,X
// FCB $00 ; 0E25: ' ' 00 00 NEG <$00
// FCB $00 ; 0E26: ' ' 00 D0 NEG <$D0
// FCB $D0 ; 0E27: ' ' D0 C0 SUBB <$C0
// FCB $C0 ; 0E28: ' ' C0 00 SUBB #$00
// FCB $00 ; 0E29: ' ' 00 00 NEG <$00
// FCB $00 ; 0E2A: ' ' 00 30 NEG <$30
// FCB $30 ; 0E2B: '0' 30 A0 LEAX ,Y+
// FCB $A0 ; 0E2C: ' ' A0 00 SUBA 0,X
// FCB $00 ; 0E2D: ' ' 00 00 NEG <$00
// FCB $00 ; 0E2E: ' ' 00 D0 NEG <$D0
// FCB $D0 ; 0E2F: ' ' D0 C0 SUBB <$C0
// FCB $C0 ; 0E30: ' ' C0 00 SUBB #$00
// FCB $00 ; 0E31: ' ' 00 00 NEG <$00
// FCB $00 ; 0E32: ' ' 00 C0 NEG <$C0
// FCB $C0 ; 0E33: ' ' C0 D0 SUBB #$D0
// FCB $D0 ; 0E34: ' ' D0 00 SUBB <$00
// FCB $00 ; 0E35: ' ' 00 00 NEG <$00
// FCB $00 ; 0E36: ' ' 00 A0 NEG <$A0
// FCB $A0 ; 0E37: ' ' A0 30 SUBA -16,Y
// FCB $30 ; 0E38: '0' 30 00 LEAX 0,X
// FCB $00 ; 0E39: ' ' 00 00 NEG <$00
// FCB $00 ; 0E3A: ' ' 00 C0 NEG <$C0
// FCB $C0 ; 0E3B: ' ' C0 D0 SUBB #$D0
// FCB $D0 ; 0E3C: ' ' D0 00 SUBB <$00
// FCB $00 ; 0E3D: ' ' 00 00 NEG <$00
// FCB $00 ; 0E3E: ' ' 00 A0 NEG <$A0
// FCB $A0 ; 0E3F: ' ' A0 30 SUBA -16,Y
// FCB $30 ; 0E40: '0' 30 00 LEAX 0,X
// FCB $00 ; 0E41: ' ' 00 00 NEG <$00
// FCB $00 ; 0E42: ' ' 00 C0 NEG <$C0
// FCB $C0 ; 0E43: ' ' C0 40 SUBB #$40
// FCB $40 ; 0E44: '@' 40 NEGA
// FCB $00 ; 0E45: ' ' 00 00 NEG <$00
// FCB $00 ; 0E46: ' ' 00 D0 NEG <$D0
// FCB $D0 ; 0E47: ' ' D0 60 SUBB <$60
// FCB $60 ; 0E48: '`' 60 00 NEG 0,X
// FCB $00 ; 0E49: ' ' 00 00 NEG <$00
// FCB $00 ; 0E4A: ' ' 00 30 NEG <$30
// FCB $30 ; 0E4B: '0' 30 40 LEAX 0,U
// FCB $40 ; 0E4C: '@' 40 NEGA
// FCB $00 ; 0E4D: ' ' 00 00 NEG <$00
// FCB $00 ; 0E4E: ' ' 00 D0 NEG <$D0
// FCB $D0 ; 0E4F: ' ' D0 60 SUBB <$60
// FCB $60 ; 0E50: '`' 60 00 NEG 0,X
// FCB $00 ; 0E51: ' ' 00 00 NEG <$00
// FCB $00 ; 0E52: ' ' 00 30 NEG <$30
// FCB $30 ; 0E53: '0' 30 40 LEAX 0,U
// FCB $40 ; 0E54: '@' 40 NEGA
// FCB $00 ; 0E55: ' ' 00 00 NEG <$00
// FCB $00 ; 0E56: ' ' 00 40 NEG <$40
// FCB $40 ; 0E57: '@' 40 NEGA
// FCB $30 ; 0E58: '0' 30 00 LEAX 0,X
// FCB $00 ; 0E59: ' ' 00 00 NEG <$00
// FCB $00 ; 0E5A: ' ' 00 60 NEG <$60
// FCB $60 ; 0E5B: '`' 60 D0 NEG ???
// FCB $D0 ; 0E5C: ' ' D0 00 SUBB <$00
// FCB $00 ; 0E5D: ' ' 00 00 NEG <$00
// FCB $00 ; 0E5E: ' ' 00 40 NEG <$40
// FCB $40 ; 0E5F: '@' 40 NEGA
// FCB $00 ; 0E60: ' ' 00 40 NEG <$40
// FCB $40 ; 0E61: '@' 40 NEGA
// FCB $C0 ; 0E62: ' ' C0 00 SUBB #$00
// FCB $00 ; 0E63: ' ' 00 C0 NEG <$C0
// FCB $C0 ; 0E64: ' ' C0 00 SUBB #$00
// FCB $00 ; 0E65: ' ' 00 00 NEG <$00
// FCB $00 ; 0E66: ' ' 00 C0 NEG <$C0
// FCB $C0 ; 0E67: ' ' C0 40 SUBB #$40
// FCB $40 ; 0E68: '@' 40 NEGA
// FCB $00 ; 0E69: ' ' 00 40 NEG <$40
// FCB $40 ; 0E6A: '@' 40 NEGA
// FCB $00 ; 0E6B: ' ' 00 00 NEG <$00
// FCB $00 ; 0E6C: ' ' 00 20 NEG <$20
// FCB $20 ; 0E6D: ' ' 20 40 BRA $0EAF
// FCB $40 ; 0E6E: '@' 40 NEGA
// FCB $00 ; 0E6F: ' ' 00 00 NEG <$00
// FCB $00 ; 0E70: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0E71: ' ' E0 C0 SUBB ,U+
// FCB $C0 ; 0E72: ' ' C0 00 SUBB #$00
// FCB $00 ; 0E73: ' ' 00 00 NEG <$00
// FCB $00 ; 0E74: ' ' 00 40 NEG <$40
// FCB $40 ; 0E75: '@' 40 NEGA
// FCB $48 ; 0E76: 'H' 48 ASLA
// FCB $00 ; 0E77: ' ' 00 00 NEG <$00
// FCB $00 ; 0E78: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0E79: ' ' E0 D8 00 SUBB [$00,U]
// FCB $D8 ; 0E7A: ' ' D8 00 EORB <$00
// FCB $00 ; 0E7B: ' ' 00 00 NEG <$00
// FCB $00 ; 0E7C: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0E7D: ' ' E0 E0 SUBB ,S+
// FCB $E0 ; 0E7E: ' ' E0 00 SUBB 0,X
// FCB $00 ; 0E7F: ' ' 00 20 NEG <$20
// FCB $20 ; 0E80: ' ' 20 00 BRA $0E82
// FCB $00 ; 0E81: ' ' 00 00 NEG <$00
// FCB $00 ; 0E82: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0E83: ' ' E0 28 SUBB 8,Y
// FCB $28 ; 0E84: '(' 28 00 BVC $0E86
// FCB $00 ; 0E85: ' ' 00 00 NEG <$00
// FCB $00 ; 0E86: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0E87: ' ' E0 B8 00 SUBB [$00,Y]
// FCB $B8 ; 0E88: ' ' B8 00 00 EORA $0000
// FCB $00 ; 0E89: ' ' 00 00 NEG <$00
// FCB $00 ; 0E8A: ' ' 00 40 NEG <$40
// FCB $40 ; 0E8B: '@' 40 NEGA
// FCB $E0 ; 0E8C: ' ' E0 00 SUBB 0,X
// FCB $00 ; 0E8D: ' ' 00 00 NEG <$00
// FCB $00 ; 0E8E: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0E8F: ' ' E0 D8 00 SUBB [$00,U]
// FCB $D8 ; 0E90: ' ' D8 00 EORB <$00
// FCB $00 ; 0E91: ' ' 00 00 NEG <$00
// FCB $00 ; 0E92: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0E93: ' ' E0 48 SUBB 8,U
// FCB $48 ; 0E94: 'H' 48 ASLA
// FCB $00 ; 0E95: ' ' 00 00 NEG <$00
// FCB $00 ; 0E96: ' ' 00 40 NEG <$40
// FCB $40 ; 0E97: '@' 40 NEGA
// FCB $00 ; 0E98: ' ' 00 40 NEG <$40
// FCB $40 ; 0E99: '@' 40 NEGA
// FCB $B8 ; 0E9A: ' ' B8 00 00 EORA $0000
// FCB $00 ; 0E9B: ' ' 00 00 NEG <$00
// FCB $00 ; 0E9C: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0E9D: ' ' E0 28 SUBB 8,Y
// FCB $28 ; 0E9E: '(' 28 00 BVC $0EA0
// FCB $00 ; 0E9F: ' ' 00 00 NEG <$00
// FCB $00 ; 0EA0: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0EA1: ' ' E0 20 SUBB 0,Y
// FCB $20 ; 0EA2: ' ' 20 00 BRA $0EA4
// FCB $00 ; 0EA3: ' ' 00 04 NEG <$04
// FCB $04 ; 0EA4: ' ' 04 08 LSR <$08
// FCB $08 ; 0EA5: ' ' 08 60 ASL <$60
// FCB $60 ; 0EA6: '`' 60 10 NEG -16,X
// FCB $10 ; 0EA7: ' ' 10 F0 Invalid
// FCB $F0 ; 0EA8: ' ' F0 60 A0 SUBB $60A0
// FCB $60 ; 0EA9: '`' 60 A0 NEG ,Y+
// FCB $A0 ; 0EAA: ' ' A0 F0 SUBA ???
// FCB $F0 ; 0EAB: ' ' F0 10 A0 SUBB $10A0
// FCB $10 ; 0EAC: ' ' 10 A0 Invalid
// FCB $A0 ; 0EAD: ' ' A0 02 SUBA 2,X
// FCB $02 ; 0EAE: ' ' 02 Invalid
// FCB $05 ; 0EAF: ' ' 05 Invalid
// FCB $20 ; 0EB0: ' ' 20 20 BRA $0ED2
// FCB $20 ; 0EB1: ' ' 20 20 BRA $0ED3
// FCB $20 ; 0EB2: ' ' 20 C0 BRA $0E74
// FCB $C0 ; 0EB3: ' ' C0 04 SUBB #$04
// FCB $04 ; 0EB4: ' ' 04 03 LSR <$03
// FCB $03 ; 0EB5: ' ' 03 30 COM <$30
// FCB $30 ; 0EB6: '0' 30 40 LEAX 0,U
// FCB $40 ; 0EB7: '@' 40 NEGA
// FCB $30 ; 0EB8: '0' 30 B0 LEAX ???
// FCB $B0 ; 0EB9: ' ' B0 B0 B0 SUBA $B0B0
// FCB $B0 ; 0EBA: ' ' B0 B0 B0 SUBA $B0B0
// FCB $B0 ; 0EBB: ' ' B0 B0 40 SUBA $B040
// FCB $B0 ; 0EBC: ' ' B0 40 04 SUBA $4004
// FCB $40 ; 0EBD: '@' 40 NEGA
// FCB $04 ; 0EBE: ' ' 04 05 LSR <$05
// FCB $05 ; 0EBF: ' ' 05 Invalid
// FCB $40 ; 0EC0: '@' 40 NEGA
// FCB $10 ; 0EC1: ' ' 10 40 Invalid
// FCB $40 ; 0EC2: '@' 40 NEGA
// FCB $F0 ; 0EC3: ' ' F0 C0 F0 SUBB $C0F0
// FCB $C0 ; 0EC4: ' ' C0 F0 SUBB #$F0
// FCB $F0 ; 0EC5: ' ' F0 C0 10 SUBB $C010
// FCB $C0 ; 0EC6: ' ' C0 10 SUBB #$10
// FCB $10 ; 0EC7: ' ' 10 00 Invalid
// FCB $00 ; 0EC8: ' ' 00 0C NEG <$0C
// FCB $0C ; 0EC9: ' ' 0C 08 INC <$08
// FCB $08 ; 0ECA: ' ' 08 FF ASL <$FF
// FCB $FF ; 0ECB: ' ' FF 00 F0 STU $00F0
// FCB $00 ; 0ECC: ' ' 00 F0 NEG <$F0
// FCB $F0 ; 0ECD: ' ' F0 FF E8 SUBB $FFE8
// FCB $FF ; 0ECE: ' ' FF E8 00 STU $E800
// FCB $E8 ; 0ECF: ' ' E8 00 EORB 0,X
// FCB $00 ; 0ED0: ' ' 00 FF NEG <$FF
// FCB $FF ; 0ED1: ' ' FF 00 10 STU $0010
// FCB $00 ; 0ED2: ' ' 00 10 NEG <$10
// FCB $10 ; 0ED3: ' ' 10 FF 18 00 STS $1800
// FCB $FF ; 0ED4: ' ' FF 18 00 STU $1800
// FCB $18 ; 0ED5: ' ' 18 Invalid
// FCB $00 ; 0ED6: ' ' 00 00 NEG <$00
// FCB $00 ; 0ED7: ' ' 00 F4 NEG <$F4
// FCB $F4 ; 0ED8: ' ' F4 F8 01 ANDB $F801
// FCB $F8 ; 0ED9: ' ' F8 01 FF EORB $01FF
// FCB $01 ; 0EDA: ' ' 01 Invalid
// FCB $FF ; 0EDB: ' ' FF 04 00 STU $0400
// FCB $04 ; 0EDC: ' ' 04 00 LSR <$00
// FCB $00 ; 0EDD: ' ' 00 FF NEG <$FF
// FCB $FF ; 0EDE: ' ' FF 04 FC STU $04FC
// FCB $04 ; 0EDF: ' ' 04 FC LSR <$FC
// FCB $FC ; 0EE0: ' ' FC FF FC LDD $FFFC
// FCB $FF ; 0EE1: ' ' FF FC F0 STU $FCF0
// FCB $FC ; 0EE2: ' ' FC F0 FF LDD $F0FF
// FCB $F0 ; 0EE3: ' ' F0 FF F8 SUBB $FFF8
// FCB $FF ; 0EE4: ' ' FF F8 00 STU $F800
// FCB $F8 ; 0EE5: ' ' F8 00 FF EORB $00FF
// FCB $00 ; 0EE6: ' ' 00 FF NEG <$FF
// FCB $FF ; 0EE7: ' ' FF FC 10 STU $FC10
// FCB $FC ; 0EE8: ' ' FC 10 FF LDD $10FF
// FCB $10 ; 0EE9: ' ' 10 FF 04 04 STS $0404
// FCB $FF ; 0EEA: ' ' FF 04 04 STU $0404
// FCB $04 ; 0EEB: ' ' 04 04 LSR <$04
// FCB $04 ; 0EEC: ' ' 04 FF LSR <$FF
// FCB $FF ; 0EED: ' ' FF 04 00 STU $0400
// FCB $04 ; 0EEE: ' ' 04 00 LSR <$00
// FCB $00 ; 0EEF: ' ' 00 FF NEG <$FF
// FCB $FF ; 0EF0: ' ' FF 00 28 STU $0028
// FCB $00 ; 0EF1: ' ' 00 28 NEG <$28
// FCB $28 ; 0EF2: '(' 28 01 BVC $0EF5
// FCB $01 ; 0EF3: ' ' 01 Invalid
// FCB $00 ; 0EF4: ' ' 00 0A NEG <$0A
// FCB $0A ; 0EF5: ' ' 0A 05 DEC <$05
// FCB $05 ; 0EF6: ' ' 05 Invalid
// FCB $FF ; 0EF7: ' ' FF 04 F0 STU $04F0
// FCB $04 ; 0EF8: ' ' 04 F0 LSR <$F0
// FCB $F0 ; 0EF9: ' ' F0 FF EF SUBB $FFEF
// FCB $FF ; 0EFA: ' ' FF EF 06 STU $EF06
// FCB $EF ; 0EFB: ' ' EF 06 STU 6,X
// FCB $06 ; 0EFC: ' ' 06 FF ROR <$FF
// FCB $FF ; 0EFD: ' ' FF F7 FD STU $F7FD
// FCB $F7 ; 0EFE: ' ' F7 FD FF STB $FDFF
// FCB $FD ; 0EFF: ' ' FD FF FD STD $FFFD
// FCB $FF ; 0F00: ' ' FF FD 11 STU $FD11
// FCB $FD ; 0F01: ' ' FD 11 FF STD $11FF
// FCB $11 ; 0F02: ' ' 11 FF Invalid
// FCB $FF ; 0F03: ' ' FF 0F F7 STU $0FF7
// FCB $0F ; 0F04: ' ' 0F F7 CLR <$F7
// FCB $F7 ; 0F05: ' ' F7 01 FF STB $01FF
// FCB $01 ; 0F06: ' ' 01 Invalid
// FCB $FF ; 0F07: ' ' FF 06 FA STU $06FA
// FCB $06 ; 0F08: ' ' 06 FA ROR <$FA
// FCB $FA ; 0F09: ' ' FA FF FE ORB $FFFE
// FCB $FF ; 0F0A: ' ' FF FE FC STU $FEFC
// FCB $FE ; 0F0B: ' ' FE FC FF LDU $FCFF
// FCB $FC ; 0F0C: ' ' FC FF 02 LDD $FF02
// FCB $FF ; 0F0D: ' ' FF 02 F8 STU $02F8
// FCB $02 ; 0F0E: ' ' 02 Invalid
// FCB $F8 ; 0F0F: ' ' F8 FF FA EORB $FFFA
// FCB $FF ; 0F10: ' ' FF FA FE STU $FAFE
// FCB $FA ; 0F11: ' ' FA FE FF ORB $FEFF
// FCB $FE ; 0F12: ' ' FE FF FC LDU $FFFC
// FCB $FF ; 0F13: ' ' FF FC 06 STU $FC06
// FCB $FC ; 0F14: ' ' FC 06 FF LDD $06FF
// FCB $06 ; 0F15: ' ' 06 FF ROR <$FF
// FCB $FF ; 0F16: ' ' FF 08 10 STU $0810
// FCB $08 ; 0F17: ' ' 08 10 ASL <$10
// FCB $10 ; 0F18: ' ' 10 FF FE 14 STS $FE14
// FCB $FF ; 0F19: ' ' FF FE 14 STU $FE14
// FCB $FE ; 0F1A: ' ' FE 14 FF LDU $14FF
// FCB $14 ; 0F1B: ' ' 14 Invalid
// FCB $FF ; 0F1C: ' ' FF 02 14 STU $0214
// FCB $02 ; 0F1D: ' ' 02 Invalid
// FCB $14 ; 0F1E: ' ' 14 Invalid
// FCB $01 ; 0F1F: ' ' 01 Invalid
// FCB $0E ; 0F20: ' ' 0E 02 JMP <$02
// FCB $02 ; 0F21: ' ' 02 Invalid
// FCB $18 ; 0F22: ' ' 18 Invalid
// FCB $02 ; 0F23: ' ' 02 Invalid
// FCB $22 ; 0F24: '"' 22 01 BHI $0F27
// FCB $01 ; 0F25: ' ' 01 Invalid
// FCB $27 ; 0F26: ''' 27 03 BEQ $0F2B
// FCB $03 ; 0F27: ' ' 03 36 COM <$36
// FCB $36 ; 0F28: '6' 36 01 PSHU CC
// FCB $01 ; 0F29: ' ' 01 Invalid
// FCB $3B ; 0F2A: ';' 3B RTI
// FCB $02 ; 0F2B: ' ' 02 Invalid
// FCB $45 ; 0F2C: 'E' 45 Invalid
// FCB $01 ; 0F2D: ' ' 01 Invalid
// FCB $60 ; 0F2E: '`' 60 1C NEG -4,X
// FCB $1C ; 0F2F: ' ' 1C 0C ANDCC #$0C
// FCB $0C ; 0F30: ' ' 0C 04 INC <$04
// FCB $04 ; 0F31: ' ' 04 10 LSR <$10
// FCB $10 ; 0F32: ' ' 10 40 Invalid
// FCB $40 ; 0F33: '@' 40 NEGA
// FCB $10 ; 0F34: ' ' 10 10 Invalid
// FCB $10 ; 0F35: ' ' 10 04 Invalid
// FCB $04 ; 0F36: ' ' 04 10 LSR <$10
// FCB $10 ; 0F37: ' ' 10 4C Invalid
// FCB $4C ; 0F38: 'L' 4C INCA
// FCB $18 ; 0F39: ' ' 18 Invalid
// FCB $20 ; 0F3A: ' ' 20 04 BRA $0F40
// FCB $04 ; 0F3B: ' ' 04 20 LSR <$20
// FCB $20 ; 0F3C: ' ' 20 00 BRA $0F3E
// FCB $00 ; 0F3D: ' ' 00 20 NEG <$20
// FCB $20 ; 0F3E: ' ' 20 20 BRA $0F60
// FCB $20 ; 0F3F: ' ' 20 04 BRA $0F45
// FCB $04 ; 0F40: ' ' 04 20 LSR <$20
// FCB $20 ; 0F41: ' ' 20 40 BRA $0F83
// FCB $40 ; 0F42: '@' 40 NEGA
// FCB $24 ; 0F43: '$' 24 2C BCC $0F71
// FCB $2C ; 0F44: ',' 2C 04 BGE $0F4A
// FCB $04 ; 0F45: ' ' 04 30 LSR <$30
// FCB $30 ; 0F46: '0' 30 60 LEAX 0,S
// FCB $60 ; 0F47: '`' 60 1C NEG -4,X
// FCB $1C ; 0F48: ' ' 1C 40 ANDCC #$40
// FCB $40 ; 0F49: '@' 40 NEGA
// FCB $04 ; 0F4A: ' ' 04 40 LSR <$40
// FCB $40 ; 0F4B: '@' 40 NEGA
// FCB $30 ; 0F4C: '0' 30 20 LEAX 0,Y
// FCB $20 ; 0F4D: ' ' 20 40 BRA $0F8F
// FCB $40 ; 0F4E: '@' 40 NEGA
// FCB $04 ; 0F4F: ' ' 04 40 LSR <$40
// FCB $40 ; 0F50: '@' 40 NEGA
// FCB $00 ; 0F51: ' ' 00 20 NEG <$20
// FCB $20 ; 0F52: ' ' 20 3C BRA $0F90
// FCB $3C ; 0F53: '<' 3C 04 CWAI #$04
// FCB $04 ; 0F54: ' ' 04 40 LSR <$40
// FCB $40 ; 0F55: '@' 40 NEGA
// FCB $30 ; 0F56: '0' 30 20 LEAX 0,Y
// FCB $20 ; 0F57: ' ' 20 4C BRA $0FA5
// FCB $4C ; 0F58: 'L' 4C INCA
// FCB $04 ; 0F59: ' ' 04 50 LSR <$50
// FCB $50 ; 0F5A: 'P' 50 NEGB
// FCB $40 ; 0F5B: '@' 40 NEGA
// FCB $24 ; 0F5C: '$' 24 60 BCC $0FBE
// FCB $60 ; 0F5D: '`' 60 04 NEG 4,X
// FCB $04 ; 0F5E: ' ' 04 60 LSR <$60
// FCB $60 ; 0F5F: '`' 60 00 NEG 0,X
// FCB $00 ; 0F60: ' ' 00 10 NEG <$10
// FCB $10 ; 0F61: ' ' 10 60 Invalid
// FCB $60 ; 0F62: '`' 60 04 NEG 4,X
// FCB $04 ; 0F63: ' ' 04 60 LSR <$60
// FCB $60 ; 0F64: '`' 60 0C NEG 12,X
// FCB $0C ; 0F65: ' ' 0C 34 INC <$34
// FCB $34 ; 0F66: '4' 34 78 PSHS U,Y,X,DP
// FCB $78 ; 0F67: 'x' 78 04 78 ASL $0478
// FCB $04 ; 0F68: ' ' 04 78 LSR <$78
// FCB $78 ; 0F69: 'x' 78 0E 01 ASL $0E01
// FCB $0E ; 0F6A: ' ' 0E 01 JMP <$01
// FCB $01 ; 0F6B: ' ' 01 Invalid
// FCB $13 ; 0F6C: ' ' 13 SYNC
// FCB $01 ; 0F6D: ' ' 01 Invalid
// FCB $18 ; 0F6E: ' ' 18 Invalid
// FCB $01 ; 0F6F: ' ' 01 Invalid
// FCB $1D ; 0F70: ' ' 1D SEX
// FCB $02 ; 0F71: ' ' 02 Invalid
// FCB $27 ; 0F72: ''' 27 02 BEQ $0F76
// FCB $02 ; 0F73: ' ' 02 Invalid
// FCB $31 ; 0F74: '1' 31 03 LEAY 3,X
// FCB $03 ; 0F75: ' ' 03 40 COM <$40
// FCB $40 ; 0F76: '@' 40 NEGA
// FCB $01 ; 0F77: ' ' 01 Invalid
// FCB $0C ; 0F78: ' ' 0C 04 INC <$04
// FCB $04 ; 0F79: ' ' 04 60 LSR <$60
// FCB $60 ; 0F7A: '`' 60 1C NEG -4,X
// FCB $1C ; 0F7B: ' ' 1C 10 ANDCC #$10
// FCB $10 ; 0F7C: ' ' 10 1C Invalid
// FCB $1C ; 0F7D: ' ' 1C 04 ANDCC #$04
// FCB $04 ; 0F7E: ' ' 04 20 LSR <$20
// FCB $20 ; 0F7F: ' ' 20 20 BRA $0FA1
// FCB $20 ; 0F80: ' ' 20 20 BRA $0FA2
// FCB $20 ; 0F81: ' ' 20 30 BRA $0FB3
// FCB $30 ; 0F82: '0' 30 04 LEAX 4,X
// FCB $04 ; 0F83: ' ' 04 40 LSR <$40
// FCB $40 ; 0F84: '@' 40 NEGA
// FCB $10 ; 0F85: ' ' 10 30 Invalid
// FCB $30 ; 0F86: '0' 30 40 LEAX 0,U
// FCB $40 ; 0F87: '@' 40 NEGA
// FCB $04 ; 0F88: ' ' 04 10 LSR <$10
// FCB $10 ; 0F89: ' ' 10 28 40 40 LBVC $4FCD
// FCB $28 ; 0F8A: '(' 28 40 BVC $0FCC
// FCB $40 ; 0F8B: '@' 40 NEGA
// FCB $40 ; 0F8C: '@' 40 NEGA
// FCB $03 ; 0F8D: ' ' 03 60 COM <$60
// FCB $60 ; 0F8E: '`' 60 1C NEG -4,X
// FCB $1C ; 0F8F: ' ' 1C 40 ANDCC #$40
// FCB $40 ; 0F90: '@' 40 NEGA
// FCB $4C ; 0F91: 'L' 4C INCA
// FCB $04 ; 0F92: ' ' 04 10 LSR <$10
// FCB $10 ; 0F93: ' ' 10 14 Invalid
// FCB $14 ; 0F94: ' ' 14 Invalid
// FCB $50 ; 0F95: 'P' 50 NEGB
// FCB $4C ; 0F96: 'L' 4C INCA
// FCB $04 ; 0F97: ' ' 04 40 LSR <$40
// FCB $40 ; 0F98: '@' 40 NEGA
// FCB $10 ; 0F99: ' ' 10 50 Invalid
// FCB $50 ; 0F9A: 'P' 50 NEGB
// FCB $60 ; 0F9B: '`' 60 04 NEG 4,X
// FCB $04 ; 0F9C: ' ' 04 00 LSR <$00
// FCB $00 ; 0F9D: ' ' 00 10 NEG <$10
// FCB $10 ; 0F9E: ' ' 10 60 Invalid
// FCB $60 ; 0F9F: '`' 60 60 NEG 0,S
// FCB $60 ; 0FA0: '`' 60 04 NEG 4,X
// FCB $04 ; 0FA1: ' ' 04 20 LSR <$20
// FCB $20 ; 0FA2: ' ' 20 10 BRA $0FB4
// FCB $10 ; 0FA3: ' ' 10 64 Invalid
// FCB $64 ; 0FA4: 'd' 64 60 LSR 0,S
// FCB $60 ; 0FA5: '`' 60 04 NEG 4,X
// FCB $04 ; 0FA6: ' ' 04 40 LSR <$40
// FCB $40 ; 0FA7: '@' 40 NEGA
// FCB $24 ; 0FA8: '$' 24 60 BCC $100A
// FCB $60 ; 0FA9: '`' 60 78 NEG -8,S
// FCB $78 ; 0FAA: 'x' 78 04 0C ASL $040C
// FCB $04 ; 0FAB: ' ' 04 0C LSR <$0C
// FCB $0C ; 0FAC: ' ' 0C 38 INC <$38
// FCB $38 ; 0FAD: '8' 38 Invalid
// FCB $78 ; 0FAE: 'x' 78 00 00 ASL $0000
// FCB $00 ; 0FAF: ' ' 00 00 NEG <$00
// FCB $00 ; 0FB0: ' ' 00 1C NEG <$1C
// FCB $1C ; 0FB1: ' ' 1C FF ANDCC #$FF
// FCB $FF ; 0FB2: ' ' FF 0C F4 STU $0CF4
// FCB $0C ; 0FB3: ' ' 0C F4 INC <$F4
// FCB $F4 ; 0FB4: ' ' F4 FF 00 ANDB $FF00
// FCB $FF ; 0FB5: ' ' FF 00 E0 STU $00E0
// FCB $00 ; 0FB6: ' ' 00 E0 NEG <$E0
// FCB $E0 ; 0FB7: ' ' E0 FF SUBB ???
// FCB $FF ; 0FB8: ' ' FF F8 F4 STU $F8F4
// FCB $F8 ; 0FB9: ' ' F8 F4 FF EORB $F4FF
// FCB $F4 ; 0FBA: ' ' F4 FF FC ANDB $FFFC
// FCB $FF ; 0FBB: ' ' FF FC CC STU $FCCC
// FCB $FC ; 0FBC: ' ' FC CC FF LDD $CCFF
// FCB $CC ; 0FBD: ' ' CC FF FC LDD #$FFFC
// FCB $FF ; 0FBE: ' ' FF FC 34 STU $FC34
// FCB $FC ; 0FBF: ' ' FC 34 FF LDD $34FF
// FCB $34 ; 0FC0: '4' 34 FF PSHS PC,U,Y,X,DP,B,A,CC
// FCB $FF ; 0FC1: ' ' FF F8 0C STU $F80C
// FCB $F8 ; 0FC2: ' ' F8 0C FF EORB $0CFF
// FCB $0C ; 0FC3: ' ' 0C FF INC <$FF
// FCB $FF ; 0FC4: ' ' FF 00 20 STU $0020
// FCB $00 ; 0FC5: ' ' 00 20 NEG <$20
// FCB $20 ; 0FC6: ' ' 20 FF BRA $0FC7
// FCB $FF ; 0FC7: ' ' FF 0C 0C STU $0C0C
// FCB $0C ; 0FC8: ' ' 0C 0C INC <$0C
// FCB $0C ; 0FC9: ' ' 0C 00 INC <$00
// FCB $00 ; 0FCA: ' ' 00 00 NEG <$00
// FCB $00 ; 0FCB: ' ' 00 E4 NEG <$E4
// FCB $E4 ; 0FCC: ' ' E4 01 ANDB 1,X
// FCB $01 ; 0FCD: ' ' 01 Invalid
// FCB $00 ; 0FCE: ' ' 00 0C NEG <$0C
// FCB $0C ; 0FCF: ' ' 0C 10 INC <$10
// FCB $10 ; 0FD0: ' ' 10 FF F4 0C STS $F40C
// FCB $FF ; 0FD1: ' ' FF F4 0C STU $F40C
// FCB $F4 ; 0FD2: ' ' F4 0C FF ANDB $0CFF
// FCB $0C ; 0FD3: ' ' 0C FF INC <$FF
// FCB $FF ; 0FD4: ' ' FF F4 F4 STU $F4F4
// FCB $F4 ; 0FD5: ' ' F4 F4 FF ANDB $F4FF
// FCB $F4 ; 0FD6: ' ' F4 FF 00 ANDB $FF00
// FCB $FF ; 0FD7: ' ' FF 00 D0 STU $00D0
// FCB $00 ; 0FD8: ' ' 00 D0 NEG <$D0
// FCB $D0 ; 0FD9: ' ' D0 20 SUBB <$20
// FCB $20 ; 0FDA: ' ' 20 00 BRA $0FDC
// FCB $00 ; 0FDB: ' ' 00 E8 NEG <$E8
// FCB $E8 ; 0FDC: ' ' E8 E4 EORB ,S
// FCB $E4 ; 0FDD: ' ' E4 FF ANDB ???
// FCB $FF ; 0FDE: ' ' FF 08 0C STU $080C
// FCB $08 ; 0FDF: ' ' 08 0C ASL <$0C
// FCB $0C ; 0FE0: ' ' 0C FF INC <$FF
// FCB $FF ; 0FE1: ' ' FF 04 CC STU $04CC
// FCB $04 ; 0FE2: ' ' 04 CC LSR <$CC
// FCB $CC ; 0FE3: ' ' CC FF 04 LDD #$FF04
// FCB $FF ; 0FE4: ' ' FF 04 34 STU $0434
// FCB $04 ; 0FE5: ' ' 04 34 LSR <$34
// FCB $34 ; 0FE6: '4' 34 FF PSHS PC,U,Y,X,DP,B,A,CC
// FCB $FF ; 0FE7: ' ' FF 08 0C STU $080C
// FCB $08 ; 0FE8: ' ' 08 0C ASL <$0C
// FCB $0C ; 0FE9: ' ' 0C FF INC <$FF
// FCB $FF ; 0FEA: ' ' FF 00 30 STU $0030
// FCB $00 ; 0FEB: ' ' 00 30 NEG <$30
// FCB $30 ; 0FEC: '0' 30 01 LEAX 1,X
// FCB $01 ; 0FED: ' ' 01 Invalid
// FCB $30 ; 0FEE: '0' 30 00 LEAX 0,X
// FCB $00 ; 0FEF: ' ' 00 00 NEG <$00
// FCB $00 ; 0FF0: ' ' 00 F8 NEG <$F8
// FCB $F8 ; 0FF1: ' ' F8 D0 08 EORB $D008
// FCB $D0 ; 0FF2: ' ' D0 08 SUBB <$08
// FCB $08 ; 0FF3: ' ' 08 00 ASL <$00
// FCB $00 ; 0FF4: ' ' 00 F0 NEG <$F0
// FCB $F0 ; 0FF5: ' ' F0 45 4E SUBB $454E
// FCB $45 ; 0FF6: 'E' 45 Invalid
// FCB $4E ; 0FF7: 'N' 4E Invalid
// FCB $44 ; 0FF8: 'D' 44 LSRA
// FCB $80 ; 0FF9: ' ' 80 03 SUBA #$03
// FCB $03 ; 0FFA: ' ' 03 97 COM <$97
// FCB $97 ; 0FFB: ' ' 97 68 STA <$68
// FCB $68 ; 0FFC: 'h' 68 0F ASL 15,X
// FCB $0F ; 0FFD: ' ' 0F 67 CLR <$67
// FCB $67 ; 0FFE: 'g' 67 39 ASR -7,Y
// FCB $39 ; 0FFF: '9' 39 RTS