// ORG $0000
// FCC "g GCE 1982"
// FDB $80
// FDB music3
// FCB $F8, $50 ; h,w of raster image
// FCB $20, $C0 ; y,x of raster image
// FCC "ARMOR ATTACK"
// FDB $80
#include <stdint.h>
int main(int argc, char **argv) {
typedef uint32_t UINT32;
typedef int32_t SINT32;
typedef uint16_t UINT16;
typedef int16_t SINT16;
typedef uint8_t UINT8;
typedef int8_t SINT8;
UINT8 memory[0x10000], *memory_DP = &memory[0xD000];
// Modify this header to suit your target...
SINT32 res, A, B, D, C;
UINT16 PC, X, Y, S, U, Z, DP = 0xD0, arg, ea, msn, lsn, val;
UINT8 N, H, V, CC;
#define JUMP do {} while (0)
L001F:// LDX #$C880 ; 001F: 8E C8 80
X = 0xc880;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDD #$0280 ; 0022: CC 02 80
A = (UINT8)((0x0280) >> 8);
B = (UINT8)((0x0280) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// JSR Clear_x_d ; 0025: BD F5 48
memory[--S] = 0x0028 & 0xff; memory[--S] = 0x0028 >> 8;
PC = 0xf548;
JUMP;
L0028:// LDD #$0203 ; 0028: CC 02 03
A = (UINT8)((0x0203) >> 8);
B = (UINT8)((0x0203) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// JSR Select_Game ; 002B: BD F7 A9
memory[--S] = 0x002e & 0xff; memory[--S] = 0x002e >> 8;
PC = 0xf7a9;
JUMP;
DP = 0xc8 << 8; memory_DP = &memory[DP]; // Unfortunately this should be inserted after the label below.
L002E:// JSR DP_to_C8 ; 002E: BD F1 AF
memory[--S] = 0x0031 & 0xff; memory[--S] = 0x0031 >> 8;
PC = 0xf1af;
JUMP;
DP = 0xc8 << 8; memory_DP = &memory[DP]; // Unfortunately this should be inserted after the label below.
L0031:// LDA #$FF ; 0031: 86 FF
A = (SINT8)0xff;
// N = A;
// Z = A;
// V = 0;
// STA <$29 ; 0033: 97 29
// Z = A;
// N = A;
// V = 0;
memory_DP[0x29] = A;
// LDB #$BB ; 0035: C6 BB
B = (SINT8)0xbb;
// N = B;
// Z = B;
// V = 0;
// LDA <$7A ; 0037: 96 7A
A = memory_DP[0x7a];
// N = A;
// Z = A;
// V = 0;
// CMPA #$01 ; 0039: 81 01
res = A - (SINT8)0x01;
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ (SINT8)0x01) & (A ^ res);
// BEQ $45 ; 003B: 27 08
if (!Z) {
PC = 0x0045;
JUMP;
}
// LDB #$88 ; 003D: C6 88
B = (SINT8)0x88;
// N = B;
// Z = B;
// V = 0;
// CMPA #$02 ; 003F: 81 02
res = A - (SINT8)0x02;
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ (SINT8)0x02) & (A ^ res);
// BEQ $45 ; 0041: 27 02
if (!Z) {
PC = 0x0045;
JUMP;
}
// INC <$29 ; 0043: 0C 29
res = (UINT8)((memory_DP[0x29]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0x29]);
memory_DP[0x29] = res;
L0045:// STB <$F0 ; 0045: D7 F0
// Z = B;
// N = B;
// V = 0;
memory_DP[0xf0] = B;
// CLR <$20 ; 0047: 0F 20
memory_DP[0x20] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// CLR <$22 ; 0049: 0F 22
memory_DP[0x22] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LDD #$7F7F ; 004B: CC 7F 7F
A = (UINT8)((0x7f7f) >> 8);
B = (UINT8)((0x7f7f) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD <$C9 ; 004E: DD C9
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xc9] = A;
memory_DP[0xc9 + 1] = B;
L0050:// LDA <$79 ; 0050: 96 79
A = memory_DP[0x79];
// N = A;
// Z = A;
// V = 0;
// STA <$C8 ; 0052: 97 C8
// Z = A;
// N = A;
// V = 0;
memory_DP[0xc8] = A;
// CLR <$87 ; 0054: 0F 87
memory_DP[0x87] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LDA #$10 ; 0056: 86 10
A = (SINT8)0x10;
// N = A;
// Z = A;
// V = 0;
// STA <$1A ; 0058: 97 1A
// Z = A;
// N = A;
// V = 0;
memory_DP[0x1a] = A;
// LDD #$FA38 ; 005A: CC FA 38
A = (UINT8)((0xfa38) >> 8);
B = (UINT8)((0xfa38) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD <$2A ; 005D: DD 2A
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x2a] = A;
memory_DP[0x2a + 1] = B;
// LDX #$C8DE ; 005F: 8E C8 DE
X = 0xc8de;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDU #$0D3F ; 0062: CE 0D 3F
U = 0x0d3f;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDA #$07 ; 0065: 86 07
A = (SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
// JSR $0CF6 ; 0067: BD 0C F6
memory[--S] = 0x006a & 0xff; memory[--S] = 0x006a >> 8;
PC = 0x0cf6;
JUMP;
L006A:// LDX #$CA88 ; 006A: 8E CA 88
X = 0xca88;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDD #$7888 ; 006D: CC 78 88
A = (UINT8)((0x7888) >> 8);
B = (UINT8)((0x7888) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD ,X++ ; 0070: ED 81
ea = X; X = X + 2;
// Z = A | B;
// N = A;
// V = 0;
memory[ea] = A;
memory[ea + 1] = B;
// JSR Clear_Score ; 0072: BD F8 4F
memory[--S] = 0x0075 & 0xff; memory[--S] = 0x0075 >> 8;
PC = 0xf84f;
JUMP;
L0075:// LEAX $07,X ; 0075: 30 07
X = (X + 0x0007);
// Z = X;
// LDD #$7838 ; 0077: CC 78 38
A = (UINT8)((0x7838) >> 8);
B = (UINT8)((0x7838) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD ,X++ ; 007A: ED 81
ea = X; X = X + 2;
// Z = A | B;
// N = A;
// V = 0;
memory[ea] = A;
memory[ea + 1] = B;
// JSR Clear_Score ; 007C: BD F8 4F
memory[--S] = 0x007f & 0xff; memory[--S] = 0x007f >> 8;
PC = 0xf84f;
JUMP;
L007F:// JSR Init_Music_Buf ; 007F: BD F5 33
memory[--S] = 0x0082 & 0xff; memory[--S] = 0x0082 >> 8;
PC = 0xf533;
JUMP;
L0082:// LDA #$FF ; 0082: 86 FF
A = (SINT8)0xff;
// N = A;
// Z = A;
// V = 0;
// STA <$71 ; 0084: 97 71
// Z = A;
// N = A;
// V = 0;
memory_DP[0x71] = A;
// STA <$8A ; 0086: 97 8A
// Z = A;
// N = A;
// V = 0;
memory_DP[0x8a] = A;
// STA <$E9 ; 0088: 97 E9
// Z = A;
// N = A;
// V = 0;
memory_DP[0xe9] = A;
// STA <$ED ; 008A: 97 ED
// Z = A;
// N = A;
// V = 0;
memory_DP[0xed] = A;
// STA <$91 ; 008C: 97 91
// Z = A;
// N = A;
// V = 0;
memory_DP[0x91] = A;
// LDX #$0FEE ; 008E: 8E 0F EE
X = 0x0fee;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDU #$CA9A ; 0091: CE CA 9A
U = 0xca9a;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDB #$02 ; 0094: C6 02
B = (SINT8)0x02;
// N = B;
// Z = B;
// V = 0;
// JSR $0CAC ; 0096: BD 0C AC
memory[--S] = 0x0099 & 0xff; memory[--S] = 0x0099 >> 8;
PC = 0x0cac;
JUMP;
L0099:// LDA <$E1 ; 0099: 96 E1
A = memory_DP[0xe1];
// N = A;
// Z = A;
// V = 0;
// STA <$2E ; 009B: 97 2E
// Z = A;
// N = A;
// V = 0;
memory_DP[0x2e] = A;
// LDA <$E0 ; 009D: 96 E0
A = memory_DP[0xe0];
// N = A;
// Z = A;
// V = 0;
// STA <$2F ; 009F: 97 2F
// Z = A;
// N = A;
// V = 0;
memory_DP[0x2f] = A;
// LDA <$DE ; 00A1: 96 DE
A = memory_DP[0xde];
// N = A;
// Z = A;
// V = 0;
// STA <$30 ; 00A3: 97 30
// Z = A;
// N = A;
// V = 0;
memory_DP[0x30] = A;
// JSR $084B ; 00A5: BD 08 4B
memory[--S] = 0x00a8 & 0xff; memory[--S] = 0x00a8 >> 8;
PC = 0x084b;
JUMP;
L00A8:// JSR $0CD4 ; 00A8: BD 0C D4
memory[--S] = 0x00ab & 0xff; memory[--S] = 0x00ab >> 8;
PC = 0x0cd4;
JUMP;
L00AB:// CLR <$94 ; 00AB: 0F 94
memory_DP[0x94] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LDX #$C9C0 ; 00AD: 8E C9 C0
X = 0xc9c0;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDD #$0807 ; 00B0: CC 08 07
A = (UINT8)((0x0807) >> 8);
B = (UINT8)((0x0807) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// JSR $0CDA ; 00B3: BD 0C DA
memory[--S] = 0x00b6 & 0xff; memory[--S] = 0x00b6 >> 8;
PC = 0x0cda;
JUMP;
L00B6:// CLR <$67 ; 00B6: 0F 67
memory_DP[0x67] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LDA <$E2 ; 00B8: 96 E2
A = memory_DP[0xe2];
// N = A;
Z = A;
// V = 0;
// BNE $DD ; 00BA: 26 21
if (Z) {
PC = 0x00dd;
JUMP;
}
// LDX #$CA8A ; 00BC: 8E CA 8A
X = 0xca8a;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LEAU $09,X ; 00BF: 33 09
U = (X + 0x0009);
// JSR Compare_Score ; 00C1: BD F8 C7
memory[--S] = 0x00c4 & 0xff; memory[--S] = 0x00c4 >> 8;
PC = 0xf8c7;
JUMP;
L00C4:// CMPA #$02 ; 00C4: 81 02
res = A - (SINT8)0x02;
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ (SINT8)0x02) & (A ^ res);
// BNE $CA ; 00C6: 26 02
if (Z) {
PC = 0x00ca;
JUMP;
}
// LEAX ,U ; 00C8: 30 C4
X = U;
// Z = X;
L00CA:// LDU #Vec_High_Score ; 00CA: CE CB EB
U = 0xcbeb;
// Z = U;
// N = (U) >> 8;
// V = 0;
// JSR New_High_Score ; 00CD: BD F8 D8
memory[--S] = 0x00d0 & 0xff; memory[--S] = 0x00d0 >> 8;
PC = 0xf8d8;
JUMP;
L00D0:// CLR <$ED ; 00D0: 0F ED
memory_DP[0xed] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// LDD #$0BFF ; 00D2: CC 0B FF
A = (UINT8)((0x0bff) >> 8);
B = (UINT8)((0x0bff) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD <$32 ; 00D5: DD 32
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x32] = A;
memory_DP[0x32 + 1] = B;
// LDA <$C8 ; 00D7: 96 C8
A = memory_DP[0xc8];
// N = A;
// Z = A;
// V = 0;
// STA <$E9 ; 00D9: 97 E9
Z = A;
N = A;
V = 0;
memory_DP[0xe9] = A;
// BRA $011B ; 00DB: 20 3E
PC = 0x011b;
JUMP;
L00DD:// LDA <$C7 ; 00DD: 96 C7
A = memory_DP[0xc7];
// N = A;
Z = A;
// V = 0;
// BNE $EF ; 00DF: 26 0E
if (Z) {
PC = 0x00ef;
JUMP;
}
// LDA <$2E ; 00E1: 96 2E
A = memory_DP[0x2e];
// N = A;
Z = A;
// V = 0;
// BEQ $99 ; 00E3: 27 B4
if (!Z) {
PC = 0x0099;
JUMP;
}
// LDA <$C8 ; 00E5: 96 C8
A = memory_DP[0xc8];
// N = A;
// Z = A;
// V = 0;
// STA <$E9 ; 00E7: 97 E9
// Z = A;
// N = A;
// V = 0;
memory_DP[0xe9] = A;
// DEC <$2E ; 00E9: 0A 2E
res = (UINT8)(memory_DP[0x2e] - 1);
// N = res;
Z = res;
// V = memory_DP[0x2e] & ~res;
memory_DP[0x2e] = res;
// BNE $011B ; 00EB: 26 2E
if (Z) {
PC = 0x011b;
JUMP;
}
// COM <$E9 ; 00ED: 03 E9
memory_DP[0xe9] = memory_DP[0xe9] ^ 0xff;
// Z = memory_DP[0xe9];
// N = memory_DP[0xe9];
// V = 0;
// C = 1;
L00EF:// LDB <$C7 ; 00EF: D6 C7
B = memory_DP[0xc7];
// N = B;
Z = B;
// V = 0;
// BEQ $A8 ; 00F1: 27 B5
if (!Z) {
PC = 0x00a8;
JUMP;
}
// LDA <$8A ; 00F3: 96 8A
A = memory_DP[0x8a];
N = A;
// Z = A;
// V = 0;
// BPL $010F ; 00F5: 2A 18
if ((SINT8)N >= 0) {
PC = 0x010f;
JUMP;
}
// NEGA ; 00F7: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
// STA <$8A ; 00F8: 97 8A
// Z = A;
// N = A;
// V = 0;
memory_DP[0x8a] = A;
// ANDA #$03 ; 00FA: 84 03
A = A & (SINT8)0x03;
// Z = A;
// N = A;
// V = 0;
// CMPA #$01 ; 00FC: 81 01
res = A - (SINT8)0x01;
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ (SINT8)0x01) & (A ^ res);
// BNE $010F ; 00FE: 26 0F
if (Z) {
PC = 0x010f;
JUMP;
}
// LDB <$87 ; 0100: D6 87
B = memory_DP[0x87];
// N = B;
// Z = B;
// V = 0;
// LDU #$0CFF ; 0102: CE 0C FF
U = 0x0cff;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LEAU B,U ; 0105: 33 C5
U = (U + (SINT8)B);
// LDX #$C880 ; 0107: 8E C8 80
X = 0xc880;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDA #$08 ; 010A: 86 08
A = (SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
// JSR $0CF6 ; 010C: BD 0C F6
memory[--S] = 0x010f & 0xff; memory[--S] = 0x010f >> 8;
PC = 0x0cf6;
JUMP;
L010F:// JSR $0A59 ; 010F: BD 0A 59
memory[--S] = 0x0112 & 0xff; memory[--S] = 0x0112 >> 8;
PC = 0x0a59;
JUMP;
L0112:// JSR $08BA ; 0112: BD 08 BA
memory[--S] = 0x0115 & 0xff; memory[--S] = 0x0115 >> 8;
PC = 0x08ba;
JUMP;
L0115:// JSR $039D ; 0115: BD 03 9D
memory[--S] = 0x0118 & 0xff; memory[--S] = 0x0118 >> 8;
PC = 0x039d;
JUMP;
L0118:// JSR $06C6 ; 0118: BD 06 C6
memory[--S] = 0x011b & 0xff; memory[--S] = 0x011b >> 8;
PC = 0x06c6;
JUMP;
L011B:// INC <$EE ; 011B: 0C EE
res = (UINT8)((memory_DP[0xee]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0xee]);
memory_DP[0xee] = res;
// JSR $0BD3 ; 011D: BD 0B D3
memory[--S] = 0x0120 & 0xff; memory[--S] = 0x0120 >> 8;
PC = 0x0bd3;
JUMP;
L0120:// JSR $0185 ; 0120: BD 01 85
memory[--S] = 0x0123 & 0xff; memory[--S] = 0x0123 >> 8;
PC = 0x0185;
JUMP;
L0123:// LDA <$ED ; 0123: 96 ED
A = memory_DP[0xed];
N = A;
// Z = A;
// V = 0;
// BMI $EF ; 0125: 2B C8
if ((SINT8)N < 0) {
PC = 0x00ef;
JUMP;
}
// LDB <$0F ; 0127: D6 0F
B = memory_DP[0x0f];
N = B;
Z = B;
V = 0;
// LBNE $50 ; 0129: 10 26 FF 23
if (Z) {
PC = 0x0050;
JUMP;
}
// DEC <$33 ; 012D: 0A 33
res = (UINT8)(memory_DP[0x33] - 1);
// N = res;
Z = res;
// V = memory_DP[0x33] & ~res;
memory_DP[0x33] = res;
// BNE $011B ; 012F: 26 EA
if (Z) {
PC = 0x011b;
JUMP;
}
// DEC <$32 ; 0131: 0A 32
res = (UINT8)(memory_DP[0x32] - 1);
// N = res;
Z = res;
// V = memory_DP[0x32] & ~res;
memory_DP[0x32] = res;
// BNE $011B ; 0133: 26 E6
if (Z) {
PC = 0x011b;
JUMP;
}
// LDD #$06FF ; 0135: CC 06 FF
A = (UINT8)((0x06ff) >> 8);
B = (UINT8)((0x06ff) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD <$32 ; 0138: DD 32
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x32] = A;
memory_DP[0x32 + 1] = B;
L013A:// JSR Wait_Recal ; 013A: BD F1 92
memory[--S] = 0x013d & 0xff; memory[--S] = 0x013d >> 8;
PC = 0xf192;
JUMP;
DP = 0xd0 << 8; memory_DP = &memory[DP]; // Unfortunately this should be inserted after the label below.
L013D:// JSR Read_Btns ; 013D: BD F1 BA
memory[--S] = 0x0140 & 0xff; memory[--S] = 0x0140 >> 8;
PC = 0xf1ba;
JUMP;
L0140:// JSR DP_to_C8 ; 0140: BD F1 AF
memory[--S] = 0x0143 & 0xff; memory[--S] = 0x0143 >> 8;
PC = 0xf1af;
JUMP;
DP = 0xc8 << 8; memory_DP = &memory[DP]; // Unfortunately this should be inserted after the label below.
L0143:// LDX <$32 ; 0143: 9E 32
X = ((memory_DP[0x32]<<8)|memory_DP[0x32 + 1]);
// Z = X;
// N = (X) >> 8;
// V = 0;
// LEAX $FFFF,X ; 0145: 30 1F
X = (X + 0xffff);
// Z = X;
// STX <$32 ; 0147: 9F 32
Z = X;
// N = (X) >> 8;
// V = 0;
memory_DP[0x32] = (UINT8)((X) >> 8);
memory_DP[(UINT16)(0x32 + 1)] = (UINT8)((X) & 0xff);
// BEQ $0150 ; 0149: 27 05
if (!Z) {
PC = 0x0150;
JUMP;
}
// LDA Vec_Btn_State ; 014B: B6 C8 0F
A = memory[0xc80f];
N = A;
Z = A;
V = 0;
// BEQ $013A ; 014E: 27 EA
if (!Z) {
PC = 0x013a;
JUMP;
}
L0150:// JMP Cold_Start ; 0150: 7E F0 00
PC = 0xf000;
JUMP;
L0153:// STA <$04 ; 0153: 97 04
// Z = A;
// N = A;
// V = 0;
memory_DP[0x04] = A;
// LDD ,U++ ; 0155: EC C1
ea = U; U = U + 2;
A = memory[ea];
B = memory[(UINT16)((ea)+1)];
// Z = A|B;
// N = A;
// V = 0;
// JSR Moveto_d ; 0157: BD F3 12
memory[--S] = 0x015a & 0xff; memory[--S] = 0x015a >> 8;
PC = 0xf312;
JUMP;
L015A:// LDA #$3F ; 015A: 86 3F
A = (SINT8)0x3f;
// N = A;
// Z = A;
// V = 0;
// STA <$04 ; 015C: 97 04
// Z = A;
// N = A;
// V = 0;
memory_DP[0x04] = A;
// LDA $03,S ; 015E: A6 63
A = memory[(UINT16)(S + 0x0003)];
// N = A;
// Z = A;
// V = 0;
// STA Vec_Misc_Count ; 0160: B7 C8 23
// Z = A;
// N = A;
// V = 0;
memory[0xc823] = A;
// JSR Draw_Pat_VL ; 0163: BD F4 37
memory[--S] = 0x0166 & 0xff; memory[--S] = 0x0166 >> 8;
PC = 0xf437;
JUMP;
L0166:// DEC $02,S ; 0166: 6A 62
res = (UINT8)(memory[(UINT16)(S + 0x0002)] - 1);
N = res;
Z = res;
V = memory[(UINT16)(S + 0x0002)] & ~res;
memory[(UINT16)(S + 0x0002)] = res;
// RTS ; 0168: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0169:// LDD ,U++ ; 0169: EC C1
ea = U; U = U + 2;
A = memory[ea];
B = memory[(UINT16)((ea)+1)];
// Z = A|B;
// N = A;
// V = 0;
// PSHS X,B,A ; 016B: 34 16
memory[--S] = X & 0xff; memory[--S] = X >> 8;
memory[--S] = B;
memory[--S] = A;
L016D:// LDX $02,S ; 016D: AE 62
X = ((memory[(UINT16)(S + 0x0002)]<<8)|memory[(UINT16)(((UINT16)(S + 0x0002))+1)]);
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDA $C8CA ; 016F: B6 C8 CA
A = memory[0xc8ca];
N = A;
Z = A;
V = 0;
// BSR $0153 ; 0172: 8D DF
memory[--S] = 0x0174 & 0xff; memory[--S] = 0x0174 >> 8;
PC = 0x0153;
JUMP;
L0174:// BNE $016D ; 0174: 26 F7
if (Z) {
PC = 0x016d;
JUMP;
}
// PULS A,B,X,PC ; 0176: 35 96 ;(PUL? PC=RTS)
A = memory[S++];
B = memory[S++];
X = memory[S++]<<8;
X |= memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
L0178:// LDD ,U++ ; 0178: EC C1
ea = U; U = U + 2;
A = memory[ea];
B = memory[(UINT16)((ea)+1)];
// Z = A|B;
// N = A;
// V = 0;
// PSHS B,A ; 017A: 34 06
memory[--S] = B;
memory[--S] = A;
L017C:// LDA $C8C9 ; 017C: B6 C8 C9
A = memory[0xc8c9];
N = A;
Z = A;
V = 0;
// BSR $0153 ; 017F: 8D D2
memory[--S] = 0x0181 & 0xff; memory[--S] = 0x0181 >> 8;
PC = 0x0153;
JUMP;
L0181:// BNE $017C ; 0181: 26 F9
if (Z) {
PC = 0x017c;
JUMP;
}
// PULS A,B,PC ; 0183: 35 86 ;(PUL? PC=RTS)
A = memory[S++];
B = memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
L0185:// INC <$24 ; 0185: 0C 24
res = (UINT8)((memory_DP[0x24]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0x24]);
memory_DP[0x24] = res;
// JSR Wait_Recal ; 0187: BD F1 92
memory[--S] = 0x018a & 0xff; memory[--S] = 0x018a >> 8;
PC = 0xf192;
JUMP;
DP = 0xd0 << 8; memory_DP = &memory[DP]; // Unfortunately this should be inserted after the label below.
L018A:// JSR Do_Sound ; 018A: BD F2 89
memory[--S] = 0x018d & 0xff; memory[--S] = 0x018d >> 8;
PC = 0xf289;
JUMP;
L018D:// JSR Intensity_5F ; 018D: BD F2 A5
memory[--S] = 0x0190 & 0xff; memory[--S] = 0x0190 >> 8;
PC = 0xf2a5;
JUMP;
L0190:// LDX #$0E18 ; 0190: 8E 0E 18
X = 0x0e18;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDU #$0EA4 ; 0193: CE 0E A4
U = 0x0ea4;
Z = U;
N = (U) >> 8;
V = 0;
// BSR $0178 ; 0196: 8D E0
memory[--S] = 0x0198 & 0xff; memory[--S] = 0x0198 >> 8;
PC = 0x0178;
JUMP;
L0198:// LDX #$0E60 ; 0198: 8E 0E 60
X = 0x0e60;
Z = X;
N = (X) >> 8;
V = 0;
// BSR $0169 ; 019B: 8D CC
memory[--S] = 0x019d & 0xff; memory[--S] = 0x019d >> 8;
PC = 0x0169;
JUMP;
L019D:// LEAX $0C,X ; 019D: 30 0C
X = (X + 0x000c);
Z = X;
// BSR $0169 ; 019F: 8D C8
memory[--S] = 0x01a1 & 0xff; memory[--S] = 0x01a1 >> 8;
PC = 0x0169;
JUMP;
L01A1:// LEAX $08,X ; 01A1: 30 08
X = (X + 0x0008);
Z = X;
// BSR $0178 ; 01A3: 8D D3
memory[--S] = 0x01a5 & 0xff; memory[--S] = 0x01a5 >> 8;
PC = 0x0178;
JUMP;
L01A5:// CLR Vec_0Ref_Enable ; 01A5: 7F C8 24
memory[0xc824] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LEAS $FFF6,S ; 01A8: 32 76
S = (S + 0xfff6);
// LDU #$C900 ; 01AA: CE C9 00
U = 0xc900;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDD #$038F ; 01AD: CC 03 8F
A = (UINT8)((0x038f) >> 8);
B = (UINT8)((0x038f) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD ,S ; 01B0: ED E4
// Z = A | B;
// N = A;
// V = 0;
memory[S] = A;
memory[S + 1] = B;
// LDD #$0275 ; 01B2: CC 02 75
A = (UINT8)((0x0275) >> 8);
B = (UINT8)((0x0275) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD $02,S ; 01B5: ED 62
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0002)] = A;
memory[(UINT16)(S + 0x0002) + 1] = B;
// LDA $C881 ; 01B7: B6 C8 81
A = memory[0xc881];
// N = A;
// Z = A;
// V = 0;
// LDB #$40 ; 01BA: C6 40
B = (SINT8)0x40;
// N = B;
// Z = B;
// V = 0;
// JSR $0381 ; 01BC: BD 03 81
memory[--S] = 0x01bf & 0xff; memory[--S] = 0x01bf >> 8;
PC = 0x0381;
JUMP;
L01BF:// LDU #$CA00 ; 01BF: CE CA 00
U = 0xca00;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDD #$02E6 ; 01C2: CC 02 E6
A = (UINT8)((0x02e6) >> 8);
B = (UINT8)((0x02e6) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD $02,S ; 01C5: ED 62
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0002)] = A;
memory[(UINT16)(S + 0x0002) + 1] = B;
// LDA $C8C8 ; 01C7: B6 C8 C8
A = memory[0xc8c8];
// N = A;
// Z = A;
// V = 0;
// LDB #$27 ; 01CA: C6 27
B = (SINT8)0x27;
// N = B;
// Z = B;
// V = 0;
// JSR $0381 ; 01CC: BD 03 81
memory[--S] = 0x01cf & 0xff; memory[--S] = 0x01cf >> 8;
PC = 0x0381;
JUMP;
L01CF:// LDU #$C9C0 ; 01CF: CE C9 C0
U = 0xc9c0;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDD #$02B2 ; 01D2: CC 02 B2
A = (UINT8)((0x02b2) >> 8);
B = (UINT8)((0x02b2) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD $02,S ; 01D5: ED 62
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0002)] = A;
memory[(UINT16)(S + 0x0002) + 1] = B;
// LDY #$CA56 ; 01D7: 10 8E CA 56
Y = 0xca56;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
// LDD #$0807 ; 01DB: CC 08 07
A = (UINT8)((0x0807) >> 8);
B = (UINT8)((0x0807) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// JSR $0381 ; 01DE: BD 03 81
memory[--S] = 0x01e1 & 0xff; memory[--S] = 0x01e1 >> 8;
PC = 0x0381;
JUMP;
L01E1:// LDU #$C894 ; 01E1: CE C8 94
U = 0xc894;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDD #$0308 ; 01E4: CC 03 08
A = (UINT8)((0x0308) >> 8);
B = (UINT8)((0x0308) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD $02,S ; 01E7: ED 62
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0002)] = A;
memory[(UINT16)(S + 0x0002) + 1] = B;
// LDA #$01 ; 01E9: 86 01
A = (SINT8)0x01;
// N = A;
// Z = A;
// V = 0;
// JSR $0381 ; 01EB: BD 03 81
memory[--S] = 0x01ee & 0xff; memory[--S] = 0x01ee >> 8;
PC = 0x0381;
JUMP;
L01EE:// LDD #$0CA3 ; 01EE: CC 0C A3
A = (UINT8)((0x0ca3) >> 8);
B = (UINT8)((0x0ca3) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD ,S ; 01F1: ED E4
// Z = A | B;
// N = A;
// V = 0;
memory[S] = A;
memory[S + 1] = B;
// LDX #$CA8A ; 01F3: 8E CA 8A
X = 0xca8a;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDU #$C8E5 ; 01F6: CE C8 E5
U = 0xc8e5;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDA $C8C8 ; 01F9: B6 C8 C8
A = memory[0xc8c8];
// N = A;
// Z = A;
// V = 0;
// JSR $0381 ; 01FC: BD 03 81
memory[--S] = 0x01ff & 0xff; memory[--S] = 0x01ff >> 8;
PC = 0x0381;
JUMP;
L01FF:// LDD #$7E7F ; 01FF: CC 7E 7F
A = (UINT8)((0x7e7f) >> 8);
B = (UINT8)((0x7e7f) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STB <$04 ; 0202: D7 04
// Z = B;
// N = B;
// V = 0;
memory_DP[0x04] = B;
// JSR Intensity_a ; 0204: BD F2 AB
memory[--S] = 0x0207 & 0xff; memory[--S] = 0x0207 >> 8;
PC = 0xf2ab;
JUMP;
L0207:// LDA $C8E9 ; 0207: B6 C8 E9
A = memory[0xc8e9];
N = A;
// Z = A;
// V = 0;
// BMI $021A ; 020A: 2B 0E
if ((SINT8)N < 0) {
PC = 0x021a;
JUMP;
}
// LDA $C8C8 ; 020C: B6 C8 C8
A = memory[0xc8c8];
// N = A;
// Z = A;
// V = 0;
// LDX #Print_Str_yx ; 020F: 8E F3 78
X = 0xf378;
// Z = X;
// N = (X) >> 8;
// V = 0;
// STX ,S ; 0212: AF E4
// Z = X;
// N = (X) >> 8;
// V = 0;
memory[S] = (UINT8)((X) >> 8);
memory[(UINT16)(S + 1)] = (UINT8)((X) & 0xff);
// LDU #$CA88 ; 0214: CE CA 88
U = 0xca88;
// Z = U;
// N = (U) >> 8;
// V = 0;
// JSR $0381 ; 0217: BD 03 81
memory[--S] = 0x021a & 0xff; memory[--S] = 0x021a >> 8;
PC = 0x0381;
JUMP;
L021A:// LEAS $0A,S ; 021A: 32 6A
S = (S + 0x000a);
// LDA $C8E9 ; 021C: B6 C8 E9
A = memory[0xc8e9];
N = A;
// Z = A;
// V = 0;
// BMI $0237 ; 021F: 2B 16
if ((SINT8)N < 0) {
PC = 0x0237;
JUMP;
}
// LDX #$78EF ; 0221: 8E 78 EF
X = 0x78ef;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDB $C8E2 ; 0224: F6 C8 E2
B = memory[0xc8e2];
// N = B;
// Z = B;
// V = 0;
// LDA #$60 ; 0227: 86 60
A = (SINT8)0x60;
// N = A;
// Z = A;
// V = 0;
// JSR Print_Ships ; 0229: BD F3 93
memory[--S] = 0x022c & 0xff; memory[--S] = 0x022c >> 8;
PC = 0xf393;
JUMP;
L022C:// LDA $C8ED ; 022C: B6 C8 ED
A = memory[0xc8ed];
// N = A;
Z = A;
// V = 0;
// BNE $0237 ; 022F: 26 06
if (Z) {
PC = 0x0237;
JUMP;
}
// LDU #$0FF4 ; 0231: CE 0F F4
U = 0x0ff4;
// Z = U;
// N = (U) >> 8;
// V = 0;
// JSR Print_Str_yx ; 0234: BD F3 78
memory[--S] = 0x0237 & 0xff; memory[--S] = 0x0237 >> 8;
PC = 0xf378;
JUMP;
L0237:// LDA $C8F0 ; 0237: B6 C8 F0
A = memory[0xc8f0];
// N = A;
// Z = A;
// V = 0;
// JSR Read_Btns_Mask ; 023A: BD F1 B4
memory[--S] = 0x023d & 0xff; memory[--S] = 0x023d >> 8;
PC = 0xf1b4;
JUMP;
L023D:// JSR Joy_Digital ; 023D: BD F1 F8
memory[--S] = 0x0240 & 0xff; memory[--S] = 0x0240 >> 8;
PC = 0xf1f8;
JUMP;
L0240:// LDA $C8C8 ; 0240: B6 C8 C8
A = memory[0xc8c8];
// N = A;
Z = A;
// V = 0;
// BEQ $026F ; 0243: 27 2A
if (!Z) {
PC = 0x026f;
JUMP;
}
// LDX #$CA4E ; 0245: 8E CA 4E
X = 0xca4e;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDU #Vec_Button_1_1 ; 0248: CE C8 12
U = 0xc812;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDY #Vec_Joy_1_X ; 024B: 10 8E C8 1B
Y = 0xc81b;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
L024F:// PSHS X,A ; 024F: 34 12
memory[--S] = X & 0xff; memory[--S] = X >> 8;
memory[--S] = A;
// LDD ,U++ ; 0251: EC C1
ea = U; U = U + 2;
A = memory[ea];
B = memory[(UINT16)((ea)+1)];
// Z = A|B;
// N = A;
// V = 0;
// STD ,X+ ; 0253: ED 80
// Z = A | B;
// N = A;
// V = 0;
memory[X++] = A; // 1
memory[X] = B;
// LDD ,U++ ; 0255: EC C1
ea = U; U = U + 2;
A = memory[ea];
B = memory[(UINT16)((ea)+1)];
// Z = A|B;
// N = A;
// V = 0;
// STD $01,X ; 0257: ED 01
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0001)] = A;
memory[(UINT16)(X + 0x0001) + 1] = B;
// CLRB ; 0259: 5F
B = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// LDA ,Y++ ; 025A: A6 A1
ea = Y; Y = Y + 2;
A = memory[ea];
// N = A;
Z = A;
// V = 0;
// BEQ $0268 ; 025C: 27 0A
if (!Z) {
PC = 0x0268;
JUMP;
}
// ROLA ; 025E: 49
res = ((A) << 1) + (C != 0);
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// ROLB ; 025F: 59
res = ((B) << 1) + (C != 0);
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = res ^ (B);
B = res;
// BEQ $0264 ; 0260: 27 02
if (!Z) {
PC = 0x0264;
JUMP;
}
// COMA ; 0262: 43
A = A ^ 0xff;
// Z = A;
// N = A;
// V = 0;
// C = 1;
// NEGB ; 0263: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
C = B;
L0264:// ORA B,X ; 0264: AA 85
A = A | memory[(UINT16)(X + (SINT8)B)];
// Z = A;
// N = A;
// V = 0;
// STA B,X ; 0266: A7 85
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + (SINT8)B)] = A;
L0268:// PULS A,X ; 0268: 35 12
A = memory[S++];
X = memory[S++]<<8;
X |= memory[S++];
// LEAX $04,X ; 026A: 30 04
X = (X + 0x0004);
// Z = X;
// DECA ; 026C: 4A
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
// BNE $024F ; 026D: 26 E0
if (Z) {
PC = 0x024f;
JUMP;
}
L026F:// JSR Reset0Ref ; 026F: BD F3 54
memory[--S] = 0x0272 & 0xff; memory[--S] = 0x0272 >> 8;
PC = 0xf354;
JUMP;
L0272:// JMP DP_to_C8 ; 0272: 7E F1 AF
PC = 0xf1af;
JUMP;
L0381:// PSHS B,A ; 0381: 34 06
memory[--S] = B;
memory[--S] = A;
// TSTA ; 0383: 4D
Z = A;
// N = A;
// V = 0;
// BEQ $038D ; 0384: 27 07
if (!Z) {
PC = 0x038d;
JUMP;
}
L0386:// JSR [$04,S] ; 0386: AD F8 04
memory[--S] = 0x0389 & 0xff; memory[--S] = 0x0389 >> 8;
PC = ((memory[(UINT16)(S + (SINT8)0x04)]<<8)|memory[(UINT16)(S + (SINT8)0x04 + 1)]);
JUMP;
L0389:// DEC ,S ; 0389: 6A E4
res = (UINT8)(memory[S] - 1);
N = res;
Z = res;
V = memory[S] & ~res;
memory[S] = res;
// BNE $0386 ; 038B: 26 F9
if (Z) {
PC = 0x0386;
JUMP;
}
L038D:// PULS A,B,PC ; 038D: 35 86 ;(PUL? PC=RTS)
A = memory[S++];
B = memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
L039D:// LDA #$FC ; 039D: 86 FC
A = (SINT8)0xfc;
// N = A;
// Z = A;
// V = 0;
// ANDA <$67 ; 039F: 94 67
A = A & memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
// STA <$67 ; 03A1: 97 67
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
// LDA <$2F ; 03A3: 96 2F
A = memory_DP[0x2f];
N = A;
Z = A;
V = 0;
// LBEQ $0448 ; 03A5: 10 27 00 9F
if (!Z) {
PC = 0x0448;
JUMP;
}
// DEC <$2F ; 03A9: 0A 2F
res = (UINT8)(memory_DP[0x2f] - 1);
// N = res;
Z = res;
// V = memory_DP[0x2f] & ~res;
memory_DP[0x2f] = res;
// BNE $03E9 ; 03AB: 26 3C
if (Z) {
PC = 0x03e9;
JUMP;
}
// COM <$8A ; 03AD: 03 8A
memory_DP[0x8a] = memory_DP[0x8a] ^ 0xff;
// Z = memory_DP[0x8a];
// N = memory_DP[0x8a];
// V = 0;
// C = 1;
// LDX #$CB00 ; 03AF: 8E CB 00
X = 0xcb00;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDU #$0E6C ; 03B2: CE 0E 6C
U = 0x0e6c;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDA #$04 ; 03B5: 86 04
A = (SINT8)0x04;
// N = A;
// Z = A;
// V = 0;
// PSHS A ; 03B7: 34 02
memory[--S] = A;
L03B9:// LDD #$0408 ; 03B9: CC 04 08
A = (UINT8)((0x0408) >> 8);
B = (UINT8)((0x0408) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// JSR $0CE1 ; 03BC: BD 0C E1
memory[--S] = 0x03bf & 0xff; memory[--S] = 0x03bf >> 8;
PC = 0x0ce1;
JUMP;
L03BF:// DEC ,S ; 03BF: 6A E4
res = (UINT8)(memory[S] - 1);
// N = res;
Z = res;
// V = memory[S] & ~res;
memory[S] = res;
// BNE $03B9 ; 03C1: 26 F6
if (Z) {
PC = 0x03b9;
JUMP;
}
// PULS A ; 03C3: 35 02
A = memory[S++];
// LDA <$80 ; 03C5: 96 80
A = memory_DP[0x80];
// N = A;
// Z = A;
// V = 0;
// STA <$88 ; 03C7: 97 88
// Z = A;
// N = A;
// V = 0;
memory_DP[0x88] = A;
// CMPA #$01 ; 03C9: 81 01
res = A - (SINT8)0x01;
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ (SINT8)0x01) & (A ^ res);
// BNE $03D2 ; 03CB: 26 05
if (Z) {
PC = 0x03d2;
JUMP;
}
// LDD #$01FD ; 03CD: CC 01 FD
A = (UINT8)((0x01fd) >> 8);
B = (UINT8)((0x01fd) & 0xff);
Z = A|B;
N = A;
V = 0;
// BRA $03D5 ; 03D0: 20 03
PC = 0x03d5;
JUMP;
L03D2:// LDD #$02FE ; 03D2: CC 02 FE
A = (UINT8)((0x02fe) >> 8);
B = (UINT8)((0x02fe) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
L03D5:// STD <$EB ; 03D5: DD EB
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xeb] = A;
memory_DP[0xeb + 1] = B;
// JSR $0CD4 ; 03D7: BD 0C D4
memory[--S] = 0x03da & 0xff; memory[--S] = 0x03da >> 8;
PC = 0x0cd4;
JUMP;
L03DA:// LDA <$82 ; 03DA: 96 82
A = memory_DP[0x82];
// N = A;
// Z = A;
// V = 0;
// STA <$89 ; 03DC: 97 89
// Z = A;
// N = A;
// V = 0;
memory_DP[0x89] = A;
// LDX #$C900 ; 03DE: 8E C9 00
X = 0xc900;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDB <$81 ; 03E1: D6 81
B = memory_DP[0x81];
// N = B;
// Z = B;
// V = 0;
// STB <$8B ; 03E3: D7 8B
// Z = B;
// N = B;
// V = 0;
memory_DP[0x8b] = B;
L03E5:// STB <$CD ; 03E5: D7 CD
Z = B;
N = B;
V = 0;
memory_DP[0xcd] = B;
// BNE $03EA ; 03E7: 26 01
if (Z) {
PC = 0x03ea;
JUMP;
}
L03E9:// RTS ; 03E9: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L03EA:// LDA #$09 ; 03EA: 86 09
A = (SINT8)0x09;
// N = A;
// Z = A;
// V = 0;
// MUL ; 03EC: 3D
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// LDU #$0D7C ; 03ED: CE 0D 7C
U = 0x0d7c;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LEAU B,U ; 03F0: 33 C5
U = (U + (SINT8)B);
// INCA ; 03F2: 4C
res = (UINT8)((A) + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
// STA ,X+ ; 03F3: A7 80
// Z = A;
// N = A;
// V = 0;
memory[X++] = A;
// LDA #$08 ; 03F5: 86 08
A = (SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
L03F7:// CLR ,X+ ; 03F7: 6F 80
memory[X++] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// DECA ; 03F9: 4A
res = (UINT8)(A - 1);
// N = res;
Z = res;
// V = A & ~res;
A = res;
// BNE $03F7 ; 03FA: 26 FB
if (Z) {
PC = 0x03f7;
JUMP;
}
// JSR Random_3 ; 03FC: BD F5 11
memory[--S] = 0x03ff & 0xff; memory[--S] = 0x03ff >> 8;
PC = 0xf511;
JUMP;
L03FF:// ANDA #$03 ; 03FF: 84 03
A = A & (SINT8)0x03;
// Z = A;
// N = A;
// V = 0;
// STA ,X+ ; 0401: A7 80
// Z = A;
// N = A;
// V = 0;
memory[X++] = A;
// LDA #$09 ; 0403: 86 09
A = (SINT8)0x09;
// N = A;
// Z = A;
// V = 0;
// JSR $0CF6 ; 0405: BD 0C F6
memory[--S] = 0x0408 & 0xff; memory[--S] = 0x0408 >> 8;
PC = 0x0cf6;
JUMP;
L0408:// LEAU $FFFE,X ; 0408: 33 1E
U = (X + 0xfffe);
// LDA ,U ; 040A: A6 C4
A = memory[U];
// N = A;
Z = A;
// V = 0;
// BNE $0410 ; 040C: 26 02
if (Z) {
PC = 0x0410;
JUMP;
}
// LDA ,-U ; 040E: A6 C2
A = memory[--U];
// N = A;
// Z = A;
// V = 0;
L0410:// LDB <$88 ; 0410: D6 88
B = memory_DP[0x88];
// N = B;
// Z = B;
// V = 0;
// MUL ; 0412: 3D
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// NEGB ; 0413: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
// C = B;
// STB ,U ; 0414: E7 C4
// Z = B;
// N = B;
// V = 0;
memory[U] = B;
// LDB $FFF6,X ; 0416: E6 16
B = memory[(UINT16)(X + 0xfff6)];
// N = B;
Z = B;
// V = 0;
// BEQ $0427 ; 0418: 27 0D
if (!Z) {
PC = 0x0427;
JUMP;
}
// LEAU $FFFB,X ; 041A: 33 1B
U = (X + 0xfffb);
// COMA ; 041C: 43
A = A ^ 0xff;
// Z = A;
// N = A;
// V = 0;
// C = 1;
L041D:// NEGA ; 041D: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
// LEAU A,U ; 041E: 33 C6
U = (U + (SINT8)A);
// NEG ,U ; 0420: 60 C4
// V = (UINT8)(-memory[U]) & (memory[U]);
memory[U] = (UINT8)(-memory[U]);
// Z = memory[U];
// N = memory[U];
// C = memory[U];
// NEG $02,U ; 0422: 60 42
// V = (UINT8)(-memory[(UINT16)(U + 0x0002)]) & (memory[(UINT16)(U + 0x0002)]);
memory[(UINT16)(U + 0x0002)] = (UINT8)(-memory[(UINT16)(U + 0x0002)]);
// Z = memory[(UINT16)(U + 0x0002)];
// N = memory[(UINT16)(U + 0x0002)];
// C = memory[(UINT16)(U + 0x0002)];
// DECB ; 0424: 5A
res = (UINT8)(B - 1);
// N = res;
Z = res;
// V = B & ~res;
B = res;
// BNE $041D ; 0425: 26 F6
if (Z) {
PC = 0x041d;
JUMP;
}
L0427:// CLRA ; 0427: 4F
A = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// TFR D,Y ; 0428: 1F 02
Y = ((A << 8) | B);
// LDD $FFFB,X ; 042A: EC 1B
A = memory[(UINT16)(X + 0xfffb)];
B = memory[(UINT16)(((UINT16)(X + 0xfffb))+1)];
// Z = A|B;
// N = A;
// V = 0;
// JSR $0C80 ; 042C: BD 0C 80
memory[--S] = 0x042f & 0xff; memory[--S] = 0x042f >> 8;
PC = 0x0c80;
JUMP;
L042F:// STA $FFF3,X ; 042F: A7 13
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfff3)] = A;
// LDA $FFFF,X ; 0431: A6 1F
A = memory[(UINT16)(X + 0xffff)];
// N = A;
// Z = A;
// V = 0;
// LEAU ,X ; 0433: 33 84
U = X;
// LDX #$0EC8 ; 0435: 8E 0E C8
X = 0x0ec8;
// Z = X;
// N = (X) >> 8;
// V = 0;
// JSR Rot_VL_Mode_a ; 0438: BD F6 1F
memory[--S] = 0x043b & 0xff; memory[--S] = 0x043b >> 8;
PC = 0xf61f;
JUMP;
L043B:// LDA -$20,U ; 043B: A6 C8 E0
A = memory[(UINT16)(U + (SINT8)0xe0)];
// N = A;
// Z = A;
// V = 0;
// JSR Rot_VL_Mode_a ; 043E: BD F6 1F
memory[--S] = 0x0441 & 0xff; memory[--S] = 0x0441 >> 8;
PC = 0xf61f;
JUMP;
L0441:// LEAX $01,U ; 0441: 30 41
X = (U + 0x0001);
// Z = X;
// LDB <$CD ; 0443: D6 CD
B = memory_DP[0xcd];
// N = B;
// Z = B;
// V = 0;
// DECB ; 0445: 5A
res = (UINT8)(B - 1);
N = res;
Z = res;
V = B & ~res;
B = res;
// BRA $03E5 ; 0446: 20 9D
PC = 0x03e5;
JUMP;
L0448:// LDA <$8B ; 0448: 96 8B
A = memory_DP[0x8b];
// N = A;
Z = A;
// V = 0;
// BNE $0451 ; 044A: 26 05
if (Z) {
PC = 0x0451;
JUMP;
}
// LDA <$E0 ; 044C: 96 E0
A = memory_DP[0xe0];
// N = A;
// Z = A;
// V = 0;
// STA <$2F ; 044E: 97 2F
Z = A;
N = A;
V = 0;
memory_DP[0x2f] = A;
// RTS ; 0450: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0451:// LDB $C900 ; 0451: F6 C9 00
B = memory[0xc900];
N = B;
Z = B;
V = 0;
// BGT $0464 ; 0454: 2E 0E
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0464;
JUMP;
}
// LDB $C940 ; 0456: F6 C9 40
B = memory[0xc940];
N = B;
Z = B;
V = 0;
// BGT $0464 ; 0459: 2E 09
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0464;
JUMP;
}
// LDB $C980 ; 045B: F6 C9 80
B = memory[0xc980];
N = B;
Z = B;
V = 0;
// BGT $0464 ; 045E: 2E 04
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0464;
JUMP;
}
// LDA #$FC ; 0460: 86 FC
A = (SINT8)0xfc;
// N = A;
// Z = A;
// V = 0;
// STA <$EC ; 0462: 97 EC
// Z = A;
// N = A;
// V = 0;
memory_DP[0xec] = A;
L0464:// LDA <$67 ; 0464: 96 67
A = memory_DP[0x67];
// N = A;
// Z = A;
// V = 0;
// ORA <$EB ; 0466: 9A EB
A = A | memory_DP[0xeb];
// Z = A;
// N = A;
// V = 0;
// ANDA <$EC ; 0468: 94 EC
A = A & memory_DP[0xec];
// Z = A;
// N = A;
// V = 0;
// STA <$67 ; 046A: 97 67
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
// LDX #$C8C8 ; 046C: 8E C8 C8
X = 0xc8c8;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDB <$8E ; 046F: D6 8E
B = memory_DP[0x8e];
// N = B;
// Z = B;
// V = 0;
L0471:// INCB ; 0471: 5C
res = (UINT8)((B) + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
// ANDB #$03 ; 0472: C4 03
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
// STB <$8E ; 0474: D7 8E
Z = B;
// N = B;
// V = 0;
memory_DP[0x8e] = B;
// BEQ $0471 ; 0476: 27 F9
if (!Z) {
PC = 0x0471;
JUMP;
}
// LDA #$40 ; 0478: 86 40
A = (SINT8)0x40;
// N = A;
// Z = A;
// V = 0;
// MUL ; 047A: 3D
res = (UINT16)(A * B);
// Z = res;
C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// ABX ; 047B: 3A
X = X + B;
// LDA $FFF8,X ; 047C: A6 18
A = memory[(UINT16)(X + 0xfff8)];
N = A;
Z = A;
// V = 0;
// BEQ $048B ; 047E: 27 0B
if (!Z) {
PC = 0x048b;
JUMP;
}
// BMI $04A5 ; 0480: 2B 23
if ((SINT8)N < 0) {
PC = 0x04a5;
JUMP;
}
// LDB $FFF9,X ; 0482: E6 19
B = memory[(UINT16)(X + 0xfff9)];
// N = B;
Z = B;
// V = 0;
// BNE $048C ; 0484: 26 06
if (Z) {
PC = 0x048c;
JUMP;
}
// TSTA ; 0486: 4D
Z = A;
N = A;
V = 0;
// LBNE $0552 ; 0487: 10 26 00 C7
if (Z) {
PC = 0x0552;
JUMP;
}
L048B:// RTS ; 048B: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L048C:// LDA #$80 ; 048C: 86 80
A = (SINT8)0x80;
// N = A;
// Z = A;
// V = 0;
// STA $FFF8,X ; 048E: A7 18
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfff8)] = A;
// LDU #$CB00 ; 0490: CE CB 00
U = 0xcb00;
// Z = U;
// N = (U) >> 8;
// V = 0;
// STU $02,X ; 0493: EF 02
// Z = U;
// N = (U) >> 8;
// V = 0;
memory[(UINT16)(X + 0x0002)] = (UINT8)((U) >> 8);
memory[(UINT16)((X + 0x0002) + 1)] = (UINT8)((U) & 0xff);
// LDB #$10 ; 0495: C6 10
B = (SINT8)0x10;
// N = B;
// Z = B;
// V = 0;
// LDA $0A,X ; 0497: A6 0A
A = memory[(UINT16)(X + 0x000a)];
// N = A;
// Z = A;
// V = 0;
// STB $04,X ; 0499: E7 04
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0004)] = B;
// CLR $05,X ; 049B: 6F 05
memory[(UINT16)(X + 0x0005)] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// LEAU $0B,X ; 049D: 33 0B
U = (X + 0x000b);
// LDX #$0EF4 ; 049F: 8E 0E F4
X = 0x0ef4;
Z = X;
N = (X) >> 8;
V = 0;
// JMP Rot_VL_Mode_a ; 04A2: 7E F6 1F
PC = 0xf61f;
JUMP;
L04A5:// INC $FFF8,X ; 04A5: 6C 18
res = (UINT8)((memory[(UINT16)(X + 0xfff8)]) + 1);
Z = res;
// N = res;
// V = res & ~(memory[(UINT16)(X + 0xfff8)]);
memory[(UINT16)(X + 0xfff8)] = res;
// BNE $04B2 ; 04A7: 26 09
if (Z) {
PC = 0x04b2;
JUMP;
}
// CLR $FFF9,X ; 04A9: 6F 19
memory[(UINT16)(X + 0xfff9)] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// DEC <$8B ; 04AB: 0A 8B
res = (UINT8)(memory_DP[0x8b] - 1);
// N = res;
Z = res;
// V = memory_DP[0x8b] & ~res;
memory_DP[0x8b] = res;
// BNE $04B1 ; 04AD: 26 02
if (Z) {
PC = 0x04b1;
JUMP;
}
// CLR <$EB ; 04AF: 0F EB
memory_DP[0xeb] = 0;
V = 0;
Z = 0;
N = 0;
C = 0;
L04B1:// RTS ; 04B1: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L04B2:// CMPA #$F8 ; 04B2: 81 F8
res = A - (SINT8)0xf8;
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = (A ^ (SINT8)0xf8) & (A ^ res);
// BLT $04BC ; 04B4: 2D 06
if ((SINT8)(N^V) < 0) {
PC = 0x04bc;
JUMP;
}
// LDA #$02 ; 04B6: 86 02
A = (SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
// ADDA $04,X ; 04B8: AB 04
A = (UINT8)(A + memory[(UINT16)(X + 0x0004)]);
res = A + memory[(UINT16)(X + 0x0004)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = A ^ memory[(UINT16)(X + 0x0004)] ^ res ^ C;
H = res;
// V = res;
// STA $04,X ; 04BA: A7 04
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0004)] = A;
L04BC:// JSR $0709 ; 04BC: BD 07 09
memory[--S] = 0x04bf & 0xff; memory[--S] = 0x04bf >> 8;
PC = 0x0709;
JUMP;
L04BF:// LDB $FFF9,X ; 04BF: E6 19
B = memory[(UINT16)(X + 0xfff9)];
// N = B;
// Z = B;
// V = 0;
// DECB ; 04C1: 5A
res = (UINT8)(B - 1);
// N = res;
Z = res;
// V = B & ~res;
B = res;
// BEQ $04CF ; 04C2: 27 0B
if (!Z) {
PC = 0x04cf;
JUMP;
}
// LDU #$0F07 ; 04C4: CE 0F 07
U = 0x0f07;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LEAX $1E,X ; 04C7: 30 88 1E
X = (X + (SINT8)0x1e);
// Z = X;
// LDA #$19 ; 04CA: 86 19
A = (SINT8)0x19;
N = A;
Z = A;
V = 0;
// JMP $0CF6 ; 04CC: 7E 0C F6
PC = 0x0cf6;
JUMP;
L04CF:// DEC $FFFA,X ; 04CF: 6A 1A
res = (UINT8)(memory[(UINT16)(X + 0xfffa)] - 1);
N = res;
Z = res;
V = memory[(UINT16)(X + 0xfffa)] & ~res;
memory[(UINT16)(X + 0xfffa)] = res;
// BGT $0501 ; 04D1: 2E 2E
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0501;
JUMP;
}
// LDU #$C9DC ; 04D3: CE C9 DC
U = 0xc9dc;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDB <$8E ; 04D6: D6 8E
B = memory_DP[0x8e];
// N = B;
// Z = B;
// V = 0;
// LDA #$07 ; 04D8: 86 07
A = (SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
// MUL ; 04DA: 3D
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// LEAU B,U ; 04DB: 33 C5
U = (U + (SINT8)B);
// LDB ,U ; 04DD: E6 C4
B = memory[U];
// N = B;
Z = B;
// V = 0;
// BNE $0501 ; 04DF: 26 20
if (Z) {
PC = 0x0501;
JUMP;
}
// LDD $06,X ; 04E1: EC 06
A = memory[(UINT16)(X + 0x0006)];
B = memory[(UINT16)(((UINT16)(X + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
// STD $01,U ; 04E3: ED 41
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0001)] = A;
memory[(UINT16)(U + 0x0001) + 1] = B;
// LDB $FFFE,X ; 04E5: E6 1E
B = memory[(UINT16)(X + 0xfffe)];
// N = B;
// Z = B;
// V = 0;
// LDA <$86 ; 04E7: 96 86
A = memory_DP[0x86];
// N = A;
// Z = A;
// V = 0;
// STA $FFFA,X ; 04E9: A7 1A
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfffa)] = A;
L04EB:// LDA #$07 ; 04EB: 86 07
A = (SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
// JSR Rise_Run_X ; 04ED: BD F5 FF
memory[--S] = 0x04f0 & 0xff; memory[--S] = 0x04f0 >> 8;
PC = 0xf5ff;
JUMP;
L04F0:// STD $03,U ; 04F0: ED 43
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0003)] = A;
memory[(UINT16)(U + 0x0003) + 1] = B;
// ASRA ; 04F2: 47
// C = A & 1;
A = (UINT8)(A >> 1);
// Z = A;
// N = A;
// ASRB ; 04F3: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// STD $05,U ; 04F4: ED 45
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0005)] = A;
memory[(UINT16)(U + 0x0005) + 1] = B;
// LDD $03,U ; 04F6: EC 43
A = memory[(UINT16)(U + 0x0003)];
B = memory[(UINT16)(((UINT16)(U + 0x0003))+1)];
// Z = A|B;
// N = A;
// V = 0;
// SUBA $05,U ; 04F8: A0 45
A = (UINT8)(A - memory[(UINT16)(U + 0x0005)]);
// res = A - memory[(UINT16)(U + 0x0005)];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((A) ^ (memory[(UINT16)(U + 0x0005)])) & ((A) ^ res);
// SUBB $06,U ; 04FA: E0 46
B = (UINT8)(B - memory[(UINT16)(U + 0x0006)]);
res = B - memory[(UINT16)(U + 0x0006)];
C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((B) ^ (memory[(UINT16)(U + 0x0006)])) & ((B) ^ res);
// STD $03,U ; 04FC: ED 43
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0003)] = A;
memory[(UINT16)(U + 0x0003) + 1] = B;
// DEC ,U ; 04FE: 6A C4
res = (UINT8)(memory[U] - 1);
N = res;
Z = res;
V = memory[U] & ~res;
memory[U] = res;
L0500:// RTS ; 0500: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0501:// LDA #$7F ; 0501: 86 7F
A = (SINT8)0x7f;
// N = A;
// Z = A;
// V = 0;
// STA <$D0 ; 0503: 97 D0
// Z = A;
// N = A;
// V = 0;
memory_DP[0xd0] = A;
// LDU #$CA06 ; 0505: CE CA 06
U = 0xca06;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDA $FFFA,U ; 0508: A6 5A
A = memory[(UINT16)(U + 0xfffa)];
N = A;
Z = A;
V = 0;
// BLE $0517 ; 050A: 2F 0B
if (((SINT8)(N^V) < 0) || (!Z)) {
PC = 0x0517;
JUMP;
}
// LDD $06,X ; 050C: EC 06
A = memory[(UINT16)(X + 0x0006)];
B = memory[(UINT16)(((UINT16)(X + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
// JSR $0C76 ; 050E: BD 0C 76
memory[--S] = 0x0511 & 0xff; memory[--S] = 0x0511 >> 8;
PC = 0x0c76;
JUMP;
L0511:// CMPB #$04 ; 0511: C1 04
res = B - (SINT8)0x04;
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = (B ^ (SINT8)0x04) & (B ^ res);
// BLT $0549 ; 0513: 2D 34
if ((SINT8)(N^V) < 0) {
PC = 0x0549;
JUMP;
}
// STD <$CF ; 0515: DD CF
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcf] = A;
memory_DP[0xcf + 1] = B;
L0517:// LDA <$C8 ; 0517: 96 C8
A = memory_DP[0xc8];
// N = A;
// Z = A;
// V = 0;
// DECA ; 0519: 4A
res = (UINT8)(A - 1);
// N = res;
Z = res;
// V = A & ~res;
A = res;
// BEQ $0530 ; 051A: 27 14
if (!Z) {
PC = 0x0530;
JUMP;
}
// LEAU $27,U ; 051C: 33 C8 27
U = (U + (SINT8)0x27);
// LDA $FFFA,U ; 051F: A6 5A
A = memory[(UINT16)(U + 0xfffa)];
N = A;
// Z = A;
V = 0;
// BLT $0530 ; 0521: 2D 0D
if ((SINT8)(N^V) < 0) {
PC = 0x0530;
JUMP;
}
// LDD $06,X ; 0523: EC 06
A = memory[(UINT16)(X + 0x0006)];
B = memory[(UINT16)(((UINT16)(X + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
// JSR $0C76 ; 0525: BD 0C 76
memory[--S] = 0x0528 & 0xff; memory[--S] = 0x0528 >> 8;
PC = 0x0c76;
JUMP;
L0528:// CMPB #$04 ; 0528: C1 04
res = B - (SINT8)0x04;
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = (B ^ (SINT8)0x04) & (B ^ res);
// BLT $0549 ; 052A: 2D 1D
if ((SINT8)(N^V) < 0) {
PC = 0x0549;
JUMP;
}
// CMPB <$D0 ; 052C: D1 D0
res = B - memory_DP[0xd0];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = (B ^ memory_DP[0xd0]) & (B ^ res);
// BLT $0532 ; 052E: 2D 02
if ((SINT8)(N^V) < 0) {
PC = 0x0532;
JUMP;
}
L0530:// LDA <$CF ; 0530: 96 CF
A = memory_DP[0xcf];
// N = A;
// Z = A;
// V = 0;
L0532:// ANDA <$84 ; 0532: 94 84
A = A & memory_DP[0x84];
// Z = A;
// N = A;
// V = 0;
// CMPA $FFFE,X ; 0534: A1 1E
res = A - memory[(UINT16)(X + 0xfffe)];
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ memory[(UINT16)(X + 0xfffe)]) & (A ^ res);
// BEQ $0500 ; 0536: 27 C8
if (!Z) {
PC = 0x0500;
JUMP;
}
// LDB <$EE ; 0538: D6 EE
B = memory_DP[0xee];
// N = B;
// Z = B;
// V = 0;
// BITB #$01 ; 053A: C5 01
res = B & (SINT8)0x01;
Z = res;
// N = res;
// V = 0;
// BEQ $0500 ; 053C: 27 C2
if (!Z) {
PC = 0x0500;
JUMP;
}
// STA $FFFE,X ; 053E: A7 1E
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfffe)] = A;
// LEAU $1E,X ; 0540: 33 88 1E
U = (X + (SINT8)0x1e);
// LDX #$0EDB ; 0543: 8E 0E DB
X = 0x0edb;
Z = X;
N = (X) >> 8;
V = 0;
// JMP Rot_VL_Mode_a ; 0546: 7E F6 1F
PC = 0xf61f;
JUMP;
L0549:// LDA #$02 ; 0549: 86 02
A = (SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
// STA $FFF9,X ; 054B: A7 19
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfff9)] = A;
// LDA #$80 ; 054D: 86 80
A = (SINT8)0x80;
// N = A;
// Z = A;
// V = 0;
// STA $FFFA,U ; 054F: A7 5A
Z = A;
N = A;
V = 0;
memory[(UINT16)(U + 0xfffa)] = A;
// RTS ; 0551: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0552:// LDA ,X ; 0552: A6 84
A = memory[X];
// N = A;
Z = A;
// V = 0;
// BEQ $0568 ; 0554: 27 12
if (!Z) {
PC = 0x0568;
JUMP;
}
// SUBA <$89 ; 0556: 90 89
A = (UINT8)(A - memory_DP[0x89]);
// res = A - memory_DP[0x89];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((A) ^ (memory_DP[0x89])) & ((A) ^ res);
// STA ,X ; 0558: A7 84
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
// LDA $0A,X ; 055A: A6 0A
A = memory[(UINT16)(X + 0x000a)];
// N = A;
// Z = A;
// V = 0;
// ADDA $FFFD,X ; 055C: AB 1D
A = (UINT8)(A + memory[(UINT16)(X + 0xfffd)]);
res = A + memory[(UINT16)(X + 0xfffd)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = A ^ memory[(UINT16)(X + 0xfffd)] ^ res ^ C;
H = res;
// V = res;
// STA $0A,X ; 055E: A7 0A
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x000a)] = A;
// LEAU $0B,X ; 0560: 33 0B
U = (X + 0x000b);
// LDX #$0EC8 ; 0562: 8E 0E C8
X = 0x0ec8;
Z = X;
N = (X) >> 8;
V = 0;
// JMP Rot_VL_Mode_a ; 0565: 7E F6 1F
PC = 0xf61f;
JUMP;
L0568:// LDY #$0DA0 ; 0568: 10 8E 0D A0
Y = 0x0da0;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
// LDA $05,X ; 056C: A6 05
A = memory[(UINT16)(X + 0x0005)];
N = A;
Z = A;
V = 0;
// LBEQ $0600 ; 056E: 10 27 00 8E
if (!Z) {
PC = 0x0600;
JUMP;
}
// LEAU $40,X ; 0572: 33 88 40
U = (X + (SINT8)0x40);
// CMPU #$C9C8 ; 0575: 11 83 C9 C8
res = (U) - (0xc9c8);
// C = res & 0x10000;
res = (UINT16)res;
Z = res;
// N = res >> 8;
// V = (((U) ^ (0xc9c8)) & ((U) ^ res)) >> 8;
// BNE $057E ; 0579: 26 03
if (Z) {
PC = 0x057e;
JUMP;
}
// LDU #$C908 ; 057B: CE C9 08
U = 0xc908;
// Z = U;
// N = (U) >> 8;
// V = 0;
L057E:// LDA $FFF8,U ; 057E: A6 58
A = memory[(UINT16)(U + 0xfff8)];
N = A;
Z = A;
V = 0;
// BLE $05DD ; 0580: 2F 5B
if (((SINT8)(N^V) < 0) || (!Z)) {
PC = 0x05dd;
JUMP;
}
// LDD $06,U ; 0582: EC 46
A = memory[(UINT16)(U + 0x0006)];
B = memory[(UINT16)(((UINT16)(U + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
// SUBA $06,X ; 0584: A0 06
A = (UINT8)(A - memory[(UINT16)(X + 0x0006)]);
res = A - memory[(UINT16)(X + 0x0006)];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
V = ((A) ^ (memory[(UINT16)(X + 0x0006)])) & ((A) ^ res);
// BVS $05DD ; 0586: 29 55
if ((SINT8)V < 0) {
PC = 0x05dd;
JUMP;
}
// SUBB $07,X ; 0588: E0 07
B = (UINT8)(B - memory[(UINT16)(X + 0x0007)]);
res = B - memory[(UINT16)(X + 0x0007)];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
V = ((B) ^ (memory[(UINT16)(X + 0x0007)])) & ((B) ^ res);
// BVS $05DD ; 058A: 29 51
if ((SINT8)V < 0) {
PC = 0x05dd;
JUMP;
}
// JSR Abs_a_b ; 058C: BD F5 84
memory[--S] = 0x058f & 0xff; memory[--S] = 0x058f >> 8;
PC = 0xf584;
JUMP;
L058F:// STD <$CB ; 058F: DD CB
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcb] = A;
memory_DP[0xcb + 1] = B;
// TSTA ; 0591: 4D
Z = A;
// N = A;
// V = 0;
// BEQ $0597 ; 0592: 27 03
if (!Z) {
PC = 0x0597;
JUMP;
}
// TSTB ; 0594: 5D
Z = B;
// N = B;
// V = 0;
// BNE $05DD ; 0595: 26 46
if (Z) {
PC = 0x05dd;
JUMP;
}
L0597:// ADDA <$CC ; 0597: 9B CC
A = (UINT8)(A + memory_DP[0xcc]);
// res = A + memory_DP[0xcc];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ memory_DP[0xcc] ^ res ^ C;
// H = res;
// V = res;
// CMPA #$0C ; 0599: 81 0C
res = A - (SINT8)0x0c;
// C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
V = (A ^ (SINT8)0x0c) & (A ^ res);
// BGT $05DD ; 059B: 2E 40
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x05dd;
JUMP;
}
// LDA $03,X ; 059D: A6 03
A = memory[(UINT16)(X + 0x0003)];
// N = A;
// Z = A;
// V = 0;
// CMPA $02,X ; 059F: A1 02
res = A - memory[(UINT16)(X + 0x0002)];
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ memory[(UINT16)(X + 0x0002)]) & (A ^ res);
// BEQ $05DD ; 05A1: 27 3A
if (!Z) {
PC = 0x05dd;
JUMP;
}
// DECA ; 05A3: 4A
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
// LDB #$08 ; 05A4: C6 08
B = (SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
// MUL ; 05A6: 3D
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// LEAY $04,Y ; 05A7: 31 24
Y = (Y + 0x0004);
// Z = Y;
// LEAY D,Y ; 05A9: 31 AB
Y = (Y + D);
// Z = Y;
// LDB $04,X ; 05AB: E6 04
B = memory[(UINT16)(X + 0x0004)];
// N = B;
// Z = B;
// V = 0;
// LDA B,Y ; 05AD: A6 A5
A = memory[(UINT16)(Y + (SINT8)B)];
// N = A;
// Z = A;
// V = 0;
// SUBA $05,X ; 05AF: A0 05
A = (UINT8)(A - memory[(UINT16)(X + 0x0005)]);
res = A - memory[(UINT16)(X + 0x0005)];
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = ((A) ^ (memory[(UINT16)(X + 0x0005)])) & ((A) ^ res);
// BEQ $05DD ; 05B1: 27 2A
if (!Z) {
PC = 0x05dd;
JUMP;
}
// STA $05,X ; 05B3: A7 05
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0005)] = A;
// ADDB #$02 ; 05B5: CB 02
B = (UINT8)(B + (SINT8)0x02);
// res = B + (SINT8)0x02;
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = B ^ (SINT8)0x02 ^ res ^ C;
// H = res;
// V = res;
// ANDB #$03 ; 05B7: C4 03
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
// STB $04,X ; 05B9: E7 04
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0004)] = B;
// LEAY $FFFC,Y ; 05BB: 31 3C
Y = (Y + 0xfffc);
// Z = Y;
// INCB ; 05BD: 5C
res = (UINT8)((B) + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
// ANDB #$03 ; 05BE: C4 03
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
// LDA B,Y ; 05C0: A6 A5
A = memory[(UINT16)(Y + (SINT8)B)];
// N = A;
Z = A;
// V = 0;
// BNE $05CF ; 05C2: 26 0B
if (Z) {
PC = 0x05cf;
JUMP;
}
// INCB ; 05C4: 5C
res = (UINT8)((B) + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
// INCB ; 05C5: 5C
res = (UINT8)((B) + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
// ANDB #$03 ; 05C6: C4 03
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
// LDA B,Y ; 05C8: A6 A5
A = memory[(UINT16)(Y + (SINT8)B)];
// N = A;
Z = A;
// V = 0;
// BNE $05CF ; 05CA: 26 03
if (Z) {
PC = 0x05cf;
JUMP;
}
// INCB ; 05CC: 5C
res = (UINT8)((B) + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
// ANDB #$03 ; 05CD: C4 03
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
L05CF:// STB $FFFC,X ; 05CF: E7 1C
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0xfffc)] = B;
// NEG $08,X ; 05D1: 60 08
// V = (UINT8)(-memory[(UINT16)(X + 0x0008)]) & (memory[(UINT16)(X + 0x0008)]);
memory[(UINT16)(X + 0x0008)] = (UINT8)(-memory[(UINT16)(X + 0x0008)]);
// Z = memory[(UINT16)(X + 0x0008)];
// N = memory[(UINT16)(X + 0x0008)];
// C = memory[(UINT16)(X + 0x0008)];
// NEG $09,X ; 05D3: 60 09
// V = (UINT8)(-memory[(UINT16)(X + 0x0009)]) & (memory[(UINT16)(X + 0x0009)]);
memory[(UINT16)(X + 0x0009)] = (UINT8)(-memory[(UINT16)(X + 0x0009)]);
// Z = memory[(UINT16)(X + 0x0009)];
// N = memory[(UINT16)(X + 0x0009)];
// C = memory[(UINT16)(X + 0x0009)];
// CLR $FFFF,X ; 05D5: 6F 1F
memory[(UINT16)(X + 0xffff)] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LDD $02,X ; 05D7: EC 02
A = memory[(UINT16)(X + 0x0002)];
B = memory[(UINT16)(((UINT16)(X + 0x0002))+1)];
// Z = A|B;
// N = A;
// V = 0;
// STA $03,X ; 05D9: A7 03
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0003)] = A;
// STB $02,X ; 05DB: E7 02
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0002)] = B;
L05DD:// LDA $05,X ; 05DD: A6 05
A = memory[(UINT16)(X + 0x0005)];
// N = A;
// Z = A;
// V = 0;
// SUBA <$88 ; 05DF: 90 88
A = (UINT8)(A - memory_DP[0x88]);
res = A - memory_DP[0x88];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
// V = ((A) ^ (memory_DP[0x88])) & ((A) ^ res);
// BPL $05F3 ; 05E1: 2A 10
if ((SINT8)N >= 0) {
PC = 0x05f3;
JUMP;
}
// LEAY $09,X ; 05E3: 31 09
Y = (X + 0x0009);
// Z = Y;
// LDB ,Y ; 05E5: E6 A4
B = memory[Y];
// N = B;
Z = B;
// V = 0;
// BNE $05EB ; 05E7: 26 02
if (Z) {
PC = 0x05eb;
JUMP;
}
// LDB ,-Y ; 05E9: E6 A2
B = memory[--Y];
N = B;
// Z = B;
// V = 0;
L05EB:// BPL $05EE ; 05EB: 2A 01
if ((SINT8)N >= 0) {
PC = 0x05ee;
JUMP;
}
// NEGA ; 05ED: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
L05EE:// ADDA ,--Y ; 05EE: AB A3
Y = Y - 2;
A = (UINT8)(A + memory[Y]);
// res = A + memory[Y];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ memory[Y] ^ res ^ C;
// H = res;
// V = res;
// STA ,Y ; 05F0: A7 A4
// Z = A;
// N = A;
// V = 0;
memory[Y] = A;
// CLRA ; 05F2: 4F
A = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
L05F3:// STA $05,X ; 05F3: A7 05
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0005)] = A;
// LDD $06,X ; 05F5: EC 06
A = memory[(UINT16)(X + 0x0006)];
B = memory[(UINT16)(((UINT16)(X + 0x0006))+1)];
// Z = A|B;
// N = A;
// V = 0;
// ADDA $08,X ; 05F7: AB 08
A = (UINT8)(A + memory[(UINT16)(X + 0x0008)]);
// res = A + memory[(UINT16)(X + 0x0008)];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ memory[(UINT16)(X + 0x0008)] ^ res ^ C;
// H = res;
// V = res;
// ADDB $09,X ; 05F9: EB 09
B = (UINT8)(B + memory[(UINT16)(X + 0x0009)]);
res = B + memory[(UINT16)(X + 0x0009)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ memory[(UINT16)(X + 0x0009)] ^ res ^ C;
H = res;
// V = res;
// STD $06,X ; 05FB: ED 06
Z = A | B;
N = A;
V = 0;
memory[(UINT16)(X + 0x0006)] = A;
memory[(UINT16)(X + 0x0006) + 1] = B;
// JMP $04CF ; 05FD: 7E 04 CF
PC = 0x04cf;
JUMP;
L0600:// LDA $FFFB,X ; 0600: A6 1B
A = memory[(UINT16)(X + 0xfffb)];
// N = A;
Z = A;
// V = 0;
// BEQ $0618 ; 0602: 27 14
if (!Z) {
PC = 0x0618;
JUMP;
}
// LDB #$08 ; 0604: C6 08
B = (SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
// STB $05,X ; 0606: E7 05
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0005)] = B;
// SUBA $01,X ; 0608: A0 01
A = (UINT8)(A - memory[(UINT16)(X + 0x0001)]);
// res = A - memory[(UINT16)(X + 0x0001)];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((A) ^ (memory[(UINT16)(X + 0x0001)])) & ((A) ^ res);
// ANDA #$03 ; 060A: 84 03
A = A & (SINT8)0x03;
// Z = A;
// N = A;
// V = 0;
// STA $01,X ; 060C: A7 01
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0001)] = A;
// LDA $FFFB,X ; 060E: A6 1B
A = memory[(UINT16)(X + 0xfffb)];
// N = A;
// Z = A;
// V = 0;
// ANDA #$02 ; 0610: 84 02
A = A & (SINT8)0x02;
// Z = A;
// N = A;
// V = 0;
// ASRA ; 0612: 47
// C = A & 1;
A = (UINT8)(A >> 1);
// Z = A;
// N = A;
// STA $04,X ; 0613: A7 04
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0004)] = A;
// CLR $FFFB,X ; 0615: 6F 1B
memory[(UINT16)(X + 0xfffb)] = 0;
V = 0;
Z = 0;
N = 0;
C = 0;
// RTS ; 0617: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0618:// LDA $02,X ; 0618: A6 02
A = memory[(UINT16)(X + 0x0002)];
// N = A;
// Z = A;
// V = 0;
// DECA ; 061A: 4A
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
// LDB #$08 ; 061B: C6 08
B = (SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
// MUL ; 061D: 3D
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// LEAY D,Y ; 061E: 31 AB
Y = (Y + D);
// Z = Y;
// LDB $FFFC,X ; 0620: E6 1C
B = memory[(UINT16)(X + 0xfffc)];
N = B;
// Z = B;
// V = 0;
// BMI $0628 ; 0622: 2B 04
if ((SINT8)N < 0) {
PC = 0x0628;
JUMP;
}
// COM $FFFC,X ; 0624: 63 1C
memory[(UINT16)(X + 0xfffc)] = memory[(UINT16)(X + 0xfffc)] ^ 0xff;
Z = memory[(UINT16)(X + 0xfffc)];
N = memory[(UINT16)(X + 0xfffc)];
V = 0;
C = 1;
// BSR $065F ; 0626: 8D 37
memory[--S] = 0x0628 & 0xff; memory[--S] = 0x0628 >> 8;
PC = 0x065f;
JUMP;
L0628:// LDB $FFFE,X ; 0628: E6 1E
B = memory[(UINT16)(X + 0xfffe)];
// N = B;
// Z = B;
// V = 0;
// LSRB ; 062A: 54
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
// LSRB ; 062B: 54
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
// LSRB ; 062C: 54
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
// LSRB ; 062D: 54
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
// CMPB $01,X ; 062E: E1 01
res = B - memory[(UINT16)(X + 0x0001)];
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (B ^ memory[(UINT16)(X + 0x0001)]) & (B ^ res);
// BNE $0633 ; 0630: 26 01
if (Z) {
PC = 0x0633;
JUMP;
}
// NEGB ; 0632: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
// C = B;
L0633:// ADDB $01,X ; 0633: EB 01
B = (UINT8)(B + memory[(UINT16)(X + 0x0001)]);
res = B + memory[(UINT16)(X + 0x0001)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ memory[(UINT16)(X + 0x0001)] ^ res ^ C;
H = res;
// V = res;
// CMPB #$04 ; 0635: C1 04
res = B - (SINT8)0x04;
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (B ^ (SINT8)0x04) & (B ^ res);
// BNE $063B ; 0637: 26 02
if (Z) {
PC = 0x063b;
JUMP;
}
// LDB #$02 ; 0639: C6 02
B = (SINT8)0x02;
// N = B;
// Z = B;
// V = 0;
L063B:// ANDB #$03 ; 063B: C4 03
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
// TFR B,A ; 063D: 1F 98
A = B;
// INCA ; 063F: 4C
res = (UINT8)((A) + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
// PSHS B,A ; 0640: 34 06
memory[--S] = B;
memory[--S] = A;
// JSR Random ; 0642: BD F5 17
memory[--S] = 0x0645 & 0xff; memory[--S] = 0x0645 >> 8;
PC = 0xf517;
JUMP;
L0645:// PULS A,B ; 0645: 35 06
A = memory[S++];
B = memory[S++];
// BCC $064B ; 0647: 24 02
if (!C) {
PC = 0x064b;
JUMP;
}
// EXG A,B ; 0649: 1E 89
val = A;
A = B;
B = val;
L064B:// STA <$CB ; 064B: 97 CB
Z = A;
N = A;
V = 0;
memory_DP[0xcb] = A;
// BSR $065F ; 064D: 8D 10
memory[--S] = 0x064f & 0xff; memory[--S] = 0x064f >> 8;
PC = 0x065f;
JUMP;
L064F:// LDB <$CB ; 064F: D6 CB
B = memory_DP[0xcb];
N = B;
Z = B;
V = 0;
// BSR $065F ; 0651: 8D 0C
memory[--S] = 0x0653 & 0xff; memory[--S] = 0x0653 >> 8;
PC = 0x065f;
JUMP;
L0653:// LDB $04,X ; 0653: E6 04
B = memory[(UINT16)(X + 0x0004)];
N = B;
Z = B;
V = 0;
// BSR $065F ; 0655: 8D 08
memory[--S] = 0x0657 & 0xff; memory[--S] = 0x0657 >> 8;
PC = 0x065f;
JUMP;
L0657:// LDB #$03 ; 0657: C6 03
B = (SINT8)0x03;
N = B;
Z = B;
V = 0;
L0659:// BSR $065F ; 0659: 8D 04
memory[--S] = 0x065b & 0xff; memory[--S] = 0x065b >> 8;
PC = 0x065f;
JUMP;
L065B:// DECB ; 065B: 5A
res = (UINT8)(B - 1);
N = res;
Z = res;
V = B & ~res;
B = res;
// BPL $0659 ; 065C: 2A FB
if ((SINT8)N >= 0) {
PC = 0x0659;
JUMP;
}
// RTS ; 065E: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L065F:// ANDB #$03 ; 065F: C4 03
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
// LDA B,Y ; 0661: A6 A5
A = memory[(UINT16)(Y + (SINT8)B)];
// N = A;
Z = A;
// V = 0;
// BEQ $066D ; 0663: 27 08
if (!Z) {
PC = 0x066d;
JUMP;
}
// CMPA $03,X ; 0665: A1 03
res = A - memory[(UINT16)(X + 0x0003)];
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ memory[(UINT16)(X + 0x0003)]) & (A ^ res);
// BNE $066E ; 0667: 26 05
if (Z) {
PC = 0x066e;
JUMP;
}
// TST $FFFF,X ; 0669: 6D 1F
Z = memory[(UINT16)(X + 0xffff)];
N = memory[(UINT16)(X + 0xffff)];
V = 0;
// BEQ $0672 ; 066B: 27 05
if (!Z) {
PC = 0x0672;
JUMP;
}
L066D:// RTS ; 066D: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L066E:// CLR $FFFF,X ; 066E: 6F 1F
memory[(UINT16)(X + 0xffff)] = 0;
V = 0;
Z = 0;
N = 0;
C = 0;
// BRA $0674 ; 0670: 20 02
PC = 0x0674;
JUMP;
L0672:// INC $FFFF,X ; 0672: 6C 1F
res = (UINT8)((memory[(UINT16)(X + 0xffff)]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory[(UINT16)(X + 0xffff)]);
memory[(UINT16)(X + 0xffff)] = res;
L0674:// STD ,S++ ; 0674: ED E1
ea = S; S = S + 2;
// Z = A | B;
// N = A;
// V = 0;
memory[ea] = A;
memory[ea + 1] = B;
// CMPA $02,X ; 0676: A1 02
res = A - memory[(UINT16)(X + 0x0002)];
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ memory[(UINT16)(X + 0x0002)]) & (A ^ res);
// BNE $0683 ; 0678: 26 09
if (Z) {
PC = 0x0683;
JUMP;
}
// RORB ; 067A: 56
res = B;
res = res | (C != 0) ? 0x100 : 0;
C = res & 1;
res = res >> 1;
// Z = res;
// N = res;
B = res;
// BCS $067F ; 067B: 25 02
if (C) {
PC = 0x067f;
JUMP;
}
// ADDB #$02 ; 067D: CB 02
B = (UINT8)(B + (SINT8)0x02);
// res = B + (SINT8)0x02;
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = B ^ (SINT8)0x02 ^ res ^ C;
// H = res;
// V = res;
L067F:// ADDB #$02 ; 067F: CB 02
B = (UINT8)(B + (SINT8)0x02);
res = B + (SINT8)0x02;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ (SINT8)0x02 ^ res ^ C;
H = res;
// V = res;
// STB $FFFB,X ; 0681: E7 1B
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0xfffb)] = B;
L0683:// LDA $02,X ; 0683: A6 02
A = memory[(UINT16)(X + 0x0002)];
// N = A;
// Z = A;
// V = 0;
// STA $03,X ; 0685: A7 03
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0003)] = A;
// LDD $FFFE,S ; 0687: EC 7E
A = memory[(UINT16)(S + 0xfffe)];
B = memory[(UINT16)(((UINT16)(S + 0xfffe))+1)];
// Z = A|B;
// N = A;
// V = 0;
// STA $02,X ; 0689: A7 02
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0002)] = A;
// LEAY B,Y ; 068B: 31 A5
Y = (Y + (SINT8)B);
// Z = Y;
// LDA $04,Y ; 068D: A6 24
A = memory[(UINT16)(Y + 0x0004)];
// N = A;
// Z = A;
// V = 0;
// STA $05,X ; 068F: A7 05
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0005)] = A;
// TFR B,A ; 0691: 1F 98
A = B;
// SUBB $04,X ; 0693: E0 04
B = (UINT8)(B - memory[(UINT16)(X + 0x0004)]);
// res = B - memory[(UINT16)(X + 0x0004)];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((B) ^ (memory[(UINT16)(X + 0x0004)])) & ((B) ^ res);
// ANDB #$03 ; 0695: C4 03
B = B & (SINT8)0x03;
Z = B;
// N = B;
// V = 0;
// BEQ $06A5 ; 0697: 27 0C
if (!Z) {
PC = 0x06a5;
JUMP;
}
// STA $04,X ; 0699: A7 04
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0004)] = A;
// CMPB #$02 ; 069B: C1 02
res = B - (SINT8)0x02;
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (B ^ (SINT8)0x02) & (B ^ res);
// BNE $06A6 ; 069D: 26 07
if (Z) {
PC = 0x06a6;
JUMP;
}
// LDD $08,X ; 069F: EC 08
A = memory[(UINT16)(X + 0x0008)];
B = memory[(UINT16)(((UINT16)(X + 0x0008))+1)];
// Z = A|B;
// N = A;
// V = 0;
// NEGA ; 06A1: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
L06A2:// NEGB ; 06A2: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
C = B;
L06A3:// STD $08,X ; 06A3: ED 08
Z = A | B;
N = A;
V = 0;
memory[(UINT16)(X + 0x0008)] = A;
memory[(UINT16)(X + 0x0008) + 1] = B;
L06A5:// RTS ; 06A5: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L06A6:// LDA #$10 ; 06A6: 86 10
A = (SINT8)0x10;
// N = A;
// Z = A;
// V = 0;
// STA ,X ; 06A8: A7 84
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
// LDA $01,X ; 06AA: A6 01
A = memory[(UINT16)(X + 0x0001)];
// N = A;
// Z = A;
// V = 0;
// RORA ; 06AC: 46
res = A;
res = res | (C != 0) ? 0x100 : 0;
C = res & 1;
res = res >> 1;
// Z = res;
// N = res;
A = res;
// BCC $06B3 ; 06AD: 24 04
if (!C) {
PC = 0x06b3;
JUMP;
}
// ADDB #$02 ; 06AF: CB 02
B = (UINT8)(B + (SINT8)0x02);
res = B + (SINT8)0x02;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ (SINT8)0x02 ^ res ^ C;
H = res;
// V = res;
// ANDB #$03 ; 06B1: C4 03
B = B & (SINT8)0x03;
// Z = B;
// N = B;
// V = 0;
L06B3:// LDA <$89 ; 06B3: 96 89
A = memory_DP[0x89];
// N = A;
// Z = A;
// V = 0;
// STA $FFFD,X ; 06B5: A7 1D
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0xfffd)] = A;
// LDA $09,X ; 06B7: A6 09
A = memory[(UINT16)(X + 0x0009)];
// N = A;
// Z = A;
// V = 0;
// PSHS B ; 06B9: 34 04
memory[--S] = B;
// LDB $08,X ; 06BB: E6 08
B = memory[(UINT16)(X + 0x0008)];
// N = B;
// Z = B;
// V = 0;
// DEC ,S+ ; 06BD: 6A E0
res = (UINT8)(memory[S++] - 1);
// N = res;
Z = res;
// V = memory[S++] & ~res;
memory[S++] = res;
// BEQ $06A2 ; 06BF: 27 E1
if (!Z) {
PC = 0x06a2;
JUMP;
}
// NEGA ; 06C1: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
// NEG $FFFD,X ; 06C2: 60 1D
V = (UINT8)(-memory[(UINT16)(X + 0xfffd)]) & (memory[(UINT16)(X + 0xfffd)]);
memory[(UINT16)(X + 0xfffd)] = (UINT8)(-memory[(UINT16)(X + 0xfffd)]);
Z = memory[(UINT16)(X + 0xfffd)];
N = memory[(UINT16)(X + 0xfffd)];
C = memory[(UINT16)(X + 0xfffd)];
// BRA $06A3 ; 06C4: 20 DD
PC = 0x06a3;
JUMP;
L06C6:// LDX #$CA00 ; 06C6: 8E CA 00
X = 0xca00;
// Z = X;
// N = (X) >> 8;
// V = 0;
// CLRA ; 06C9: 4F
A = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// STA <$DA ; 06CA: 97 DA
// Z = A;
// N = A;
// V = 0;
memory_DP[0xda] = A;
// LDY #$CA4E ; 06CC: 10 8E CA 4E
Y = 0xca4e;
Z = Y;
N = (Y) >> 8;
V = 0;
L06D0:// BSR $0711 ; 06D0: 8D 3F
memory[--S] = 0x06d2 & 0xff; memory[--S] = 0x06d2 >> 8;
PC = 0x0711;
JUMP;
L06D2:// LDA #$02 ; 06D2: 86 02
A = (SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
// STA <$DA ; 06D4: 97 DA
// Z = A;
// N = A;
// V = 0;
memory_DP[0xda] = A;
// LEAY $04,Y ; 06D6: 31 24
Y = (Y + 0x0004);
// Z = Y;
// LEAX $27,X ; 06D8: 30 88 27
X = (X + (SINT8)0x27);
// Z = X;
// CMPX #$CA4E ; 06DB: 8C CA 4E
res = (X) - (0xca4e);
C = res & 0x10000;
res = (UINT16)res;
Z = res;
N = res >> 8;
V = (((X) ^ (0xca4e)) & ((X) ^ res)) >> 8;
// BNE $06D0 ; 06DE: 26 F0
if (Z) {
PC = 0x06d0;
JUMP;
}
// RTS ; 06E0: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L06E1:// LDB $03,X ; 06E1: E6 03
B = memory[(UINT16)(X + 0x0003)];
// N = B;
// Z = B;
// V = 0;
// CMPA #$80 ; 06E3: 81 80
res = A - (SINT8)0x80;
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ (SINT8)0x80) & (A ^ res);
// BNE $06EF ; 06E5: 26 08
if (Z) {
PC = 0x06ef;
JUMP;
}
// LDB #$02 ; 06E7: C6 02
B = (SINT8)0x02;
// N = B;
// Z = B;
// V = 0;
// STB $04,X ; 06E9: E7 04
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0004)] = B;
// LDB #$01 ; 06EB: C6 01
B = (SINT8)0x01;
// N = B;
// Z = B;
// V = 0;
// STB $03,X ; 06ED: E7 03
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0003)] = B;
L06EF:// INCA ; 06EF: 4C
res = (UINT8)((A) + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
// STA ,X ; 06F0: A7 84
Z = A;
// N = A;
// V = 0;
memory[X] = A;
// BNE $06FB ; 06F2: 26 07
if (Z) {
PC = 0x06fb;
JUMP;
}
// DEC <$C7 ; 06F4: 0A C7
res = (UINT8)(memory_DP[0xc7] - 1);
// N = res;
Z = res;
// V = memory_DP[0xc7] & ~res;
memory_DP[0xc7] = res;
// BNE $06FA ; 06F6: 26 02
if (Z) {
PC = 0x06fa;
JUMP;
}
// DEC <$E2 ; 06F8: 0A E2
res = (UINT8)(memory_DP[0xe2] - 1);
N = res;
Z = res;
V = memory_DP[0xe2] & ~res;
memory_DP[0xe2] = res;
L06FA:// RTS ; 06FA: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L06FB:// CMPA #$C2 ; 06FB: 81 C2
res = A - (SINT8)0xc2;
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (A ^ (SINT8)0xc2) & (A ^ res);
// BNE $0701 ; 06FD: 26 02
if (Z) {
PC = 0x0701;
JUMP;
}
// NEG $04,X ; 06FF: 60 04
// V = (UINT8)(-memory[(UINT16)(X + 0x0004)]) & (memory[(UINT16)(X + 0x0004)]);
memory[(UINT16)(X + 0x0004)] = (UINT8)(-memory[(UINT16)(X + 0x0004)]);
// Z = memory[(UINT16)(X + 0x0004)];
// N = memory[(UINT16)(X + 0x0004)];
// C = memory[(UINT16)(X + 0x0004)];
L0701:// ASRA ; 0701: 47
C = A & 1;
A = (UINT8)(A >> 1);
// Z = A;
// N = A;
// BCS $06FA ; 0702: 25 F6
if (C) {
PC = 0x06fa;
JUMP;
}
// ADDB $04,X ; 0704: EB 04
B = (UINT8)(B + memory[(UINT16)(X + 0x0004)]);
res = B + memory[(UINT16)(X + 0x0004)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ memory[(UINT16)(X + 0x0004)] ^ res ^ C;
H = res;
// V = res;
// STB $03,X ; 0706: E7 03
Z = B;
N = B;
V = 0;
memory[(UINT16)(X + 0x0003)] = B;
// RTS ; 0708: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0709:// LDA $05,X ; 0709: A6 05
A = memory[(UINT16)(X + 0x0005)];
// N = A;
// Z = A;
// V = 0;
// INCA ; 070B: 4C
res = (UINT8)((A) + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
// ANDA #$03 ; 070C: 84 03
A = A & (SINT8)0x03;
// Z = A;
// N = A;
// V = 0;
// STA $05,X ; 070E: A7 05
Z = A;
N = A;
V = 0;
memory[(UINT16)(X + 0x0005)] = A;
L0710:// RTS ; 0710: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0711:// LDA ,X ; 0711: A6 84
A = memory[X];
N = A;
Z = A;
// V = 0;
// BMI $06E1 ; 0713: 2B CC
if ((SINT8)N < 0) {
PC = 0x06e1;
JUMP;
}
// BEQ $0710 ; 0715: 27 F9
if (!Z) {
PC = 0x0710;
JUMP;
}
// PSHS X ; 0717: 34 10
memory[--S] = X & 0xff; memory[--S] = X >> 8;
// LDA $03,X ; 0719: A6 03
A = memory[(UINT16)(X + 0x0003)];
// N = A;
Z = A;
// V = 0;
// BEQ $0721 ; 071B: 27 04
if (!Z) {
PC = 0x0721;
JUMP;
}
// DEC $03,X ; 071D: 6A 03
res = (UINT8)(memory[(UINT16)(X + 0x0003)] - 1);
// N = res;
Z = res;
// V = memory[(UINT16)(X + 0x0003)] & ~res;
memory[(UINT16)(X + 0x0003)] = res;
// BNE $0771 ; 071F: 26 50
if (Z) {
PC = 0x0771;
JUMP;
}
L0721:// LDA $03,Y ; 0721: A6 23
A = memory[(UINT16)(Y + 0x0003)];
// N = A;
Z = A;
// V = 0;
// BEQ $0771 ; 0723: 27 4C
if (!Z) {
PC = 0x0771;
JUMP;
}
// LDB <$DA ; 0725: D6 DA
B = memory_DP[0xda];
// N = B;
// Z = B;
// V = 0;
// LDU $01,X ; 0727: EE 01
U = ((memory[(UINT16)(X + 0x0001)]<<8)|memory[(UINT16)(((UINT16)(X + 0x0001))+1)]);
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDA ,U ; 0729: A6 C4
A = memory[U];
// N = A;
Z = A;
// V = 0;
// BEQ $0734 ; 072B: 27 07
if (!Z) {
PC = 0x0734;
JUMP;
}
// INCB ; 072D: 5C
res = (UINT8)((B) + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
// LEAU $07,U ; 072E: 33 47
U = (U + 0x0007);
// LDA ,U ; 0730: A6 C4
A = memory[U];
// N = A;
Z = A;
// V = 0;
// BNE $0771 ; 0732: 26 3D
if (Z) {
PC = 0x0771;
JUMP;
}
L0734:// STB <$CB ; 0734: D7 CB
// Z = B;
// N = B;
// V = 0;
memory_DP[0xcb] = B;
// DEC ,U ; 0736: 6A C4
res = (UINT8)(memory[U] - 1);
// N = res;
// Z = res;
// V = memory[U] & ~res;
memory[U] = res;
// LDA #$10 ; 0738: 86 10
A = (SINT8)0x10;
// N = A;
// Z = A;
// V = 0;
// ORA <$67 ; 073A: 9A 67
A = A | memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
// STA <$67 ; 073C: 97 67
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
// LDA $06,X ; 073E: A6 06
A = memory[(UINT16)(X + 0x0006)];
// N = A;
// Z = A;
// V = 0;
// LDB $08,X ; 0740: E6 08
B = memory[(UINT16)(X + 0x0008)];
// N = B;
// Z = B;
// V = 0;
// STD $01,U ; 0742: ED 41
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0x0001)] = A;
memory[(UINT16)(U + 0x0001) + 1] = B;
// LDB $0A,X ; 0744: E6 0A
B = memory[(UINT16)(X + 0x000a)];
// N = B;
// Z = B;
// V = 0;
// JSR $04EB ; 0746: BD 04 EB
memory[--S] = 0x0749 & 0xff; memory[--S] = 0x0749 >> 8;
PC = 0x04eb;
JUMP;
L0749:// LDA #$08 ; 0749: 86 08
A = (SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
// STA $03,X ; 074B: A7 03
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0003)] = A;
// LDB #$0A ; 074D: C6 0A
B = (SINT8)0x0a;
// N = B;
// Z = B;
// V = 0;
// LDA <$CB ; 074F: 96 CB
A = memory_DP[0xcb];
// N = A;
// Z = A;
// V = 0;
// MUL ; 0751: 3D
res = (UINT16)(A * B);
// Z = res;
C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// LDU #$CA56 ; 0752: CE CA 56
U = 0xca56;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LEAU B,U ; 0755: 33 C5
U = (U + (SINT8)B);
// LDA $0A,X ; 0757: A6 0A
A = memory[(UINT16)(X + 0x000a)];
// N = A;
// Z = A;
// V = 0;
// LDX #$0D7B ; 0759: 8E 0D 7B
X = 0x0d7b;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDB #$04 ; 075C: C6 04
B = (SINT8)0x04;
// N = B;
// Z = B;
// V = 0;
// JSR Rot_VL_ab ; 075E: BD F6 10
memory[--S] = 0x0761 & 0xff; memory[--S] = 0x0761 >> 8;
PC = 0xf610;
JUMP;
DP = 0xc8 << 8; memory_DP = &memory[DP]; // Unfortunately this should be inserted after the label below.
L0761:// LDA <$EF ; 0761: 96 EF
A = memory_DP[0xef];
N = A;
// Z = A;
// V = 0;
// BMI $076F ; 0763: 2B 0A
if ((SINT8)N < 0) {
PC = 0x076f;
JUMP;
}
// LDA #$80 ; 0765: 86 80
A = (SINT8)0x80;
// N = A;
// Z = A;
// V = 0;
// ORA <$67 ; 0767: 9A 67
A = A | memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
// STA <$67 ; 0769: 97 67
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
// LDA #$20 ; 076B: 86 20
A = (SINT8)0x20;
// N = A;
// Z = A;
// V = 0;
// STA <$EF ; 076D: 97 EF
Z = A;
N = A;
V = 0;
memory_DP[0xef] = A;
L076F:// PULS X,PC ; 076F: 35 90 ;(PUL? PC=RTS)
X = memory[S++]<<8;
X |= memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
L0771:// LDA $02,Y ; 0771: A6 22
A = memory[(UINT16)(Y + 0x0002)];
// N = A;
Z = A;
// V = 0;
// BEQ $07CD ; 0773: 27 58
if (!Z) {
PC = 0x07cd;
JUMP;
}
// LDB $04,X ; 0775: E6 04
B = memory[(UINT16)(X + 0x0004)];
// N = B;
// Z = B;
// V = 0;
// SEX ; 0777: 1D
// Z = B;
// N = B & 0x80;
A = ((B & 0x80) != 0) ? 0xff : 0;
// ASLB ; 0778: 58
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
// ROLA ; 0779: 49
res = ((A) << 1) + (C != 0);
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// ASLB ; 077A: 58
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
// ROLA ; 077B: 49
res = ((A) << 1) + (C != 0);
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// ASLB ; 077C: 58
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
// ROLA ; 077D: 49
res = ((A) << 1) + (C != 0);
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// STD <$CB ; 077E: DD CB
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcb] = A;
memory_DP[0xcb + 1] = B;
// ADDD $06,X ; 0780: E3 06
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);
// STD $06,X ; 0782: ED 06
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0006)] = A;
memory[(UINT16)(X + 0x0006) + 1] = B;
// LDB $05,X ; 0784: E6 05
B = memory[(UINT16)(X + 0x0005)];
// N = B;
// Z = B;
// V = 0;
// SEX ; 0786: 1D
// Z = B;
// N = B & 0x80;
A = ((B & 0x80) != 0) ? 0xff : 0;
// ASLB ; 0787: 58
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
// ROLA ; 0788: 49
res = ((A) << 1) + (C != 0);
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// ASLB ; 0789: 58
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
// ROLA ; 078A: 49
res = ((A) << 1) + (C != 0);
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// ASLB ; 078B: 58
res = B << 1;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = B ^ res;
B = res;
// ROLA ; 078C: 49
res = ((A) << 1) + (C != 0);
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// STD <$CD ; 078D: DD CD
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcd] = A;
memory_DP[0xcd + 1] = B;
// ADDD $08,X ; 078F: E3 08
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);
// STD $08,X ; 0791: ED 08
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0008)] = A;
memory[(UINT16)(X + 0x0008) + 1] = B;
// CLRB ; 0793: 5F
B = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LDA $06,X ; 0794: A6 06
A = memory[(UINT16)(X + 0x0006)];
N = A;
// Z = A;
// V = 0;
// BPL $079A ; 0796: 2A 02
if ((SINT8)N >= 0) {
PC = 0x079a;
JUMP;
}
// NEGA ; 0798: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
// INCB ; 0799: 5C
res = (UINT8)((B) + 1);
// Z = res;
// N = res;
// V = res & ~(B);
B = res;
L079A:// STA <$DB ; 079A: 97 DB
// Z = A;
// N = A;
// V = 0;
memory_DP[0xdb] = A;
// LDA $08,X ; 079C: A6 08
A = memory[(UINT16)(X + 0x0008)];
N = A;
// Z = A;
// V = 0;
// BPL $07A3 ; 079E: 2A 03
if ((SINT8)N >= 0) {
PC = 0x07a3;
JUMP;
}
// NEGA ; 07A0: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
C = A;
// ORB #$02 ; 07A1: CA 02
B = B | (SINT8)0x02;
// Z = B;
// N = B;
// V = 0;
L07A3:// STA <$DC ; 07A3: 97 DC
// Z = A;
// N = A;
// V = 0;
memory_DP[0xdc] = A;
// PSHS B ; 07A5: 34 04
memory[--S] = B;
// LDB <$DB ; 07A7: D6 DB
B = memory_DP[0xdb];
// N = B;
// Z = B;
// V = 0;
// LDU #$0F6A ; 07A9: CE 0F 6A
U = 0x0f6a;
Z = U;
N = (U) >> 8;
V = 0;
// BSR $081C ; 07AC: 8D 6E
memory[--S] = 0x07ae & 0xff; memory[--S] = 0x07ae >> 8;
PC = 0x081c;
JUMP;
L07AE:// BVC $07B2 ; 07AE: 28 02
if ((SINT8)V >= 0) {
PC = 0x07b2;
JUMP;
}
// STB <$DB ; 07B0: D7 DB
// Z = B;
// N = B;
// V = 0;
memory_DP[0xdb] = B;
L07B2:// LDB <$DC ; 07B2: D6 DC
B = memory_DP[0xdc];
// N = B;
// Z = B;
// V = 0;
// LDU #$0F20 ; 07B4: CE 0F 20
U = 0x0f20;
Z = U;
N = (U) >> 8;
V = 0;
// BSR $081C ; 07B7: 8D 63
memory[--S] = 0x07b9 & 0xff; memory[--S] = 0x07b9 >> 8;
PC = 0x081c;
JUMP;
L07B9:// BVC $07BD ; 07B9: 28 02
if ((SINT8)V >= 0) {
PC = 0x07bd;
JUMP;
}
// STB <$DC ; 07BB: D7 DC
// Z = B;
// N = B;
// V = 0;
memory_DP[0xdc] = B;
L07BD:// LDD <$DB ; 07BD: DC DB
A = memory_DP[0xdb];
B = memory_DP[0xdb + 1];
// Z = A|B;
// N = A;
// V = 0;
// ROR ,S ; 07BF: 66 E4
res = memory[S];
res = res | (C != 0) ? 0x100 : 0;
C = res & 1;
res = res >> 1;
// Z = res;
// N = res;
memory[S] = res;
// BCC $07C4 ; 07C1: 24 01
if (!C) {
PC = 0x07c4;
JUMP;
}
// NEGA ; 07C3: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
C = A;
L07C4:// STA $06,X ; 07C4: A7 06
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0006)] = A;
// ROR ,S+ ; 07C6: 66 E0
res = memory[S++];
res = res | (C != 0) ? 0x100 : 0;
C = res & 1;
res = res >> 1;
// Z = res;
// N = res;
memory[S++] = res;
// BCC $07CB ; 07C8: 24 01
if (!C) {
PC = 0x07cb;
JUMP;
}
// NEGB ; 07CA: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
// C = B;
L07CB:// STB $08,X ; 07CB: E7 08
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0008)] = B;
L07CD:// CLRA ; 07CD: 4F
A = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LDB ,Y ; 07CE: E6 A4
B = memory[Y];
// N = B;
Z = B;
// V = 0;
// BEQ $07D3 ; 07D0: 27 01
if (!Z) {
PC = 0x07d3;
JUMP;
}
// INCA ; 07D2: 4C
res = (UINT8)((A) + 1);
// Z = res;
// N = res;
// V = res & ~(A);
A = res;
L07D3:// LDB $01,Y ; 07D3: E6 21
B = memory[(UINT16)(Y + 0x0001)];
// N = B;
Z = B;
// V = 0;
// BEQ $07D8 ; 07D5: 27 01
if (!Z) {
PC = 0x07d8;
JUMP;
}
// DECA ; 07D7: 4A
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
L07D8:// TSTA ; 07D8: 4D
Z = A;
// N = A;
// V = 0;
// BEQ $07FA ; 07D9: 27 1F
if (!Z) {
PC = 0x07fa;
JUMP;
}
// ADDA $0A,X ; 07DB: AB 0A
A = (UINT8)(A + memory[(UINT16)(X + 0x000a)]);
res = A + memory[(UINT16)(X + 0x000a)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = A ^ memory[(UINT16)(X + 0x000a)] ^ res ^ C;
H = res;
// V = res;
// ANDA #$3F ; 07DD: 84 3F
A = A & (SINT8)0x3f;
// Z = A;
// N = A;
// V = 0;
// STA $0A,X ; 07DF: A7 0A
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x000a)] = A;
// TFR A,B ; 07E1: 1F 89
B = A;
// LDA #$20 ; 07E3: 86 20
A = (SINT8)0x20;
// N = A;
// Z = A;
// V = 0;
// JSR Rise_Run_X ; 07E5: BD F5 FF
memory[--S] = 0x07e8 & 0xff; memory[--S] = 0x07e8 >> 8;
PC = 0xf5ff;
JUMP;
L07E8:// STD $04,X ; 07E8: ED 04
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0004)] = A;
memory[(UINT16)(X + 0x0004) + 1] = B;
// LDA <$DA ; 07EA: 96 DA
A = memory_DP[0xda];
// N = A;
// Z = A;
// V = 0;
// LDB #$0E ; 07EC: C6 0E
B = (SINT8)0x0e;
// N = B;
// Z = B;
// V = 0;
// MUL ; 07EE: 3D
res = (UINT16)(A * B);
// Z = res;
C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// LDA $0A,X ; 07EF: A6 0A
A = memory[(UINT16)(X + 0x000a)];
// N = A;
// Z = A;
// V = 0;
// LEAU $0B,X ; 07F1: 33 0B
U = (X + 0x000b);
// LDX #$0D46 ; 07F3: 8E 0D 46
X = 0x0d46;
Z = X;
N = (X) >> 8;
V = 0;
// ABX ; 07F6: 3A
X = X + B;
// JSR Rot_VL_Mode_a ; 07F7: BD F6 1F
memory[--S] = 0x07fa & 0xff; memory[--S] = 0x07fa >> 8;
PC = 0xf61f;
JUMP;
L07FA:// PULS X,PC ; 07FA: 35 90 ;(PUL? PC=RTS)
X = memory[S++]<<8;
X |= memory[S++];
PC = memory[S++]<<8;
PC |= memory[S++];
L081C:// SUBB #$0A ; 081C: C0 0A
B = (UINT8)(B - (SINT8)0x0a);
res = B - (SINT8)0x0a;
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
// V = ((B) ^ ((SINT8)0x0a)) & ((B) ^ res);
// BMI $084A ; 081E: 2B 2A
if ((SINT8)N < 0) {
PC = 0x084a;
JUMP;
}
// ANDB #$70 ; 0820: C4 70
B = B & (SINT8)0x70;
// Z = B;
// N = B;
// V = 0;
// ASRB ; 0822: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// ASRB ; 0823: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// ASRB ; 0824: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// LDD B,U ; 0825: EC C5
A = memory[(UINT16)(U + (SINT8)B)];
B = memory[(UINT16)(((UINT16)(U + (SINT8)B))+1)];
// Z = A|B;
// N = A;
// V = 0;
// LEAU A,U ; 0827: 33 C6
U = (U + (SINT8)A);
// STB <$DD ; 0829: D7 DD
// Z = B;
// N = B;
// V = 0;
memory_DP[0xdd] = B;
L082B:// LDD <$DB ; 082B: DC DB
A = memory_DP[0xdb];
B = memory_DP[0xdb + 1];
// Z = A|B;
// N = A;
// V = 0;
// SUBA ,U ; 082D: A0 C4
A = (UINT8)(A - memory[U]);
res = A - memory[U];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
// V = ((A) ^ (memory[U])) & ((A) ^ res);
// BMI $0842 ; 082F: 2B 11
if ((SINT8)N < 0) {
PC = 0x0842;
JUMP;
}
// CMPA $01,U ; 0831: A1 41
res = A - memory[(UINT16)(U + 0x0001)];
// C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
V = (A ^ memory[(UINT16)(U + 0x0001)]) & (A ^ res);
// BGT $0842 ; 0833: 2E 0D
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0842;
JUMP;
}
// SUBB $02,U ; 0835: E0 42
B = (UINT8)(B - memory[(UINT16)(U + 0x0002)]);
res = B - memory[(UINT16)(U + 0x0002)];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
// V = ((B) ^ (memory[(UINT16)(U + 0x0002)])) & ((B) ^ res);
// BMI $0842 ; 0837: 2B 09
if ((SINT8)N < 0) {
PC = 0x0842;
JUMP;
}
// CMPB $03,U ; 0839: E1 43
res = B - memory[(UINT16)(U + 0x0003)];
C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
V = (B ^ memory[(UINT16)(U + 0x0003)]) & (B ^ res);
// BGT $0842 ; 083B: 2E 05
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0842;
JUMP;
}
// LDB $04,U ; 083D: E6 44
B = memory[(UINT16)(U + 0x0004)];
N = B;
Z = B;
// V = 0;
// ORCC #$02 ; 083F: 1A 02
V = 1;
// RTS ; 0841: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0842:// LEAU $05,U ; 0842: 33 45
U = (U + 0x0005);
// DEC <$DD ; 0844: 0A DD
res = (UINT8)(memory_DP[0xdd] - 1);
N = res;
Z = res;
// V = memory_DP[0xdd] & ~res;
memory_DP[0xdd] = res;
// BNE $082B ; 0846: 26 E3
if (Z) {
PC = 0x082b;
JUMP;
}
// ANDCC #$FD ; 0848: 1C FD
V = 0;
L084A:// RTS ; 084A: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L084B:// LDU #$CA00 ; 084B: CE CA 00
U = 0xca00;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDY #$C9C0 ; 084E: 10 8E C9 C0
Y = 0xc9c0;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
// LDX #$0D46 ; 0852: 8E 0D 46
X = 0x0d46;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDA <$C8 ; 0855: 96 C8
A = memory_DP[0xc8];
// N = A;
// Z = A;
// V = 0;
// STA <$C7 ; 0857: 97 C7
// Z = A;
// N = A;
// V = 0;
memory_DP[0xc7] = A;
// LDB #$20 ; 0859: C6 20
B = (SINT8)0x20;
// N = B;
// Z = B;
// V = 0;
L085B:// PSHS B,A ; 085B: 34 06
memory[--S] = B;
memory[--S] = A;
// STA ,U+ ; 085D: A7 C0
// Z = A;
// N = A;
// V = 0;
memory[U++] = A;
// STY ,U++ ; 085F: 10 AF C1
ea = U; U = U + 2;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
memory[ea] = (UINT8)((Y) >> 8);
memory[(UINT16)(ea + 1)] = (UINT8)((Y) & 0xff);
// LDB #$08 ; 0862: C6 08
B = (SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
L0864:// CLR ,U+ ; 0864: 6F C0
memory[U++] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// DECB ; 0866: 5A
res = (UINT8)(B - 1);
// N = res;
Z = res;
// V = B & ~res;
B = res;
// BNE $0864 ; 0867: 26 FB
if (Z) {
PC = 0x0864;
JUMP;
}
// LDD ,S ; 0869: EC E4
A = memory[S];
B = memory[(UINT16)((S)+1)];
// Z = A|B;
// N = A;
// V = 0;
// STD $FFFA,U ; 086B: ED 5A
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(U + 0xfffa)] = A;
memory[(UINT16)(U + 0xfffa) + 1] = B;
// JSR Rot_VL_Mode_a ; 086D: BD F6 1F
memory[--S] = 0x0870 & 0xff; memory[--S] = 0x0870 >> 8;
PC = 0xf61f;
JUMP;
L0870:// LEAY $0E,Y ; 0870: 31 2E
Y = (Y + 0x000e);
// Z = Y;
// PULS A,B ; 0872: 35 06
A = memory[S++];
B = memory[S++];
// NEGB ; 0874: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
C = B;
// DECA ; 0875: 4A
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
// BNE $085B ; 0876: 26 E3
if (Z) {
PC = 0x085b;
JUMP;
}
// RTS ; 0878: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0879:// NEGA ; 0879: 40
V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
// BVC $088D ; 087A: 28 11
if ((SINT8)V >= 0) {
PC = 0x088d;
JUMP;
}
// DECA ; 087C: 4A
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
// CLRB ; 087D: 5F
B = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// STD <$92 ; 087E: DD 92
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x92] = A;
memory_DP[0x92 + 1] = B;
// ASR <$A3 ; 0880: 07 A3
// C = memory_DP[0xa3] & 1;
memory_DP[0xa3] = (UINT8)(memory_DP[0xa3] >> 1);
// Z = memory_DP[0xa3];
// N = memory_DP[0xa3];
// ASR <$A4 ; 0882: 07 A4
// C = memory_DP[0xa4] & 1;
memory_DP[0xa4] = (UINT8)(memory_DP[0xa4] >> 1);
// Z = memory_DP[0xa4];
// N = memory_DP[0xa4];
// DECB ; 0884: 5A
res = (UINT8)(B - 1);
// N = res;
// Z = res;
// V = B & ~res;
B = res;
// STB <$EF ; 0885: D7 EF
// Z = B;
// N = B;
// V = 0;
memory_DP[0xef] = B;
// LDA #$80 ; 0887: 86 80
A = (SINT8)0x80;
// N = A;
// Z = A;
// V = 0;
// ORA <$67 ; 0889: 9A 67
A = A | memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
// STA <$67 ; 088B: 97 67
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
L088D:// INC <$94 ; 088D: 0C 94
res = (UINT8)((memory_DP[0x94]) + 1);
Z = res;
// N = res;
// V = res & ~(memory_DP[0x94]);
memory_DP[0x94] = res;
// BNE $089A ; 088F: 26 09
if (Z) {
PC = 0x089a;
JUMP;
}
// CLR <$EF ; 0891: 0F EF
memory_DP[0xef] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// LDA #$F7 ; 0893: 86 F7
A = (SINT8)0xf7;
// N = A;
// Z = A;
// V = 0;
// ANDA <$67 ; 0895: 94 67
A = A & memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
// STA <$67 ; 0897: 97 67
Z = A;
N = A;
V = 0;
memory_DP[0x67] = A;
// RTS ; 0899: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L089A:// RORA ; 089A: 46
res = A;
res = res | (C != 0) ? 0x100 : 0;
C = res & 1;
res = res >> 1;
// Z = res;
// N = res;
A = res;
// BCC $08B7 ; 089B: 24 1A
if (!C) {
PC = 0x08b7;
JUMP;
}
// INC <$A5 ; 089D: 0C A5
res = (UINT8)((memory_DP[0xa5]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0xa5]);
memory_DP[0xa5] = res;
// DEC <$A6 ; 089F: 0A A6
res = (UINT8)(memory_DP[0xa6] - 1);
// N = res;
// Z = res;
// V = memory_DP[0xa6] & ~res;
memory_DP[0xa6] = res;
// RORA ; 08A1: 46
res = A;
res = res | (C != 0) ? 0x100 : 0;
C = res & 1;
res = res >> 1;
// Z = res;
// N = res;
A = res;
// BCC $08A8 ; 08A2: 24 04
if (!C) {
PC = 0x08a8;
JUMP;
}
// DEC <$92 ; 08A4: 0A 92
res = (UINT8)(memory_DP[0x92] - 1);
// N = res;
// Z = res;
// V = memory_DP[0x92] & ~res;
memory_DP[0x92] = res;
// INC <$93 ; 08A6: 0C 93
res = (UINT8)((memory_DP[0x93]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0x93]);
memory_DP[0x93] = res;
L08A8:// LDA <$A6 ; 08A8: 96 A6
A = memory_DP[0xa6];
// N = A;
// Z = A;
// V = 0;
// LEAU $0A,X ; 08AA: 33 0A
U = (X + 0x000a);
// LDX #$0FCE ; 08AC: 8E 0F CE
X = 0x0fce;
// Z = X;
// N = (X) >> 8;
// V = 0;
// JSR Rot_VL_Mode_a ; 08AF: BD F6 1F
memory[--S] = 0x08b2 & 0xff; memory[--S] = 0x08b2 >> 8;
PC = 0xf61f;
JUMP;
L08B2:// LDA <$A6 ; 08B2: 96 A6
A = memory_DP[0xa6];
N = A;
Z = A;
V = 0;
// JSR Rot_VL_Mode_a ; 08B4: BD F6 1F
memory[--S] = 0x08b7 & 0xff; memory[--S] = 0x08b7 >> 8;
PC = 0xf61f;
JUMP;
L08B7:// JMP $0965 ; 08B7: 7E 09 65
PC = 0x0965;
JUMP;
L08BA:// LDX <$30 ; 08BA: 9E 30
X = ((memory_DP[0x30]<<8)|memory_DP[0x30 + 1]);
Z = X;
// N = (X) >> 8;
// V = 0;
// BEQ $0911 ; 08BC: 27 53
if (!Z) {
PC = 0x0911;
JUMP;
}
// LEAX $FFFF,X ; 08BE: 30 1F
X = (X + 0xffff);
// Z = X;
// STX <$30 ; 08C0: 9F 30
Z = X;
// N = (X) >> 8;
// V = 0;
memory_DP[0x30] = (UINT8)((X) >> 8);
memory_DP[(UINT16)(0x30 + 1)] = (UINT8)((X) & 0xff);
// BNE $0910 ; 08C2: 26 4C
if (Z) {
PC = 0x0910;
JUMP;
}
// LDA #$F7 ; 08C4: 86 F7
A = (SINT8)0xf7;
// N = A;
// Z = A;
// V = 0;
// ANDA <$67 ; 08C6: 94 67
A = A & memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
// STA <$67 ; 08C8: 97 67
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
// COM <$8A ; 08CA: 03 8A
memory_DP[0x8a] = memory_DP[0x8a] ^ 0xff;
// Z = memory_DP[0x8a];
// N = memory_DP[0x8a];
// V = 0;
// C = 1;
// LDX #$C894 ; 08CC: 8E C8 94
X = 0xc894;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDB #$19 ; 08CF: C6 19
B = (SINT8)0x19;
// N = B;
// Z = B;
// V = 0;
// JSR Clear_x_b ; 08D1: BD F5 3F
memory[--S] = 0x08d4 & 0xff; memory[--S] = 0x08d4 >> 8;
PC = 0xf53f;
JUMP;
L08D4:// LDA #$00 ; 08D4: 86 00
A = (SINT8)0x00;
// N = A;
// Z = A;
// V = 0;
// STA <$71 ; 08D6: 97 71
// Z = A;
// N = A;
// V = 0;
memory_DP[0x71] = A;
// LDA #$02 ; 08D8: 86 02
A = (SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
// STA <$94 ; 08DA: 97 94
// Z = A;
// N = A;
// V = 0;
memory_DP[0x94] = A;
// DECA ; 08DC: 4A
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
// STA <$95 ; 08DD: 97 95
// Z = A;
// N = A;
// V = 0;
memory_DP[0x95] = A;
// LDD #$CA00 ; 08DF: CC CA 00
A = (UINT8)((0xca00) >> 8);
B = (UINT8)((0xca00) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD <$9B ; 08E2: DD 9B
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x9b] = A;
memory_DP[0x9b + 1] = B;
// LDA <$83 ; 08E4: 96 83
A = memory_DP[0x83];
// N = A;
// Z = A;
// V = 0;
// STA <$96 ; 08E6: 97 96
// Z = A;
// N = A;
// V = 0;
memory_DP[0x96] = A;
// LDA <$86 ; 08E8: 96 86
A = memory_DP[0x86];
// N = A;
// Z = A;
// V = 0;
// STA <$9A ; 08EA: 97 9A
// Z = A;
// N = A;
// V = 0;
memory_DP[0x9a] = A;
// LEAX $09,X ; 08EC: 30 09
X = (X + 0x0009);
// Z = X;
// JSR Random ; 08EE: BD F5 17
memory[--S] = 0x08f1 & 0xff; memory[--S] = 0x08f1 >> 8;
PC = 0xf517;
JUMP;
L08F1:// CLRB ; 08F1: 5F
B = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// ROLA ; 08F2: 49
res = ((A) << 1) + (C != 0);
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// ROLB ; 08F3: 59
res = ((B) << 1) + (C != 0);
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (B);
B = res;
// LEAX B,X ; 08F4: 30 85
X = (X + (SINT8)B);
// Z = X;
// STB <$CB ; 08F6: D7 CB
// Z = B;
// N = B;
// V = 0;
memory_DP[0xcb] = B;
// LDB #$7F ; 08F8: C6 7F
B = (SINT8)0x7f;
// N = B;
// Z = B;
// V = 0;
// ROLA ; 08FA: 49
res = ((A) << 1) + (C != 0);
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = res ^ (A);
A = res;
// BCC $08FE ; 08FB: 24 01
if (!C) {
PC = 0x08fe;
JUMP;
}
// NEGB ; 08FD: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
// C = B;
L08FE:// STB ,X ; 08FE: E7 84
// Z = B;
// N = B;
// V = 0;
memory[X] = B;
// ASRB ; 0900: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// ASRB ; 0901: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// STB $02,X ; 0902: E7 02
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0002)] = B;
// LDA #$07 ; 0904: 86 07
A = (SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
// SUBA <$CB ; 0906: 90 CB
A = (UINT8)(A - memory_DP[0xcb]);
// res = A - memory_DP[0xcb];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((A) ^ (memory_DP[0xcb])) & ((A) ^ res);
// SUBA <$CB ; 0908: 90 CB
A = (UINT8)(A - memory_DP[0xcb]);
// res = A - memory_DP[0xcb];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((A) ^ (memory_DP[0xcb])) & ((A) ^ res);
// LEAX A,X ; 090A: 30 86
X = (X + (SINT8)A);
// Z = X;
// INC ,X ; 090C: 6C 84
res = (UINT8)((memory[X]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory[X]);
memory[X] = res;
// COM <$98 ; 090E: 03 98
memory_DP[0x98] = memory_DP[0x98] ^ 0xff;
Z = memory_DP[0x98];
N = memory_DP[0x98];
V = 0;
C = 1;
L0910:// RTS ; 0910: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0911:// LDX #$C894 ; 0911: 8E C8 94
X = 0xc894;
// Z = X;
// N = (X) >> 8;
// V = 0;
// JSR $0709 ; 0914: BD 07 09
memory[--S] = 0x0917 & 0xff; memory[--S] = 0x0917 >> 8;
PC = 0x0709;
JUMP;
L0917:// LEAX $09,X ; 0917: 30 09
X = (X + 0x0009);
// Z = X;
// LDA <$94 ; 0919: 96 94
A = memory_DP[0x94];
N = A;
Z = A;
V = 0;
// LBMI $0879 ; 091B: 10 2B FF 5A
if ((SINT8)N < 0) {
PC = 0x0879;
JUMP;
}
// BNE $0928 ; 091F: 26 07
if (Z) {
PC = 0x0928;
JUMP;
}
// STD <$8C ; 0921: DD 8C
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x8c] = A;
memory_DP[0x8c + 1] = B;
// LDD <$DE ; 0923: DC DE
A = memory_DP[0xde];
B = memory_DP[0xde + 1];
// Z = A|B;
// N = A;
// V = 0;
// STD <$30 ; 0925: DD 30
Z = A | B;
N = A;
V = 0;
memory_DP[0x30] = A;
memory_DP[0x30 + 1] = B;
// RTS ; 0927: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0928:// LDA #$08 ; 0928: 86 08
A = (SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
// ORA <$67 ; 092A: 9A 67
A = A | memory_DP[0x67];
// Z = A;
// N = A;
// V = 0;
// STA <$67 ; 092C: 97 67
// Z = A;
// N = A;
// V = 0;
memory_DP[0x67] = A;
// LDB <$98 ; 092E: D6 98
B = memory_DP[0x98];
N = B;
// Z = B;
// V = 0;
// BPL $0940 ; 0930: 2A 0E
if ((SINT8)N >= 0) {
PC = 0x0940;
JUMP;
}
// LEAU $0A,X ; 0932: 33 0A
U = (X + 0x000a);
// LDX #$0FAF ; 0934: 8E 0F AF
X = 0x0faf;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDA <$A6 ; 0937: 96 A6
A = memory_DP[0xa6];
// N = A;
// Z = A;
// V = 0;
// JSR Rot_VL_Mode_a ; 0939: BD F6 1F
memory[--S] = 0x093c & 0xff; memory[--S] = 0x093c >> 8;
PC = 0xf61f;
JUMP;
L093C:// CLR <$98 ; 093C: 0F 98
memory_DP[0x98] = 0;
V = 0;
Z = 0;
N = 0;
C = 0;
// BRA $0965 ; 093E: 20 25
PC = 0x0965;
JUMP;
L0940:// LDD <$8C ; 0940: DC 8C
A = memory_DP[0x8c];
B = memory_DP[0x8c + 1];
// Z = A|B;
// N = A;
// V = 0;
// TFR D,Y ; 0942: 1F 02
Y = ((A << 8) | B);
// JSR $0C66 ; 0944: BD 0C 66
memory[--S] = 0x0947 & 0xff; memory[--S] = 0x0947 >> 8;
PC = 0x0c66;
JUMP;
L0947:// ANDA <$84 ; 0947: 94 84
A = A & memory_DP[0x84];
// Z = A;
// N = A;
// V = 0;
// STD <$CD ; 0949: DD CD
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcd] = A;
memory_DP[0xcd + 1] = B;
// LEAX $09,X ; 094B: 30 09
X = (X + 0x0009);
// Z = X;
// CMPB #$08 ; 094D: C1 08
res = B - (SINT8)0x08;
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (B ^ (SINT8)0x08) & (B ^ res);
// BLS $0959 ; 094F: 23 08
if ((!Z) || C) {
PC = 0x0959;
JUMP;
}
// SUBA <$A6 ; 0951: 90 A6
A = (UINT8)(A - memory_DP[0xa6]);
res = A - memory_DP[0xa6];
C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
V = ((A) ^ (memory_DP[0xa6])) & ((A) ^ res);
// BEQ $0959 ; 0953: 27 04
if (!Z) {
PC = 0x0959;
JUMP;
}
// BSR $0989 ; 0955: 8D 32
memory[--S] = 0x0957 & 0xff; memory[--S] = 0x0957 >> 8;
PC = 0x0989;
JUMP;
L0957:// DEC <$98 ; 0957: 0A 98
res = (UINT8)(memory_DP[0x98] - 1);
// N = res;
// Z = res;
// V = memory_DP[0x98] & ~res;
memory_DP[0x98] = res;
L0959:// LEAX $FFFF,X ; 0959: 30 1F
X = (X + 0xffff);
// Z = X;
// LDA <$95 ; 095B: 96 95
A = memory_DP[0x95];
// N = A;
// Z = A;
// V = 0;
// ANDA #$01 ; 095D: 84 01
A = A & (SINT8)0x01;
// Z = A;
// N = A;
// V = 0;
// ASLA ; 095F: 48
res = A << 1;
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
// V = A ^ res;
A = res;
// LDU #$0A55 ; 0960: CE 0A 55
U = 0x0a55;
// Z = U;
// N = (U) >> 8;
// V = 0;
// JSR [A,U] ; 0963: AD D6
memory[--S] = 0x0965 & 0xff; memory[--S] = 0x0965 >> 8;
PC = ((memory[(UINT16)(U + (SINT8)A)]<<8)|memory[(UINT16)(U + (SINT8)A + 1)]);
JUMP;
L0965:// LDD #$78FF ; 0965: CC 78 FF
A = (UINT8)((0x78ff) >> 8);
B = (UINT8)((0x78ff) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// LEAX $FFFA,X ; 0968: 30 1A
X = (X + 0xfffa);
// Z = X;
// CMPA ,X+ ; 096A: A1 80
res = A - memory[X++];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = (A ^ memory[X]) & (A ^ res);
// BLT $097E ; 096C: 2D 10
if ((SINT8)(N^V) < 0) {
PC = 0x097e;
JUMP;
}
// CMPA ,X+ ; 096E: A1 80
res = A - memory[X++];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = (A ^ memory[X]) & (A ^ res);
// BLT $097E ; 0970: 2D 0C
if ((SINT8)(N^V) < 0) {
PC = 0x097e;
JUMP;
}
// NEGA ; 0972: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
// NEGB ; 0973: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
// C = B;
// LEAX $FFFE,X ; 0974: 30 1E
X = (X + 0xfffe);
// Z = X;
// CMPA ,X+ ; 0976: A1 80
res = A - memory[X++];
// C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
V = (A ^ memory[X]) & (A ^ res);
// BGT $097E ; 0978: 2E 04
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x097e;
JUMP;
}
// CMPA ,X+ ; 097A: A1 80
res = A - memory[X++];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = (A ^ memory[X]) & (A ^ res);
// BLT $0980 ; 097C: 2D 02
if ((SINT8)(N^V) < 0) {
PC = 0x0980;
JUMP;
}
L097E:// STB $03,X ; 097E: E7 03
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0003)] = B;
L0980:// LDD <$9F ; 0980: DC 9F
A = memory_DP[0x9f];
B = memory_DP[0x9f + 1];
// Z = A|B;
// N = A;
// V = 0;
// ADDA <$A3 ; 0982: 9B A3
A = (UINT8)(A + memory_DP[0xa3]);
// res = A + memory_DP[0xa3];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ memory_DP[0xa3] ^ res ^ C;
// H = res;
// V = res;
// ADDB <$A4 ; 0984: DB A4
B = (UINT8)(B + memory_DP[0xa4]);
res = B + memory_DP[0xa4];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ memory_DP[0xa4] ^ res ^ C;
H = res;
// V = res;
// STD <$9F ; 0986: DD 9F
Z = A | B;
N = A;
V = 0;
memory_DP[0x9f] = A;
memory_DP[0x9f + 1] = B;
// RTS ; 0988: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0989:// ANDA #$3F ; 0989: 84 3F
A = A & (SINT8)0x3f;
// Z = A;
// N = A;
// V = 0;
// LDB #$01 ; 098B: C6 01
B = (SINT8)0x01;
// N = B;
// Z = B;
// V = 0;
// CMPA #$20 ; 098D: 81 20
res = A - (SINT8)0x20;
// C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
V = (A ^ (SINT8)0x20) & (A ^ res);
// BLE $0992 ; 098F: 2F 01
if (((SINT8)(N^V) < 0) || (!Z)) {
PC = 0x0992;
JUMP;
}
// NEGB ; 0991: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
// C = B;
L0992:// STB <$CF ; 0992: D7 CF
// Z = B;
// N = B;
// V = 0;
memory_DP[0xcf] = B;
// ADDB ,X ; 0994: EB 84
B = (UINT8)(B + memory[X]);
// res = B + memory[X];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = B ^ memory[X] ^ res ^ C;
// H = res;
// V = res;
// ANDB #$3F ; 0996: C4 3F
B = B & (SINT8)0x3f;
// Z = B;
// N = B;
// V = 0;
// CMPB <$CD ; 0998: D1 CD
res = B - memory_DP[0xcd];
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (B ^ memory_DP[0xcd]) & (B ^ res);
// BEQ $09A0 ; 099A: 27 04
if (!Z) {
PC = 0x09a0;
JUMP;
}
// ADDB <$CF ; 099C: DB CF
B = (UINT8)(B + memory_DP[0xcf]);
res = B + memory_DP[0xcf];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ memory_DP[0xcf] ^ res ^ C;
H = res;
// V = res;
// ANDB #$3F ; 099E: C4 3F
B = B & (SINT8)0x3f;
// Z = B;
// N = B;
// V = 0;
L09A0:// STB ,X ; 09A0: E7 84
Z = B;
N = B;
V = 0;
memory[X] = B;
// RTS ; 09A2: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0A59:// NEG <$91 ; 0A59: 00 91
// V = (UINT8)(-memory_DP[0x91]) & (memory_DP[0x91]);
memory_DP[0x91] = (UINT8)(-memory_DP[0x91]);
// Z = memory_DP[0x91];
// N = memory_DP[0x91];
// C = memory_DP[0x91];
// LDY #$C8E3 ; 0A5B: 10 8E C8 E3
Y = 0xc8e3;
// Z = Y;
// N = (Y) >> 8;
// V = 0;
// CLR $02,Y ; 0A5F: 6F 22
memory[(UINT16)(Y + 0x0002)] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// CLR $03,Y ; 0A61: 6F 23
memory[(UINT16)(Y + 0x0003)] = 0;
// V = 0;
// Z = 0;
// N = 0;
// C = 0;
// LDA #$02 ; 0A63: 86 02
A = (SINT8)0x02;
// N = A;
// Z = A;
// V = 0;
// STA <$DA ; 0A65: 97 DA
// Z = A;
// N = A;
// V = 0;
memory_DP[0xda] = A;
// LDX #$C9C0 ; 0A67: 8E C9 C0
X = 0xc9c0;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDD #$0B6E ; 0A6A: CC 0B 6E
A = (UINT8)((0x0b6e) >> 8);
B = (UINT8)((0x0b6e) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD <$CC ; 0A6D: DD CC
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xcc] = A;
memory_DP[0xcc + 1] = B;
// LDB #$08 ; 0A6F: C6 08
B = (SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
L0A71:// STB <$D2 ; 0A71: D7 D2
// Z = B;
// N = B;
// V = 0;
memory_DP[0xd2] = B;
// LDA ,X ; 0A73: A6 84
A = memory[X];
N = A;
Z = A;
// V = 0;
// BMI $0AAD ; 0A75: 2B 36
if ((SINT8)N < 0) {
PC = 0x0aad;
JUMP;
}
// BEQ $0A92 ; 0A77: 27 19
if (!Z) {
PC = 0x0a92;
JUMP;
}
// LDU #$CB00 ; 0A79: CE CB 00
U = 0xcb00;
// Z = U;
// N = (U) >> 8;
// V = 0;
// DECA ; 0A7C: 4A
res = (UINT8)(A - 1);
// N = res;
// Z = res;
// V = A & ~res;
A = res;
// STA ,X ; 0A7D: A7 84
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
// ANDA #$03 ; 0A7F: 84 03
A = A & (SINT8)0x03;
Z = A;
// N = A;
// V = 0;
// BNE $0A8B ; 0A81: 26 08
if (Z) {
PC = 0x0a8b;
JUMP;
}
// LDB $04,X ; 0A83: E6 04
B = memory[(UINT16)(X + 0x0004)];
// N = B;
// Z = B;
// V = 0;
// ADDB $04,X ; 0A85: EB 04
B = (UINT8)(B + memory[(UINT16)(X + 0x0004)]);
res = B + memory[(UINT16)(X + 0x0004)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ memory[(UINT16)(X + 0x0004)] ^ res ^ C;
H = res;
// V = res;
// STB $04,X ; 0A87: E7 04
// Z = B;
// N = B;
// V = 0;
memory[(UINT16)(X + 0x0004)] = B;
// DEC $03,X ; 0A89: 6A 03
res = (UINT8)(memory[(UINT16)(X + 0x0003)] - 1);
// N = res;
// Z = res;
// V = memory[(UINT16)(X + 0x0003)] & ~res;
memory[(UINT16)(X + 0x0003)] = res;
L0A8B:// LDB #$08 ; 0A8B: C6 08
B = (SINT8)0x08;
// N = B;
// Z = B;
// V = 0;
// MUL ; 0A8D: 3D
res = (UINT16)(A * B);
// Z = res;
// C = res & 0x80; /* ??? 8000 ??? */
A = res >> 8;
B = (UINT8)res;
// LEAU B,U ; 0A8E: 33 C5
U = (U + (SINT8)B);
// STU $05,X ; 0A90: EF 05
// Z = U;
// N = (U) >> 8;
// V = 0;
memory[(UINT16)(X + 0x0005)] = (UINT8)((U) >> 8);
memory[(UINT16)((X + 0x0005) + 1)] = (UINT8)((U) & 0xff);
L0A92:// LEAX $07,X ; 0A92: 30 07
X = (X + 0x0007);
// Z = X;
// LDB <$D2 ; 0A94: D6 D2
B = memory_DP[0xd2];
// N = B;
// Z = B;
// V = 0;
// DECB ; 0A96: 5A
res = (UINT8)(B - 1);
// N = res;
Z = res;
// V = B & ~res;
B = res;
// BEQ $0AAC ; 0A97: 27 13
if (!Z) {
PC = 0x0aac;
JUMP;
}
// CMPB #$06 ; 0A99: C1 06
res = B - (SINT8)0x06;
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (B ^ (SINT8)0x06) & (B ^ res);
// BNE $0A9F ; 0A9B: 26 02
if (Z) {
PC = 0x0a9f;
JUMP;
}
// INC <$DA ; 0A9D: 0C DA
res = (UINT8)((memory_DP[0xda]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0xda]);
memory_DP[0xda] = res;
L0A9F:// CMPB #$04 ; 0A9F: C1 04
res = B - (SINT8)0x04;
C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = (B ^ (SINT8)0x04) & (B ^ res);
// BNE $0A71 ; 0AA1: 26 CE
if (Z) {
PC = 0x0a71;
JUMP;
}
// LDU #$0B2C ; 0AA3: CE 0B 2C
U = 0x0b2c;
// Z = U;
// N = (U) >> 8;
// V = 0;
// STU <$CC ; 0AA6: DF CC
// Z = U;
// N = (U) >> 8;
// V = 0;
memory_DP[0xcc] = (UINT8)((U) >> 8);
memory_DP[(UINT16)(0xcc + 1)] = (UINT8)((U) & 0xff);
// INC <$DA ; 0AA8: 0C DA
res = (UINT8)((memory_DP[0xda]) + 1);
Z = res;
N = res;
V = res & ~(memory_DP[0xda]);
memory_DP[0xda] = res;
// BRA $0A71 ; 0AAA: 20 C5
PC = 0x0a71;
JUMP;
L0AAC:// RTS ; 0AAC: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0AAD:// LDA <$91 ; 0AAD: 96 91
A = memory_DP[0x91];
// N = A;
// Z = A;
// V = 0;
// ADDA #$04 ; 0AAF: 8B 04
A = (UINT8)(A + (SINT8)0x04);
// res = A + (SINT8)0x04;
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ (SINT8)0x04 ^ res ^ C;
// H = res;
// V = res;
// LEAU A,X ; 0AB1: 33 86
U = (X + (SINT8)A);
// LDD $01,X ; 0AB3: EC 01
A = memory[(UINT16)(X + 0x0001)];
B = memory[(UINT16)(((UINT16)(X + 0x0001))+1)];
// Z = A|B;
// N = A;
// V = 0;
// ADDA ,U ; 0AB5: AB C4
A = (UINT8)(A + memory[U]);
// res = A + memory[U];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ memory[U] ^ res ^ C;
// H = res;
// V = res;
// ADDB $01,U ; 0AB7: EB 41
B = (UINT8)(B + memory[(UINT16)(U + 0x0001)]);
// res = B + memory[(UINT16)(U + 0x0001)];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = B ^ memory[(UINT16)(U + 0x0001)] ^ res ^ C;
// H = res;
// V = res;
// STD $01,X ; 0AB9: ED 01
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0001)] = A;
memory[(UINT16)(X + 0x0001) + 1] = B;
// JSR Abs_a_b ; 0ABB: BD F5 84
memory[--S] = 0x0abe & 0xff; memory[--S] = 0x0abe >> 8;
PC = 0xf584;
JUMP;
L0ABE:// STD <$DB ; 0ABE: DD DB
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0xdb] = A;
memory_DP[0xdb + 1] = B;
// CMPA #$78 ; 0AC0: 81 78
res = A - (SINT8)0x78;
C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = (A ^ (SINT8)0x78) & (A ^ res);
// BCC $0B1B ; 0AC2: 24 57
if (!C) {
PC = 0x0b1b;
JUMP;
}
// CMPB #$78 ; 0AC4: C1 78
res = B - (SINT8)0x78;
C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = (B ^ (SINT8)0x78) & (B ^ res);
// BCC $0B1B ; 0AC6: 24 53
if (!C) {
PC = 0x0b1b;
JUMP;
}
// LDU #$0F20 ; 0AC8: CE 0F 20
U = 0x0f20;
// Z = U;
// N = (U) >> 8;
V = 0;
// JSR $081C ; 0ACB: BD 08 1C
memory[--S] = 0x0ace & 0xff; memory[--S] = 0x0ace >> 8;
PC = 0x081c;
JUMP;
L0ACE:// BVS $0B1B ; 0ACE: 29 4B
if ((SINT8)V < 0) {
PC = 0x0b1b;
JUMP;
}
// LDB <$DB ; 0AD0: D6 DB
B = memory_DP[0xdb];
// N = B;
// Z = B;
// V = 0;
// LDU #$0F6A ; 0AD2: CE 0F 6A
U = 0x0f6a;
// Z = U;
// N = (U) >> 8;
V = 0;
// JSR $081C ; 0AD5: BD 08 1C
memory[--S] = 0x0ad8 & 0xff; memory[--S] = 0x0ad8 >> 8;
PC = 0x081c;
JUMP;
L0AD8:// BVS $0B1B ; 0AD8: 29 41
if ((SINT8)V < 0) {
PC = 0x0b1b;
JUMP;
}
// LDU #$C900 ; 0ADA: CE C9 00
U = 0xc900;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDB <$81 ; 0ADD: D6 81
B = memory_DP[0x81];
// N = B;
// Z = B;
// V = 0;
L0ADF:// STB <$CB ; 0ADF: D7 CB
// Z = B;
// N = B;
// V = 0;
memory_DP[0xcb] = B;
// SUBB <$D2 ; 0AE1: D0 D2
B = (UINT8)(B - memory_DP[0xd2]);
// res = B - memory_DP[0xd2];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((B) ^ (memory_DP[0xd2])) & ((B) ^ res);
// ADDB #$03 ; 0AE3: CB 03
B = (UINT8)(B + (SINT8)0x03);
res = B + (SINT8)0x03;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = B ^ (SINT8)0x03 ^ res ^ C;
H = res;
// V = res;
// SUBB <$81 ; 0AE5: D0 81
B = (UINT8)(B - memory_DP[0x81]);
res = B - memory_DP[0x81];
// C = res & 0x100;
res = (UINT8)res;
Z = res;
// N = res;
// V = ((B) ^ (memory_DP[0x81])) & ((B) ^ res);
// BEQ $0B0B ; 0AE7: 27 22
if (!Z) {
PC = 0x0b0b;
JUMP;
}
// LDD ,U ; 0AE9: EC C4
A = memory[U];
B = memory[(UINT16)((U)+1)];
// Z = A|B;
// N = A;
// V = 0;
// TSTA ; 0AEB: 4D
Z = A;
// N = A;
// V = 0;
// BEQ $0B0B ; 0AEC: 27 1D
if (!Z) {
PC = 0x0b0b;
JUMP;
}
// CMPB #$02 ; 0AEE: C1 02
res = B - (SINT8)0x02;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = (B ^ (SINT8)0x02) & (B ^ res);
// BGE $0B0B ; 0AF0: 2C 19
if ((SINT8)(N^V) >= 0) {
PC = 0x0b0b;
JUMP;
}
// LDA #$05 ; 0AF2: 86 05
A = (SINT8)0x05;
// N = A;
// Z = A;
// V = 0;
// STA <$E8 ; 0AF4: 97 E8
// Z = A;
// N = A;
// V = 0;
memory_DP[0xe8] = A;
// LDD $0E,U ; 0AF6: EC 4E
A = memory[(UINT16)(U + 0x000e)];
B = memory[(UINT16)(((UINT16)(U + 0x000e))+1)];
Z = A|B;
N = A;
V = 0;
// BSR $0B52 ; 0AF8: 8D 58
memory[--S] = 0x0afa & 0xff; memory[--S] = 0x0afa >> 8;
PC = 0x0b52;
JUMP;
L0AFA:// BVC $0B0B ; 0AFA: 28 0F
if ((SINT8)V >= 0) {
PC = 0x0b0b;
JUMP;
}
// LDB $01,U ; 0AFC: E6 41
B = memory[(UINT16)(U + 0x0001)];
// N = B;
// Z = B;
// V = 0;
// LDA B,Y ; 0AFE: A6 A5
A = memory[(UINT16)(Y + (SINT8)B)];
// N = A;
// Z = A;
// V = 0;
// LDB <$DA ; 0B00: D6 DA
B = memory_DP[0xda];
// N = B;
// Z = B;
// V = 0;
// ADDA B,Y ; 0B02: AB A5
A = (UINT8)(A + memory[(UINT16)(Y + (SINT8)B)]);
res = A + memory[(UINT16)(Y + (SINT8)B)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = A ^ memory[(UINT16)(Y + (SINT8)B)] ^ res ^ C;
H = res;
// V = res;
// DAA ; 0B04: 19
res = A;
msn = res & 0xf0;
lsn = res & 0x0f;
res = res | (((lsn > 0x09) || (H & 0x10)) ? 0x06 : 0);
res = res | (((msn > 0x80) && (lsn > 0x09)) ? 0x60 : 0);
res = res | (((msn > 0x90) || (C != 0)) ? 0x60 : 0);
C = C | (res & 0x100);
res = (UINT8)res;
A = res;
// N = res;
// Z = res;
// V = 0;
// STA B,Y ; 0B05: A7 A5
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(Y + (SINT8)B)] = A;
// INC $01,U ; 0B07: 6C 41
res = (UINT8)((memory[(UINT16)(U + 0x0001)]) + 1);
Z = res;
N = res;
V = res & ~(memory[(UINT16)(U + 0x0001)]);
memory[(UINT16)(U + 0x0001)] = res;
// BRA $0B1B ; 0B09: 20 10
PC = 0x0b1b;
JUMP;
L0B0B:// LEAU $40,U ; 0B0B: 33 C8 40
U = (U + (SINT8)0x40);
// LDB <$CB ; 0B0E: D6 CB
B = memory_DP[0xcb];
// N = B;
// Z = B;
// V = 0;
// DECB ; 0B10: 5A
res = (UINT8)(B - 1);
N = res;
Z = res;
V = B & ~res;
B = res;
// BNE $0ADF ; 0B11: 26 CC
if (Z) {
PC = 0x0adf;
JUMP;
}
// JSR [$C8CC] ; 0B13: AD 9F C8 CC
memory[--S] = 0x0b17 & 0xff; memory[--S] = 0x0b17 >> 8;
PC = ((memory[0xc8cc]<<8)|memory[(UINT16)((0xc8cc)+1)]);
JUMP;
L0B17:// LBVC $0A92 ; 0B17: 10 28 FF 77
if ((SINT8)V >= 0) {
PC = 0x0a92;
JUMP;
}
L0B1B:// LDA #$08 ; 0B1B: 86 08
A = (SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
// STA ,X ; 0B1D: A7 84
// Z = A;
// N = A;
// V = 0;
memory[X] = A;
// LDD #$090A ; 0B1F: CC 09 0A
A = (UINT8)((0x090a) >> 8);
B = (UINT8)((0x090a) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD $03,X ; 0B22: ED 03
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(X + 0x0003)] = A;
memory[(UINT16)(X + 0x0003) + 1] = B;
// LDD #$CB00 ; 0B24: CC CB 00
A = (UINT8)((0xcb00) >> 8);
B = (UINT8)((0xcb00) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
// STD $05,X ; 0B27: ED 05
Z = A | B;
N = A;
V = 0;
memory[(UINT16)(X + 0x0005)] = A;
memory[(UINT16)(X + 0x0005) + 1] = B;
// JMP $0A92 ; 0B29: 7E 0A 92
PC = 0x0a92;
JUMP;
L0B52:// SUBA $01,X ; 0B52: A0 01
A = (UINT8)(A - memory[(UINT16)(X + 0x0001)]);
res = A - memory[(UINT16)(X + 0x0001)];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = ((A) ^ (memory[(UINT16)(X + 0x0001)])) & ((A) ^ res);
// BVS $0B6B ; 0B54: 29 15
if ((SINT8)V < 0) {
PC = 0x0b6b;
JUMP;
}
// BPL $0B59 ; 0B56: 2A 01
if ((SINT8)N >= 0) {
PC = 0x0b59;
JUMP;
}
// NEGA ; 0B58: 40
// V = (UINT8)(-A) & (A);
A = (UINT8)(-A);
// Z = A;
// N = A;
// C = A;
L0B59:// SUBB $02,X ; 0B59: E0 02
B = (UINT8)(B - memory[(UINT16)(X + 0x0002)]);
res = B - memory[(UINT16)(X + 0x0002)];
// C = res & 0x100;
res = (UINT8)res;
// Z = res;
N = res;
V = ((B) ^ (memory[(UINT16)(X + 0x0002)])) & ((B) ^ res);
// BVS $0B6B ; 0B5B: 29 0E
if ((SINT8)V < 0) {
PC = 0x0b6b;
JUMP;
}
// BPL $0B60 ; 0B5D: 2A 01
if ((SINT8)N >= 0) {
PC = 0x0b60;
JUMP;
}
// NEGB ; 0B5F: 50
// V = (UINT8)(-B) & (B);
B = (UINT8)(-B);
// Z = B;
// N = B;
// C = B;
L0B60:// CMPA <$E8 ; 0B60: 91 E8
res = A - memory_DP[0xe8];
// C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
V = (A ^ memory_DP[0xe8]) & (A ^ res);
// BGT $0B6B ; 0B62: 2E 07
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0b6b;
JUMP;
}
// CMPB <$E8 ; 0B64: D1 E8
res = B - memory_DP[0xe8];
C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
V = (B ^ memory_DP[0xe8]) & (B ^ res);
// BGT $0B6B ; 0B66: 2E 03
if (((SINT8)(N^V) >= 0) && Z) {
PC = 0x0b6b;
JUMP;
}
// ORCC #$02 ; 0B68: 1A 02
V = 1;
// RTS ; 0B6A: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0B6B:// ANDCC #$FD ; 0B6B: 1C FD
V = 0;
// RTS ; 0B6D: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0BD0:// JMP Explosion_Snd ; 0BD0: 7E F9 2E
PC = 0xf92e;
JUMP;
L0BD3:// LDU #$0C5E ; 0BD3: CE 0C 5E
U = 0x0c5e;
// Z = U;
// N = (U) >> 8;
// V = 0;
// LDA <$EF ; 0BD6: 96 EF
A = memory_DP[0xef];
N = A;
Z = A;
// V = 0;
// BEQ $0BE5 ; 0BD8: 27 0B
if (!Z) {
PC = 0x0be5;
JUMP;
}
// BMI $0BD0 ; 0BDA: 2B F4
if ((SINT8)N < 0) {
PC = 0x0bd0;
JUMP;
}
// DEC <$EF ; 0BDC: 0A EF
res = (UINT8)(memory_DP[0xef] - 1);
N = res;
Z = res;
V = memory_DP[0xef] & ~res;
memory_DP[0xef] = res;
// LEAU $04,U ; 0BDE: 33 44
U = (U + 0x0004);
// JSR Explosion_Snd ; 0BE0: BD F9 2E
memory[--S] = 0x0be3 & 0xff; memory[--S] = 0x0be3 >> 8;
PC = 0xf92e;
JUMP;
L0BE3:// BRA $0C33 ; 0BE3: 20 4E
PC = 0x0c33;
JUMP;
L0BE5:// LDA #$0F ; 0BE5: 86 0F
A = (SINT8)0x0f;
// N = A;
// Z = A;
// V = 0;
// STA <$44 ; 0BE7: 97 44
// Z = A;
// N = A;
// V = 0;
memory_DP[0x44] = A;
// STA <$43 ; 0BE9: 97 43
// Z = A;
// N = A;
// V = 0;
memory_DP[0x43] = A;
// STA <$42 ; 0BEB: 97 42
// Z = A;
// N = A;
// V = 0;
memory_DP[0x42] = A;
// LDB <$45 ; 0BED: D6 45
B = memory_DP[0x45];
// N = B;
// Z = B;
// V = 0;
// LDA <$67 ; 0BEF: 96 67
A = memory_DP[0x67];
// N = A;
// Z = A;
// V = 0;
// ANDA #$03 ; 0BF1: 84 03
A = A & (SINT8)0x03;
Z = A;
// N = A;
// V = 0;
// BEQ $0C2F ; 0BF3: 27 3A
if (!Z) {
PC = 0x0c2f;
JUMP;
}
// ANDB #$F9 ; 0BF5: C4 F9
B = B & (SINT8)0xf9;
// Z = B;
// N = B;
// V = 0;
// ORB #$30 ; 0BF7: CA 30
B = B | (SINT8)0x30;
// Z = B;
// N = B;
// V = 0;
// STB <$45 ; 0BF9: D7 45
// Z = B;
// N = B;
// V = 0;
memory_DP[0x45] = B;
// ADDA <$76 ; 0BFB: 9B 76
A = (UINT8)(A + memory_DP[0x76]);
// res = A + memory_DP[0x76];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ memory_DP[0x76] ^ res ^ C;
// H = res;
// V = res;
// STA <$76 ; 0BFD: 97 76
// Z = A;
// N = A;
// V = 0;
memory_DP[0x76] = A;
// BITA #$08 ; 0BFF: 85 08
res = A & (SINT8)0x08;
Z = res;
// N = res;
// V = 0;
// BNE $0C07 ; 0C01: 26 04
if (Z) {
PC = 0x0c07;
JUMP;
}
// ORB #$04 ; 0C03: CA 04
B = B | (SINT8)0x04;
// Z = B;
// N = B;
// V = 0;
// STB <$45 ; 0C05: D7 45
// Z = B;
// N = B;
// V = 0;
memory_DP[0x45] = B;
L0C07:// BITA #$10 ; 0C07: 85 10
res = A & (SINT8)0x10;
Z = res;
// N = res;
// V = 0;
// BNE $0C0D ; 0C09: 26 02
if (Z) {
PC = 0x0c0d;
JUMP;
}
// EORA #$07 ; 0C0B: 88 07
A = A ^ (SINT8)0x07;
// N = A;
// Z = A;
// V = 0;
L0C0D:// ANDA #$07 ; 0C0D: 84 07
A = A & (SINT8)0x07;
// Z = A;
// N = A;
// V = 0;
// ADDA #$10 ; 0C0F: 8B 10
A = (UINT8)(A + (SINT8)0x10);
res = A + (SINT8)0x10;
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = A ^ (SINT8)0x10 ^ res ^ C;
H = res;
// V = res;
// STA <$48 ; 0C11: 97 48
// Z = A;
// N = A;
// V = 0;
memory_DP[0x48] = A;
// CLR <$47 ; 0C13: 0F 47
memory_DP[0x47] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// LDA #$08 ; 0C15: 86 08
A = (SINT8)0x08;
// N = A;
// Z = A;
// V = 0;
// STA <$42 ; 0C17: 97 42
// Z = A;
// N = A;
// V = 0;
memory_DP[0x42] = A;
// LDA <$67 ; 0C19: 96 67
A = memory_DP[0x67];
// N = A;
// Z = A;
// V = 0;
// BITA #$01 ; 0C1B: 85 01
res = A & (SINT8)0x01;
Z = res;
// N = res;
// V = 0;
// BEQ $0C24 ; 0C1D: 27 05
if (!Z) {
PC = 0x0c24;
JUMP;
}
// LDD #$0FFF ; 0C1F: CC 0F FF
A = (UINT8)((0x0fff) >> 8);
B = (UINT8)((0x0fff) & 0xff);
Z = A|B;
N = A;
V = 0;
// BRA $0C27 ; 0C22: 20 03
PC = 0x0c27;
JUMP;
L0C24:// LDD #$0BFF ; 0C24: CC 0B FF
A = (UINT8)((0x0bff) >> 8);
B = (UINT8)((0x0bff) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
L0C27:// STD <$49 ; 0C27: DD 49
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x49] = A;
memory_DP[0x49 + 1] = B;
// LDA #$0E ; 0C29: 86 0E
A = (SINT8)0x0e;
// N = A;
// Z = A;
// V = 0;
// STD <$43 ; 0C2B: DD 43
Z = A | B;
N = A;
V = 0;
memory_DP[0x43] = A;
memory_DP[0x43 + 1] = B;
// BRA $0C33 ; 0C2D: 20 04
PC = 0x0c33;
JUMP;
L0C2F:// ORB #$36 ; 0C2F: CA 36
B = B | (SINT8)0x36;
// Z = B;
// N = B;
// V = 0;
// STB <$45 ; 0C31: D7 45
// Z = B;
// N = B;
// V = 0;
memory_DP[0x45] = B;
L0C33:// LDB <$45 ; 0C33: D6 45
B = memory_DP[0x45];
// N = B;
// Z = B;
// V = 0;
// LDA <$67 ; 0C35: 96 67
A = memory_DP[0x67];
// N = A;
// Z = A;
// V = 0;
// BITA #$08 ; 0C37: 85 08
res = A & (SINT8)0x08;
Z = res;
// N = res;
// V = 0;
// BEQ $0C59 ; 0C39: 27 1E
if (!Z) {
PC = 0x0c59;
JUMP;
}
// INC <$6A ; 0C3B: 0C 6A
res = (UINT8)((memory_DP[0x6a]) + 1);
// Z = res;
// N = res;
// V = res & ~(memory_DP[0x6a]);
memory_DP[0x6a] = res;
// LDA <$6A ; 0C3D: 96 6A
A = memory_DP[0x6a];
// N = A;
// Z = A;
// V = 0;
// BITA #$02 ; 0C3F: 85 02
res = A & (SINT8)0x02;
Z = res;
// N = res;
// V = 0;
// BEQ $0C59 ; 0C41: 27 16
if (!Z) {
PC = 0x0c59;
JUMP;
}
// ANDB #$F7 ; 0C43: C4 F7
B = B & (SINT8)0xf7;
// Z = B;
// N = B;
// V = 0;
// STB <$45 ; 0C45: D7 45
// Z = B;
// N = B;
// V = 0;
memory_DP[0x45] = B;
// RORA ; 0C47: 46
res = A;
res = res | (C != 0) ? 0x100 : 0;
C = res & 1;
res = res >> 1;
// Z = res;
// N = res;
A = res;
// LDB #$20 ; 0C48: C6 20
B = (SINT8)0x20;
// N = B;
// Z = B;
// V = 0;
// BCS $0C4D ; 0C4A: 25 01
if (C) {
PC = 0x0c4d;
JUMP;
}
// LSRB ; 0C4C: 54
// C = (B) & 1;
B = (B) >> 1;
// N = 0;
// Z = B;
L0C4D:// CLRA ; 0C4D: 4F
A = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// STD <$4B ; 0C4E: DD 4B
// Z = A | B;
// N = A;
// V = 0;
memory_DP[0x4b] = A;
memory_DP[0x4b + 1] = B;
// LDB #$03 ; 0C50: C6 03
B = (SINT8)0x03;
// N = B;
// Z = B;
// V = 0;
// STB <$46 ; 0C52: D7 46
// Z = B;
// N = B;
// V = 0;
memory_DP[0x46] = B;
// LDA #$0D ; 0C54: 86 0D
A = (SINT8)0x0d;
// N = A;
// Z = A;
// V = 0;
// STA <$44 ; 0C56: 97 44
Z = A;
N = A;
V = 0;
memory_DP[0x44] = A;
// RTS ; 0C58: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0C59:// ORB #$09 ; 0C59: CA 09
B = B | (SINT8)0x09;
// Z = B;
// N = B;
// V = 0;
// STB <$45 ; 0C5B: D7 45
Z = B;
N = B;
V = 0;
memory_DP[0x45] = B;
// RTS ; 0C5D: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0C66:// LDD ,X ; 0C66: EC 84
A = memory[X];
B = memory[(UINT16)((X)+1)];
// Z = A|B;
// N = A;
// V = 0;
// ASRA ; 0C68: 47
// C = A & 1;
A = (UINT8)(A >> 1);
// Z = A;
// N = A;
// ASRB ; 0C69: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// STD $FFFE,S ; 0C6A: ED 7E
// Z = A | B;
// N = A;
// V = 0;
memory[(UINT16)(S + 0xfffe)] = A;
memory[(UINT16)(S + 0xfffe) + 1] = B;
// LDD $02,X ; 0C6C: EC 02
A = memory[(UINT16)(X + 0x0002)];
B = memory[(UINT16)(((UINT16)(X + 0x0002))+1)];
// Z = A|B;
// N = A;
// V = 0;
// ASRA ; 0C6E: 47
// C = A & 1;
A = (UINT8)(A >> 1);
// Z = A;
// N = A;
// ASRB ; 0C6F: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// ADDA $FFFE,S ; 0C70: AB 7E
A = (UINT8)(A + memory[(UINT16)(S + 0xfffe)]);
// res = A + memory[(UINT16)(S + 0xfffe)];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ memory[(UINT16)(S + 0xfffe)] ^ res ^ C;
// H = res;
// V = res;
// ADDB $FFFF,S ; 0C72: EB 7F
B = (UINT8)(B + memory[(UINT16)(S + 0xffff)]);
res = B + memory[(UINT16)(S + 0xffff)];
C = res & 0x100;
res = (UINT8)res;
Z = res;
N = res;
res = B ^ memory[(UINT16)(S + 0xffff)] ^ res ^ C;
H = res;
V = res;
// BRA $0C82 ; 0C74: 20 0C
PC = 0x0c82;
JUMP;
L0C76:// PSHS B,A ; 0C76: 34 06
memory[--S] = B;
memory[--S] = A;
// LDA ,U ; 0C78: A6 C4
A = memory[U];
// N = A;
// Z = A;
// V = 0;
// LDB $02,U ; 0C7A: E6 42
B = memory[(UINT16)(U + 0x0002)];
// N = B;
// Z = B;
// V = 0;
// TFR D,Y ; 0C7C: 1F 02
Y = ((A << 8) | B);
// PULS A,B ; 0C7E: 35 06
A = memory[S++];
B = memory[S++];
L0C80:// ASRA ; 0C80: 47
// C = A & 1;
A = (UINT8)(A >> 1);
// Z = A;
// N = A;
// ASRB ; 0C81: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
L0C82:// PSHS B,A ; 0C82: 34 06
memory[--S] = B;
memory[--S] = A;
// TFR Y,D ; 0C84: 1F 20
A = (UINT8)((Y) >> 8);
B = (UINT8)((Y) & 0xff);
// ASRA ; 0C86: 47
// C = A & 1;
A = (UINT8)(A >> 1);
// Z = A;
// N = A;
// ASRB ; 0C87: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// SUBA ,S+ ; 0C88: A0 E0
A = (UINT8)(A - memory[S++]);
// res = A - memory[S];
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((A) ^ (memory[S])) & ((A) ^ res);
// SUBB ,S+ ; 0C8A: E0 E0
B = (UINT8)(B - memory[S++]);
res = B - memory[S];
C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// V = ((B) ^ (memory[S])) & ((B) ^ res);
// PSHS B,A ; 0C8C: 34 06
memory[--S] = B;
memory[--S] = A;
// JSR Rise_Run_Angle ; 0C8E: BD F5 93
memory[--S] = 0x0c91 & 0xff; memory[--S] = 0x0c91 >> 8;
PC = 0xf593;
JUMP;
L0C91:// PULS A,B ; 0C91: 35 06
A = memory[S++];
B = memory[S++];
// JSR Abs_a_b ; 0C93: BD F5 84
memory[--S] = 0x0c96 & 0xff; memory[--S] = 0x0c96 >> 8;
PC = 0xf584;
JUMP;
L0C96:// PSHS A ; 0C96: 34 02
memory[--S] = A;
// ORB ,S+ ; 0C98: EA E0
B = B | memory[S++];
// Z = B;
// N = B;
// V = 0;
// LDA <$36 ; 0C9A: 96 36
A = memory_DP[0x36];
N = A;
Z = A;
V = 0;
// RTS ; 0C9C: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0CAC:// LEAY ,X ; 0CAC: 31 84
Y = X;
// Z = Y;
// LDA #$04 ; 0CAE: 86 04
A = (SINT8)0x04;
// N = A;
// Z = A;
// V = 0;
// PSHS B,A ; 0CB0: 34 06
memory[--S] = B;
memory[--S] = A;
// LDB #$04 ; 0CB2: C6 04
B = (SINT8)0x04;
// N = B;
// Z = B;
// V = 0;
// PSHS B,A ; 0CB4: 34 06
memory[--S] = B;
memory[--S] = A;
L0CB6:// LDA $01,S ; 0CB6: A6 61
A = memory[(UINT16)(S + 0x0001)];
// N = A;
// Z = A;
// V = 0;
L0CB8:// ADDA #$10 ; 0CB8: 8B 10
A = (UINT8)(A + (SINT8)0x10);
// res = A + (SINT8)0x10;
// C = res & 0x100;
// res = (UINT8)res;
// Z = res;
// N = res;
// res = A ^ (SINT8)0x10 ^ res ^ C;
// H = res;
// V = res;
// STA $01,S ; 0CBA: A7 61
// Z = A;
// N = A;
// V = 0;
memory[(UINT16)(S + 0x0001)] = A;
// LDB $03,S ; 0CBC: E6 63
B = memory[(UINT16)(S + 0x0003)];
// N = B;
// Z = B;
// V = 0;
// JSR Rot_VL_ab ; 0CBE: BD F6 10
memory[--S] = 0x0cc1 & 0xff; memory[--S] = 0x0cc1 >> 8;
PC = 0xf610;
JUMP;
DP = 0xc8 << 8; memory_DP = &memory[DP]; // Unfortunately this should be inserted after the label below.
L0CC1:// LEAX ,Y ; 0CC1: 30 A4
X = Y;
// Z = X;
// DEC ,S ; 0CC3: 6A E4
res = (UINT8)(memory[S] - 1);
// N = res;
Z = res;
// V = memory[S] & ~res;
memory[S] = res;
// BNE $0CB6 ; 0CC5: 26 EF
if (Z) {
PC = 0x0cb6;
JUMP;
}
// LDA #$04 ; 0CC7: 86 04
A = (SINT8)0x04;
// N = A;
// Z = A;
// V = 0;
// STA ,S ; 0CC9: A7 E4
// Z = A;
// N = A;
// V = 0;
memory[S] = A;
// ADDA $01,S ; 0CCB: AB 61
A = (UINT8)(A + memory[(UINT16)(S + 0x0001)]);
res = A + memory[(UINT16)(S + 0x0001)];
C = res & 0x100;
res = (UINT8)res;
// Z = res;
// N = res;
res = A ^ memory[(UINT16)(S + 0x0001)] ^ res ^ C;
H = res;
// V = res;
// DEC $02,S ; 0CCD: 6A 62
res = (UINT8)(memory[(UINT16)(S + 0x0002)] - 1);
N = res;
Z = res;
V = memory[(UINT16)(S + 0x0002)] & ~res;
memory[(UINT16)(S + 0x0002)] = res;
// BNE $0CB8 ; 0CCF: 26 E7
if (Z) {
PC = 0x0cb8;
JUMP;
}
// LEAS $04,S ; 0CD1: 32 64
S = (S + 0x0004);
// RTS ; 0CD3: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0CD4:// LDX #$C900 ; 0CD4: 8E C9 00
X = 0xc900;
// Z = X;
// N = (X) >> 8;
// V = 0;
// LDD #$0340 ; 0CD7: CC 03 40
A = (UINT8)((0x0340) >> 8);
B = (UINT8)((0x0340) & 0xff);
// Z = A|B;
// N = A;
// V = 0;
L0CDA:// CLR ,X ; 0CDA: 6F 84
memory[X] = 0;
// V = 0;
// Z = 0;
// N = 0;
C = 0;
// ABX ; 0CDC: 3A
X = X + B;
// DECA ; 0CDD: 4A
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
// BNE $0CDA ; 0CDE: 26 FA
if (Z) {
PC = 0x0cda;
JUMP;
}
// RTS ; 0CE0: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0CE1:// PSHS B,A ; 0CE1: 34 06
memory[--S] = B;
memory[--S] = A;
// JSR Random ; 0CE3: BD F5 17
memory[--S] = 0x0ce6 & 0xff; memory[--S] = 0x0ce6 >> 8;
PC = 0xf517;
JUMP;
L0CE6:// ANDA ,S+ ; 0CE6: A4 E0
A = A & memory[S++];
// Z = A;
// N = A;
// V = 0;
// LEAU A,U ; 0CE8: 33 C6
U = (U + (SINT8)A);
// PULS A ; 0CEA: 35 02
A = memory[S++];
L0CEC:// LDB ,U+ ; 0CEC: E6 C0
B = memory[U++];
// N = B;
// Z = B;
// V = 0;
// ASRB ; 0CEE: 57
// C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// ASRB ; 0CEF: 57
C = B & 1;
B = (UINT8)(B >> 1);
// Z = B;
// N = B;
// STB ,X+ ; 0CF0: E7 80
// Z = B;
// N = B;
// V = 0;
memory[X++] = B;
// DECA ; 0CF2: 4A
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
// BNE $0CEC ; 0CF3: 26 F7
if (Z) {
PC = 0x0cec;
JUMP;
}
// RTS ; 0CF5: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
L0CF6:// LDB ,U+ ; 0CF6: E6 C0
B = memory[U++];
// N = B;
// Z = B;
// V = 0;
// STB ,X+ ; 0CF8: E7 80
// Z = B;
// N = B;
// V = 0;
memory[X++] = B;
// DECA ; 0CFA: 4A
res = (UINT8)(A - 1);
N = res;
Z = res;
V = A & ~res;
A = res;
// BNE $0CF6 ; 0CFB: 26 F9
if (Z) {
PC = 0x0cf6;
JUMP;
}
// RTS ; 0CFD: 39
PC = memory[S++]<<8;
PC |= memory[S++];
JUMP;
}